Changelog
Updated
TL;DR — Current release: 2.0.10. Tokenade is now open source (MIT OR Apache-2.0), with no account, no licence and no telemetry; binaries are published on GitHub Releases and 1.x updates itself to 2.0. 1.2.4 made savings and costs more exact on every agent: Tokenade's own context is no longer overcharged, compactions and /clear are seen everywhere, web pages are credited at the measured web saving, and requests that missed the prompt cache count at their real price. 1.2.3 counted savings more completely. 1.2.2 aligned help pages, plans and prices with what Tokenade does. 1.2.1 covers Codex even when its hooks are not approved and gives Claude Desktop's Code tab the full hook set. Check your version with
tokenade --version; updates install themselves.This page lists what changed for you in every Tokenade release, newest first. Internal changes are left out. Tokenade updates itself (see Upgrade and uninstall); run tokenade --version to see which release you have.
2.0.10
- Claude Code: no more lost lines in a transcript Tokenade folds. Before a compaction, at session start and on resume, Tokenade folds the large tool results of a session's transcript. It rewrote the whole file, so any line the session wrote during that second was lost. Each fold now replaces only its own line, in place, and only if that line has not changed; on Windows, the leftover
.jsonl.tokenade-tmpcopies are gone too. TOKENADE_NO_PRECOMPACT_MASK=1turns off the fold that runs right before a compaction, without touching the rest. See Environment variables.
2.0.9
tokenade uninstallno longer fails with "Directory not empty". When a hook or a background task wrote a file into~/.tokenadewhile it was being deleted, the folder was left behind. Uninstall now sweeps it again, a few times at most, before giving up.
2.0.8
- Windows: Tokenade's status line no longer comes up empty. Claude Code runs the status line through Git Bash, which stripped the backslashes from the unquoted
tokenadepath thatinstallwrote, so nothing ran. The path is now quoted the way the hooks already were; existing installs are corrected automatically and keep your own status line. A path with a space was fixed the same way on every system. - When the search engines refuse a search,
tokenade searchsends your agent to its own web search. Before, the first search to hit a blocked or saturated engine only said "no usable results", so an agent could stall or conclude the web had nothing on the subject.
2.0.7
- Windows: your own status line shows again next to Tokenade's. When your Claude Code status line command quoted a path (
node "d:\x\statusline.mjs"), Tokenade ran it in a way Windows'cmdcould not read: nothing ran and only Tokenade's ticker remained. It now runs through Git Bash, the way Claude Code runs it. - A failing status line says why. If your status line command fails without printing anything, a short warning with its error replaces the silence.
2.0.6
- Claude Code: git works in worktree-isolated subagents. Claude Code refuses, in a subagent isolated in its own worktree, any command where git is an argument of another program, which is what Tokenade's rewrite produced. Every git call of those subagents failed. There, git now runs exactly as written and its output is piped into Tokenade, so it is still compacted.
- Your global
CLAUDE.mdis no longer stripped through a symlink. When two paths of the cascade lead to the same file (aCLAUDE_CONFIG_DIRwhoseCLAUDE.mdlinks to~/.claude/CLAUDE.md, a dotfile repo, a symlinked project), the startup dedup compared the file with itself and removed every line but the headings. Files are now recognised by their real path.
2.0.5
- opencode 2: savings reset after a compaction. The plugin bridge now listens for opencode 2's compaction event (
session.compaction.ended), so the savings count restarts when the host compacts the conversation. It was listening for the 1.x event name, which opencode 2 no longer sends. - opencode 2: structured shell output is folded. When a tool result carries its text only in a structured
output, Tokenade now folds it as well, instead of letting it reach the model whole. - opencode 2: clean unload. The bridge stops its event subscription when opencode unloads the plugin.
2.0.4
- Shortened reads get their content back. When Tokenade shrinks a
Readto its first 20 lines, it delivers the compacted view or, for an unchanged file read again, the "unchanged" note right after. That delivery was silently lost, so the agent got 20 lines and nothing else. - Your rules files are left alone. In
CLAUDE.md,AGENTS.mdand the other rules files, Tokenade now only touches its own marked block (<!-- tokenade-scaffold -->), its<!-- tokenade:start -->fence, and the intro of a file it created itself. Sections of yours titled## Commands,## Project rules,## Engineering principlesor## Codebase explorationare no longer removed. Leftovers from 1.x outside those markers are no longer cleaned up automatically. - opencode 2: the plugin loads again. opencode 2 rejected the bridge's export shape, so nothing was folded or scanned for secrets; folding also keeps a shell result's structured output and exit notice intact.
2.0.3
- A one-time line links the GitHub repository. After a successful
tokenade install(or, if that run was not in a terminal, the firsttokenade dashboardwith saved tokens to show), one line says Tokenade is open source and invites you to star the repository. It appears once per machine, never outside a terminal or under CI, andTOKENADE_NO_STAR_INVITE=1turns it off. It makes no network call.
2.0.2
tokenade gaindrops the old metered line. Themetered:line, and theoperations_as_metered/saved_as_meteredfields ofgain --json, described the former paid service; they are gone.- Relative reads recognise your repository.
tokenade readwith a relative path from a subdirectory of a git repository now sees the repository, so a source file you are about to edit comes back unchanged instead of with its comments stripped. tokenade read --helpdescribes source code handling. Unchanged when it is likely to be edited (inside a git repository, under ~20k tokens); comments stripped for other source files over 3 KB;TOKENADE_NO_CODE_STRIP=1turns the stripping off.expand-foldfixes.tokenade expand-fold --helpshows its own help, andexpand-fold <template_id> --max Nno longer readsNas the content hash.
2.0.1
- Cleaner 1.x migration. The cleanup now also removes
last-report.zip(the support bundle of the removedtokenade report, which held a copy of agent transcripts) and a strayreporter.lock, including on machines already on 2.0.0.
2.0.0
- Tokenade is open source. The code is published on GitHub under MIT OR Apache-2.0, at your choice. It is free for everyone, on any number of machines, with no quota.
- Licences and sign-in are gone. Tokenade no longer asks for a card or a sign-in, and no longer reports usage counts or a machine id. Savings stay visible locally with
tokenade gain,tokenade dashboardand the status line. See What Tokenade sends and stores. tokenade login,tokenade activateandtokenade reportare removed. None of them has anything left to do. To report a bug, open an issue on GitHub.- Binaries come from GitHub Releases.
npm install -g @tokenade/clistill installs Tokenade; the binaries and automatic updates now come from GitHub Releases. SetTOKENADE_NO_AUTO_UPDATE=1to turn update checks off. - 1.x moves to 2.0 by itself. With auto-update on, a 1.x install upgrades on its own; otherwise run
npm i -g @tokenade/cli@latest. The upgrade deletes the licence and account files 1.x left on the machine. See Install Tokenade.
1.2.5
- Messages follow the new pricing. Tokenade now needs an account with a card on file: the first 7 days are a free, unlimited trial, then you pay 1% of the API value of the tokens Tokenade saves. There is no monthly quota any more.
tokenade login, the status line and the agent notices no longer mention free tokens or plan upgrades. - A paused account says why and where to fix it. If compaction is paused, Tokenade says why: your €10 legacy allowance is used up, no card is on file, or billing needs attention. Each message gives the link to your billing page, and your agent passes it on to you.
- Your billing state is shown where you look.
tokenade login,tokenade healthcheckand the local dashboard show your trial end date, an active subscription, or how much of the €10 legacy allowance is used. The status line shows the days left in your trial. - Without an account, Tokenade sends you to sign up. On a machine that isn't connected, the status line, the dashboard and the npm installer point to sign-up and
tokenade login, and mention the 7-day free trial.
1.2.4
- The cost of Tokenade's own context is no longer overstated in long sessions. What Tokenade adds to a conversation is charged for every later call until the conversation is compacted. When a compaction went unnoticed, it kept being charged past it, sometimes twice its real cost. Compactions are now also recognised from the drop in what each call sends, and the call that first sends a fold or an addition is no longer counted a second time.
- Savings and costs inside subagents and on agents without a readable session use one measured count. Credit for a fold and charge for added context used opposite, pessimistic counts of how often a token is re-read. Both now use the same measured value: subagent folds are no longer credited a tenth of their worth, and context added inside a subagent is charged for its real number of re-reads.
- Shorter answers are credited at their measured value. The share of output Tokenade's style rules save is now the one measured against agents without Tokenade (30%), instead of 35%; and on later turns that saving is no longer counted 60% too high. Savings already recorded keep their value.
- Compactions are no longer missed after Tokenade tidies the transcript. Before a compaction, Tokenade trims stale tool output from the conversation file, which made the file shorter and caused the compaction itself to be skipped when savings and costs were counted. The file now keeps its size.
- Compactions and
/clearend what is counted as re-read, in every agent. Folded output and Tokenade's own additions kept counting as re-read after Qwen Code, opencode, Kilo Code, Pi, OpenClaw or Cline compacted the conversation, after Pi started a new one, or after a/clearthat keeps the same session. They now stop at that point, on both the savings and the cost side. - Kilo Code usage since its database move is counted again. Kilo now stores its sessions in
kilo.db; Tokenade still read the older files, which stopped growing when Kilo switched, so its recent usage was missing. - opencode, Kilo Code and Pi sessions are counted call by call. How often a token is re-read was estimated from Claude Code averages for these agents. It is now read from their own session records, call by call and up to each compaction, as already done for Claude Code and Codex. Cline was counted 31% short: each request it makes now counts as one call, and no longer a second time under a phantom session that also charged Tokenade's rules a second time. Hermes is counted per request too, and a compression that keeps the same session now ends what was counted as re-read.
tokenade calibrateworks with the current benchmark results. It stopped with « no such column: tool » since the benchmark renamed that column.- OpenClaw conversations are counted one by one. Savings and costs of every conversation served by one OpenClaw gateway were pooled together, so compacting one conversation reset the count of the others.
- The rules Tokenade adds to your agent are charged as they really are. Their cost now comes from what your rules file actually contains, counts from the first call of the session, and keeps counting after a compaction, since the agent reloads that file.
- Subagents that load your rules file are charged for it. Most Claude Code subagents load CLAUDE.md, Tokenade's section included, and re-read it on every one of their calls; that cost was counted nowhere. It is now charged for each such subagent, and not for the ones that skip CLAUDE.md (Explore, Plan, web-fetch, or a custom agent that opts out).
- Web pages are credited at the measured web saving again, on every agent. On the same web tasks, agents spend about 67% fewer tokens with Tokenade than without — a figure that includes the work agents like Claude Code hand to a smaller model to read each page. A page Tokenade serves, whole or as an excerpt, is now credited on that basis (three times what it delivers), on Claude Code and on every agent whose own web tool could not be measured page by page; agents that would have read the raw HTML keep being credited against that page. This replaces the small flat credit introduced in 1.2.3. Savings already recorded keep their value.
- A web page is credited on what actually reaches your agent. When Tokenade answers with an excerpt of a page, puts a long page behind a recovery pointer, or points to a page already delivered in the session, the saving was computed as if the whole page had been delivered. It is now computed on what was delivered.
- The proxy no longer rewrites conversation history your provider has already cached. Output that went out unfolded on an earlier request now stays as it was sent; folding it later made the provider write the rest of the conversation to its cache again, a cost no saving accounted for. Credentials are still removed wherever they appear.
- Re-reads that missed the prompt cache are valued at what they cost. When a request finds its cache expired, the provider bills the whole conversation at the cache-write price rather than the cache-read one, about 12 times more on Claude. On Claude Code, opencode, Kilo Code, Pi and the proxy, Tokenade now sees those requests and values the context it removed — and the context it added — at that price on them. Measured on 30 days of sessions: 0.5% of requests, about 5% more on both sides.
- Your savings read the same in the terminal and on tokenade.net. A cost whose category had been lost when the local history was archived could be counted as a saving on the site; and avoided batched re-reads were valued at the fresh-input price locally but at the cache price on the site. Both sides now classify and price every entry the same way.
1.2.3
- Web pages read in Claude Code are credited at what they really replace. Claude Code's own web fetch puts only a short summary of a page into the conversation, so a page read through Tokenade is no longer credited as 60% of its raw HTML; it now earns the same small credit as with agents whose web tool returns clean text. Savings already recorded keep their value.
- Image savings are no longer overstated. When Tokenade shrinks an image before the agent sees it, the saving was counted 60% too high in dollars for Claude models. Images read from now on are valued as they are billed; savings already recorded keep their value.
- Codex sessions count the turns Tokenade saves or costs. Sending several pages or questions in one call saves the agent extra turns, and retrieving folded output adds one. Both were counted only in Claude Code. In Codex they now use the context size of the call, read from Codex's own session log; the size used is that of the call before, so the figure stays on the low side.
- Every folded result now earns credit for the turns that no longer re-read it. Only folded shell output and folded file reads were counted that way. Folds from
tokenade readandskeleton, repeated file reads and large reads saved aside earned nothing for the later turns that would have re-read the full text. Each fold counts only up to what the agent would actually have been shown; web pages, documents and images, whose savings are estimates rather than measured text, are left out. - Commands your agent runs as
tokenade …count toward its session. When Claude Code typedtokenade wrap …(orweb,read…) itself, the savings were logged without a session, so the session total missed them and folded output never earned credit for the later turns that no longer re-read it. These commands now use Claude Code's session id. - Savings history can no longer be lost when the log is trimmed. When the savings log grows large, older entries are summarised into a long-term total before being removed. If that summary could not be written at that moment, the entries were removed anyway and disappeared from your lifetime figures. They are now kept until the summary has them.
1.2.2
- Help pages match what the commands do.
tokenade --helpand each command's--helpwere checked against the code:installpoints totokenade login;stylelistsautoand says the setting is global;llm-proxycovers serving without--upstream,--enable, and wheninstallsets the proxy up for you;statuslineandwatchhave their own help;codex-trust,ensure-hooksandaudit-gainsare listed; hidden flags are now shown (audit-claude-md --apply/--compress/--stale,gain --recent,search --html,index --json,upgrade --check,uninstall --keep-data); and the main help points to your own TOML compactors (add-compactor). - Plans and prices are current everywhere in the CLI. The quota message shows the current Pro and pay-as-you-save prices.
loginandactivateno longer mention machine limits on Free and Pro, which have none. uninstall --dry-runonly says what it would do. A few lines read "removed" although nothing was touched.
1.2.1
- Web search can be fully left to your agent. With
TOKENADE_NO_WEBSEARCH=1, the agent's own web search was already left alone, buttokenade searchstill ran and the rules Tokenade writes still recommended it. Now the command refuses to run and the rules leave it out, so no query goes through Tokenade. The switch is documented in the README. - The LLM proxy stops re-sending identical tool output. When an agent reads the same unchanged file or gets the same command output twice, the proxy sends it once and replaces later copies with a short pointer to the first. This applies where the agent's own hooks don't already remove duplicates — for example Codex before its hooks are approved. Measured with Codex: the second read of a file went out as a pointer, and the answer was unchanged.
- MCP savings in desktop apps are credited to the app. Tool results folded for Claude Desktop, the Codex app, Cursor or any app whose MCP servers
mcp-wrapset up were counted under "unknown", because a desktop app tells its servers nothing about itself. Each wrapped server now carries the app's name, and the savings show under it. Removing the wrap takes that name out again and leaves your own settings untouched. - Claude Desktop's Code tab gets the full set of Claude Code hooks. With no
claudecommand installed separately,tokenade installcould not see the Claude Code built into Claude Desktop and skipped web-search and MCP compaction, even though that built-in version supports both. It now checks the app's own copy. - On Windows, the LLM proxy's savings are credited to the right agent, and an update really restarts it. A proxy set up with
llm-proxy autostartcounted its savings under "unknown" instead of the agent it serves. And because Windows starts the proxy as a separate process, restarting it after an update left the old one running, still serving the previous version. Both are fixed. llm-proxy install --autostartworks on an agent that is already set up. Adding start-at-boot to an agent installed without it was refused with "the agent already points at this proxy", and the only way out was to uninstall first. It now keeps the existing setup and adds the startup entry.- tokenade never asks for administrator rights. On a Mac with nobody signed in at the screen, setting up the proxy to start at boot ran
sudocommands, andcleanupdid the same to remove tools installed in system folders: both could stop on a password prompt in the middle of an install or update. tokenade now prints those commands for you to run, and never runs them itself. - The LLM proxy starts at boot for every agent on Windows and macOS, not just the last one. Each agent gets its own proxy, but Windows had a single startup task and macOS a single service name: setting up a second agent replaced the first one's, and on macOS the start-at-boot step pointed at a file that was never written. Each proxy now has its own startup entry on all three systems, and the old shared one is removed on update.
- The LLM proxy steps in exactly where an agent's hooks are switched off. For each agent, tokenade now reads whether its hooks actually run (Codex hook approval, switches such as
disableAllHooks, plugin enable lists) and lets the proxy cover what they would have done only when they do not. tokenade healthsays when Claude Code ignores hooks in this folder. Claude Code runs no hooks at all in an interactive session in a folder whose trust prompt was not accepted;healthnow points this out.mcp-wrapleaves the Codex app's own tools alone. The Codex desktop app installs its own MCP server (browser and computer use) in your Codex settings;mcp-wrap installrouted it through tokenade, pinning a path the app changes on every update. Servers that belong to an app's own install are now left as they are, on Windows, macOS and Linux.- Codex is covered even if you never approve its hooks. tokenade's Codex hooks only run once approved, which most people never do, in the command-line tool as in the desktop app. Codex now gets the local LLM proxy for what those hooks would have done: folded tool output, scrubbed credentials, the style note and its savings figures. If the hooks do run, nothing is done twice.
- The LLM proxy keeps Codex signed in with your ChatGPT account. Routed through the proxy, Codex expected an OpenAI API key that ChatGPT-account users (including every desktop-app user) do not have. It now uses your ChatGPT sign-in and reaches the ChatGPT service.
1.2.0
mcp-wrapfinds Claude Desktop installed from the Microsoft Store. The Store version of Claude Desktop on Windows keeps its configuration in its own app folder, whichmcp-wrapnever looked at, so its MCP servers were never folded.- The LLM proxy reaches Qwen Code when a model has its own provider address. A model configured with its own base URL (an OpenRouter setup, for instance) is sent there first by Qwen Code, so the proxy was never used for it, and requests that did reach it were forwarded to the wrong provider. The proxy now sits on the address that model actually uses, forwards to the right provider, and an existing install is repaired at the next upgrade.
- The LLM proxy relays requests with their own method. Every request was forwarded as a POST, so a request such as Codex's model list was refused by the provider.
- Folded output now earns its re-reads on agents without a per-message event. On opencode, Kilo, Pi, OpenClaw, Cline, Hermes, Cursor, Grok and Qwen, output tokenade folded was never credited for the later requests that no longer re-read it. It now is, counted conservatively at under half a request per tool call, until the conversation would have been compacted.
- What tokenade adds to the conversation is now charged on every agent. On agents where tokenade cannot see each turn (Droid, Copilot CLI, Grok, Qwen, Cursor, opencode, Kilo, Pi, OpenClaw, Cline, Hermes), the context it adds was charged once, or every user message at most, while an autonomous run can make a hundred requests from a single message. Each tool call is now counted as a request that re-reads it, until the conversation would be compacted. The tokenade section of these agents' rules file, loaded into every session, is charged too; it cost nothing on agents without a session-start event.
- Style notes are charged on every agent that receives them. Qwen's, OpenClaw's and Cline's style notes were added to the conversation without being counted.
- Pi's folded requests now show in your savings, and never carry a credential. Pi's request folding recorded nothing; and without a valid license it sent requests unscrubbed. It now records what it folds and always scrubs credentials.
- Over the free quota, what tokenade already added keeps being charged. It stopped being counted at the limit while earlier savings kept accruing.
- The LLM proxy folds Codex's tool output with its command, in every shape. Output given as a list of parts, freeform tool output (such as patches) and tool messages with several parts went to the model unfolded and unscrubbed; Codex's shell output was folded without knowing which command produced it. All are now folded by the compactor for their command.
- The style note is never added twice. A multi-line style note already present in the conversation was not recognised, and a second copy was added.
- Gemini streaming answers are read correctly by the LLM proxy.
- The LLM proxy service now knows which agent it serves. The background services started for each agent never told the proxy which agent was behind its port, so it could not check what that agent already gets from its own hooks, and its savings were credited to no agent. The service is rewritten with the agent at the next upgrade.
- The style note reaches the agents that need it from the proxy, and only them. The proxy added the style note to every agent's requests, including agents that already read it from their rules file, so they received it twice; agents served by the installed proxy service received it from no one. It is now added only for agents that get it no other way, such as Grok.
- The LLM proxy respects your plan's limits. Without a valid license or past the free quota it kept folding; it now only scrubs credentials, like the hooks.
- What the LLM proxy saves now shows in your figures. For agents it folds for, the proxy's savings were never recorded: the dashboard showed nothing for them. Each folded tool result is now counted once, the first time it is sent, and every later request that re-sends it folded counts as a re-read saved, until the conversation would have been compacted. The style note the proxy adds to those agents' requests is charged on every request that carries it. Rows are attributed to the agent and model of the request.
- The LLM proxy never lets a credential through when it declines to fold. When folding a request was not worth it (rewriting would have cost a cache write), the original request went out, including a key a redaction had already caught in a tool result. The scrubbed request now goes out instead.
- The LLM proxy no longer folds the prompt or files sent by Cursor-style editors. Their requests have no schema the proxy can read, and any long text could be folded, including the user's own prompt or a file sent as context. Only text that reads as a command's output is folded now; every other text is only scrubbed of credentials, short ones included.
- The LLM proxy reads the request's endpoint before its shape. A first Anthropic request without a system prompt was taken for an OpenAI one and could be refused by the provider, and an embeddings request could be given a field it does not accept. Requests to endpoints that generate nothing are now passed through untouched.
- The LLM proxy keeps folding a conversation it has started folding. It could stop folding mid-conversation once the history grew, which made the provider write the whole history to its cache again.
- Links in fetched pages can be followed.
tokenade webkept links as the page wrote them, relative to itself (../builtins/exceptions.html), which point nowhere once only the text is left. They are now resolved against the page: written from the site root on the same site (/3/builtins/exceptions.html#OSError), as an anchor when they point into the page itself, and in full for another site — a 1–3 % longer page instead of the 8–35 % that writing every link in full would cost. - Output folded inside a subagent is no longer credited as if the main conversation had re-read it. A subagent shares its parent's session but not its conversation: its folded output was credited for every later call of the main conversation, though the main conversation never held it. About 30% of all folded output happens inside subagents. It is now credited for the subagent's own calls, on the low side.
- What tokenade adds to a subagent's conversation is charged for that conversation. The instructions it gives a subagent, and any note or recovered output it adds while the subagent runs, were counted as if they stayed in the main conversation and were re-read on every one of its later calls, while a subagent typically makes a few dozen calls and then ends. They are now charged for fifty re-reads, more than most subagents make.
- The status line's session value is priced like the total next to it. The dollar figure for the current session multiplied its token count by the model's input price, while the all-time figure priced each saving at its own kind (fresh input, cache read, output) in the model's own tokens. The session figure now follows the same rule; on a real session it rose from $8.37 to $15.37 for the same savings.
- The dashboards say what each figure counts. In the web dashboard, hovering "tokens saved", "+ estimated" or "future cache saved" now explains how the number is obtained, where it comes from and how precise it is. The terminal dashboard's dollar figure now says it covers everything since install, not just the period shown above it.
- Reopening folded output now costs what it really costs. When
tokenade expand-refhands back folded text, that text was already charged once; it is now also charged for every later re-read until the conversation is compacted, like the rest of what tokenade adds to the conversation, and, in Claude Code, for the extra call the recovery took when it was the only thing that call did. flutter analyzeanddart analyzeshow every problem, grouped by cause. A large analysis was cut to its first couple of dozen lines, so most problems were hidden, with no count of each kind and no list of the files concerned. Each cause is now listed once, errors first, with how many times it occurs and where (the first dozen places and a count of the rest); on a real app with 529 problems, all 25 causes are shown and the output is a tenth of its original size.flutter pub getanddart pub getno longer list each dependency that did not change: changed, added, removed and discontinued packages are kept, the rest are counted.tokenade dashboard --jsonnow gives the realistic net too.estimated_breakdown.net_realisticcounts each very large output at what the agent would actually have been shown, as the text dashboard's "realistic" line does;netkeeps the raw figure.- The local dashboards price saved turns as what they would have cost. A turn avoided by batching re-sends the cached conversation, billed at about a tenth of fresh input; the terminal block and the local web dashboard priced it as fresh input, about ten times too high. Both now use the same split as the figure sent to tokenade.net. And when tokenade's added context costs more in re-reads than the re-reads it saved, that line now shows the cost as a negative number and the dollar figure counts it, instead of showing zero.
- Folded output is credited for every turn it would have been re-read, by the same rule as tokenade's own cost. Output tokenade folds away would have stayed in the conversation and been re-read on later turns; that saving was capped at twice the folded size and one context window per session, while tokenade's own added context was charged up to twelve re-reads. Both sides now follow one rule. In Claude Code and Codex they are counted exactly: a folded token is credited once per API call made after it, until the conversation is compacted — or until the point where it would have been compacted without tokenade, whichever comes first, so the saving is never overstated — and tokenade's added context is charged once per call until the real compaction. With other agents, whose conversation does not show its calls, the count is estimated from measured averages — API calls per message and context growth per call, scaled to the model's context window — always taking the figures that understate the saving and overstate tokenade's cost. Command output folded through
tokenade wrap, and old results trimmed when a session is resumed, now earn this credit too; only folded file reads did, about a quarter of what tokenade folds. On this project's last 30 days of sessions, the re-read saving goes from 1.2 M to about 24.6 M tokens, priced as cached input. - The dashboard no longer overstates what tokenade's own context costs in old sessions. Before 1.1.21, a long session could be charged dozens of times for the context tokenade added to it — up to 429 times what it injected, on this project's own sessions — and those charges stayed in the 30-day figure. A session is now never charged more than twelve re-reads of what tokenade injected into it, the rule current versions already follow; this also holds for figures sent by older clients, and for the daily totals kept from older history, bounded together. It applies to every figure: the priced total, the terminal block and the local web dashboard.
- Output handed over with
tokenade read --cmd "<command>"is summarised as if tokenade had run the command. The plugin bridges (opencode, Cline, Kilo, Hermes, pi, OpenClaw) pass a command's output this way; it reached only part of the per-command readers, and a summary that guessed the format from the bytes could win by being shorter while losing what mattered — adotnet buildwith 122 warnings came back as an "archive listing" of 549 bytes, without a single warning or the build verdict. The command's reader is now always considered, and a guess from the bytes wins only if it keeps everything that reader kept. On real outputs:dotnet build1.3 kB with every warning code and the verdict,git log -n 15052 commits instead of 25 in fewer bytes,git statusandgit diff --statshorter. dotnet buildanddotnet testare summarised for what you fix. A build prints every warning and error twice; each now appears once, with warnings grouped by code — the message, how many, and the first files and lines that raised it — where the folded output used to give a count and a single example.dotnet testkeeps each failure, its message and the stack frames in your code, without the runtime and test-framework frames or the duplicate[FAIL]line. On a real solution: a build with 122 warnings went from 57 kB to 1.4 kB (2.3 kB before, without the file names), a test run with 3 failures from 2.5 kB to 1.4 kB.- A recursive
Get-ChildItemlists every folder, not just the first.Get-ChildItem -Recurseprints one table per folder; only the first 50 lines were kept, which showed the first folder and nothing of the others. It is now summarised like afindlisting: every folder with its file count and file types, the full output still recoverable. On a realGet-ChildItem -Recurse C:\Windows\System32\drivers(158 kB, 1 228 files in 15 folders), the summary names all 15 folders instead of 1. - More Windows output is summarised:
Select-String, Frenchdir, lists of Windows paths.Select-Stringresults are read likegrep(the repeatedC:\…\fileprefix said once, lines the console wrapped kept), a French-localedirlisting is recognised, and a list ofC:\…paths is grouped by folder instead of being cut one line in two.cmd /c <command>is credited to the command it runs. On real Windows output:Select-String12.2 kB → 6.2 kB,cmd /c dir9.0 kB → 2.2 kB. - PowerShell commands launched from the shell are summarised by their cmdlet.
powershell -NoProfile -Command "Get-Service"was read under the namepowershelland folded as generic text; it is now read asGet-Service,Get-ChildItem,Get-Processand so on, exactly as when the cmdlet runs on its own — on real Windows output, aGet-ChildItem … | Select-Object -First 400listing went from 10.0 kB to 3.0 kB andGet-Servicefrom 10.9 kB to 3.9 kB. time cmd,bash -c "…"and commands that begin with a line continuation are credited to the program that ran.time cargo build,bash -c "cd $D && make"and\+ newline +sed …were recorded undertime,bashor no name at all; they are now recorded undercargo,makeandsed. A script that changes directory and then runstokenade execwith its code in a heredoc is no longer recorded under a word of that code (for). A shell function defined in the command (p(){ sed -n "$2p" "$1"; }; p a.ts 1,20) is recorded under the program its body runs instead ofp(){, and a program kept in a variable with its arguments (S="ssh -i key host"; $S …) under that program. What reaches the agent is unchanged.pwdordatebefore a command no longer hides it.cd repo && pwd && git log --statwas recorded underpwdand cut likepwd's one-line output, losing most of the log; it is now recorded undergitand summarised like anygit log.- Node test runs reached through a script are summarised.
pnpm test,npm testor any script runningnode --test/tsx --testprinted TAP that was read as a markdown document or cut head-and-tail; it is now read as a test run: passing tests counted, every failure and the run's summary kept as printed. A real 81-test run went from 3.7 kB to 0.7 kB, and a 2.5 kB one to 0.6 kB. The passing count now counts tests only, not the suites that group them. - A command run in a subshell,
( … ), is read as that command.for d in a b; do ( git log --stat -- $d ) & donewas recorded under no name at all and its output summarised as generic text; it is now recorded undergitand summarised like anygit log, commit headers kept. - A command run through
bash -c '…' | headis credited to the program it ran.bash -c 'git log' 2>&1 | head -20was recorded on your dashboard underbash; it is now recorded undergit. What reaches the agent is unchanged. - Dollar savings are priced in the tokens Claude actually bills. Savings were counted with a tokenizer that undercounts Claude's: on real sessions, Claude bills about 1.6 tokens for each one tokenade counted. The dollar value of your savings now uses the tokens your model bills, so it reads about 60 % higher than before for Claude models — the tokens saved did not change, only how they are priced.
- The savings figure now deducts what you recover with
expand-ref. When the agent opened a folded output again, the fold was still credited in full although part of it came back into context; whatexpand-refprints is now subtracted, so the figure is what was actually saved. - The batching figure no longer counts turns the agent would have saved anyway. Fetching several pages, searches or questions in one tokenade call was credited as if the agent would otherwise have asked for them one turn at a time. Measured on real sessions, agents already ask for several pages or searches in a single turn about 95 % of the time, and for several files about 76 % of the time, so the credit now keeps only the remaining share.
- Several questions asked in one call now count as turns saved.
tokenade read,web,expand-refanddisclosewith--prompt "q1, q2, q3"answer each question under its own heading in one round-trip; the turns this avoided were never counted. They now appear in the dashboard's batching figure, counting only the questions that found an answer. The same goes fortokenade skeleton a b c(each outline served whole) andtokenade query A B C(each symbol found), credited after deducting how often agents look up several files (76 %) or several symbols (47 %) in one turn anyway. In Claude Code, each turn saved this way is also credited with what it would have cost to re-read the conversation at that moment — read from the session itself, not estimated — the largest part of what a saved turn is worth. - The dashboard counts the turns saved by parallel tool calls again. When the agent ran several tools in one turn, the results it no longer had to carry through extra turns were meant to be credited, but Claude Code now writes each call of a turn on its own line and none were recognised as one batch: the figure stayed at zero. Each turn's calls are now grouped together — on 1 045 real sessions, 12 000 batched turns are counted where none were. Each parallel call is credited with the share tokenade's last batching reminder caused, which shrinks with the number of turns since that reminder: measured on real sessions, batching of commands is 5.4 times likelier on the turn right after a reminder (81 % caused by it), still 3 times likelier 11 to 20 turns later (68 %), and settles at about 1.3 times (22 %) after 50 turns. Parallel calls made before any reminder are the agent's own habit and are not credited — about 60 % of the previous figure remains. Each call a batch spared is also credited with the conversation it would have re-read — read from the session's own usage figures — as for tokenade's own batched commands.
- GoogleTest binaries are summarised whatever their name. A C/C++ test binary built with GoogleTest (
./my_lib_tests) was folded as generic text that regrouped lines by shape: with two failing tests, the second failure's location and values were printed under the first one's suite. Each failing test now keeps its whole block in order, passing tests are counted per suite, and the final summary is kept as printed (a real 180-test run: 13.7 KB → 1.5 KB). - A command that starts with
mkdir,touch,sourceordisownis read as the command that follows.mkdir -p out && git log --statwas treated asmkdir— its output folded by the wrong reader and the dashboard creditingmkdir; it is now handled exactly likegit log --stattyped alone. Same forsource .venv/bin/activate && pytest,touch f && …,cmd & disown; tail log. npxcommands are no longer mistaken for package installs on the day npm announces an update. npm's "New minor version of npm available" notice, added to whatevernpxran, made the whole output read as annpm install: a realnpx slidev buildcame back with annpm: 0 warnings, 0 errorsheader and its build table untouched. The notice is now ignored when deciding what the output is, so the build, type-check or lint output gets its own compaction (4.3 KB → 1.9 KB on that build).- Vite builds (
vite build,npm run build,slidev build): the asset table is summarised. A build listed every emitted file — sixtydist/assets/…-hash.js 0.58 kBlines for a small slide deck — and reached the agent almost whole. The result line, warnings, HTML entries and the five largest files are now kept as printed, and the rest is summed up by folder and file type (a realnpm run buildof a slide deck: 4 KB → 2 KB). - Worktrunk (
wt):wt mergekeeps the verdict of the hooks it runs. Awt mergethat ran the project's tests was cut to its first 50 lines: the test suite's result and the merge itself (◎ Merging) were dropped, while dozens of… oklines were kept. Each hook's output is now compacted like the hook's own command (a 400-test run: 20 KB → under 1 KB, verdict and every worktrunk line kept; a failing test kept in full). - Reading several files in a loop keeps each file.
for f in a b c d; do echo "=== $f"; cat -n "src/$f.rs"; donewas cut like plain text: the middle files and their headers disappeared (2 of 4 headers, 8 definitions kept on a real four-file read). It is now read likecatof those files: every header the loop printed and 32 definitions, at the same size. - The dashboard's command list names the command that ran. A command written over several lines, launched through
bash -c '…'orsh -c "…"(also behindtimeout,nohup,env X=1orVAR=x), run asbash script.sh, guarded by[ -f x ] &&, grouped in{ …; }or ending a wait loop withbreak, was listed underbash,sh,[,for,if,{, or a word from a heredoc's body, so the commands that actually used tokens were hidden. They are now listed under their real name (git,python3,cat, the script's name — and a program held in a variable,B=./bin/tool; $B …, by the program's own name), and the output goes to that command's compaction:timeout 60 bash -c 'git show HEAD'is now compacted exactly likegit show HEAD. codex execandcodex reviewoutput is cut to what the calling agent needs — plain or--json. An agent that hands a task to Codex received the whole session (with--json, every event twice and every command's full output): every command's output, hook messages, and the same diff up to four times. It now gets the model, the session id (forcodex exec resume), the token count, each command with its status (with the last lines of any failure no later run fixed), errors, the final diff once (or, with--json, the files it changed), and Codex's answer or review, once; the full session stays onetokenade expand-refaway.tokenade dashboardsays where the page went. When a browser was already running, the dashboard opened as a new tab in the background and the command printed only afile://address, so it looked as if nothing had happened; it now saysdashboard opened in your browser (new tab).