03 — Prior art and market scan

Summary

Current tools concentrate on visible prose and memory while leaving cache reads, cache writes, and thinking—the dominant measured cost buckets—largely untreated. TL;DR

• All four operator-named tools exist, verified from primary pages: caveman (71,891 stars) compresses visible prose; cavemem (521) stores pre-compressed memory; cavekit (1,014) is a spec-driven build loop; fff (8,351) is a resident file-search MCP with latency numbers (3–9 s -> sub-10 ms) but no published token percentage.
• The market crowds onto the two smallest cost buckets of a real heavy session — visible prose (17% of dollars) and memory files (slice of the 2% uncached input) — while nothing ships for the big three: cache reads (32%), cache writes (29%), thinking (20%) (local measurement; see 01 — Token Economics and Measurement).
• The best-evidenced technique is negative-cost and already a Claude Code default: MCP tool deferral / Tool Search Tool — 85% tool-token cut with accuracy up 49% -> 74% (Anthropic); locally 1,420 -> ~60 tok (96%) on an 11-tool fleet.
• Caching is the floor, not free money: on the modeled heavy day it already turns ~$84 into ~$22 (-74%, ESTIMATE from local profile + live multipliers) — the remaining bill is 61% cache reads+writes, and any technique that breaks prefix stability must beat ~5.5x compression just to break even (ESTIMATE, record 19).
• Local kills (fresh, checked-in token counter, Fable-family tokenizer): TOON saves 41.2% vs minified JSON, not "60%" (34.3% of the headline is just minification); caveman's "~75%" replicates as 58.5% on tokens; the Fable-vs-Sonnet tokenizer gap is content-specific — prose/ASCII gets the premium, but code/CJK probes were near-neutral.

Question and scope

Which published tools and techniques reduce end-to-end coding-agent tokens, and which claims collapse under direct measurement?

Method

Scope and method

Scanned: the four operator-named tools, Claude Code's official cost levers, the plugin/MCP ecosystem, gateways, and research-grade prompt compression. Every external claim carries a source URL and evidence tier. Local numbers use checked-in token counter (free count_tokens endpoint; the single-user-message wrapper adds a constant 7 tokens — percentages below are conservative by <1 point). Dollar arithmetic uses the modeled heavy-day profile from 01 — Token Economics and Measurement: ~6 sessions/day, ~19 calls/session, 5.5k uncached input, 85k cache-write, 1.17M cache-read, 27k output (54.8% thinking), ~$22/day split 32% cache-read / 29% cache-write / 20% thinking / 17% visible output / 2% uncached input. Validation protocols are designed to run on the harness in 16 — Validation Harness: the No-Quality-Loss Proof Protocol; this machine's own overhead baseline is in 02 — Baseline audit of the research environment.

Findings

Market map

Local measurements run for this file (checked-in token counter, claude-fable-5)

Serialization — identical 10-row x 4-field uniform dataset, plus a nested-config control:

An independent local measurement with a different dataset of the same shape produced -60.6%/-40.8%/-33.6%, agreeing within about one percentage point.

Tool-result filtering — synthetic 630-line cargo-test log (577 pass, 3 failure blocks), filtered with grep -B1 -A6 -E "FAILED|panicked|error\[" | head -100. Repetitive pass-lines are the favorable (and typical) case; the honest general claim stays "80–99%":

Cross-tokenizer, identical fixed text (7-tok wrapper included):

Sonnet 4.6 and Haiku 4.5 return byte-identical counts — shared tokenizer confirmed. Other baseline samples measured +15% for code and +38% for prose; a tighter probe measured prose +35%, code −3%, and CJK −4% — the premium is prose/ASCII-specific, not code-wide. Treat the Rust row above as sample-specific.

Self-cost of the optimizer: the caveman plugin family's always-on skill listing (7 skills, names + descriptions as injected in the measured environment) = 940 tokens of prefix per session — ~0.5% of the modeled day in cache-read rent before it saves anything. Root AGENTS.md measured at 2,744 tokens.

---

The four operator-named tools

01. caveman (JuliusBrussee/caveman) — terse-register output compression: "why use many token when few do trick"; README headline "cuts ~75% of output tokens"; 71,891 stars (gh api)

