AI支出追踪

Questions

My spend

<details> <summary><strong>I know what the month cost. How much of it was wasted, and how would I know?</strong></summary>

Run codeburn optimize. It reads the last 30 days of sessions and your ~/.claude/ config, lists what cost tokens without earning them, and prints a Potential savings line in tokens and dollars for the period it scanned. Findings come in three groups: Fix now, which CodeBurn can apply for you, Habits, which is how you drive the next session, and FYI, which may well be money well spent. Each finding says whether its number is measured from your own token counts or modelled from an average. The setup gets a grade from A to F, and that grade rates the config, not the spending, so an expensive month with a clean setup still scores an A. See Optimize.

</details>

<details> <summary><strong>Which sessions burn the most, and why?</strong></summary>

The desktop Overview and the terminal dashboard both list the five most expensive sessions. Click one in the app and you land on Sessions with the drawer open on it: project, models, tokens, and the per-model, per-category, per-branch and per-day split of that one session. codeburn sessions is the same list in the terminal. codeburn optimize flags sessions that cost more than twice their own project's average. The drawer usually shows the cause, such as one model doing most of the work or one category taking most of the turns. See Drill-through.

</details>

<details> <summary><strong>My agent spent an hour on a five-minute task. Where did the money go?</strong></summary>

Open that session in the Sessions drawer for the per-turn cost, then run codeburn context and pick it from the list. codeburn context prints what filled the context window: assistant split into text, reasoning and tool calls with a row per tool, user split into text, images and compaction summaries, and tool with the tool-result total, which is usually the biggest line. It also counts how many compactions happened, which is the usual sign of an hour spent re-reading. The block sizes are estimated from character counts. The exact context figure comes from the last call's reported usage, and the output labels it as such.

</details>

<details> <summary><strong>Is Opus worth it, or would Sonnet have done the same job?</strong></summary>

Run codeburn compare, or press c in the dashboard, to put two models side by side on your own history: one-shot rate, retry rate, self-correction, cost per call, cost per edit, cache hit rate. Cohorts mode narrows that to the same kind of work, one row per edit turn, with median and P90 cost per edit turn and the sample list you can read yourself. Turns that mixed two models are excluded and counted, never assigned to one. codeburn optimize goes further and prints a Model defaults recommendation when a project has enough edit turns to judge: a cheaper model you already used there whose one-shot rate held up, applied with codeburn act apply-model <project>. See Cohort comparison.

</details>

<details> <summary><strong>Which project costs the most, and which branch inside it?</strong></summary>

Open the Spend page and pick a project in the By branch panel. Each branch row shows its cost, calls, tokens, distinct sessions and activity window, attributed turn by turn, so a session that switched branches lands on both rows with its own slice instead of counting twice. From the terminal the same report is codeburn spend --format branch-json. Branch is recorded per turn by Claude Code and by almost nothing else, so the coverage note under the rows splits the project three ways: spend on named branches, spend before a branch was recorded, and spend from tools that carry no branch at all. See Spend by branch.

</details>

<details> <summary><strong>Do my subagents cost more than they save?</strong></summary>

codeburn sessions --by-work-unit gives one row per orchestration root with its delegated children folded underneath, so the parent and its fan-out read as one number. codeburn models --by-agent splits each model's spend by the Claude subagent that drove it, with main sessions and other tools bucketed under main. The dashboard has a Claude Agent Types panel with calls and cost per agent type, and Delegation is one of the task categories. CodeBurn tells you what the fan-out cost. Whether the same work would have been cheaper in one long session is not something it can measure.

</details>

<details> <summary><strong>What did that pull request cost me?</strong></summary>

The app has a Pull requests page, and codeburn sessions --by-pr is the same report in the terminal. It groups spend by the PR links your sessions recorded, and expanding a row takes you to the sessions behind it. Turns that touched more than one PR contribute their share to each, so the rows are not an exclusive split, and spend tied to no PR is labeled rather than hidden. The links come from what the session wrote down, so CodeBurn never calls GitHub and never checks whether the PR merged. For that part, codeburn yield correlates sessions with commits and sorts the spend into productive, reverted and abandoned, and the Overview's Cost per outcome panel shows cost per commit and cost per productive session. See Yield.

</details>

Subscriptions and limits

<details> <summary><strong>I pay a flat fee for Claude Max. Why does CodeBurn show me dollars?</strong></summary>

The dollar figure is what your tokens would have cost at API rates. It is not an invoice. The card labels it API-equivalent, not a live provider window. It is still the only per-session, per-project, per-model number you can get on a subscription, because a subscription gives you one price and no breakdown. Run codeburn plan set claude-max and the Plans page then shows what you have spent this cycle as a share of the plan, and whether you are on track or on pace to exceed it. See Plans and quota.

