Tokentelemetry

Tokentelemetry

Local, MIT-licensed token and cost observability for AI coding agents — reads the logs your agents already write.

70/100Safe BetFreeFree

For solo developers running Claude Code, Codex, Cursor or Gemini CLI locally, TokenTelemetry is the lowest-friction way to answer 'what did that actually cost me' — one curl command, no instrumentation, nothing uploaded. Against Langfuse, LangSmith and Helicone, its differentiator is structural: those require an SDK and an account, TokenTelemetry reads logs already on your disk. Hermes Agent operators get something no competitor offers — a dedicated /hermes hub for a 38-source autonomous agent. Skip it if you need shared cloud seats, dashboards across a team, or a vendor SLA; that isn't the product here.

Verified 2d ago · liveness 70/100 · cite: rightaichoice.com/tools/tokentelemetry

Best for
  • Solo developers who want to know what Claude Code, Codex, or Cursor actually costs them
  • Hermes Agent operators monitoring bots across 38 source platforms from one local dashboard
  • Prompt engineers tuning reasoning-token usage, cache efficiency, and budget alerts
  • Privacy-conscious engineers who can't send prompts, paths, or costs to a third-party cloud
Not ideal for
  • Teams needing shared cloud dashboards, seats, or multi-user collaboration
  • Users who want a fully hosted product with no local Node 18+ / Python 3.9+ runtime
  • Organizations that block curl-pipe-bash installers or unsanctioned local services
Visit Website

Beginner-friendlySolo developer: under five minutes — paste the curl command (or run the PowerShell script on Windows), let it auto-detect your agents, and the dashboard opens itself. Hermes operators: add about two minutes for 'hermes plugins install VasiHemanth/tokentelemetry-hermes-plugin' and 'hermes dashboard', remembering the plugin only works while TT is already running on port 13000. Clone-and-run orDesktop · CLINo public APIVerified 2d ago
Pricing
Free
FreeFree tier2 hidden costs
Learning curve
Beginner-friendly
Solo developer: under five minutes — paste the curl command (or run the PowerShell script on Windows), let it auto-detect your agents, and the dashboard opens itself. Hermes operators: add about two minutes for 'hermes plugins install VasiHemanth/tokentelemetry-hermes-plugin' and 'hermes dashboard', remembering the plugin only works while TT is already running on port 13000. Clone-and-run or
Runs on
DesktopCLI
No public API · 15 integrations
Who it's for
Solo developer running Claude Code and Codex dailyHermes Agent operator running a bot across Telegram, Discord and cronPrompt engineer tuning reasoning-token usage
Live sentiment
Is Tokentelemetry actually worth it?

We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.

  • Honest verdict, not marketing
  • Real pros & cons from real users
  • Attributed quotes with receipts
Run a free scan

3 free scans · no card needed

Skip it if

Skip TokenTelemetry if you need a shared cloud dashboard with seats for a team, or if your organization blocks curl-pipe-bash installers and unsanctioned local services.

The 30-second take
Biggest gripe

Summarization is one-click but not free — you bring and pay for your own LLM API key, so heavy use of session briefs adds a separate model bill on top of your agent spend.

Price reality

TokenTelemetry is MIT-licensed and free to run, so the cost comparison is against your own time and hosting rather than a subscription. Langfuse, LangSmith and Helicone are the nearest observability substitutes and all three are freemium: you get a hosted tier and a bill once you exceed it. TokenTelemetry trades that commercial support model for zero recurring cost and full local control, which fits solo developers and small shops far better than it fits teams needing seats and an SLA.

In short

Tokentelemetry — Local, MIT-licensed token and cost observability for AI coding agents — reads the logs your agents already write. Best for Solo developers who want to know what Claude Code, Codex, or Cursor actually costs them, Hermes Agent operators monitoring bots across 38 source platforms from one local dashboard, Prompt engineers tuning reasoning-token usage, cache efficiency, and budget alerts. Free to use.

What people actually say about Tokentelemetry — is it worth it?

We ran a structured research pass across product reviews, community discussions, and post-purchase forum threads to surface the patterns vendors won't publish themselves. Below: the recurring strengths, the hidden costs people mention most, and the cohort that consistently regrets adopting this tool.

20 mentions across 3 sources (YouTube, Product Hunt, GitHub) · researched Aug 29, 2026.

67% positive33% critical

Average across the 3 sources that answered — each source counts once, not each post.

Recurring strengths
  • +100% local and offline; your data never leaves your machine.
  • +Zero configuration: auto-detects 17 agents without SDK or code.
  • +One-command setup and read-only; never writes to agent files.
  • +Replayable traces with kind-aware highlighting for deep debugging.
  • +Cost anomaly detection flags silent reasoning-token waste.
