tare scale v0.1.0 · (c) 2026 priberry
logs ................... found  ~/.claude/projects
prices ................. ok  cache reads, cache writes and output, each at its own rate
network ................ off  nothing leaves this machine
tokens spent ........... 0  tare never calls a model
scale .................. zeroed

> same work, fewer tokens, with the receipt

Find out what your AI coding assistant really costs, and cut the waste.

Your coding agent keeps a log of every call it makes. Tare reads those logs, prices every token, and shows you where the money went: the context you carry on every call, the test logs that sit there for an hour, the cache that went cold while you made coffee. Then it cuts the waste without breaking the prompt cache, and proves each saving on your own work.

AI coding assistants such as Claude Code bill by the token, and most teams can't see where those tokens go. Tare reads the records the assistant already keeps on each computer, shows what the work cost and what was wasted, switches on the fixes that are safe, and later shows whether they really saved money without slowing the work down.

$ npx tarelab

[ get started ] [ source on github ]

═ tare wrapped ═

$ npx tarelab
reading session logs… 254 sessions in the last 30 days

  $6,720 API-equivalent spend
  $623 of it avoidable

  reading cached context      ██████████████████████ $3,809
  writing to the cache        ████████████ $2,072
  output, thinking included   █████ $838

  › ~82k tokens load before you type a word.
  › sed output cost $262 just by sitting in context.
  › Coffee-break tax: $722 re-caching after 636 pauses.
  › Sub-agents spent $2,734 (41%).

$ tare fix
✓ output trim · ✓ cache countdown in the status line

A real month of Priberry's own Claude Code use, read by Tare on one laptop. Prices are API list prices; on a subscription the bill is flat, and this is what the same work would cost on the API.

═[1]═ how it works

See it. Cut it. Prove it. Local, free, and it never spends a token of its own.

See the cost. Cut the waste. Prove the saving. It all happens on your own computer.

$ npx tarelab1. See: Reads Claude Code's session logs, prices every call (fresh input, cache writes at 5-minute and 1-hour rates, cache reads, output, thinking) and attributes the spend: startup context, each tool's output, sub-agents, cache rebuilds. Your Wrapped in seconds; cached, so the second run takes under one.Tare reads the assistant's own records and turns them into a bill you can understand: what was spent, on which projects, and what was wasted.
$ tare fix2. Cut: Installs fixes that cut waste where it enters the context, never by rewriting history, so the prompt cache stays intact. Backed up first; tare fix --undo restores your settings exactly.Tare switches on a few safe changes that stop waste before it happens. Every change can be undone with one command.
$ tare receipt3. Prove: Compares cost per commit before and after, with a 90% range, and checks that just as many sessions still finish. If the data isn't there yet, it says so instead of printing a number.A few weeks later, Tare compares the cost of finished work before and after, and checks the work didn't suffer. If there isn't enough data yet, it says so.

═[2]═ tare wrappedwhere the money goes

Most of the bill isn't the agent thinking. It's the agent re-reading everything it has already seen, on every call.

what Tare measures	why it costs
Startup context	The system prompt, tool list, skills and memory ride along on every single call. 82k tokens in our own setup.
Carry cost of tool output	A test log is written to the cache once, then read back on every later call until the conversation is compacted.
Coffee-break tax	After 5 minutes idle the cache expires, and the whole conversation is written again at 1.25× the input price.
Cache breaks	Switching models or changing tools mid-session rewrites the context from scratch.
Sub-agents and models	Which agents and which models did the spending, by project, by day and by hour.
Repeats	Tool calls that returned byte-for-byte what the agent already had.

Sample Tare Wrapped card: $6,720 API-equivalent spend over 30 days, $623 avoidable, with the top fix. — tare card · a shareable card, made on your machine; you decide whether to post it

═[3]═ tare fixthe fixes

Cut waste where it enters. Never rewrite what's already there. A compressor that rewrites history breaks the cache, and the "saving" costs money.

