Have you ever opened your LLM billing dashboard after a long refactoring sprint and noticed how much of your spend went to polite filler rather than actual code? Modern coding agents repeat verbose pleasantries, hedge obvious conclusions, and re-ingest massive terminal logs on every single turn of an agentic loop.
Caveman is an open-source agent skill and local proxy created by Julius Brussee under the deliberately broken-English tagline "why use many token when few token do trick." It compresses conversational responses and verbose tool outputs across coding agents while preserving code blocks, file paths, commands, and errors byte-for-byte, allowing the original text to be restored losslessly whenever needed.
Important
- Lossless Local Recovery: Bulky terminal and tool outputs compressed by the local proxy receive content-addressed handles (
ccr_...) backed by a local SQLite store (~/.caveman/ccr.db), letting the agent retrieve the exact raw text on demand via MCP. - Transparent Benchmark Attribution: Project maintainers report roughly 65% token reduction on short prose benchmarks, whereas an independent July 2026 JetBrains SkillsBench study measured 8.5% output-token reduction on end-to-end coding tasks; Kling Digital has not independently lab-tested the 65% claim.
- Byte-Exact Technical Fidelity: Compression targets natural-language fluff and repetitive log noise only—source code, diffs, CLI commands, and stack traces remain untouched.
For engineering organizations designing production enterprise AI solutions, uncontrolled token consumption directly erodes unit economics. Even when delivery teams estimate upfront engineering budgets with a project cost calculator, recurring LLM inference overhead during multi-file debugging loops quickly dominates operational spend. That financial reality explains why Caveman spread rapidly among developers facing unexpectedly steep API bills.
Why Caveman Gained Rapid Developer Adoption
By late 2026, terminal and IDE coding agents—including Claude Code, Codex CLI, Cursor, Windsurf, OpenCode, and Gemini CLI—have shifted from single-turn autocomplete to long-horizon autonomous loops. A single bug fix can trigger dozens of file reads, test suite executions, linter runs, and stack trace inspections.
Because frontier language models are aligned for courteous human dialogue, they wrap terse technical facts in generous padding. Explaining a React re-render issue might take 69 tokens of conversational prose, whereas the exact same engineering root cause fits into 19 tokens: "New object ref each render. Inline object prop = new ref = re-render. Wrap in useMemo."
Within the broader November 2026 open-source AI agent ecosystem, Caveman crystallized a practical movement toward context hygiene. Yet evaluating whether Caveman belongs in your team's toolchain requires separating its early prompt-compression layer from its more recent local proxy architecture.
Two-Layer Architecture: "Say Less" Skill and "Read Less" Local Proxy
Caveman evolved from a lightweight prompt skill into a dual-layer token-optimization stack addressing both directions of model traffic.
1. Output Compression Layer (Agent Skill & Verbosity Modes)
The core caveman skill is published under the MIT License and plugs directly into agent skill registries or rule files. It instructs the model to drop pleasantries, hedging qualifiers, redundant articles, and conversational transitions while enforcing strict preservation of code fences, paths, and shell invocations.
Developers can adjust terseness dynamically mid-session through slash commands:
/caveman lite: Removes conversational pleasantries and filler phrases while retaining readable prose (maintainers cite roughly 30% prose reduction)./caveman(defaultfullmode): Activates telegraphic engineering syntax where maintainers report roughly 65% output reduction on prose-heavy explanations./caveman ultra: Maximum telegraphic compression, stripping secondary framing altogether (maintainers cite 75%–80% on prose outputs)./caveman off: Immediately restores standard prose—essential when drafting pull request summaries, architecture decision records, or customer-facing documentation.
2. Input & Tool-Output Compression Layer (caveman-proxy)
In real coding loops, input tokens—not output tokens—drive the bulk of API costs. Every passing test line, redundant JSON payload, and repeated build log re-enters the prompt window turn after turn. Caveman's local proxy (caveman start or caveman wrap, with proxy/engine packages licensed under BSL-1.1 / Apache-2.0 depending on the component) intercepts traffic between the agent and provider APIs to shrink noisy inputs before billing occurs.
Crucially, Caveman avoids destructive truncation through a content-addressed recovery store:
- When the proxy elides or compresses a bulky tool response, it preserves exact exit codes, file paths, and error signatures while emitting a compact recovery handle (such as
ccr_...orccr://). - Simultaneously, the uncompressed raw bytes are persisted locally in a bounded SQLite database (
~/.caveman/ccr.db) alongside metadata and timestamps. - Whenever the agent determines that the compressed summary lacks a subtle line needed for debugging, it invokes a local Model Context Protocol (MCP) tool (
caveman_retrieve) with the handle. The proxy returns the byte-exact original content straight from local disk—zero cloud storage, zero silent data loss.
Tip
If static instruction files such as CLAUDE.md or project preference manifests inflate every session prompt, Caveman includes /caveman-compress . It rewrites the file into compact form while automatically preserving a human-readable backup outside your repository tree under $XDG_DATA_HOME/caveman-compress/backups/.
Evaluating the ~65% Token Reduction Claim Honestly
Credible engineering guidance demands distinguishing vendor or maintainer benchmarks from independent workload evaluations. According to Caveman's maintainers, token expenditure drops by roughly 65% (and up to 75% in ultra modes) when measured on short prose explanations and conversational Q&A. To be completely transparent, Kling Digital has not run an internal laboratory benchmark to verify that 65% figure, and teams should never treat a headline percentage as a universal billing guarantee.
In July 2026, JetBrains published an independent A/B evaluation of the Caveman prompt skill using SkillsBench across hundreds of realistic, long-horizon coding tasks. Two findings stood out:
- Real-World Coding Output Savings Averaged 8.5%: Because real agent runs spend most of their output budget on code blocks, unified diffs, and structured tool arguments—all of which Caveman intentionally leaves untouched—the prompt-only skill reduced end-to-end output tokens by 8.5% rather than 65%.
- No Measurable Accuracy Penalty: JetBrains found no statistically significant drop in task completion quality (p = 0.82), confirming that stripping conversational politeness does not degrade technical reasoning.
That independent evidence accelerated Caveman's architectural pivot toward the local input-compression proxy (caveman-proxy). Subsequent proxy-layer benchmarks shared by the project report approximately 33.2% fewer provider-reported input tokens on log-heavy agent loops without harming accuracy. The engineering takeaway is straightforward: terse output style alone trims a modest slice of coding bills, whereas reversible compression of bloated tool inputs attacks the true cost multiplier.
Comparison: Token Optimization Strategies for Coding Agents
No single utility solves every dimension of agent token economics. The table below compares Caveman's two layers alongside standard workflows and persistent session memory:
| Strategy | Primary Token Target | Reported / Observed Impact | Original Data Recovery | Code Fidelity | Best Engineering Fit |
|---|---|---|---|---|---|
| Standard Agent Loop | None (raw prompts & logs) | Baseline (0%) | Already uncompressed | Full | Onboarding explanations, client docs, specs |
| Caveman Skill (Prompt Layer) | Assistant prose outputs | Maintainers: ~65% prose; JetBrains SkillsBench: ~8.5% end-to-end coding | Instant toggle via /caveman off | Byte-exact code & paths | Interactive debugging and concise architectural Q&A |
Caveman Local Proxy (caveman-proxy) | Tool outputs, test logs, JSON inputs | Maintainer proxy tests: ~33.2% fewer input tokens | Lossless restore via ccr_... + caveman_retrieve MCP | Exact error classes & paths | Large monorepos with verbose test/build loops |
Persistent Memory (claude-mem) | Cross-session context re-explanation | Progressive 3-layer index injection | Drill-down via timeline & get_observations | Full file references | Multi-day features spanning dozens of sessions |
Notice how output/input compression and cross-session memory complement one another. While Caveman trims noise inside an active session, teams battling session amnesia can pair it with the claude-mem persistent memory guide so agents stop re-scanning the same repository from scratch every morning.
Installation and Local Proxy Configuration
Teams can adopt either the lightweight MIT skill alone or the complete CLI and local proxy workflow from the official JuliusBrussee/caveman repository:
npx skills add JuliusBrussee/caveman -g
npx @caveman-ai/cli@latest
curl -fsSL https://raw.githubusercontent.com/JuliusBrussee/caveman/main/install.sh | bash
caveman tools config path
caveman-proxy recovery-store status
Global proxy settings reside in ~/.caveman-cloud/config.json, while teams can commit per-repository overrides in ./.caveman/config.json:
{
"mode": "full",
"proxy": {
"enabled": true,
"preserveCodeBlocks": true,
"recoveryStore": "~/.caveman/ccr.db",
"maxStoreSizeMb": 256
},
"mcp": {
"retrieveTool": "caveman_retrieve"
}
}
Warning
Security & Licensing Governance: Because caveman-proxy intercepts local API payloads and persists raw tool outputs into ~/.caveman/ccr.db, ensure secrets, access tokens, and regulated customer records are never printed to stdout during agent sessions—and configure strict local disk permissions or retention caps. Before bundling proxy engine components into commercial developer platforms, review the BSL-1.1 license terms with legal counsel.
When Should Engineering Teams Deploy Caveman?
Like any optimization layer, Caveman shines when applied selectively rather than blindly across every prompt. For teams executing complex custom software development, three practical guardrails keep quality high:
- Enable during iterative execution loops: High-frequency test failures, CI log triage, dependency upgrades, and multi-file searches benefit immediately from shorter responses and reversible log elision.
- Toggle off for human-facing artifacts: Run
/caveman offbefore generating RFCs, security audit justifications, client handover notes, or onboarding walkthroughs where nuance and tone matter. - Measure against your own baseline: Track seven days of baseline input/output token telemetry per repository before enabling the skill and proxy separately so your ROI decision rests on actual workspace traffic rather than external averages.
If you are also evaluating how MCP-driven developer tools operate under strict local isolation boundaries, see our REA MCP architecture and setup guide. To design audited, cost-disciplined AI coding workflows tailored to your engineering stack, reach out through the Kling Digital contact page.




