# CodeBurn Alternatives: 6 Tools Compared

> Six CodeBurn alternatives, split between tools that measure the burn and tools that lower it, ranked on measured session cost, agent coverage, privacy and licence.

Source: https://tokenade.net/en/comparisons/alternatives/codeburn-alternatives · Updated: 2026-10-28

## What should you use instead of CodeBurn?

If CodeBurn already showed you a number you don't like, use Tokenade: it sits between your AI agent and its tools and is the only tool on the open THOL benchmark that measurably lowered what a session costs. If you only want a different meter, ccusage is the lightest and tokscale the most social.

That split is the whole page. CodeBurn measures the burn. Most of the tools it gets compared with also measure the burn. Very few of them change it, and the ones that claim to rarely prove it on a whole session.

CodeBurn deserves its reputation. It is a free, local, MIT-licensed tracker from AgentSeal, with about 11,500 GitHub stars when I checked and a release on 2026-10-11. `npx codeburn` reads the session files 42 AI coding tools already write to disk and prices every token, with no account, no API key and no proxy.

Disclosure before the ranking: I maintain the THOL benchmark and I build Tokenade. The benchmark is public and reproducible, and it includes results that don't flatter my tool, but it is not an independent third party.

Features read on each project's GitHub README and site on 2026-10-15. Session-cost figures come from the published THOL campaign (Claude Code 2.1.206, Claude Sonnet 4.6, long sessions), the only one this site quotes.

## What does CodeBurn do well, and where does it stop?

**CodeBurn is an excellent meter with a light layer of advice on top, and it stops at the edge of the session: it reads what happened, it doesn't change what your agent reads next.**

What it does well:

- **Breakdown.** Cost by tool, model, project, git branch and task type (coding, debugging, planning), worked out from the sessions themselves.
- **One-shot rate.** The share of edit turns that needed no retry, per model and per task, plus `codeburn compare` to set two models side by side on your own history.
- **Surfaces.** A terminal dashboard, `codeburn web`, desktop apps for macOS, Windows and Linux, a menu bar or tray readout, a VS Code extension and a local MCP server.
- **Limits.** `codeburn quota` reads live plan limits, and the opt-in Guard adds Claude Code hooks that warn a session at $5 and stop it at $15 by default.

Where it stops:

- **`codeburn optimize` fixes configuration, not traffic.** It flags unused MCP servers, an oversized `CLAUDE.md` and files re-read every turn, and can apply and undo fixes. Its savings figures are its own estimates; to its credit, `codeburn act report` checks each one against your later sessions.
- **Nothing sits in the path.** Command output, file reads and MCP results reach the model at full size, every turn.
- **Not measured end to end.** CodeBurn isn't in the published THOL campaign, so there is no session-cost figure for it.
- **Small print.** It needs Node.js 22.13+, and the desktop apps ask about anonymous telemetry on first launch, with the toggle on by default outside the EU, EEA, UK and Switzerland.

## The short list

| Tool | What it is | Entry price | Best for |
|------|-----------|-------------|----------|
| Tokenade | A binary between your agent and its tools: output filtering, file-read trimming, code search, with a local savings dashboard | Free, open source (MIT/Apache-2.0) | A measured drop in session cost |
| ccusage | A CLI meter over local agent transcripts | Free (MIT) | The lightest pure meter |
| tokscale | A Rust-core TUI meter with an opt-in public leaderboard | Free (MIT) | Many agents, contribution graphs |
| context-mode | A sandbox for tool output, with stats and a hosted dashboard | Free (Elastic License 2.0) | Deep Claude Code analytics |
| rtk | A Rust proxy that filters shell output, with `rtk gain` | Free (Apache-2.0) | Free command-output filtering |
| Claude Code `/usage` + Console | The first-party usage views | Included | Zero install, Claude only |

> Measuring the burn is step one. Tokenade is step two: it trims command output, file reads and MCP results before your agent pays for them.
>
> Install: `npm install -g @tokenade/cli && tokenade install` — or let your agent do it: https://tokenade.net/install.md

## How did we rank them?

**Five criteria, applied identically to every entry including mine, with measured session cost first because it's the only one that shows up on the invoice.**

- **Measured session cost.** End to end, against a no-tool control, from THOL. Where a tool isn't in the campaign, the table says "Not measured" and any vendor figure stays in prose, attributed, with its scope.
- **Does it lower token use, or only report it.** The line this page is built on.
- **Agent coverage.** One agent, or the whole stack CodeBurn reads.
- **Where data goes.** Fully local, opt-in upload, or a hosted dashboard.
- **Licence.** Including the restrictions people find late.

## 1. Tokenade — the one that lowers the number

**Tokenade is the CodeBurn alternative to pick when the meter has done its job, because it is the only tool on the open THOL benchmark that measurably reduced what a session costs.**

