The short version

Run Claude Code, Codex, or OpenCode daily and you’ve started wondering “how much is this actually costing me”? Then agentacct is worth a weekend test drive. It reads your local session logs, estimates the spend against each client’s pricing table, and ties every dollar to the concrete work — the tools it called, the files it touched, the tests it ran. Nothing leaves your machine. Nor is any API key ever requested. Because it’s honest about which numbers are evidence and which are estimates, that matters more than the dashboard itself.

What agentacct actually is

Agentacct calls itself an “Agent Work Intelligence” dashboard. Skip the buzzword — here’s the mechanic. So it pulls two evidence streams, then joins them by the real session id.

The first stream is usage truth: the token counts your client already writes to its own session logs, each tagged client_reported. The second is work meaning: the steps recorded through MCP (which tools fired, which files changed) plus machine-checked signals like “this test actually passed.” Every attribution carries a confidence tag — exact, high, medium, or low. When agentacct can’t prove a link, it shows the gap instead of filling it with a guess.

That last part is the whole philosophy, spelled out in the README as “honest by design.” The cost is an estimate (a pricing-table lookup), never a fake invoice. There’s no hosted service, no telemetry, and no API key saved anywhere. While most observability tools want your data and your credentials, this one wants neither.

Why your agent’s own log isn’t enough

Your coding agent already keeps a ledger. Claude Code writes a session transcript with tokens; Codex does the same; even OpenCode does. But that ledger only records usage, not meaning. It’ll tell you “token count: 42,000” — and then it goes silent. It won’t tell you “I changed 14 files, ran the test suite three times, and only two of those runs actually passed.”

That join is what separates agentacct from the alternatives. Numbat watches your agent’s endpoints for security (on-device detection, pre-emptive blocking). Headroom compresses your tokens to save money. Superlog gives you server-side observability. Yet agentacct’s lane is different: it makes the cost visible in the first place. Which is why the headroom piece on this site argued — before you compress your way to savings, you need to actually see the bill.

Installing and onboarding agentacct — the real run

The install is two commands and about ninety seconds of my life. On Python 3.11+, either of these works:

# if you have pipx
pipx install agentacct

# or with uv
uv tool install agentacct

Then, once per machine:

agentacct onboard

onboard installs globally, writes zero files into your repo, and auto-detects whatever agent logs live on your box. About thirty seconds after I ran it, opening http://127.0.0.1:8765 gave me a dashboard with per-agent token breakdowns, estimated-cost charts, and a split by client. That said, one snag I’ll flag honestly: it binds its MCP server and hooks at the start of a session, so your onboarding session doesn’t count as your first tracked task. Though you have to open a fresh agent session afterward to see real data. The README calls this out, and it tripped me up for a minute.

agentacct demo also deserves a shout — it walks through a fake store end-to-end, so you can see the whole flow without touching real data or spending API money. Because I ran it before pointing it at my actual logs, it felt like a safe way to learn the UI.

The receipt I was looking for

My real test: a three-hour Claude Code session refactoring a services layer. When I opened the dashboard afterward, the single Task row showed a token total around 48,000, with an estimated cost of about $1.60 against Claude’s pricing table. The work log showed 14 files modified and three test invocations — and here’s the part that sold me. Two of those test runs were machine-verified and tagged Verified; the third was marked agent-reported rather than confirmed.

That distinction isn’t pedantic. Though an agent says it ran the tests either way, agentacct only stamps Verified when it has independent confirmation the suite actually passed. In my testing, that gave me a truer picture of the session than the raw transcript ever did. The per-agent breakdown chart also confirmed a suspicion: one of my long-running background agents was quietly burning more tokens than the headline task.

Background agents are exactly the kind of workload you shouldn’t leave chewing through your workstation all night. Moving a long-running agent to a small dedicated box costs next to nothing and frees your machine — a $6 DigitalOcean Droplet ($200 free credit for new users) handles it comfortably, and you can keep agentacct pointed at the same session logs from there (affiliate link).

The honest trade-offs with agentacct

Alpha is alpha, so here’s the unvarnished list:

• Windows is WSL-only. Native Windows support isn’t there yet. I tested on Linux; WSL users should be fine, bare Windows won’t be.
• Costs are estimates, not invoices. The number is a pricing-table lookup tagged client_reported plus an estimate. Don’t hand it to accounting.
• Capability varies by client. Claude Code and Codex have a live-observed path; the Hermes, OpenCode, and Cursor paths are narrower. Your mileage depends on which agent you lean on.
• The API can shift. It’s a young project moving fast — 67 forks and a commit yesterday say it’s alive, but the interface could change under you.
• It’s a local tool. By design. That means it shows you your machine’s story, not a team-wide view.

agentacct vs the field

Each niche is real. Numbat keeps you safe; headroom cuts your bill; superlog scales observability across a team. But agentacct answers the question the other three don’t touch: what did this session cost, and what did it actually do? Chasing only one of those? Pick the specialist. If you want the receipt — the honest one — this is the tool.

Who should actually use it

If you’re a solo dev or small-team lead who lives in Claude Code or Codex, you’ve started squinting at token bills, and you’re tired of guessing whether that background agent is a bargain or a slow leak — you’re the target reader. It’s also a genuinely good fit if privacy is a hard requirement: everything stays on your disk, and that’s the feature, not a compromise. If you run your agents across more than one box, a cheap second node on Vultr ($100 trial credit) is a low-risk way to keep the cost picture complete without touching your main machine.

Or skip it if you’re all-in on Cursor and never look at costs, or if you need team-wide deployment today — that’s superlog’s territory.

The bottom line

I went in expecting another “monitoring” tool and found something rarer: a tool with a philosophy. Agentacct’s “honest by design” stance — estimate what you can’t prove, verify what you can, never ask for a key — is the trust posture the rest of the agent-observability space mostly skips. It’s young, Windows support is a gap, and the numbers are estimates. But for the question it answers — how much is my coding agent really costing me? — it’s currently one of the best options on the board, and it runs entirely on your machine.

Grab it, run pipx install agentacct, and give one real session a look. And if the security side of the agent lifecycle is on your radar too, the numbat review covers that angle — agent activity monitoring is the flip side of the cost coin. If you’re starting from scratch and want the cheapest possible always-on node to run your agents and tracking on, Hostinger sells budget VPS plans that keep the whole setup under a few dollars a month.