• Layer: output (visible prose only). Mechanism: skill-prompt register change — lite/full/ultra strip filler, wenyan variants answer in Classical Chinese; companions: caveman-compress (memory files, "~46% input tokens"), cavecrew subagents ("~60% fewer tokens than vanilla"), caveman-commit/review; sibling caveman-code claims "~2x fewer tokens than Codex".
• Expected savings: visible output = 17% of modeled-day dollars ($3.74). Ultra locally cuts 58.5% of prose tokens; code/diffs pass through verbatim, so realistic whole-bill effect ~4–6%/day (ESTIMATE: 17% x 58.5% x prose share; independent mayhemcode estimate ~4%), hard ceiling ~10%.
• Evidence tier: T3, partially replicated locally. README benchmark: 10 tasks, per-task mean 65% (range 22–87%), pooled 1214 -> 294 = 75.8% — the "~75%" headline is the pooled ratio, 65% the per-task mean, both off one table, against an "Answer concisely." baseline, reproduction scripts in benchmarks/. Local: ultra 58.5%; wenyan-full 56.6% tokens (80.9% chars); wenyan-ultra 74.5%.
• Quality risk: QUALITY-TRADE at ultra/wenyan (lossy register, unreadable transcripts); ~NEUTRAL at lite/full. The README concedes the economics: "Caveman only affects output tokens — thinking/reasoning tokens untouched... cost savings a bonus", and cites arXiv 2604.00025 (repo-cited, unverified) claiming brevity improved accuracy 26 points. Degradation = dropped caveats/rationale; falsify by blind-grading paired answers.
• Availability: CLAUDE-CODE-TODAY (plugin marketplace; installed in this environment). Effort to adopt: minutes.
• Composability: stacks with caching/hygiene/deferral; does not touch thinking (54.8% of output tokens locally); its own skill listing costs 940 tok/session of prefix (above); wenyan modes meet an unfavorable CJK tokenizer (~1.47 chars/tok).
• Validation protocol: 20 fixed tasks, caveman-ultra vs "answer concisely"; visible-output tokens from JSONL usage minus thinking; blind-grade completeness on a 5-point rubric; require <=0.5-point drop; report per-register deltas.

02. cavemem (JuliusBrussee/cavemem) — pre-compressed persistent memory over MCP; claims "~75% fewer prose tokens"; 521 stars (gh api)

• Layer: input (memory/context injection). Mechanism: session event -> redact -> caveman-compress -> SQLite+FTS5; MCP retrieval (BM25 + vector blend, alpha 0.5), progressive disclosure (snippets first, bodies on demand); code/URLs/paths preserved verbatim.
• Expected savings: unmeasurable from published data — no benchmark table, one worked example. On the modeled day, injection lands in the 29% cache-write + 32% cache-read lines; the offset (avoided re-exploration) is unquantified by anyone. Given local register data, expect ~55–60% on stored prose, not 75% (ESTIMATE).
• Evidence tier: T4 verging T3-weak (README; no independent replication found; adds its own MCP schema overhead).
• Quality risk: RISKY — lossy memory drops nuance; retrieval ranking unmeasured; degradation = confidently-wrong recalled "facts". Falsify by quizzing the store against original transcripts.
• Availability: CLAUDE-CODE-TODAY (MCP; also Cursor, Gemini CLI, OpenCode, Codex). Effort to adopt: minutes-to-hours.
• Composability: family stack ("cavekit orchestrates, caveman compresses output, cavemem compresses memory" — getcaveman.dev); competes with claude-mem (15); deferral (10) absorbs its schema cost.
• Validation protocol: one-week A/B (memory on/off) on one project; ccusage day totals; injected-context tokens vs re-exploration tokens saved; separately ct.py-verify the ~75% claim on 50 real observations.

03. cavekit (JuliusBrussee/cavekit) — spec-driven autonomous build loop; caveman-encoded blueprints "~75% fewer tokens than prose"; 1,014 stars (gh api)

• Layer: turn-structure / orchestration artifacts. Mechanism: NL -> compressed blueprint kits -> parallel build -> verification; durable repo-root SPEC.md means /clear or compaction does not force re-deriving intent. Token relevance is secondary to the workflow change.
• Expected savings: no end-to-end number exists anywhere. Artifact compression touches a slice of the 2% uncached + write lines; the loop itself can multiply total calls — net sign unknown.
• Evidence tier: T4 — token claims inherited from caveman encoding; no published cavekit-vs-vanilla measurement.
• Quality risk: RISKY — autonomous iteration can spend far more than it saves; degradation = ballooning call counts per feature. Falsify with the protocol below.
• Availability: CLAUDE-CODE-TODAY (plugin). Effort to adopt: hours-to-days (whole-workflow change).
• Composability: designed for the caveman family; orthogonal to caching; the durable-spec idea composes with /clear (06) for free.
• Validation protocol: build the same 3 small features via cavekit and via a vanilla plan->implement session; compare total day tokens (ccusage), iteration counts, and diff quality; require equal-or-better diffs.

04. fff (dmtrKovalenko/fff) — resident file-search MCP: "Fewer grep roundtrips, less wasted context, faster answers" (README); 8,351 stars (gh api)