</details>

<details> <summary><strong>I keep hitting my 5-hour or weekly limit. Can I see it coming?</strong></summary>

codeburn quota asks each provider how much of your plan is left, signing the request with the credential that tool already stores on your machine. For Claude that is a 5-hour row and a weekly row, each with a percentage used and a reset time, shown as 42% used · resets in 3h 20m on the Plans page's Live quota panel. The Capacity Dock carries the same reading, and the macOS menu bar can carry a second line with quota remaining and its countdown. CodeBurn does not predict the hour you will run out. What you get is how full the window is and when it clears.

</details>

<details> <summary><strong>Is my plan the right size, or am I paying for capacity I never use?</strong></summary>

Set what you pay for with codeburn plan set claude-max, or claude-pro, cursor-pro, copilot-pro, google-ai-pro, or custom --monthly-usd 200 --provider codex. The Plans page then shows spend this cycle against that budget with a pacing line, either On track or on pace to exceed with the projected figure and the date. After two or three cycles the pattern is clear. Consistently under a quarter of the plan means you are buying capacity you do not use, and consistently over means the cheaper plan is costing you. CodeBurn shows the share and the pace, and leaves the choice of plan to you.

</details>

<details> <summary><strong>Three tools, three subscriptions. What is my real total?</strong></summary>

Plans are stored per provider, so codeburn plan set claude-max, codeburn plan set cursor-pro and a custom Codex plan sit side by side rather than blending into one figure. codeburn plan prints them all, and the app carries one card per active plan with its own spent, percentage and overage. The spend tables stay per tool underneath, so you can see which subscription is carrying the work and which one is idle. Copilot is tracked in AI credits rather than dollars, because credits are what Copilot actually meters.

</details>

How my agent works

<details> <summary><strong>My agent reads the same file twenty times. How do I see that and stop it?</strong></summary>

codeburn optimize has a detector for exactly this, reported as "Claude is re-reading the same files" with the files and what the re-reads cost. Next to it sit reads into node_modules, .git and dist, and sessions that edit far more than they read first. Those two are the ones a written rule can fix: codeburn optimize --apply appends a marker block to the current project's CLAUDE.md, shows you the file before it writes, and backs it up under ~/.config/codeburn/actions/. codeburn act undo --last puts it back. The re-read finding itself has no file to edit, so the fix there is how you open the next session.

</details>

<details> <summary><strong>How much of my context is tool output, and what is it costing me?</strong></summary>

Run codeburn context and pick a session. It works for Claude Code and Codex, and gives you a tree: assistant split into text, reasoning and tool calls with a row per tool, user split into text, images, compaction summaries and meta, then tool with the tool-result line, and system. The headline shows the exact context size from the last call's usage next to the model's window. The tree counts tokens rather than dollars, because that context is re-sent every turn and its price depends on how much of it came from cache. For the dollars over a period, codeburn models prices the same sessions.

</details>

<details> <summary><strong>Which MCP servers and skills am I paying for but never using?</strong></summary>

codeburn optimize compares what is configured against what was actually invoked. It names MCP servers configured but never called, servers with many tools and almost none used, and skills, agents and slash commands that are defined and never invoked. An MCP server's tool schemas ride along in the prompt whether you call it or not, so an unused one costs tokens on every turn. codeburn optimize --apply removes the server entry from ~/.claude.json or the project's .mcp.json, and moves unused skills into ~/.claude/skills/.archived/ rather than deleting them.

</details>

<details> <summary><strong>How often does my agent actually get it right first try?</strong></summary>

The one-shot rate. It is the One-shot figure on the app's Overview, a column in the dashboard's activity table, and a per-model row in codeburn compare. A retry is counted when the same file is edited again after a shell command ran in between, which is the shape of an edit that did not work. Editing a different file after a shell step is not a retry. Coding at 90% means nine edit turns in ten needed no second pass. File-level tracking works for Claude, Codex and Goose. Other tools fall back to tool names, so their figure is rougher. See How it works.

</details>

<details> <summary><strong>How does CodeBurn know a session was coding rather than debugging or planning?</strong></summary>

From the tools the session used and the words in your own messages, with no model call anywhere. Edit and Write make it Coding. Error and fix words alongside tool use make it Debugging. pytest or vitest in a shell command makes it Testing. Read and Grep with no edits make it Exploration, and the Agent tool makes it Delegation. There are 13 categories and the rules are deterministic, so the same session always lands in the same category. The full table is in How it works.

