Core Job and Data Path
CodeBurn is designed to answer where an AI coding budget went and whether that spend produced useful engineering work. Its official project describes local parsing across 32 tools and agents, with breakdowns by task, model, tool, project, and provider. It reads the session files those tools already write, so adoption does not require a gateway, wrapper, API key, or change to the request path. That architecture makes it a practical fit for individual developers and platform teams that first need an evidence trail from local activity before considering a centralized observability product.
Tokscale follows the same privacy-friendly starting point but emphasizes multi-client token accounting and visualization. Its current README lists a wide matrix of coding clients and local data locations, including Claude Code, Codex, OpenCode, Cursor exports, Gemini CLI, Copilot CLI, Kimi, Qwen, Roo Code, Kilo, and many newer agents. A native Rust core handles parsing and aggregation, while the interactive TUI exposes overview, model, daily, hourly, statistics, and agent views. The comparison is therefore not local versus cloud; it is diagnostic workflow versus a broader usage dashboard and community-facing presentation layer.
Cost Accuracy and Model Coverage
CodeBurn prices calls with a LiteLLM-derived catalog refreshed daily and separates input, output, cache-write, and cache-read costs where source logs expose them. The project also documents source-specific caveats: Cursor Auto costs are estimates because the underlying model is hidden, while Gemini and other clients may expose more precise token categories. This labeling is valuable because a cost dashboard can look exact while depending on incomplete upstream logs. CodeBurn’s compare and overview views are most useful when teams preserve those caveats and treat estimated rows as directional rather than invoice reconciliation.
Tokscale also uses current LiteLLM pricing, keeps a short-lived local pricing cache, and documents fallbacks for newly released models. Its detailed views include input, output, cache read and write, and reasoning tokens when available. The breadth of supported clients is a major advantage, but it creates the same normalization challenge: some tools expose native token counts, some require exports or local synchronization, and some provide aggregate usage only. Buyers should validate two or three representative sessions against vendor billing before using either product for chargeback, especially when Auto routing, subscriptions, or model aliases obscure the billed model.
Analytics, Optimization, and Reporting
CodeBurn goes beyond spend totals with an optimize workflow that looks for repeated file reads, poor read-to-edit patterns, noisy shell output, unused MCP schemas, bloated instruction files, cache overhead, and expensive sessions with weak delivery signals. Its compare view evaluates models using retry, one-shot, self-correction, cost-per-call, cost-per-edit, cache-hit, and related workflow metrics. The yield command correlates sessions with Git commits and classifies spend as productive, reverted, or abandoned. These are vendor-defined heuristics rather than audited ROI measurements, but they create a more actionable path from cost observation to a change in agent configuration.
Tokscale concentrates on flexible exploration and presentation. Its TUI provides several time and agent views, filters by platform and date, exports JSON, and can generate contribution-style visualizations. Task-attributed reports can group sessions through supported local or model-backed summarizers, while subscription and usage views help developers understand how activity changes over time. The optional submit flow can publish usage to a leaderboard and public profile, which is useful for community participation but should be treated as an explicit data-sharing decision. Teams that only want private local accounting can leave that social path unused.
Setup, Performance, and Privacy
CodeBurn can run through npx, npm, Bun, Homebrew, or a macOS menu-bar surface, with a local browser dashboard available for richer charts. It requires a supported Node.js release and access to the relevant local session directories. Everything is intended to remain on the machine unless the user chooses another export or sharing action. The main operational concern is permission scope: a cost tool that reads many agent histories can infer project names, model choices, timestamps, and workflow patterns even when prompt text is not uploaded, so organizations should define who may install it on managed developer devices.
Tokscale ships prebuilt native components behind familiar npx, bunx, and Deno entry points, giving it a responsive cross-platform TUI without asking most users to build Rust locally. Some providers are read directly from local databases or JSONL, while others rely on an explicit sync or cached export because the client does not expose a stable local transcript. Its optional social and autosubmit features should be reviewed separately from core local analysis. For regulated environments, the safer default is local-only use, disabled submission, a documented retention policy, and a review of which session directories the process can read.
Team Fit and Buying Tradeoffs
CodeBurn is the better fit when the question is not merely how many tokens were consumed but which projects, task types, model choices, retries, and configuration patterns drove the bill. Its waste findings, model comparisons, budget guardrails, and delivery correlation give engineering leaders several ways to turn local evidence into policy. It remains an open-source local tool rather than a managed enterprise cost platform, so central aggregation, identity controls, retention governance, and authoritative billing reconciliation still require separate systems. That limitation is acceptable for developer-level diagnosis and important for enterprise buyers to state clearly.
Tokscale is compelling for developers who value a polished, fast terminal experience, broad support for emerging agents, flexible time views, and shareable visualizations. Its public profile and leaderboard model also gives it a community dimension that CodeBurn does not center. The tradeoff is that dashboards and social output do not automatically produce an optimization program; teams must still decide which behavior to change and how to measure improvement. Tokscale can therefore be the better personal usage journal, while CodeBurn is more naturally positioned as a local FinOps diagnostic tool for coding-agent workflows.
Verdict: CodeBurn Wins the Default Recommendation
Choose Tokscale when the primary goal is a high-performance multi-agent token dashboard with extensive client coverage, contribution graphs, date filtering, JSON export, and an optional social layer. It is especially appealing to developers who rotate among new coding agents and want one visual timeline without deploying a proxy. Before enabling submit or autosubmit, confirm what leaves the device and whether project or usage metadata can be public. Also validate any estimated or synchronized provider rows against billing, because source quality varies by client regardless of the dashboard used.
Choose CodeBurn when cost analysis must lead to a concrete engineering decision. Its project and task breakdowns, retry and cache metrics, waste detectors, budget guard, model comparison, and shipped-work correlation cover more of the optimization loop while preserving a local-first data path. That breadth earns CodeBurn the winner relation in this comparison. The conclusion is based on documented product scope rather than a controlled benchmark, and Tokscale remains a credible choice for visualization and community sharing; CodeBurn simply provides the stronger default toolkit for diagnosing and reducing coding-agent spend.