• Layer: turn-structure (tool-call count) + tool-result tokens. Mechanism: always-warm Rust index (no per-query spawn or .gitignore re-read); MCP tools ffgrep/fffind with frecency ranking, git-aware annotations, weak-match detection ("flags scattered fuzzy noise before it floods the agent's context"), fuzzy fallback avoiding zero-result dead ends — each avoided dead end is one avoided tool_use/tool_result pair.
• Expected savings: token side unquantified by the project — README text publishes latency ("3-9 SECONDS per ripgrep spawn and sub-10 ms per FFF query" on a 500k-file Chromium checkout; ~26 MB resident on 14k files) and a token-efficiency chart image, but no percentage in text. Tool results ride the 29%+32% cache lines; direction favorable, magnitude unknown.
• Evidence tier: T1 for latency (published, reproducible); T4 for tokens (qualitative: "faster and more token-efficient than the built-in one").
• Quality risk: potential NEGATIVE-COST — better-ranked results mean fewer wrong-file reads; unproven on the token axis. Degradation = fuzzy false-positives polluting context; falsify via the A/B below.
• Availability: CLAUDE-CODE-TODAY (MCP; also Neovim/Rust/C/Node). Effort to adopt: minutes.
• Composability: competes with native Grep/Glob and LSP-style code intelligence (official docs: a "go to definition" call replaces grep + reading candidates); opposite philosophy to aider's map (16): ranked search vs ranked map.
• Validation protocol: fixed 20-query search suite on this repo, native Grep/Glob vs fff MCP; sum tool_result tokens + call counts from session JSONL; require equal-or-better target-file hit rate.

---

Industry standard (automatic or near-universal)

05. Prompt caching — reads 0.1x, writes 1.25x/2x, automatic in Claude Code; the single biggest shipped lever

• Layer: cache / price multiplier. Mechanism: prefix storage with free refresh-on-hit; 512-token minimum on Fable 5; Claude Code places breakpoints automatically (platform.claude.com/docs/en/build-with-claude/prompt-caching).
• Expected savings: already banked. Counterfactual on the modeled day: without caching, reads bill 10x — day ~$84 vs $22 = -74% (ESTIMATE). Vendor launch table: up to -90% (book chat), -53% (multi-turn) (claude.com/blog/prompt-caching). The remaining bill is still 61% reads+writes — the target of 07 — Caching exploitation.
• Evidence tier: T1 (live pricing + launch table); locally corroborated: heavy-session prompt mix 0.44% uncached / 6.73% write / 92.83% read (local measurement).
• Quality risk: NEGATIVE-COST (pure price, no behavior change). Failure mode is economic: prefix churn converts 0.1x reads into 1.25x writes; falsify by diffing usage fields across a deliberately churned prefix.
• Availability: CLAUDE-CODE-TODAY (automatic) / SDK (explicit breakpoints, 1h TTL). Effort to adopt: zero in Claude Code; hours of prefix-stability discipline in SDK.
• Composability: stacks with batch (13); undermined by anything mutating the prefix — model switch (08), compaction (06), dynamic system prompts, LLMLingua (19).
• Validation protocol: from session JSONL, compute hit ratio and re-price the same usage at no-cache rates (confirm ~74% on your traffic); check whether Claude Code ever issues 1h-TTL writes (open question affecting the 29% write line).

06. Context hygiene — /clear, steered /compact, auto-compact at ~83% capacity (~167k) with ~33k reserved buffer

• Layer: turn-structure / context window. Mechanism: /clear resets ("Stale context wastes tokens on every subsequent message" — code.claude.com/docs/en/costs); /compact takes focus instructions; auto-compact summarizes near the threshold.
• Expected savings: unquantified by Anthropic. Independent JSONL trace: typical sessions = 76% useful work / 7% compaction summaries / 17% reserved headroom (dev.to slima4). Earlier /clear directly shrinks the 1.17M cache-read line (32% of modeled-day dollars) on every subsequent call.
• Evidence tier: T1 (official docs) + T3 (trace with thresholds).
• Quality risk: QUALITY-TRADE — summaries lose detail; degradation = re-asking answered questions post-compaction. Falsify by quizzing post-compaction state against pre-compaction facts.
• Availability: CLAUDE-CODE-TODAY. Effort to adopt: minutes (habits + compact instructions in CLAUDE.md).
• Composability: compaction rewrites the prefix — a hidden cache-write spike (anti-synergy with 05); /clear is cheaper than /compact when continuity is not needed; cavekit's durable spec (03) reduces what compaction must preserve.
• Validation protocol: capture usage.cache_creation_input_tokens around 10 compaction events to quantify the write spike; compare task success for /clear-per-task vs run-long-and-compact.

07. CLAUDE.md slimming + path-scoped rules + skills offload — official guidance "Aim to keep CLAUDE.md under 200 lines"