Recurring frustrations
  • −Cost estimates may be inaccurate for some providers/models.
  • −Limited community feedback; only 335 GitHub stars.
  • −No formal support; troubleshooting relies on GitHub issues.
  • −Dashboard may be overwhelming for beginners new to observability.
  • −YouTube data largely off-topic; unclear if tool works with all agents.
Patterns worth knowing
Local-first and privacy-focused observability is a major plus
Seen on Product Hunt, GitHub
Zero-configuration ease of use attracts users
Seen on Product Hunt, GitHub
Concerns about cost estimate accuracy and ongoing maintenance
Seen on GitHub
Learning curve
beginnerProductive in ~5 minutes
Hidden costs people mention
  • • None—fully free and open-source; optional anonymous stats can be disabled.

Viability Score

70/100
Safe Bet

How well maintained and how widely used is Tokentelemetry? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this

Recent activity
90
Traction
100
Site health
95
User sentiment
67
What the vendor publishes
20

Last calculated: October 2026

How we score →

Key Features

  • Auto-detects AI coding agents from logs already written to disk, zero configuration
  • Read-only local analysis: no SDK, no API key, no signup, no code changes
  • One-line curl installer plus a separate Windows PowerShell script
  • Live dashboard on localhost:13000 with 15-second KPI auto-refresh
  • Per-agent and per-model token, cost, and usage distribution charts
  • Replayable session traces with events, messages, tool calls, artifacts and plan-mode output
  • Honest labeling on encrypted reasoning rather than inferred content
  • One-click LLM summarization into narrative or structured What/Tools/Why/Next briefs, cached by content hash
  • Cost anomaly detection for silent reasoning-token waste (MiMo thinking-mode)
  • Project view with per-working-directory cards, 365-day heatmap, streaks and configuration overlays
  • Cache-efficiency metrics surfaced in the Analytics tab
  • Delegation & Ecosystem view for subagent spend, skills used, and MCP servers
  • Budgets & Alerts configuration built into the dashboard
  • Dedicated /hermes dashboard: gateway health, scheduled-job status, skills and memory pages
  • Hermes source breakdown across 38 platforms (CLI, Telegram, Discord, Slack, Feishu, DingTalk, cron, webhook)

About Tokentelemetry

FreeBeginner-friendlyNo APIDesktop · CLI

TokenTelemetry is a free, MIT-licensed observability dashboard for AI coding agents that runs entirely on your own machine. Rather than asking you to instrument code, it reads the log files your agents already write to disk — no SDK, no API key, no signup, no code changes. Setup is one curl command (or a Windows PowerShell script), and the app auto-detects agents including Claude Code, Codex, Gemini CLI, Cursor, GitHub Copilot, Qwen CLI, Antigravity, Grok Build, Cline, OpenCode, DeepSeek Harness, Qoder, Z.ai ZCode, Kimi Code, Vibe, SmallCode, Pi, Muse Code, Prime Agent and Hermes Agent, then serves a live UI at localhost:13000. It needs Node 18+ and Python 3.9+, runs offline, and never writes to your agent files. What you get on screen: a live KPI strip with 15-second auto-refresh, per-agent and per-model token and cost breakdowns, date-range filtering, replayable session traces with kind-aware highlighting, a project view tracking working directories with a 365-day heatmap and streaks, cache-efficiency metrics in Analytics, budget and alert configuration, and one-click LLM summarization into a narrative or a structured What/Tools/Why/Next brief. Cost anomaly detection flags silent reasoning-token waste. The Delegation & Ecosystem view breaks out subagent spend, skills used, and MCP servers. A native Electron shell is available for desktop use. Hermes Agent, from Nous Research, gets its own /hermes surface — gateway health, scheduled-job status, a source breakdown across 38 platforms (CLI, Telegram, Discord, Slack, Feishu, DingTalk, cron, webhook), per-API-call latency and cache-hit percentage parsed from agent.log, plus inline subagent delegation and Skills and Memory pages tracking loaded skills and MEMORY.md / USER.md char limits. A one-command plugin embeds a TokenTelemetry tab inside Hermes's own web UI on port 9119. Privacy is both the pitch and the constraint: two content-free outbound features — an hourly GitHub update check and anonymous product telemetry — are on by default but can be disabled in Settings or with DO_NOT_TRACK=1.

Behind the Verdict

