ClawMetry observes 33 AI-agent runtimes. Each runtime that
isn't OpenClaw ships a dedicated reader adapter (clawmetry/adapters/) that
translates its native session format into ClawMetry's unified Session/Event
shapes; the daemon then ingests them into the same local DuckDB store and cloud
snapshot, tagged with the runtime. When more than one runtime is present on a
node, the Session replay tab shows a runtime switcher (All / per runtime).
This page tracks each one's real status, honestly.
New to NanoClaw / PicoClaw? See
RUNTIME_FAMILY.mdfor a primer on the OpenClaw-family runtimes specifically.
Running Perplexity's numbat agent-security
tool? ClawMetry ingests its findings and enforcement decisions out of the box.
See NUMBAT.md.
| Runtime / Agent | Status | Session store | Notes |
|---|---|---|---|
| OpenClaw | Native | v3 JSONL ~/.openclaw/agents/main/sessions/ |
Reference runtime; auto-detected. |
| NVIDIA NemoClaw | Native | OpenClaw v3 JSONL on the host or inside an OpenShell container | Auto-detected (binary + container scan). See NEMOCLAW.md. |
| PicoClaw | Beta adapter | Flat providers.Message JSONL ~/.picoclaw/workspace/sessions/ |
Transcripts, model, tool calls. Tokens/cost not on disk. |
| NanoClaw | Beta adapter | Per-session SQLite data/v2-sessions/<group>/<session>/{inbound,outbound}.db |
Transcripts. Model/tokens/cost not on disk. |
| Hermes | Beta adapter | SQLite ~/.hermes/state.db (sessions + messages) |
Transcripts, model, pre-computed tokens/cost. |
| Claude Code | Beta adapter | JSONL ~/.claude/projects/<cwd>/<id>.jsonl (v-type lines) |
Transcripts, model, tool calls + thinking, token usage. |
| Codex | Beta adapter | "rollout" JSONL ~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl |
Transcripts, model, tool calls, token usage (from token_count events). |
| Cursor | Beta adapter | SQLite state.vscdb (cursorDiskKV / ItemTable, global + per-workspace) |
Chat/composer transcripts, model. No billed cost on disk (server-side). |
| Aider | Beta adapter | Markdown .aider.chat.history.md per project dir (+ .aider.input.history) |
Transcripts, model, token counts. Per-project history (set AIDER_HISTORY_DIRS). |
| Goose | Beta adapter (free) | SQLite <goose data dir>/sessions/sessions.db — ${XDG_DATA_HOME:-~/.local/share}/goose on macOS and Linux, %APPDATA%\Block\goose\data on Windows, or $GOOSE_PATH_ROOT/data when that is set (sessions + messages tables) |
Transcripts, model, tool calls, real token totals. Adapter ships in the OSS package (clawmetry/adapters/goose.py) — no plan required. |
| opencode | Beta adapter | SQLite ~/.local/share/opencode/opencode.db (session/message/part) |
Transcripts, model, tool calls, real tokens + cost. |
| Qwen Code | Beta adapter (free) | JSONL ~/.qwen/projects/<hash>/chats/<id>.jsonl (Gemini-CLI lineage) |
Transcripts, model, tool calls + thinking, real token usage. Adapter ships in the OSS package (clawmetry/adapters/qwen_code.py) — no plan required. |
| Pi | Beta adapter | JSONL ~/.pi/agent/sessions/ |
Transcripts, model, tool calls, real tokens + cost. |
| Deep Agents | Beta adapter | SQLite ~/.deepagents/.state/sessions.db |
Transcripts, model, tool calls, real tokens + cost. |
| n8n | Beta adapter | SQLite ~/.n8n/database.sqlite (execution_entity/execution_data, WAL) |
Workflow executions as sessions, node runs as tool calls, AI Agent prompts + model attribution; tokens + cost where the model sub-node records usage. Postgres and n8n Cloud installs are not covered by this adapter. |
| Antigravity | Beta adapter | Brain JSONL under ~/.gemini/<flavor>/brain/<uuid>/ (flavors: antigravity, antigravity-cli, antigravity-ide, jetski) + conversations/<uuid>.db (SQLite, WAL) |
Conversations as sessions, planner/tool steps as events, thinking + checkpoint (compaction) events; per-generation model, token split (prompt/thinking/response) and cost decoded from gen_metadata; background-generation burn; subagent + battle-mode metadata. |
| GitHub Copilot | Beta adapter | Copilot CLI events.jsonl under ~/.copilot/session-state/ + the session-store.db per-call usage ledger |
Conversations, tool calls, model routing, cache-aware token split, vendor-billed AI-credit cost. |
| Grok Build | Beta adapter | xAI Grok Build CLI: ~/.grok/logs/unified.jsonl + per-session ~/.grok/sessions/<enc-cwd>/<uuid>/{events.jsonl,summary.json} |
Conversations, per-turn token split, model routing, and the outbound repo payload staged under ~/.grok/upload_queue/. |
| Grok Bot | Beta adapter | xAI Grok Bot desktop client (Anysphere com.anysphere.sand): ~/Library/Application Support/Grok Bot/sand-client-persistence/*.blob (base32-named plaintext JSON) + ~/.grokbot/ |
Full transcripts, both sides, plus local tool-permission asks and the MCP / egress-tunnel posture. No tokens, model or cost: the bot infers on its own cloud VM and none of that reaches the client, so no spend is reported rather than a derived guess. One desktop process serves every bot, so there is no per-bot pause/stop/kill. |
| QM | Beta adapter | Postgres (no on-disk session store); adapter reads DATABASE_URL / CLAWMETRY_QM_DATABASE_URL read-only |
YC's multiplayer harness; delegates to Pi / opencode / Codex / Claude Code, which show up as their own runtimes. |
| DeepSeek Harness | Beta adapter | JSONL under $DSH_HOME/sessions (default ~/.dsh/sessions), zstd-compressed by default |
Transcripts, model, tool calls. zstandard is installed lazily, only once compressed dsh data is detected. |
| Exo | Beta adapter | One pretty-printed JSON file per event under <workspace>/.exo/exoharness/agents/*/conversations/*/events/ |
Per-call usage + cost persisted by Exo itself. State dir is workspace-relative; set CLAWMETRY_EXO_ROOTS for unusual layouts. |
| Kimi CLI | Beta adapter | One wire.jsonl event log per session under <share>/sessions/<md5(workdir)>/<uuid>/ |
Reads both share dirs (~/.kimi, ~/.kimi-code) plus $KIMI_SHARE_DIR. Model id is not written to disk. |
| Gemini CLI | Beta adapter | One JSONL chat recording per session under ~/.gemini/tmp/<project-basename>/chats/session-<ts>-<id8>.jsonl |
Recording is always on (no setting to enable). Per-turn token split + model id + tool calls with results, and nested chats/<parentSessionId>/ sub-agent transcripts. The project dir is the cwd's BASENAME; the sha256 is stored inside the file as projectHash. GEMINI_CLI_HOME names the dir containing .gemini. |
| Cline | Beta adapter | SQLite index at ~/.cline/data/db/sessions.db plus ~/.cline/data/sessions/<id>/<id>.messages.json per session |
Cost in USD is on disk, which is rare. The index records pid, status and sub-agent lineage, so liveness is reported rather than guessed. Rejected tool calls are surfaced as errors. Note the data leaf: ~/.cline itself holds only hooks and worktrees. |
| OpenHands | Beta adapter | One directory per conversation under ~/.openhands/conversations/<hex>/ — base_state.json plus one immutable JSON file per event |
Tokens and per-call cost live in the sidecar, never on the events. The directory name is the conversation id with dashes stripped. prompt_tokens is cumulative across calls, and cost reads 0.0 both for a free local model and for a failed pricing lookup. Delegated sub-agents nest under subagents/. |
| Devin | Beta adapter | One SQLite store for every session ($XDG_DATA_HOME/devin/cli/sessions.db) holding a message forest plus the ACP tool-call records |
Sessions and tool calls. Fork and revert leave abandoned branches, which the adapter excludes so they are never billed. Whether usage and cost are recorded has not been verified against a real capture yet, so no token or cost number is claimed. Devin Cloud sessions are API-only and not ingested. |
| Lovable | Beta adapter | A local git clone of the Lovable-synced GitHub repo — Lovable's agent runs entirely in the vendor cloud, and its GitHub two-way sync writes one bot commit per accepted agent edit, so the clone is a real per-edit activity record (CLAWMETRY_LOVABLE_DIRS points at clone roots) |
One session per project, one event per accepted edit, with the prompting teammate attributed from the co-author trailer. No tokens, model or cost: Lovable bills credits in the vendor cloud and none of it reaches the clone, so no spend is reported rather than a derived guess. Data is only as fresh as the last git fetch, which the session states. No liveness claims and no per-session control: nothing runs locally. |
| Replit Agent | Beta adapter | One transcript.jsonl journal per session under <workspace>/.local/state/replit/agent/transcript/<uuid>/ — the agent loop runs on Replit's infrastructure but serializes into the Repl workspace, so the daemon reads it from inside the Repl (pip install clawmetry in the workspace shell) or over a clone (CLAWMETRY_REPLIT_ROOTS) |
Full transcripts with tool calls (write/edit/bash/screenshot vocabulary), typed prompts extracted from the injected wrapper, structural tool errors. No tokens, model, cost or timestamps in the workspace journal: Replit bills effort-based checkpoints server-side, so no spend is reported rather than a derived guess, and session times come from file mtimes with the basis declared. No per-session pause/stop/kill: the loop is not a workspace process. |
| OpenWorker | Beta adapter | A SQLite index plus one append-only JSONL per session under ~/.config/coworker/ ($COWORKER_STATE_DIR, or %APPDATA%\coworker on Windows). The same coworker.db file holds both the session index and the audit log |
Sessions, events, cost and sub-agents. The token split rides a per-message sidecar tagged with the model that produced that turn, so a session that switches models is priced per model. OpenWorker writes no dollars, so cost is always derived and never reported. Team workers carry their lead session, which becomes real sub-agent lineage. The audit log's token columns meter the Auto-Approve reviewer rather than the agent, so they are excluded from session cost. Per-session pause and stop are not offered: one desktop process serves every session. |
| Muse Code | Beta adapter | No on-disk format to read. Muse Code publishes no session-log schema; its transcript is served over the Muse Session Protocol (MSP), so the adapter spawns muse serve and calls the two documented read-only surfaces — session/list ("read-only, never touches leases") and session/read (a point-in-time cold read that never subscribes). MSP also reports each session's own durable log path, so nothing is guessed. Verified against muse 1.0.3 on macOS: the store is $XDG_DATA_HOME/muse (default ~/.local/share/muse, XDG even on macOS — not ~/Library/Application Support), holding session-index.db and sessions/YYYY/MM/DD/<uuid>/session.jsonl, while ~/.config/muse holds only settings.json and auth.json. MUSE_HOME is not honoured by the binary; XDG_DATA_HOME is the only lever. Override the store with CLAWMETRY_MUSE_HOME, the config dir with CLAWMETRY_MUSE_CONFIG_DIR, and the binary with CLAWMETRY_MUSE_BIN |
Sessions, full transcripts (messages, native reasoning, tool calls, user shell, sub-agents, compaction), fork lineage and cost. Token counts are the counted-once session totals MSP itself reports, tagged with the model that produced them — read via view/page, because the folded transcript items carry an EMPTY usage block and reading those alone reports $0.00 for a real paid session. Cost is derived at published Muse Spark rates; Muse writes no dollars. Cached input is billed at Meta's published cached rate, since cached tokens sit inside the input count: verified on muse 1.0.3, where 82.7% of a measured turn's input was cache reads and the flat input rate over-charged fivefold. One honest gap remains: the protocol reports no pid anywhere, so Pause/Stop/Kill are not offered rather than offered and inert. The adapter calls only initialize, session/list, session/read and view/page (all verified read-only: after paging the session is still notLoaded, no lease is taken, and a second concurrent host can read it), and requests no capabilities — in particular not userShell, which would let the connection run commands in the workspace. |
| OpenExecutive | Beta adapter | One SQLite store, episodic_memory.db ($EPISODIC_DB_PATH; packages/core/ in a clone under make dev, /data/ in Docker). Found automatically in a clone under ~, ~/projects, ~/src, ~/code, ~/dev, ~/repos or ~/workspace; a Docker named volume is not visible to the host, so bind-mount /data or set CLAWMETRY_OPENEXECUTIVE_DB |
Sessions, events and cost. Every conversation, including ones that started in Slack or email; each specialist consult as a step with its question and answer; tool calls with failures flagged; every outbound send the scheduler queued, with its status (pending, delivered, failed). Usage rows cover the Executive's own model calls, not the specialist agents', so a session's cost is a floor: the real OpenRouter charge where routed through OpenRouter, otherwise derived from the pricing table. Pause and stop are not offered: one API server process serves every conversation and the scheduler. |
| OpenDots | Storage-contract verified; live services unverified | Local workspace database on the OpenDots host | Conversation metadata, scheduled work, results, errors and call receipts through the Pro adapter. No model IDs, token usage or costs in the local workspace. Normal chat history is held in CopilotKit Intelligence. Dot-level computer activity cannot be attributed to a specific thread. No runtime control. |
| ZeroClaw / TrustClaw / Nanobot | Not yet | unverified | Open an issue with a real session capture. |
OpenClaw, NVIDIA NemoClaw, Goose and Qwen Code are free in the OSS package —
their adapters ship in pip install clawmetry, so observing them needs no
account, no licence key and no network call. The rule: an open-source
runtime gets a free, open-source adapter; a commercial vendor product
(Claude Code, Codex, GitHub Copilot, Cursor, Antigravity, Grok) needs a
Starter or Pro plan, or a self-hosted licence key. See
ENTITLEMENTS.md.
A Beta adapter means ClawMetry ships a reader for that runtime's real
on-disk format, validated against a session captured from a real install of
that runtime (we installed and ran both, see
tests/fixtures/runtimes/<runtime>/REAL/PROVENANCE.md), with fixture-backed CI
tests that fail if the parse path regresses. It is not the same as the
earlier "Verified" claim, which was withdrawn: that had been based on fixtures
that were actually OpenClaw v3 records relabeled, and so proved only that
ClawMetry parses OpenClaw's shape. Running the real runtimes caught real bugs
the relabeled fixtures could never have (PicoClaw's nested tool-call shape and
Go's trailing-zero timestamps; NanoClaw's CWD-relative data dir).
PicoClaw and NanoClaw do not share OpenClaw's layout (verified 2026-05-25 against the real sources):
- PicoClaw (
github.com/sipeed/picoclaw, Go) writes a flatproviders.Messageper JSONL line (fieldsrole,contentas a string,model_name,created_at,tool_calls, ...), under$PICOCLAW_HOME/workspace/sessions/<key>.jsonlwith a<key>.meta.jsonsidecar. There is no token/cost field on disk, so ClawMetry shows transcripts, model, and tool calls but reports tokens/cost as unavailable. SeePRD_PICOCLAW.md. - NanoClaw (
github.com/nanocoai/nanoclaw, TypeScript) stores each session as a pair of SQLite files (inbound.db/outbound.db) underdata/v2-sessions/<agent_group_id>/<session_id>/. The message tables carry no model/token/cost columns, so ClawMetry shows transcripts and message counts but reports model/tokens/cost as unavailable. SeePRD_NANOCLAW.md.
A "Verified" badge will be restored per runtime only after a session captured from a real install of that runtime passes its adapter test, and the live end-to-end path (dashboard + cloud snapshot) is confirmed.
The sync daemon detects PicoClaw / NanoClaw installs (via each adapter's
detect()) and ships a runtime label in the encrypted snapshot, both as
runtimeInfo.items[] rows and a small top-level detectedRuntimes summary
({name, displayName, sessionCount, workspace}). The cloud Runtime panel
renders these alongside OpenClaw with no cloud code change. This was verified by
decrypting the live cloud snapshot of a real node, which showed
PicoClaw: detected (1 session) and NanoClaw: detected (2 sessions). Pure
detection only: no DuckDB access and no writer lock are involved.
When a runtime's home directory exists, its adapter registers automatically and appears in the multi-agent view:
# PicoClaw: adapter auto-registers when ~/.picoclaw exists (or PICOCLAW_HOME set)
export PICOCLAW_HOME=~/.picoclaw # only if you use a non-default home
clawmetry
# NanoClaw: adapter auto-registers when ~/.nanoclaw exists (or NANOCLAW_HOME set).
# NanoClaw resolves its data dir relative to where it was launched
# (process.cwd()/data), so if your install keeps data elsewhere, point at it:
export NANOCLAW_HOME=/path/to/nanoclaw # expects <NANOCLAW_HOME>/data/v2-sessions
clawmetryThese adapters read their runtime's files strictly read-only (NanoClaw's SQLite
is opened mode=ro&immutable=1), consistent with ClawMetry's read-only charter.
- Capture a real session from the runtime and confirm its on-disk format (path, file type, wire shape). Do not assume it matches OpenClaw.
- If it writes OpenClaw v3 JSONL under
agents/main/sessions/, it works already; add a fixture + a row here. - If it uses its own format, add a reader adapter under
clawmetry/adapters/(subclassAgentAdapter, translate the native format into the unifiedSession/Eventshapes), with fixture-backed tests, and register it indashboard.pygated on the runtime's home directory. - Be honest in
capabilities()and in this matrix: only advertise what the on-disk data actually supports.
A runtime works with zero adapter code only if it writes session files matching all of:
- One JSONL per session, named
<session_id>.jsonl - Located under
<root>/agents/<agent_id>/sessions/ - First line is a
{"type": "session", "version": 3, ...}record - Assistant turns carry
message.usage.totalTokensand (optionally)message.usage.cost.total - Model identity via
model_changeevents and/ormessage.model
Runtimes that diverge from this (PicoClaw's flat JSONL, NanoClaw's SQLite) need the dedicated adapter described above.