Supported Agents

TokenTelemetry reads log files from the agents listed below. Detection is automatic — no configuration needed. Just run your agent as normal and TokenTelemetry picks up the sessions.

Coding agents

Autonomous agents

Hermes has a dedicated dashboard at /hermes — see Hermes Agent for details.

Detection notes

Claude Code

Reads JSONL session files from ~/.claude/projects/<dir>/. Captures input and output tokens, cost, tool calls, plan-mode output, reasoning blocks (with honest labelling if encrypted), and subagent delegation cards.

Codex

Reads session JSON from ~/.codex/sessions/. Captures tokens, tool calls, and reasoning steps including extended thinking when enabled.

Gemini CLI

Reads session files from ~/.gemini/. Captures token counts (input/output), cost, and the conversation trace. Note: Gemini CLI does not expose per-call cache-hit data.

Antigravity

Antigravity is Google's browser automation agent. TokenTelemetry reads its sessions from ~/.gemini/antigravity/ and additionally captures browser screenshots and Antigravity recording strips (thumbnail sequences from browser_recordings). See Artifacts.

Cursor

Cursor stores its chat sessions in ~/.cursor/ and VS Code's workspaceStorage/. TokenTelemetry merges sessions from both locations. Plans extracted from Cursor's /plan output are available in the Projects → Plans tab.

GitHub Copilot

Reads Copilot's chat session files from VS Code's chatSessions/ directory (inside the VS Code user data folder). Token counts and cost are captured where the session log includes them.

OpenCode

