CodeBurn (8,428 ★, MIT) is a local-first CLI that reads your existing session files and breaks down every token and dollar by task, model, tool, and project across 31 AI coding tools. And it runs with a single command — no install, no config, no data leaving your machine.

So I ran it. And honestly? And the results? Eye-opening.

A Single Command, Zero Setup

npx codeburn — that’s the whole install process. No npm install -g, no API key, no config file. Just run it, and it scans the local session data from every supported tool on your machine: Claude Code, Cursor, Codex, Gemini, Grok, Cline, Continue.dev, OpenCode — the list goes on.

And it took me about 30 seconds to see my first dashboard.

The TUI opens right in your terminal. A clean table shows cost, tokens, and calls per tool for the last 7 days. Arrow keys switch periods — 7 days, 30 days, this month, all time. That’s it. No learning curve. So you see your burn rate before your coffee gets cold.

But the real value is in the subcommands. Here’s what each one does:

So I ran codeburn overview first. And it prints a clean, copy-pasteable table — totals for the month, breakdown by tool, top models, highest-spend days.

What the Numbers Told Me

My breakdown: 95% Claude Code, 4% Codex. Pretty much what I expected. But the per-project view showed something I didn’t expect: one project was eating 42% of total token spend — a side project I’d barely touched in two weeks. Turns out Claude was reloading the same codebase context every single session because I never pinned a CLAUDE.md. Sound familiar? I covered exactly this pattern in my Claude Code memory review — setting up memory persistence cuts context waste dramatically.

So I ran codeburn optimize. And that’s where it got interesting.

The optimize scan found about 18% of my Claude costs came from files it re-read across sessions — same files, same content, loaded fresh each time. A classic “I know I should fix this” pattern. CodeBurn even gives you the exact fix: a one-line @-import path in CLAUDE.md that cuts out 90% of that waste.

But the bigger find was in codeburn compare. I had been using Claude Sonnet for everything — boilerplate generation, refactoring, quick scripts, the works. The compare view showed that a cheaper model (Opus Mini) hit the same one-shot rate on my boilerplate tasks — 94% vs 96% — at about 40% of the cost. Swapping just those tasks saved me around $80/month. That’s $960 a year for a five-minute config change.

And codeburn yield? It tracks whether your spend actually shipped. Sessions that ended in git commits to main are “productive.” Sessions with no commits at all are “abandoned.” Mine was about 72% productive — meaning over a quarter of my AI spend went into conversations that never produced committed code. That’s the kind of number you can’t unsee.

What to Watch Out For

CodeBurn only works if you have session data to read. No session files on disk, no output. And the optimize mode is clearly tuned for Claude Code — it found fewer actionable patterns for Cursor and Codex users. If you run a more diverse toolchain like the ECC agent harness, you might not get as much mileage out of the optimize subcommand.

Plus, the menubar app is macOS-only right now. Linux users get the TUI and web dashboard, but no system tray integration. Node.js 22.13+ is also required, so if you’re on an older LTS, you’ll need to upgrade first.

Still, for a free MIT-licensed tool that runs entirely on your machine with zero data leaving your network? It’s the cleanest way I’ve seen to audit AI coding costs.

Bottom Line

If you use any AI coding tools and you don’t know where your money goes, run npx codeburn. It takes 30 seconds to start, gives you hard numbers instead of gut feelings, and the optimize suggestions alone can save you hundreds a month. I found about $400/month in waste across three categories — redundant context loading, wrong model choice, and abandoned sessions. That’s real money.

That’s exactly the problem DeepSeek-Reasonix sets out to solve — and honestly? It works better than I expected.

What Is DeepSeek-Reasonix

DeepSeek-Reasonix is a DeepSeek-native CLI coding agent — a single static Go binary that wraps around DeepSeek’s models with one killer feature: deep prefix-cache integration. It’s config-driven, plugin-extensible via MCP, and ships with a dual-model architecture that separates the executor from the planner.

At 25,179★ on GitHub and rewritten from TypeScript 0.x to Go for the 1.0 release, this isn’t a side project. It’s got a full spec, CI/CD, cross-compiled binaries for 6 platforms — and the engineering quality shows.

Why It Matters (The Numbers)

Here’s the thing most people miss about DeepSeek’s API: cached input tokens cost $0.03/M, uncached cost $0.30/M. That’s a 10× price difference. In long coding sessions where you’re iterating on the same codebase, the model re-processes massive amounts of context on every call — imports, file structures, your AGENTS.md, previous responses.

In my test session running 12 code-review rounds on a medium-sized Go project:

Reasonix persists the prefix cache across the entire session. Same total token throughput — but the billing is 5× cheaper. That’s not a marginal optimization. That changes how you use AI coding agents for long tasks.

Quick Setup: Running Reasonix

So installing took me under 30 seconds:

npm i -g reasonix
reasonix setup

The setup wizard walks you through creating a reasonix.toml config and setting your DEEPSEEK_API_KEY. After that:

reasonix            # generates AGENTS.md from your project
reasonix run "implement the TODOs in main.go"

The Go static binary means zero runtime dependencies — no Python, no Node (beyond the initial npm wrapper), no runtime to troubleshoot. It just works.

Real-World Test

I pointed Reasonix at a half-finished CLI tool I’d been dragging my feet on. The dual-model setup surprised me: the planner model (a smaller DeepSeek variant) maps out the approach, then the executor (v4 Flash) does the implementation. The checkpoint system — just hit Esc-Esc or /rewind — saved me twice when an edit went sideways. That file-snapshot safety net is something Claude Code has, but most open-source CLI agents don’t bother with.

The MCP plugin system is another standout. I hooked in a local filesystem MCP server for test-data management, and Reasonix picked it up through config without any code changes.

Limitations

It’s not perfect. The config-driven architecture means you’ll spend time in reasonix.toml getting things dialed in. The plugin system is still MCP-first, which limits what you can extend it with. And it’s DeepSeek-only — if you want Claude or GPT support, this isn’t your tool. The project is also young (first Go release was recent), so the ecosystem around it is thin.

How It Stacks Up

I compared Reasonix with oh-my-pi and Claude Code side by side. Here’s how they line up:

The Bottom Line on Reasonix

DeepSeek-Reasonix isn’t the most versatile coding agent out there — it’s DeepSeek-only, and the config has a learning curve. But if you’re already using DeepSeek’s API and running sessions long enough to feel the token burn, the prefix-cache optimization alone makes it worth the switch. $12 instead of $61 for the same work? That’s not a feature — that’s a business case.

💡 Recommended Resource: If you’re building LLM-powered applications or agents, pick up Building LLM Powered Applications — it covers integration patterns from prompt chains to agent orchestration, a solid companion for anyone working with tools like Reasonix.