• Layer: input (per-call fixed prefix). Mechanism: memory file rides every call's prefix; path-scoped rules load per subtree (this repo already does this via per-directory agent rule files); skills carry only name+description (30–100 tok) until invoked (code.claude.com/docs/en/costs).
• Expected savings: honest arithmetic is small in dollars: root AGENTS.md = 2,744 tok (local) -> x19 calls x6 sessions x $1/MTok cache-read = $0.31/day rent (~1.4% of the modeled day); an 80% trim saves ~$0.25/day plus window headroom. Firecrawl: 3,847 -> 312 tok = 91.9% on the file itself, "no quality regression"; 41% from path-scoping (firecrawl.dev blog).
• Evidence tier: T1 (official guidance) + T3 (Firecrawl, vendor-interested) + local file measurement.
• Quality risk: RISKY if overdone — one bad PR from a dropped rule erases months of rent savings; degradation = rule violations. Falsify by replaying rule-sensitive tasks against the slimmed file.
• Availability: CLAUDE-CODE-TODAY. Effort to adopt: hours (editorial; caveman-compress automates lossily at claimed ~46%).
• Composability: multiplies with caching (smaller prefix = smaller perpetual rent); synergy with skills/path-scoping; feeds record 21's denominator.
• Validation protocol: ct.py the file before/after; replay the 10 most rule-sensitive recent tasks on both versions; zero new rule violations allowed; log the $-rent delta.

08. Model tiering — Fable 5 $10/$50, Opus 4.8 $5/$25, Sonnet 4.6 $3/$15, Haiku 4.5 $1/$5 — with the tokenizer trap

• Layer: infra / price-per-token and token count. Mechanism: /model switching, plan-on-big/build-on-small, subagent model pinning. Pricing-page note: "Opus 4.7 and later use a new tokenizer... may use up to 35% more tokens for the same fixed text" (platform.claude.com/docs/en/about-claude/pricing).
• Expected savings: independent trace: same session ~$5.50 on Sonnet vs ~$10+ on Opus (dev.to slima4). Cross-boundary math: use 3.33x Fable:Sonnet on code/CJK-heavy text and ~4.3x on prose/ASCII-heavy text after the tokenizer premium (ESTIMATE; verification). Downgrades save at least the sticker ratio, and prose-heavy downgrades save more.
• Evidence tier: T1 (prices + official note) + local measurement; both fresh local samples exceed the official 35% ceiling — flagged.
• Quality risk: QUALITY-TRADE — capability cliff on hard tasks; degradation = failed/looping attempts on the small model (retries can cost more than the discount). Falsify with $-per-solved-task, never $/MTok.
• Availability: CLAUDE-CODE-TODAY. Effort to adopt: minutes.
• Composability: model switch invalidates the prompt cache (anti-synergy with 05) and changes the tokenizer basis mid-ledger; $/MTok routers (17) mis-price cross-boundary moves by up to ~1.45x.
• Validation protocol: fixed 10-task set on Fable 5 / Opus 4.8 / Sonnet 4.6; record solved-or-not + total $ from JSONL; tokenizer-normalize via ct.py on one canonical text per model; report $/solved-task.

09. Thinking/effort control (/effort, MAX_THINKING_TOKENS) — the only shipped lever on the largest output component

• Layer: output (thinking; bills as output, $50/MTok on Fable 5). Mechanism: effort low/medium/high shapes reasoning depth; MAX_THINKING_TOKENS=8000 for fixed-budget models; adaptive-reasoning models ignore nonzero budgets; Fable 5 cannot disable thinking; default budgets "can be tens of thousands of tokens per request" (code.claude.com/docs/en/costs).
• Expected savings: vendor: "Set to a medium effort level, Opus 4.5 matches Sonnet 4.5's best score on SWE-bench Verified, but uses 76% fewer output tokens"; highest effort +4.3 points at -48% (anthropic.com/news/claude-opus-4-5; no Fable 5 curve published). Local ceiling: thinking = 54.8% of output tokens, 20% of modeled-day dollars ($4.40); halving thinking ~= $2.20/day (ESTIMATE).
• Evidence tier: T1 (vendor numbers, model-version-specific) + local decomposition (n=1).
• Quality risk: QUALITY-TRADE — extended thinking "significantly improves performance on complex planning" (docs); degradation = shallow plans/missed edge cases on hard tasks. Falsify per task type: easy tasks at low effort should show zero quality delta.
• Availability: CLAUDE-CODE-TODAY (/effort, env var) / SDK (effort parameter). Effort to adopt: minutes.
• Composability: orthogonal to all input-side levers; the ONLY shipped tool touching the bucket caveman (01) explicitly skips. White-space: per-task-type effort routing (Gaps 1).
• Validation protocol: 20 tasks stratified easy/hard at high vs medium effort; thinking tokens = JSONL output_tokens minus count_tokens of visible blocks; require no hard-task regression; report $/day delta.

