# Eine Session, ein 3D-Globus: die Token-Bilanz

> Eine CLI-Session baut einen interaktiven 3D-Globus mit Kartenansichten im Browser — 152 Turns, 95.304 Output-Tokens, 49 % davon Reasoning. Die komplette Token-Bilanz aus der Hermes state.db.

_Kicker: session-metrics · Datum: 2026-10-15 · Lesezeit: 5 min_

Der Globus lief nach einer einzigen CLI-Session: 3D-Globus mit Kartenansichten, Browser-nativ, ohne Backend-State. Was hat das gekostet? 152 API-Calls an ein lokales 27B, 95.304 Output-Tokens — knapp die Hälfte davon Reasoning, die andere Hälfte sichtbarer Output. 219 Tool-Calls (davon 119 Terminal, 56 write_file, 34 patch). Cache-Read: 17,8 Mio Tokens bei 99,4 % Trefferquote. Kosten: 0,00 USD — lokal bleibt lokal.

## Setup

### Modell

**swift-1.5-qwen3.8-27b-orcarouter · NVFP4**

Das Standard-27B auf der RTX 5090 — uncensored, 256K Kontext, DFlash2-Decode. Dasselbe Modell, das in allen Benchmarks dieser Site lief.

### Engine

**NInfer serve · http · 127.0.0.1:8080**

Der lokale NInfer-Endpoint — kein Cloud-Call, kein Token-Kosten. Die Session lief komplett gegen die lokale GPU.

### Aufgabe

**3D-Globus mit Kartenansichten · Browser**

Ein interaktiver 3D-Erdglobus mit Karten-Overlays, nativ im Browser. Keine Backend-State, keine externe API — eine CLI-Session, die den Code schreibt, testet und ausliefert.

### Dauer & Umfang

**89,5 min · 152 Turns · 219 Tool-Calls**

Die aktive Nachrichten-Spanne (erstes bis letztes Message) lag bei 45,9 min. Die Session endete per new_session — ein Folge-Dialog wurde gestartet, nicht ein Abbruch.

## Provenance

- Session-ID: 20261015_111712_dfac2a
- Titel: Browser 3D-Globus mit Kartenansichten
- Modell: swift-1.5-qwen3.8-27b-orcarouter (27B, uncensored, NVFP4)
- Engine: NInfer serve (http, 127.0.0.1:8080/v1)
- Profil: ninfer
- Start: 2026-10-15 11:25:01 CEST
- Ende: 2026-10-15 12:54:33 CEST
- Ende-Grund: new_session
- Dauer: 89.5 min

## Token-Bilanz

| Metrik | Wert | Hinweis |
|---|---|---|
| Input-Tokens | 114.014 | Frische Prompt-Tokens (ohne Cache) pro Session |
| Output-Tokens | 95.304 | Gesamter Output: Reasoning + sichtbarer Text |
| Reasoning-Tokens | 47.011 | 49,3 % des Outputs — internes Denken |
| Sichtbarer Output | 48.293 | 50,7 % des Outputs — Text + Tool-Calls |
| Cache-Read-Tokens | 17.825.357 | Aus dem Prompt-Cache wieder gelesen |
| Cache-Write-Tokens | 0 | Keine neuen Cache-Entries |

## API-Calls nach Task

| Task | Calls | Input | Output |
|---|---|---|---|
| Haupt-Task | 152 | 114.014 | 95.304 |
| Vision | 4 | 4.688 | 4.018 |
| Title-Generation | 1 | 322 | 17 |

## Tool-Call-Verteilung

| Tool | Calls | Anteil |
|---|---|---|
| terminal | 119 | 54.3 % |
| write_file | 56 | 25.6 % |
| patch | 34 | 15.5 % |
| vision_analyze | 4 | 1.8 % |
| skill_view | 3 | 1.4 % |
| browser_exec | 2 | 0.9 % |
| web_search | 1 | 0.5 % |

## Inhalts-Analyse (Zeichen)

| Inhalt | Zeichen |
|---|---|
| Reasoning (alle Turns) | 171.721 |
| Tool-Calls (JSON) | 177.887 |
| Assistant-Text (sichtbar) | 8.977 |
| User-Text | 5.942 |

## Nachrichten

- Gesamt: 373
- Assistant: 152 (152 mit Reasoning, 150 mit Tool-Calls)
- Tool-Responses: 219
- User: 2

## Findings

### 49 % Reasoning — das Modell denkt, bevor es schreibt

Von 95.304 Output-Tokens sind 47.011 Reasoning (49,3 %). Das Modell verbringt fast genau so viel Energie im internen Denken wie im sichtbaren Output. Bei einer Code-Session mit 219 Tool-Calls ist das erwartbar: jeder Turn muss den Kontext analysieren, den nächsten Schritt planen und den Tool-Call formulieren. Der sichtbare Output (48.293 Tokens) besteht überwiegend aus JSON-Tool-Calls (177.887 Zeichen) und wenig Prosa (8.977 Zeichen Assistant-Text).

### 99,4 % Cache-Treffer — der Prompt-Cache trägt die Last

17.825.357 Cache-Read-Tokens gegen 114.014 frische Input-Tokens. Das bedeutet: 99,37 % des Prompt-Contexts kamen aus dem Cache, nicht frisch. Bei 152 API-Calls, bei denen der Kontext pro Turn wächst (System-Prompt + Memory + Skills + Historie), ist das der normale Betrieb. Der Cache verhindert, dass jeder Turn den kompletten Kontext neu tokenisiert — ohne ihn wären die Input-Tokens um den Faktor ~156 höher.

### Terminal dominiert: 54 % der Tool-Calls

119 von 219 Tool-Calls sind Terminal-Aufrufe (54,3 %). Dahinter: write_file (56, 25,6 %) und patch (34, 15,5 %). Die Session ist ein klassischer Build-Loop: Code schreiben (write_file/patch), ausführen (terminal), Ergebnis prüfen, iterieren. Die 4 vision_analyze-Calls deuten auf Screenshot-Verifikation hin (Globus-Rendering), die 2 browser_exec-Calls auf eine Live-Prüfung im Browser.

### Null Kosten — lokal bleibt lokal

0,00 USD. Die Session lief gegen den lokalen NInfer-Endpoint auf der RTX 5090. Kein Cloud-Provider, kein Token-Preis, keine Rate-Limit. Der einzige „Kostenpunkt" ist die GPU-Zeit (~89,5 min) und der Strom — bei NVFP4-Quantisierung auf einer 5090 im Bereich von wenigen Cent.

## Grenzen

- Token-Zahlen stammen aus der Hermes state.db (session_model_usage + sessions) — sie sind Provider-Reported, nicht unabhängig verifiziert.
- Reasoning-Token-Anteil ist eine Näherung: der Provider meldet reasoning_tokens separat, aber die exakte Zuordnung pro Turn ist nicht im DB-Schema.
- Cache-Read-Zahlen kumulieren über alle 152 Calls — sie stellen nicht die Cache-Größe dar, sondern die Summe aller Cache-Treffer.
- Die Session endete per new_session (nicht per /stop oder Timeout) — die letzten Turns sind in der Folge-Session.

## Quellen

- [Hermes state.db (Profile ninfer) — sessions, session_model_usage, messages](local)
- [Der 3D-Globus (diese Site, Route /globe/)](/globe/)