</details>

Trust the numbers

<details> <summary><strong>On a subscription the dollars are an estimate. What is estimated and what is measured?</strong></summary>

The tokens are measured for most tools. Claude Code, Codex, Gemini, Zed, OpenCode and others write real per-call input, output and cache counts into their own session files, and CodeBurn reads those rather than guessing. The price applied to them is published API pricing, so the dollar figure is arithmetic on measured tokens, not a guess about your bill. A few tools record no counts at all, so Cursor, Kiro and some Copilot sessions are estimated from content length, and those are marked estimated in the tables. Claude Code also bills some calls it does not write to its transcripts: some advisor calls, and subagent replies that keep only part of their usage. For those, CodeBurn can show less than Claude Code's own cost counter. codeburn audit prints a row per provider and model saying where every number came from.

</details>

<details> <summary><strong>Where do the prices come from, and what if a vendor changes them?</strong></summary>

From LiteLLM, fetched and cached for 24 hours under ~/.cache/codeburn/, so a change reaches you within a day of LiteLLM picking it up. The common Claude and GPT models also carry bundled fallback prices, so a lookup miss falls back to a known rate for those. Anything else shows as unpriced rather than guessed. If a model shows $0 its name matched no price row. codeburn models --unpriced lists those ids, codeburn model-alias points a proxy-rewritten name at the real model, and codeburn price-override sets exact rates yourself. A session is priced with today's rates when it is read, not with the rates of the day it ran. See Configuration.

</details>

<details> <summary><strong>Claude Code deletes its sessions after 30 days. Does my history go with them?</strong></summary>

The daily numbers do not. CodeBurn keeps a durable daily history under ~/.cache/codeburn/, holding each day's cost, tokens and per-project and per-model split for ten years, so codeburn report and codeburn status keep answering for days whose transcripts are gone. The per-session detail does go, because it only ever lived in the transcript. So anything that reads sessions, codeburn sessions, models, spend and compare-periods, will show less for an old range than report does for the same range. Compare periods lists those days by name with their unexplained amount instead of quietly folding them into the totals.

</details>

<details> <summary><strong>What actually leaves my computer, and how can I check?</strong></summary>

Model prices are fetched from LiteLLM and cached for 24 hours, so that call happens at most once a day. codeburn quota asks each provider you are signed in to how much of your plan is left, using the credential that tool already stores on your machine. If you set a non-USD currency, exchange rates come from Frankfurter, cached the same way. If you use Cursor, CodeBurn downloads your own usage export from cursor.com with the Cursor app's login, at most about once an hour, so Cursor figures match your bill; nothing is uploaded, and CODEBURN_CURSOR_SYNC=0 or "cursorSync": false in ~/.config/codeburn/config.json turns it off. Commands that install something, such as codeburn menubar, reach GitHub releases, which is the point of them. Your prompts, your code, your file names and your project names are read on disk and never sent anywhere, and nothing else leaves unless you point CodeBurn at a destination yourself. It is not a proxy, so no traffic of yours passes through it. You can watch what does leave with a network monitor.

</details>

Everything else

<details> <summary><strong>I work on a laptop and a desktop. Can I get one number across both?</strong></summary>

Yes, on the same local network. On the second machine run codeburn share --pair, which opens a pairing window and prints a PIN. On your main machine run codeburn devices add to find it and pair with that PIN, then codeburn devices shows combined totals by machine. codeburn devices rm <name> forgets one again. Sharing stops after ten minutes idle unless you pass --always, and pairing never leaves your network. You can also discover and pair from the browser dashboard at codeburn web. See Web dashboard.

</details>

<details> <summary><strong>Can my agent read these numbers itself, without me leaving the conversation?</strong></summary>

Register the local MCP server with claude mcp add codeburn -- npx -y codeburn mcp. It runs over stdio and exposes two tools: get_usage for spend and usage broken down by tool, model, project and task, and get_savings for the waste findings, retry tax and routing waste, which is the slower of the two. Any MCP client works, with command npx and args -y codeburn mcp. It reads the same files on disk the CLI reads, and project names are pseudonymized unless the agent asks for the real ones. See MCP.

</details>

<details> <summary><strong>Why is this free, and what is going to cost money later?</strong></summary>

CodeBurn is MIT licensed and all of it is in this repository: the CLI, the desktop app, the menu bar and tray apps, the GNOME extension. There is no account, no paid tier and no feature held back for one. It is free because it reads files you already have, which costs nothing to run. What it does cost is time, because 42 integrations sit on top of tools that change their config paths and data formats without warning. Sponsorship is what pays for keeping up with them.

</details>