10. MCP tool deferral / Tool Search Tool — the proven negative-cost optimization, now a Claude Code DEFAULT

• Layer: input (tool schemas). Mechanism: schemas stay out of context (names only) until needed; API Tool Search Tool queries a registry; Claude Code defers MCP definitions by default ("only tool names enter context until Claude uses a specific tool" — code.claude.com/docs/en/costs).
• Expected savings: vendor: "an 85% reduction in token usage" (context preserved 191,300 vs 122,800 of 200k), MCP-eval accuracy 49% -> 74% (Opus 4) and 79.5% -> 88.1% (Opus 4.5); five-server example ~55K schema tokens; internal fleets hit 134K pre-optimization (anthropic.com/engineering/advanced-tool-use). Local: 11 schemas = 1,420 tok loaded vs ~60 deferred = 96% (local measurement). Modeled day: an undeferred 20k fleet = 20k x19 x6 x $1/MTok = $2.28/day (~10%) read rent (ESTIMATE).
• Evidence tier: T1 + local reproduction (consistent direction and magnitude).
• Quality risk: NEGATIVE-COST — vendor evals show accuracy rises (less irrelevant-tool confusion). Residual failure mode: a needed deferred tool goes unfound; falsify with task suites requiring rare tools.
• Availability: CLAUDE-CODE-TODAY (default) / SDK. Effort to adopt: zero; audit via /context and /mcp.
• Composability: makes large MCP fleets viable; complements CLI-over-MCP (20); absorbs the schema cost of cavemem (02) and fff (04).
• Validation protocol: /context audit loaded-vs-deferred; fixed task set exercising 3 rarely-used tools; require 100% tool-discovery success; report prefix-token delta.

---

Proven tactics (vendor or peer-reviewed numbers)

11. Programmatic tool calling / code-execution orchestration — 37% average cut with accuracy gains

• Layer: turn-structure / tool-result tokens. Mechanism: model writes code calling tools in a sandbox; intermediate results never enter context; community "Code Mode" collapses 12-turn MCP workflows into 4 (thenewstack.io).
• Expected savings: "Average usage dropped from 43,588 to 27,297 tokens, a 37% reduction on complex research tasks"; accuracy up (25.6 -> 28.5 internal retrieval; 46.5 -> 51.2 GIA) (anthropic.com/engineering/advanced-tool-use). On the modeled day, tool results ride the 29%+32% cache lines; a 37% cut on tool-heavy turns plausibly reaches low-double-digit % of day (ESTIMATE, workload-dependent).
• Evidence tier: T1 (vendor evals).
• Quality risk: NEGATIVE-COST per vendor numbers; failure mode is sandbox bugs silently eating results. Falsify by checksumming sandbox outputs against direct calls.
• Availability: SDK (API feature); Claude Code analog = Bash piping, hooks, subagent offload — not the API feature itself (absent from the costs-page levers). Effort to adopt: days (sandbox + re-plumbing).
• Composability: stacks with Tool Search (10); same philosophy as preprocessing (20).
• Validation protocol: port 5 multi-tool workflows to code-execution; require bit-identical final artifacts; compare total tokens.

12. Context editing + memory tool (API beta) — 84% token cut on a 100-turn eval while improving performance 39%

• Layer: cache / context window (API-level). Mechanism: server-side auto-clearing of stale tool calls near the limit; memory tool persists state outside the window.
• Expected savings: "reducing token consumption by 84%" on a 100-turn web-search eval; +39% (memory+editing) / +29% (editing alone) performance (claude.com/blog/context-management). Maps onto the 32% read line for SDK agents.
• Evidence tier: T1 (vendor evals; search-task domain, NOT code-editing).
• Quality risk: NEGATIVE-COST on agentic search per vendor; unproven on code workloads where an evicted tool result may be needed 40 turns later. Falsify on SWE-bench-style tasks before trusting.
• Availability: SDK (beta header); NOT-USER-ACCESSIBLE as a tunable inside Claude Code (which ships compaction instead). Effort to adopt: hours (flag + config).
• Composability: edits invalidate cached prefix sections — same cache-vs-pruning tension as compaction (06); the user-side gap is Gaps 4.
• Validation protocol: replicate the eval shape on 10 long code sessions; measure tokens + task success vs a no-editing control.

13. Batch API (50% off) + agent-team cost discipline (~7x warning)