trim long command output is cut to the failures, the first lines and the last lines before the agent sees it. The full text is saved to a file the agent can open if it needs more. Output over about 2,500 tokens comes down to about 1,200, and the failing lines are still there.
countdown the status line shows how long until the cache goes cold, and what your next message will cost warm versus cold. tare · $41.27 · 244k ctx · cache warm 3:41 · next msg ~$0.05
habits what a switch can't fix, priced from your own logs: model switches, unused MCP servers and skills, effort that's higher than the task needs.
undo every change is backed up and touches only Tare's own entries. tare fix --undo puts the file back byte for byte.

Shorter logs: when the assistant runs a test, it sees the failures and a summary, not thousands of lines that passed.
A countdown: a small timer shows when a pause is about to make the next message expensive.
Advice with a price on it: habits that cost money, each with what it cost you last month.
One-step undo for every change.

We don't sell tokens or models. We have no reason to make you spend more.

═[4]═ tare receiptthe receipt

Token savers have a credibility problem: dashboards claim millions of tokens "saved" while the bill goes up. Tare's number is the one you can check.

  TARE RECEIPT
  ────────────────────────────────────────
  Fixes installed     2026-11-08
  Before              41 finished sessions · $3.88 per commit
  After               38 finished sessions · $3.02 per commit
  ────────────────────────────────────────
  Cost per commit     -22%  (90% range -31% to -12%)
  Sessions finishing  74% → 76%  · work held up
  Verdict: a real saving.
  ────────────────────────────────────────
  Measured on your own logs, on this machine.

Illustration of the format. Your receipt uses your sessions; with fewer than 8 finished sessions on either side, it prints "not enough data yet" and no number.

Cost per finished task, not raw tokens: a cheaper session that needs a redo isn't cheaper.
A range, not a point: a bootstrap 90% interval, and "too close to call" when it straddles zero.
The work must hold: if fewer sessions reach a commit, the receipt says so and points to the undo.
Local: the receipt is computed on your machine from your own logs.

═[5]═ pricing

Free and open source under Apache 2.0. Teams pay when it pays.

open source

free

Wrapped and the share card
every fix, with undo
the receipt on your own work
skill, plugin and MCP server

team

$30 per developer, or 10% of verified savings, whichever is lower

spend by engineer, repo and agent
cost per merged PR
a CI gate on cost per task
fixes rolled out from one place

enterprise

talk to us

self-hosted
SSO and finance exports
procurement-grade reports

═[6]═ faq

Does Tare send my logs anywhere?

No. It reads the files on your machine and writes its results next to them, in ~/.tare. It makes no network requests and never calls a model, so it costs no tokens.

I'm on a subscription. Does this matter to me?

The dollar figures are what the same work would cost at API prices, so you can compare setups and see waste. On a subscription, waste shows up as hitting your usage limits sooner; the fixes help with that too.

Will the fixes make my agent worse?

The output trim keeps every line that looks like a failure, plus the start and end, and saves the full output where the agent can read it. The receipt checks that sessions still finish, and tare fix --undo removes everything.

Why not just compress the context?

Rewriting what's already in context breaks the prompt cache. A cache miss costs 12.5 to 25 times a hit, so a tool can cut tokens and still raise the bill. Tare only trims new content, as it enters.

Which agents does it support?

Claude Code today. Codex CLI and Gemini CLI logs are next. The skill works in Claude Code and Codex now, and the MCP server works with any agent that speaks MCP.

Are you affiliated with Anthropic?

No. Tare is independent and built by Priberry, the team behind Crumple.

═[7]═ get startedtry it

Free and open source. Runs on your own machine, and nothing leaves it.

$ npx tarelab: Your Wrapped for the last 30 days. Needs Node 20 or newer, nothing else.
$ npx tarelab fix: Install the output trim and the cache countdown. Add --dry-run to see the change first.
$ npx tarelab card: Make the shareable card, with a PNG download.

Inside your agent

Claude Code plugin: /plugin marketplace add priberry-data/tarelab, then /plugin install tare@priberry. Adds the skill and the MCP server; ask "what did my agent cost this month?"
Skill (Claude Code or Codex): Copy skills/tare from the repo into ~/.claude/skills/ or ~/.codex/skills/.
MCP server (any agent): npx -y tarelab mcp over stdio. Tools: tare_wrapped, tare_receipt, tare_cache.

Version 0.1. Tell us what breaks: [email protected] · github issues