Runtimes
What each runtime exposes#
Runtimes differ enormously in what they write down. Rather than showing a plausible number everywhere, ClawMetry reports what a store actually contains and marks the rest unknown.
This page is the comparison. Each runtime's own page has the detail.
Tokens and cost#
| Runtime | Tokens on disk | Cost on disk |
|---|---|---|
| Aider | Parsed from the per-reply > Tokens: N sent, M received. line when present | Not written for local models, and the sent/received split is per-reply rather than a session usage object, so cost is reported as unknown |
| Antigravity | Decoded from the gen_metadata protobuf: prompt, thinking and response counts, calibrated against live sessions | Derived from the decoded token counts and the model id in the same blob |
| Claude Code | Full split per turn, including cache reads and writes | Derived from the token split and model |
| Cline | Real, per message, including cache reads and writes | Real dollars on disk at metadata.usage.totalCost |
| Codex | Real, on disk, but only once the model has responded: the token_count event carries a running cumulative total and ClawMetry takes the last one seen | Not written by Codex |
| Cursor | Cursor's tokenCount hint is not a billed total, and the backend is proprietary | Not on disk |
| Deep Agents | From each message's usage_metadata; a child's usage is its own, so per-child tokens never double-count | Derived from the token split and model |
| DeepSeek Harness | Inline on each assistant message: input, output, cache read and reasoning tokens, with the provider and model | Derived from the inline token split |
| Devin | On the message metadata: num_tokens, plus committed ACU and credit cost | Committed ACU / credit cost per message, summed over the active chain only |
| Exo | On the usage record attached to a messages event, with the full split | Straight from Exo's own usage.cost_usd, computed at call time |
| Gemini CLI | Real: input, output, cached, thoughts, tool and total per message | Derived from the token split and model |
| GitHub Copilot | Real, from the assistant_usage_events ledger, with input, output, cache read, cache write and reasoning splits | Vendor-billed: total_nano_aiu is the CLI's displayed credits times 1e9, and one credit is one US cent |
| Goose | Real, on disk: sessions.total_tokens, input_tokens, output_tokens | accumulated_cost is populated for paid providers |
| Grok | From shell.turn.inference_done rows: prompt, cached prompt, completion and reasoning tokens | Derived — the xAI provider is priced in ClawMetry's table and any grok model name resolves to it |
| Grok Bot | None | Unavailable |
| Hermes | Pre-computed per session by Hermes itself | Pre-computed per session by Hermes itself |
| Kimi | Real: StatusUpdate carries the full cache split per step, plus context-window occupancy | Derived — but note the model honesty caveat below |
| Lovable | None | Unavailable |
| n8n | Real, but only on the chat-model sub-node's run output — never on the Agent node itself | Derived; n8n never stores cost |
| NanoClaw | Not in the message tables | Derived from the mounted Claude transcripts |
| NemoClaw | Full split on disk | Derived at ingest, same path as OpenClaw |
| OpenClaw | Full split on disk (input, output, cache read, cache write) | Derived at ingest from the token split and the model, using the multi-provider pricing table |
| opencode | Real, per session and per assistant message, including the cache read/write split | Real, on disk |
| OpenHands | In base_state.json under stats.usage_to_metrics, keyed by an LLM usage id | Populated only when LiteLLM can price the model |
| OpenWorker | From the per-message usage sidecar, tagged with the model that produced it — so a session that switched models is priced per model and summed | Always derived; OpenWorker writes no dollars anywhere |
| Pi | Real, with cache read/write, one-hour-TTL cache writes and reasoning tokens | Real — Pi stores a per-turn cost object, which ClawMetry sums directly and only derives when the object is absent |
| PicoClaw | Not on disk | Not available |
| QM | Per-run, from session_llm_requests, normalised across the Anthropic and OpenAI usage shapes | Derived from that per-run usage |
| Qwen Code | Real: usageMetadata carries prompt, candidates, thoughts, cached and total counts | Not recorded — the endpoint may be a free local Ollama — so cost is left unknown rather than fabricated |
| Replit Agent | None | Unavailable |
The four honesty states#
Every session carries a cost status, and the dashboard renders them differently on purpose:
| Status | Meaning |
|---|---|
exact | The runtime wrote dollars, or every model call was priceable |
estimated | Cost derived from tokens, with a caveat — a model resolved from current config rather than the session's own record |
partial | Some calls priced, some not |
tokens_only | Real tokens, no priceable model |
unavailable | Neither is on disk. Reported as unknown, never as $0.00 |
A $0.00 and an unknown are different facts. A local Ollama run genuinely
costs zero, and opencode records that honestly; PicoClaw simply does not record
anything, and pretending that means zero would quietly understate a fleet.
Structural differences worth knowing#
Trees, not lists. Pi, Devin and Deep Agents all store conversations as trees or forests, because they support branching, forking and reverting. Summing every row bills you for work that was thrown away. ClawMetry walks the active chain and reports the abandoned nodes as a count.
Delegation is persisted five different ways. Copilot runs sub-agents inside
the parent's event log; Grok writes a meta.json in the parent's directory;
Antigravity gives each child a full conversation of its own and records the edge
in a summaries database; Deep Agents uses a checkpoint namespace; Pi and PicoClaw
persist no child at all, so children are synthesised from the parent's tool call
and result. See each runtime's sub-agent section.
Some stores are actively written while you read them. Cursor, Devin, n8n, Copilot and Hermes are read WAL-aware so live sessions are visible. NanoClaw's per-session databases are opened immutable so ClawMetry can never take a lock the runtime needs.
Two runtimes are not files. QM is PostgreSQL; Exo is workspace-relative rather than home-anchored. See How detection works.
Feature coverage by runtime family#
Not every dashboard page applies to every runtime — a page that would be permanently empty is hidden rather than shown blank.
| Capability | Available when |
|---|---|
| Transcripts | Any runtime with a readable store |
| Tool timeline | The store records tool calls and results separately |
| Thinking / reasoning | The runtime persists reasoning blocks (most modern ones do) |
| Cost | Tokens on disk, or dollars on disk — see the table above |
| Sub-agents | The runtime persists a delegation edge, in any of the five shapes above |
| Cron / schedules | OpenClaw, NemoClaw, Hermes, Cline |
| Memory files | OpenClaw, NemoClaw, Hermes, and any runtime with a documented memory directory |
| Skills | Runtimes with a skills directory and usage log |
| Live gateway stream | OpenClaw and NemoClaw (JSON-RPC WebSocket) |
| Pause / stop / kill | Anything that is a real local process tree — see process control |
Runtime extras#
Some runtimes expose something no generic tab can show — Grok's upload manifest of what it staged for xAI, Cline's rejected tool calls, Copilot's credit ledger, Kimi's context-window occupancy. Those surface on the Runtime extras tab, which only appears when the selected runtime actually has extras.