The pitch is unusually honest: TokenTelemetry doesn't ask you to instrument anything. It scans the log directories your agents already populate — ~/.claude/projects/ for Claude Code, ~/.codex/sessions/ for Codex, ~/.gemini/ for Gemini CLI and Antigravity, ~/.cursor/ and workspaceStorage for Cursor, VS Code chatSessions for Copilot — and serves a read-only UI at localhost:13000. That read-only stance has real consequences worth understanding before you install. The agents must already be installed and logging on the same machine; there is no remote or server-side collection, so a teammate's spend is invisible to you unless you run it on their box. Nothing is written back to agent files, which means you can't use it as a control plane — this is observability, not orchestration. Where it earns its place is day-two questions: why did last week's spend spike (cost anomaly detection flags silent reasoning-token waste), which model is cheaper for this project (per-agent and per-model breakdowns with date-range filters), and what did that multi-step run actually do (replayable traces with tool calls, subagent delegation, plan-mode output, and an honest label on encrypted reasoning rather than pretending to decode it). Analytics adds cache-efficiency metrics and a Delegation & Ecosystem section covering subagent spend, skills used, and MCP servers — the last one being genuinely rare in local tooling. Summarization is one-click, into either a narrative or a structured What/Tools/Why/Next brief, cached by content hash, and requires configuring your own LLM. Projects gives one card per working directory with a 365-day heatmap and streaks, which is more useful than it sounds for spotting which repo is burning tokens. The Hermes surface is the standout: Hermes runs across CLI, Telegram, Discord, Slack, Feishu, DingTalk, cron and webhook — 38 source platforms — and TokenTelemetry is the only tool in this comparison that observes them as a single agent, with per-API-call latency and cache-hit percentage parsed from agent.log, 90 loaded skills with platform conditions, and MEMORY.md / USER.md char-limit progress bars. A separate one-command plugin ($ hermes plugins install VasiHemanth/tokentelemetry-hermes-plugin) puts a TokenTelemetry tab inside Hermes Dashboard on port 9119, though it is a launcher, not the engine — TT still has to be running on 13000. The constraints are real. It needs Node 18+ and Python 3.9+ locally. Two outbound features are on by default — the hourly GitHub update check and anonymous content-free product telemetry — and while both are one-click off in Settings → Usage & privacy or killable with DO_NOT_TRACK=1, organizations that block unsanctioned local services or curl-pipe-bash installers will need to clone and run it instead. There is no shared cloud dashboard, no multi-user seats, and no vendor SLA. The MIT license with 180 public commits and an allowlist test in the telemetry pipeline is the mitigating factor: you can read the

Researching Tokentelemetry? Get your full AI stack in 60 seconds.

Free, no signup — tell us your goal and get tools matched to your budget & existing stack.

Real-world workflow fit

Concrete scenarios for the personas Tokentelemetry actually fits — and what changes day-one when you adopt it.

Solo developer running Claude Code and Codex daily

You paste the one-line curl installer after noticing your API bill creeping up. TokenTelemetry scans ~/.claude/projects/ and ~/.codex/sessions/, detects both agents, and opens the dashboard at localhost:13000. You filter Analytics to the last 30 days and see Codex consuming three times the tokens per session on the same repo.

Outcome: You route refactoring work to Claude Code and cut the next month's spend without changing a line of your own code.

Hermes Agent operator running a bot across Telegram, Discord and cron

You install TokenTelemetry, then run 'hermes plugins install VasiHemanth/tokentelemetry-hermes-plugin' to add the tab into Hermes Dashboard on port 9119. The /hermes view shows gateway health, scheduled-job status, and a source breakdown across the 38 platforms, with per-API-call latency and cache-hit percentage parsed from agent.log.

Outcome: You spot that one cron job has a near-zero cache-hit rate and rewrite its prompt, cutting reasoning-token waste the cost anomaly detector had flagged.

Prompt engineer tuning reasoning-token usage

You open a long session in Traces, replay the tool calls and subagent delegation inline, then run one-click summarization into a What/Tools/Why/Next brief to see where the agent looped. The Analytics tab shows cache-efficiency metrics for the same run, and you set a budget alert for the project directory.

Outcome: You identify a redundant tool call pattern from the trace and the brief, and the budget alert catches it automatically the next time it recurs.

Use Cases

Limitations

  • TokenTelemetry is a local-first, read-only dashboard that reads logs your AI coding agents already write, so those agents must be installed and logging on the same machine — there is no remote or server-side collection.
  • Data stays in ~/.tokentelemetry/ locally, and the tool requires Node 18+ and Python 3.9+.
  • Two content-free outbound features (an hourly GitHub update check and anonymous product telemetry) are on by default but can be disabled independently in Settings → Updates & privacy or with DO_NOT_TRACK=1, while optional summarization requires configuring your own LLM.