Reads session data from ~/.local/share/opencode/. Token counts and traces are captured; OpenCode children sessions are included in the relayed-session count (they are already counted in the parent session's token totals).

Cline

TokenTelemetry reads both the Cline CLI SQLite store and the VS Code extension's JSON task history, de-duplicating sessions that appear in both.

SmallCode

SmallCode writes traces into each project directory rather than a global home dir, so TokenTelemetry discovers them under the project paths it already tracks from other agents (and honors the TT_SMALLCODE_ROOTS env var for extra locations).

Pi

Pi Coding Agent writes one JSONL file per session under ~/.pi/agent/sessions/<project>/. TokenTelemetry reads per-message usage, model, provider, cache activity, and tool calls, then rolls them up into the session and project views.

Muse Code

Muse Code writes date-sharded JSONL logs to ${XDG_DATA_HOME:-~/.local/share}/muse/sessions/YYYY/MM/DD/<session-id>/session.jsonl (normally ~/.local/share/muse/sessions/ on macOS and Linux). TokenTelemetry records the root session's usage and trace, attributes child logs as subagents, and uses the session workspace as the project. Set TT_MUSE_SESSIONS_DIR when this directory is mounted or relocated.

Prime Agent

Prime Agent writes one JSONL session tree per file in ~/.prime/agent/sessions/. TokenTelemetry follows the active branch and its ancestry so the trace mirrors the conversation a user sees, while preserving reported token totals, cost, and model metadata. Set TT_PRIME_SESSIONS_DIR (or Prime's PRIME_AGENT_SESSION_DIR) when the sessions directory is relocated.

DeepSeek Harness

DeepSeek Harness (the dsh CLI, npm @deepseek-ai/dsh) writes one zstd-compressed JSONL log per session to ~/.dsh/sessions/<slugged-cwd>/<session-id>/, named session.jsonl.zstd in the original format and session.vN.jsonl.zstd in later ones (current DSH writes session.v3.jsonl.zstd). An upgraded DSH leaves the older file next to the new one, so TokenTelemetry reads the newest version in each session directory. It reads read-only and honors DSH_HOME when the directory is relocated. Decompression needs the zstandard Python package, which backend/requirements.txt already pins; a virtualenv created before that pin was added will skip DSH sessions silently, so re-run the launcher if none show up.

DSH records no cost of its own (its source zeroes the cost metadata deliberately), and it is bring-your-own-key across providers, so TokenTelemetry prices each (turn, step) with that step's own provider and model. A session that runs part of its work on a local Ollama model and part on a paid cloud model is priced correctly on both halves, with the local segments falling through to local-model pricing. Tokens are de-duplicated per step, because DSH emits the same usage sample twice: once on the streaming chunk, once on the final message.

Subagents spawned with the subagent and subagent_fork tools are linked through DSH's own parentSession and origin header fields, then folded into the parent with per-child tokens and cost. What a DSH trace shows beyond that (runtime skills and tools, sandbox and approval policy, latency breakdown) is covered in Traces.

Qoder

Qoder writes one JSONL transcript per session to ~/.qoder/projects/<slugged-cwd>/<session-id>.jsonl, in the same record shape Claude Code uses. TokenTelemetry reads it read-only. Child transcripts sit one level deeper in <session-id>/subagents/, each with a .meta.json naming the agent type and the task it was given; they are folded into the parent as delegation rather than counted as sessions of their own.

Qoder records no token counts. Every turn carries a usage block whose input, output and cache counters are all zero, and reports credits instead — its own billing unit. So a Qoder session shows 0 tokens and $0.00 API-equivalent cost, and that is what Qoder itself reports, not a failed scan. The credit spend, including how much of it went to subagents, is on the agent's own page. There is no published credit-to-currency rate available locally, so TokenTelemetry does not convert credits to dollars rather than guess a rate.

Two further things stay opaque by design: model ids are internal names such as qmodel_38max, and the catalogue that would resolve them (.models/<uid>/catalog-v6) is encrypted at rest; and each session's state.json is encrypted too, so resumable context and todos cannot be read. Both are listed on the agent page as unavailable, with the reason.

Qoder also keeps an Electron store at ~/Library/Application Support/com.qoder.app.stable. Its main.sqlite is a projection of the same sessions — the message rows are marked sdk-projection and reuse the transcript's ids — so TokenTelemetry reads it only for the human-readable session title, never as a second source of sessions. It counts towards the agent's disk footprint, which spans both directories.

ZCode

ZCode (Z.ai) keeps its state in an OpenCode-family SQLite store at ~/.zcode/cli/db/db.sqlite (override the location with ZCODE_DATA_DIR). TokenTelemetry reads it read-only — never taking a write lock on the live TUI's database: sessions and projects from the session table, models and plan mode from the message rows, per-step token totals, tool names and user prompts from the part rows, and plan artifacts from the todo table. Child sessions recorded in session.parent_id are folded into the parent as delegation rather than re-summed.

Tokens are summed with the same semantics as OpenCode, whose store shares this schema. Sessions billed through the Z.ai coding plan report a $0.00 cost from ZCode itself, so TokenTelemetry estimates API-equivalent cost at Z.ai's list rates for the session's models. The dashboard has no plan-quota gauge for ZCode yet — its usage numbers live in the Z.ai account API, which needs your account credentials and is not read today.

Kimi Code

Kimi Code (Moonshot AI's coding CLI, the kimi command) writes one JSONL wire log per session to ~/.kimi/sessions/<workdir-hash>/<session-uuid>/wire.jsonl. TokenTelemetry detects the agent from the ~/.kimi/ directory, reads each wire.jsonl read-only for per-call usage, model, and the conversation trace, and rolls the sessions up under the project named by the work_dirs entries in ~/.kimi/kimi.json. TokenTelemetry surfaces no delegation breakdown for Kimi Code: the scanner records no subagent links, so a Kimi session reports delegation as unsupported and its trace carries no subagent overlay. A run writes everything to one wire.jsonl, so a session's totals already cover whatever that run did.

~/.kimi/ belongs to Kimi Code alone. Two sibling directories that look similar are different products and are not read as Kimi Code sessions: ~/.kimi-work/ (kimi-slides, a presentation tool) and ~/.kimi-webbridge/ (the browser-automation bridge).

Hermes Agent

Hermes writes its state to ~/.hermes/ (or the directory pointed to by $HERMES_HOME). TokenTelemetry reads:

• sessions.db / session JSON for per-call token and cost data
• agent.log for per-API-call latency and cache-hit percentages
• skills/, memory/, and soul/ directories for the configuration pages
• Cron schedule files for the Schedules sub-page

Requesting a new agent

Don't see your agent? Open a GitHub issue with the agent name and its log file format and we'll add support.