• Layer: infra / price multiplier and session multiplicity. Mechanism: async batch = "50% discount on both input and output tokens", stacks with caching (platform.claude.com/docs/en/about-claude/pricing); teams = "approximately 7x more tokens than standard sessions when teammates run in plan mode" (code.claude.com/docs/en/costs).
• Expected savings: moving offline-able work (CI review, nightly triage, evals) to batch: $22 -> $11 on the modeled day upper bound (realistic = the offline fraction); batch+Haiku stack ~5% of Fable-interactive unit cost (ESTIMATE: 0.5 x 0.1 input ratio). Team discipline is loss-avoidance: one env flag (CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1) swings cost more than every compression plugin in this scan combined.
• Evidence tier: T1 (both verbatim from live Anthropic pages).
• Quality risk: NEUTRAL (batch trades latency only); teams degrade economically, not qualitatively. Falsify batch quality by diffing batch-vs-interactive outputs on identical jobs.
• Availability: SDK (batch) / CLAUDE-CODE-TODAY (teams flag). Effort to adopt: days (re-architect offline jobs); zero (don't over-spawn).
• Composability: batch x caching x Haiku is the deepest legitimate price stack; teams anti-compose with everything.
• Validation protocol: run the nightly PR-review job both ways for a week; require equal review-finding recall; report $ delta.

14. Serialization-format engineering: TOON + JSON minification [LOCALLY VERIFIED] — a third of the headline is just minifying

• Layer: input (structured data in prompts / tool results). Mechanism: TOON replaces repeated JSON keys/braces with a schema header + CSV-like rows.
• Expected savings: LOCAL TABLE ABOVE: TOON -61.4% vs pretty, -41.2% vs minified; minification alone -34.3% (tabular) / -28.7% (nested) — free and riskless. Official: 39.9% fewer tokens at equal-or-better retrieval accuracy (76.4% vs 75.0%) (toonformat.dev/guide/benchmarks); nested/irregular reality check: 1.8–20% (dev.to tejas_page). Affects only the structured-data fraction of your prompts.
• Evidence tier: T3 + local reproduction (two independent local measurements agree within about one percentage point).
• Quality risk: NEUTRAL on uniform data (accuracy equal-or-better in official benchmark); RISKY for deep nesting (format breaks down, less training exposure). Falsify with retrieval-QA over your own TOON-ized payloads.
• Availability: GATEWAY-OR-SELF-HOST for your own MCP servers/hooks; NOT adoptable for Claude Code's native tool results. Effort to adopt: hours (own tools); minification is minutes.
• Composability: natural for MCP servers returning tabular data; orthogonal to caching.
• Validation protocol: ct.py your three largest real tool-result payloads in pretty/minified/TOON; 20-question retrieval quiz per encoding; adopt only where accuracy is flat.

---

Significant industry use, weaker or absent numbers

15. claude-mem (thedotmack/claude-mem) — compressed cross-session memory; adoption king: 81,976 stars (gh api), bigger than caveman

• Layer: input (memory injection). Mechanism: 5 lifecycle hooks + Bun worker (:37777) over SQLite + Chroma; tiered retrieval: search ~50–100 tok/result, get_observations ~500–1,000; claims "~10x token savings by filtering before fetching details" (README).
• Expected savings: the ~10x is a retrieval-path claim, not whole-session; no independent net accounting (injection + compression-call cost vs re-exploration saved) exists — same hole as cavemem (02).
• Evidence tier: T3 (massive adoption, self-reported number).
• Quality risk: NEUTRAL-to-RISKY — stale/wrong memories mislead sessions; degradation = acting on outdated project facts. Falsify by auditing 50 injected memories for currency.
• Availability: CLAUDE-CODE-TODAY (also Gemini CLI, OpenCode). Effort to adopt: minutes-to-hours (persistent local service).
• Composability: competitor to cavemem; SessionStart injection enlarges the cached prefix (interacts with the 29% write line).
• Validation protocol: cavemem's week-long A/B, plus meter the worker's own SessionEnd compression calls.

16. aider repo map — graph-ranked code context: whole-repo awareness for ~1k tokens

• Layer: input (codebase context selection). Mechanism: "a concise map of your whole git repository" with key signatures, ranked on a dependency graph; --map-tokens "defaults to 1k" (aider.chat/docs/repomap.html).
• Expected savings: never published as a single number; influence is the evidence — Claude Code's Explore agent and code-intelligence plugins are descendants.
• Evidence tier: T1 for mechanism/budget; T4 for savings magnitude.
• Quality risk: NEGATIVE-COST by design intent (fewer wrong-file reads); degradation = stale symbols in the map. Falsify via tokens-per-solved-task, map on/off.
• Availability: GATEWAY-OR-SELF-HOST (aider itself); pattern portable as a Claude Code skill. Effort to adopt: zero in aider; days to port well.
• Composability: alternative to fff (04); pairs with grep retrieval.
• Validation protocol: aider benchmark harness, --map-tokens 1024 vs 0, fixed task set; report tokens/solved.

17. LiteLLM gateway — spend tracking, exact + semantic caching, routing; name-checked in Anthropic's costs docs

• Layer: infra / gateway. Mechanism: per-key spend tracking; response caching in 7 backends (semantic similarity_threshold 0.8); routing/fallbacks (docs.litellm.ai/docs/proxy/caching).
• Expected savings: none quantified in its own docs; semantic-cache hits on coding-agent traffic (unique diffs, file contents) are near-worst-case — expect ~0 (ESTIMATE; kill K8).
• Evidence tier: T1 product, T4 for any coding-agent savings number.
• Quality risk: RISKY (semantic cache can return stale code for similar-but-different questions); NEUTRAL for spend tracking. Pass-through danger: a gateway that drops cache_control destroys the 74% caching floor (05).
• Availability: GATEWAY-OR-SELF-HOST. Effort to adopt: days.
• Composability: must preserve cache_control; tokenizer-blind routing mis-prices cross-boundary moves (08).
• Validation protocol: replay a week of real traffic through the proxy; measure semantic hit rate (expect ~0 — kill the pattern with data) and verify end-to-end cache-read ratios unchanged.

18. Usage observability — ccusage (16,080 stars, gh api), /usage, JSONL tracing: saves nothing, underwrites everything

• Layer: infra / observability. Mechanism: ccusage parses local transcript JSONL into daily/session/model costs; /usage attributes usage to skills, subagents, plugins, individual MCP servers (code.claude.com/docs/en/costs).
• Expected savings: none direct; reveals the official denominators: "~$13/dev/active day", $150–250/month, 90% of users under $30/day, background burn <$0.04/session (same page).
• Evidence tier: T1 (shipped tools on real local data); the dev.to JSONL trace is the strongest independent accounting published.
• Quality risk: NEUTRAL. Failure mode: misattribution; falsify by reconciling ccusage totals against console billing.
• Availability: CLAUDE-CODE-TODAY. Effort to adopt: minutes.
• Composability: foundation for every validation protocol here; see 16 — Validation Harness: the No-Quality-Loss Proof Protocol.
• Validation protocol: reconcile one week of ccusage vs console invoice; require <5% divergence before trusting any A/B in this file.

19. LLMLingua / LongLLMLingua / LLMLingua-2 — peer-reviewed ceiling ("up to 20x"), absent from every shipped coding agent

• Layer: input (prompt body). Mechanism: small-LM perplexity pruning (EMNLP'23); question-aware coarse-to-fine for RAG (ACL'24: +21.4% RAG performance at 1/4 tokens); distilled classifier 3–6x faster (ACL'24 Findings) (github.com/microsoft/LLMLingua; 6,284 stars — maintenance slowing).
• Expected savings: 20x headline is NL-domain. Killer arithmetic on the modeled day: compression that breaks prefix caching must clear (70.4+5.1+0.44)/x + 8.14 = 22 -> x ~= 5.5 (82% compression) just to break even against plain Claude Code caching; 4x compression loses money ($27.1 > $22) (ESTIMATE).
• Evidence tier: T2 (peer-reviewed) for NL benchmarks; T4 for code-agent use (no code-domain validation found, searched).
• Quality risk: RISKY for code — identifiers and syntax are what perplexity pruning drops; degradation = hallucinated symbol names. Falsify on SWE-bench-style tasks before any use.
• Availability: GATEWAY-OR-SELF-HOST (Python lib; LangChain/LlamaIndex integrations). Effort to adopt: project (compression model in the hot path; GPU + latency).
• Composability: CONFLICTS with prompt caching (05) — the defining anti-synergy of the input-compression category.
• Validation protocol: run the break-even formula on your own JSONL profile first; only if x > 5.5 is plausible, run 20 code tasks compressed-vs-not and diff symbol-level accuracy.

20. Preprocessing pipeline — hooks filtering, markdown-not-HTML, CLI-over-MCP: shrink content BEFORE the model sees it

• Layer: input (tool results). Mechanism: PreToolUse hooks rewrite commands (official example pipes test output through grep — "tens of thousands of tokens to hundreds", code.claude.com/docs/en/costs); fetch web as markdown; max_content_tokens caps runaway pages (10 kB page ~2,500 tok, 500 kB PDF ~125,000 tok — pricing docs); prefer gh/aws/gcloud/sentry-cli over equivalent MCP servers ("still more context-efficient" — official).
• Expected savings: LOCAL: 630-line synthetic test log 10,108 -> 590 tok = -94.2% with all 3 failures preserved (local measurement, table above). Cited: 94% per web page (38,381 -> 2,788), "80-99% compression on build and test logs" (firecrawl.dev blog). Tool results ride the 29%+32% cache lines.
• Evidence tier: T1 (official pattern) + local reproduction + T3 (Firecrawl, vendor-interested).
• Quality risk: RISKY if filters hide the error the model needed; NEGATIVE-COST when failure signal is preserved — the local run shows both at once are achievable. Falsify by injecting novel error shapes and checking the filter passes them.
• Availability: CLAUDE-CODE-TODAY (hooks, settings.json); this repo's filtered test runners (TESTING.md) are the same idea already shipped. Effort to adopt: hours.
• Composability: stacks with everything; the Claude Code-native sibling of programmatic tool calling (11).
• Validation protocol: per filter, a red-team set of 10 unusual failure modes; require 10/10 surfaced post-filter; track tokens saved per call from JSONL.

21. Fixed-overhead accounting — the ~14,328-token per-call baseline + MCP fleet bloat (diagnosis, not cure)

• Layer: input (fixed per-call). Mechanism (of the measurement): independent JSONL traces ("consistently using approximately 14,328 tokens" — dev.to slima4); per-version prompt catalog (Piebald-AI/claude-code-system-prompts: Explore 575 tok, Plan mode 715, statusline 2,433); issue #52979 reports 20–30k on trivial prompts; community 15–20k multi-server MCP overhead, one deployment 143k/200k; Anthropic internal 134K pre-optimization; Anthropic cut its own tool-use system prompt 675 -> 290 tok (-57%) between Opus 4.7 and 4.8 (pricing page).
• Expected savings: N/A directly; rent arithmetic: 14,328 x19 x6 x $1/MTok = $1.63/day (~7.4% of the modeled day) in cache-read rent (ESTIMATE). Cures are records 07 and 10.
• Evidence tier: T3 (converging independent traces) + T1 (Anthropic's own figures). All cached after first write — overhead seeds the 32% read line, not full-price input (kill K9).
• Quality risk: NEUTRAL (a fact, not an action); mis-reading it as uncached cost overstates the problem 10x.
• Availability: CLAUDE-CODE-TODAY (audit via /context). Effort to adopt: minutes to audit.
• Composability: the denominator for every percentage in this file; this machine's own numbers in 02 — Baseline audit of the research environment.
• Validation protocol: /context on this setup; decompose system prompt / tools / memory / skills; reconcile with first-call cache_creation_input_tokens in JSONL; re-audit after applying 07 + 10.

---

White space — what nobody ships

1. Thinking-token optimization — 54.8% of output tokens, 20% of dollars, not disableable on Fable 5; only blunt levers exist (/effort, MAX_THINKING_TOKENS). No per-task-type effort routing, no thinking-waste detection. Caveman's README concedes the bucket explicitly.
2. Cache-economics tooling — reads+writes = 61% of heavy-session dollars; nothing optimizes breakpoint placement, predicts 5-min-vs-1-h TTL value, schedules compaction to minimize write spikes, or reports write amplification (ccusage shows totals, not causes). See 07 — Caching exploitation.
3. Tokenizer-aware routing — the prose/ASCII tokenizer premium means every $/MTok router can mis-price cross-boundary switches; nobody normalizes, and code-heavy work needs separate counts.
4. Mid-session selective context pruning in Claude Code — the API has context editing (84% cut, vendor-proven); end users get only whole-conversation compaction.
5. Net-accounted memory — claude-mem (82k stars) and cavemem inject context and run compression calls; neither publishes injection-cost-vs-exploration-saved accounting.
6. Format-aware tool-result serialization — the locally-verified 41.2%/34.3% wins are not integrated into any agent's tool-result path or popular MCP server.
7. Independent replication infrastructure — every vendor self-reports; a public ct.py-style harness re-measuring plugin claims against live tokenizers does not exist (this dossier's method is itself novel prior art; see 16 — Validation Harness: the No-Quality-Loss Proof Protocol).
8. Output brevity with quality gates — caveman trades readability blindly; nothing compresses output only when a verifier confirms zero information loss.

Surprising findings

• Token-cutting can be quality-improving, with vendor proof: Tool Search -85% tokens with accuracy 49 -> 74; programmatic calling -37% with accuracy up. Negative-cost optimization is shipped, not theoretical.
• Anthropic admitted internal tool definitions hit 134K tokens pre-optimization, and cut its own tool-use system prompt 57% (675 -> 290) between model versions — vendor-side overhead shrinks release-over-release.
• The memory niche out-adopted the compression niche: claude-mem 81,976 stars vs caveman 71,891 — and caveman 5x'd from ~14k in ~10 weeks since early April 2026, the fastest-growing plugin category of 2026.
• The optimizer taxes itself: caveman's always-on skill listing costs 940 tokens of prefix per session (local), ~0.5% of the modeled day — while plain JSON minification (-34.3%, free) goes unmarketed and one experimental flag (agent teams, ~7x) moves cost more than every compression plugin in this scan combined.

Implications for jackin❯

For jackin❯, the prior art and market scan evidence identifies which mechanisms are safe to adopt directly and which still require workload-specific validation.

Limitations and unknowns

Claims to kill (folklore ledger)

Sources

Related work

• Token-optimization techniques dossier
• Validation harness
• Context engine