as of 2026-10-09

Verification history

We have re-verified Tokentelemetry 9 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.

  1. — re-checked, vendor evidence unchanged
  2. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  3. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  4. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  5. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
  6. — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it

Showing the 6 most recent of 9 verification passes.

Free to cite with attribution — this page re-verifies continuously.

12-month cost

Project the real annual outlay, including the implied monthly cost when only an annual tier is published.

Annual total
Free
Over 12 months
Effective monthly
—
—

Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.

Plans compared

For each published Tokentelemetry tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.

Free

$0

Ideal for

Solo developers and Hermes Agent operators who want full local observability with no recurring cost or account

What this tier adds

Single MIT-licensed tier covering all 20 agents, the /hermes dashboard and the optional Hermes Dashboard plugin

Hidden costs & gotchas

What the public pricing page doesn't put in bold. Captured from pricing-page footnotes, contract terms, and recurring complaints.

  • Summarization is one-click but not free — you bring and pay for your own LLM API key, so heavy use of session briefs adds a separate model bill on top of your agent spend.
  • The dashboard is local to one machine, so auditing a team means installing and running it per developer; there is no central place to aggregate the numbers.

Where the pricing makes sense

The company stage and team size where Tokentelemetry's pricing actually pencils out — and where peers do it cheaper.

TokenTelemetry is MIT-licensed and free to run, so the cost comparison is against your own time and hosting rather than a subscription. Langfuse, LangSmith and Helicone are the nearest observability substitutes and all three are freemium: you get a hosted tier and a bill once you exceed it. TokenTelemetry trades that commercial support model for zero recurring cost and full local control, which fits solo developers and small shops far better than it fits teams needing seats and an SLA.

Setup time & first value

How long it actually takes to get something useful out of Tokentelemetry — broken out by persona, not the marketing-page minute.

Solo developer: under five minutes — paste the curl command (or run the PowerShell script on Windows), let it auto-detect your agents, and the dashboard opens itself. Hermes operators: add about two minutes for 'hermes plugins install VasiHemanth/tokentelemetry-hermes-plugin' and 'hermes dashboard', remembering the plugin only works while TT is already running on port 13000. Clone-and-run or

Switching to or from Tokentelemetry

How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.

Migrating in
  • →From manually reviewing your agent's own usage output: install with one curl command and get per-agent and per-model breakdowns with date-range filters across all 20 agents at once.
  • →From Langfuse or LangSmith: keep your existing SDK instrumentation for production apps and add TokenTelemetry alongside it purely for local coding-agent logs, since it needs no API key or code changes.
  • →From a spreadsheet of API invoices: run TokenTelemetry and let the 365-day heatmap and per-project cards replace manual tallying with session-level traces.
Migrating out
  • ↗To Langfuse or LangSmith: if you need a shared cloud dashboard with team seats and an SLA, re-instrument your app with their SDK, since TokenTelemetry's local read-only model has no cloud counterpart to export to.
  • ↗To Helicone: route your LLM calls through its proxy if you want hosted observability with an account rather than a local Node 18+ / Python 3.9+ runtime.

Integrations

Claude CodeCodexGemini CLICursorGitHub CopilotAntigravityQwen CLIOpenCodeGrok BuildClineDeepSeek HarnessHermes AgentQoderKimi CodeZ.ai ZCode

Resources & Guides

Tutorials & Learning

YouTube returned 6 videos for “Tokentelemetry”, and we withheld 6: 6 could not be judged, because “Tokentelemetry” is a single word that other videos use for other things. We are showing none, because we could not prove any of them are about Tokentelemetry.

Official links

Tools that pair well with Tokentelemetry

Common stack mates teams adopt alongside Tokentelemetry, with the specific reason each pairing earns its keep.

Featured Head-to-Head Comparisons

Alternatives to Tokentelemetry

View all
LangSmith

LangSmith

LangSmith is agent and LLM observability: trace, monitor, and evaluate AI agents in cloud, BYOC, or self-hosted.

FreemiumTry
Langfuse

Langfuse

Open-source LLM observability and agent evals: trace, evaluate, and improve production AI agents with MIT-licensed tooling.

FreemiumTry
Honeycomb Query Assistant

Honeycomb Query Assistant

Honeycomb Query Assistant turns plain-English questions into HQL against live production telemetry.

FreemiumTry

Frequently Asked Questions

Used Tokentelemetry? Help shape our editorial sentiment research.