Spend, with receipts.
Every coding session with an AI agent leaves a perfect paper trail — a JSONL transcript of every model call and every tool it ran. AURA reads that trail and hands you the itemized bill: what you spent, on which model, for which task. Local-first, open source, and honest about how fresh its own numbers are.
If you use Claude Code — or Cursor, Aider, or any agentic coding assistant — you are already producing a goldmine of structured data on how you and your team think, debug, and ship. It sits, unread, in ~/.claude/projects/**/*.jsonl. AURA — Agent Usage & Resource Analytics — turns that exhaust into a usable record: a local dashboard that shows every dollar broken down by model, agent, and project, and reconciles to the same total on every page it appears. Nothing is uploaded anywhere. This is the tour of what it does and how it stays honest.
Your transcript exhaust, read back to you
AURA answers three questions from the data your agent already writes: what did the agents do today, where is the money going, and is the pipeline telling me the truth. It is built for the individual first and the team second — the same local stack, plumbed so that each developer's processed, masked marts (never raw conversations) can later roll up to one shared dashboard.
Run it on your own machine, against your own transcripts. See which tasks you over-spend on, when you reached for Opus to fix a typo, your cache hit rate, and where the tokens and time actually go — attributed down to the files you touched.
Runs todayThe schema already carries a tenant_id per machine. Each laptop ships its masked, aggregate marts to a central store; one team dashboard reads the union — cost and throughput per project and per machine. Full detail stays private and local; only aggregates travel.
Designed, plumbedTwo independent stages, one medallion
AURA is a small data platform in a trench coat. Raw JSONL becomes bronze; bronze becomes marts. The two stages never wait on each other — dbt transforms whatever is already in raw_events the moment its clock fires, so the dashboard fills in progressively after a cold start instead of blocking on a full backfill.
Eight screens, one number
Every page shares a range filter (today / 7d / 30d / all) and, where it shows a cost, the same cost. Here is the map.
Spend for the range, a KPI strip (active sessions, cache hit rate, tool calls, commits, errors, projection), the daily-spend chart, and ledgers for apps, projects, and agents.
Every session with title, model, turns, cost, and agent. Click one for a per-turn breakdown with tabs for agents, errors, files, tokens, tools, and git.
Every subagent × app row with its true cost — technical-writer, code-reviewer, and friends no longer lump under one giant claude bucket. The same agent name in two projects shows as two rows.
Which skills and MCP servers each session, app, and agent pulled in — surfaced as top-ten lists, so you can see what your agents actually reach for, and what it costs when they do.
Cost per working directory and per project; token spend sliced by type, provider, model, and agent, with a fixed palette that makes the expensive output and cache-write tokens legible at a glance.
Hard errors, warnings, and tool failures in one place — and a live pipeline view (ingestion freshness, dbt run status, source-freshness, watcher failures) that polls every ten seconds so you always know how current a number is.
Why the numbers are trustworthy
"With receipts" is a promise about reconciliation, not decoration. A cost that says something different on two screens is a bug, not a rounding artifact — so AURA is built so it cannot happen.
- One source for every dollar. A single pre-aggregated table pivots spend to (date × app / agent / project). The Dashboard, Apps, Agents, and Tokens pages all read it — so the total equals the sum of the parts, always.
- Cost is anchored to event time. A session that began yesterday and ran into today gets yesterday's tokens on yesterday and today's on today — never bucketed by session-start.
- Cache hit rate uses the right denominator. Reads over reads-plus-writes, not reads over input tokens — the ratio you'd actually reach for.
- Pricing is time-travel-correct. The pricing seed carries valid-from / valid-to; each call is priced at the rate in effect when it ran, so history stays honest through rate changes.
- Overkill is flagged. Each request is scored on complexity and compared to the model tier it drew. Opus for a one-liner gets marked — the cheapest audit of your own habits there is.
- Subagents keep their spend. When the orchestrator dispatches a task, every event until the result is attributed to that subagent — so delegated cost lands on the delegate, not the parent.
Local-first, and honest about the seam
Everything above runs entirely on your machine — the transcripts never move. The team story is deliberately an export problem, not a hosting one: only the processed, masked gold marts leave a laptop, and the sensitive text columns are masked before they do.
The lessons are in the tuning knobs
AURA was built against a real, growing transcript set, and the interesting parts are the failures it learned from. A few, straight from the repo's troubleshooting notes:
Written from the AURA source and its running local dashboard — the architecture, the reconciliation rules, and the tuning figures are taken from the repository and its docs, not a projection. The screenshots and numbers a reader would see are their own transcripts; none of the author's private spend appears here. — Crosshire.