- **What it is:** a binary between your AI agent and its tools. It filters command output, trims file reads to structure first, folds MCP results and runs on-device code search. It hooks into Claude Code, Codex, Cursor, Copilot and other agents.
- **Strengths:** on long sessions it makes a session 39% cheaper than the agent on its own. That is the gap between CodeBurn's two halves: CodeBurn can tell you a file is re-read every turn, Tokenade shrinks what that read costs while the session runs. Compaction is local, so nothing it trims leaves your machine.
- **Its own meter:** `tokenade dashboard` opens a local, graphical report you can explore, `tokenade gain` prints a quick summary in the terminal and `tokenade receipt` signs the totals. The [gain, dashboard and receipt docs](https://tokenade.net/en/docs/gain-dashboard-receipt) cover all three, and [how savings are measured](https://tokenade.net/en/docs/savings-measurement) explains what counts.
- **Limitations:** it's my product, so weight this accordingly. Its dashboard counts savings, not your whole spend by project and branch, so plenty of people keep a meter like CodeBurn next to it.
- **Best for:** anyone who wants the bill to move, on more than one AI agent.

## 2. ccusage — the lightest pure meter

**ccusage is the CodeBurn alternative if you want a meter and nothing else: one command, a table, done.**

- **What it is:** the CLI that started this category, with about 19,000 GitHub stars. It reads local transcripts from Claude Code, Codex, OpenCode, Amp, Gemini CLI and more than a dozen other sources. MIT.
- **Strengths:** `npx ccusage@latest` or `bunx ccusage` reports spend by day, week, month and session, and `ccusage blocks` maps Claude Code's 5-hour billing windows. JSON output feeds your own scripts.
- **Limitations:** no desktop app, no task-type or one-shot view, no optimizer. Like CodeBurn, it **lowers nothing**: it is a thermometer. Not in THOL.
- **Best for:** people who found CodeBurn's surfaces more than they needed. The full field of meters is on [ccusage alternatives](https://tokenade.net/en/comparisons/alternatives/ccusage-alternatives).

## 3. tokscale — the meter with a leaderboard

**tokscale is the CodeBurn alternative for wide agent coverage in a fast terminal UI, with an optional public profile.**

- **What it is:** a CLI and TUI with a native Rust core, run with `npx tokscale@latest` or `bunx tokscale@latest`. Its README lists more than 40 clients, from Claude Code, Codex and Cursor to Gemini CLI, OpenCode and Copilot CLI. MIT, about 5,700 stars.
- **Strengths:** ten TUI views (models, daily, hourly, sessions, projects, agents and more), cache and reasoning tokens tracked separately, LiteLLM pricing with an OpenRouter fallback, and JSON export. `tokscale submit` posts your totals to the leaderboard at tokscale.ai after a GitHub login; the local viewer works without submitting.
- **Limitations:** a meter again, so it **lowers nothing**. The leaderboard ranks who burns the most tokens, which is a strange thing to optimise for if your goal is a smaller bill. Not in THOL.
- **Best for:** developers who want CodeBurn-style coverage in a TUI and enjoy a public contribution graph.

## 4. context-mode — analytics with a sandbox attached

**context-mode is the CodeBurn alternative if you live in Claude Code and want both visibility and a tool that keeps raw output out of the context window.**

- **What it is:** a Claude Code plugin, also wired into other platforms over MCP and hooks, that runs tool calls in a sandbox and indexes their output in a local SQLite knowledge base. `ctx_stats` reports context savings and call counts, and `ctx insight` opens a hosted Insight dashboard.
- **Strengths:** it is the only entry here, besides Tokenade, that acts on the session instead of reporting it afterwards. The project advertises a 98% reduction, measured on the sandboxed tool output it intercepts, not on whole-session cost.
- **Limitations:** licensed under the Elastic License 2.0, so it is source-available, not open source: you can't offer it as a hosted service. The Insight dashboard is hosted, unlike CodeBurn's fully local views. It isn't in the published THOL campaign, so **not measured** on session cost.
- **Best for:** Claude Code users who want per-session analysis and are fine with the licence. See [Tokenade vs context-mode](https://tokenade.net/en/comparisons/tokenade-vs-context-mode).

## 5. rtk — free filtering, with its own gain counter

**rtk is the CodeBurn alternative if you want a free tool that actually touches token use, and you accept it touches one layer only.**

- **What it is:** a single Rust binary that intercepts shell commands and compresses their output before your agent reads it, with 100+ supported commands. Apache-2.0.
- **Strengths:** the easiest install in this space, and `rtk gain` gives a per-command savings view backed by SQLite. The project advertises 60–90% fewer tokens, measured on the output of common dev commands.
- **Limitations:** its README notes the hook only fires on Bash tool calls, so built-in `Read`, `Grep` and `Glob` pass straight through. In THOL it showed **no measurable difference** in session cost.
- **Best for:** a zero-budget first step on noisy command output. See [rtk alternatives](https://tokenade.net/en/comparisons/alternatives/rtk-alternatives).

## 6. Claude Code `/usage` and the Claude Console — already installed

**The first-party views are the CodeBurn alternative if Claude is your only agent and you'd rather install nothing.**

- **What it is:** `/usage` inside Claude Code. On the API it shows the session's total cost, duration and usage per model; on Pro, Max, Team or Enterprise it shows plan usage bars and a breakdown of what counts against your limits. The Console usage page covers API spend, with workspace spend limits.
- **Strengths:** authoritative, free, and nothing to trust but the vendor that bills you.
- **Limitations:** Claude only, no task types, no one-shot rate, no cross-tool view. It **lowers nothing** either. [Claude usage limits explained](https://tokenade.net/en/articles/claude-usage-limits-explained) covers what the bars mean.
- **Best for:** single-agent setups and a sanity check on any third-party meter.

## At a glance

| Tool | Measured session cost (THOL) | Lowers token use? | Agents covered | Data stays local? | Licence |
|------|------------------------------|-------------------|----------------|-------------------|---------|
| Tokenade | 39% cheaper on long sessions | Yes, in the session | Most major AI agents | Yes | Free, open source (MIT/Apache-2.0) |
| ccusage | Not measured | No | 15+ sources | Yes | MIT |
| tokscale | Not measured | No | 40+ clients | Yes, unless you submit | MIT |
| context-mode | Not measured | Yes, tool output | Claude Code first | Insight is hosted | Elastic License 2.0 |
| rtk | No measurable difference | Yes, shell output | Agents with command hooks | Yes | Apache-2.0 |
| Claude Code `/usage` | Not applicable | No | Claude only | Vendor-side | Included |
| *CodeBurn (baseline)* | *Not measured* | *Config fixes only* | *42 tools* | *Yes; app telemetry asked at launch* | *MIT* |

The full leaderboard, including the tools that don't favour mine, is on the [THOL explainer](https://tokenade.net/en/thol), and the raw numbers are in the [token optimizer benchmark](https://tokenade.net/en/stats/token-optimizer-benchmark).

## Why doesn't measuring the burn lower it?

**Because a meter reads the bill after the tokens are spent, and most of a long session's cost is context the agent re-sends at every step.** Knowing which project burned the most doesn't shrink the next tool result.

CodeBurn's optimizer goes one step further than a pure meter: removing an unused MCP server or trimming `CLAUDE.md` does take tokens off every request. But the bulk of a long session is what tools return and what the transcript replays. Changing that needs something in the path, and then a controlled test to show it worked. [Measure agent token usage](https://tokenade.net/en/articles/measure-agent-token-usage) shows how to run that test on your own setup.

## Which one should you choose?

- **You want the bill to go down, on more than one AI agent:** Tokenade, with CodeBurn or ccusage beside it as an independent meter.
- **You want the lightest possible meter:** ccusage.
- **You want a fast TUI over 40+ clients and a public profile:** tokscale.
- **You live in Claude Code and want analytics plus a sandbox:** context-mode, licence checked first.
- **You want something free that trims command output:** rtk.
- **You only use Claude and want nothing to install:** `/usage` and the Console.
- **You're staying on CodeBurn:** sensible if the itemised view is what you needed. Run `codeburn optimize`, then `codeburn act report` a few days later.

Tokenade is free and open source (MIT/Apache-2.0). Setup takes two commands; see the [install guide](https://tokenade.net/en/docs/install).

## FAQ

**Is CodeBurn free?**

Yes. CodeBurn is MIT-licensed and free, as a CLI (`npx codeburn`), through npm or Homebrew, or as desktop apps for macOS, Windows and Linux. It needs no account or API key; prices come from LiteLLM and refresh daily.

**Does CodeBurn reduce token usage?**

Not by itself. It reports usage, and `codeburn optimize` suggests configuration fixes, such as removing unused MCP servers or shortening `CLAUDE.md`, that you can apply and undo. It doesn't compress what tools return during a session, and it isn't in the THOL benchmark.

**Is CodeBurn a good ccusage alternative?**

As a meter, yes: its site positions it as a privacy-first ccusage alternative, and it adds more tools, a desktop app, task types and a one-shot rate. Neither one lowers the bill. The head-to-head of ccusage against an optimizer is on [ccusage vs token-optimizer](https://tokenade.net/en/articles/ccusage-vs-token-optimizer).

**Does CodeBurn send my data anywhere?**

The CLI reads session files on disk and makes no upload, and its MCP server makes no network call of its own. The desktop app and Windows tray can send anonymous usage reports if you allow it on the first-launch consent screen, and you can turn that off in settings.

**Can I use CodeBurn and Tokenade together?**

Yes, and it's a good pairing: Tokenade trims what reaches the model, CodeBurn shows the spend that remains. Compare a week before and after with `codeburn compare` rather than trusting either tool's own counter.

---

**See also:**

- [ccusage alternatives](https://tokenade.net/en/comparisons/alternatives/ccusage-alternatives) — the same question for the original meter
- [Tokenade vs ccusage](https://tokenade.net/en/comparisons/tokenade-vs-ccusage) — meter against optimizer, attribute by attribute
- [rtk alternatives](https://tokenade.net/en/comparisons/alternatives/rtk-alternatives) — the same question for command-output filters
- [Cut Claude Code costs, keep the model](https://tokenade.net/en/articles/cut-claude-code-costs) — the levers, ranked by what they're worth
- [Token optimizer benchmark](https://tokenade.net/en/stats/token-optimizer-benchmark) — the numbers behind this ranking
- [Install Tokenade](https://tokenade.net/en/docs/install) — two commands