Caveman: Cut AI Agent Output Tokens by 65%

Q: How do you activate Caveman mode?

📋 What you need before trying Caveman

A supported AI coding agent already installed (Claude Code, Codex, Gemini CLI, Cursor, Windsurf, Cline, Copilot, or one of 30+ others)
Node.js 18 or newer for the skill installer
macOS, Linux, or Windows with PowerShell 5.1+
Chrome installed, only if you want the optional Caveman Browse tool

Caveman is an open-source Claude Code skill and AI agent plugin created by Julius Brussee that makes coding assistants answer in compressed, caveman-style prose while keeping code, commands, and error strings byte-for-byte exact. The pitch is one line: why use many token when few token do trick. Across the project’s own 10-task benchmark table, the skill cuts output tokens by an average of 65%, and version 2.0.0, released on 2026-08-11, goes further by compressing what the agent reads, not just what it says.

That second part matters more than the meme. The original skill shrank the model’s mouth, while Caveman 2 adds the ears: a local proxy and compression engine that squeeze tool outputs, logs, JSON, and history before they reach the provider. Because the project is unusually upfront about its own limits, this piece walks through what Caveman actually is, how the pieces fit together, how to install it, and where the honest numbers sit.

Why output tokens became a problem worth solving

AI coding agents are verbose by default. Ask one why a React component re-renders and you get three polite paragraphs of context, hedging, and restatement before the actual fix. Every one of those words is an output token, and output tokens are the expensive kind. Worse, the agent reads its own prior replies back as context on later turns, so the waffle compounds across a session.

Caveman started as a prompt-engineering answer to that: a skill file that instructs the agent to drop filler and answer in tight fragments. For example, the README’s side-by-side comparison shows a normal agent spending 69 tokens on a re-render explanation while the caveman agent spends 19 tokens on the same concrete fix: “New object ref each render. Inline object prop = new ref = re-render. Wrap in useMemo.”

However, shorter answers only fixed half the leak. Tool schemas, files, logs, history, and skill bodies still crossed the provider boundary in full, often on every turn. That is the gap Caveman 2 targets with its proxy and engine, and it is why the project deserves a fresh look even if you dismissed the original as a joke.

How the Caveman skill compresses responses

The skill itself is a set of agent instructions, not a model and not a wrapper around one. Once installed, the agent keeps all of its technical knowledge and simply changes how it talks. As a result, code blocks, shell commands, and error strings pass through untouched; only the prose around them gets compressed.

Intensity levels and the /caveman command

You control the compression with a slash command. Type /caveman if your agent does not activate it automatically, then switch modes with /caveman lite|full|ultra|wenyan-lite|wenyan-full|wenyan-ultra. The wenyan modes render responses in classical Chinese for maximum token density, as the project’s third-party product page also describes. Turn it off any time with /caveman off or by saying normal mode.

Caveman: Cut AI Agent Output Tokens by 65%

The companion commands that ship with it

One install also brings a small toolkit, and each piece targets a different token sink:

cavecrew-investigator, cavecrew-builder, cavecrew-reviewer: compressed subagent presets for locating, editing, and reviewing code
/caveman-commit: terse Conventional Commit messages
/caveman-review: one-line, actionable review findings
/caveman-compress <file>: smaller Markdown memory files, with the original backed up
/caveman-stats: local session token usage and estimated savings in Claude Code

ℹ️ Note: The skill is MIT licensed and stays MIT, according to the README. The engine half of the project uses a different license, covered below.

This content is blocked because it requires YouTube cookies.

What the 65% number actually means

The headline figure comes from a benchmark table committed in the repository: 10 representative coding tasks, with output-token reductions ranging from 22% (refactoring a callback to async/await) up to 87% (explaining a React re-render bug and implementing a React error boundary). On average, the table lands at 65%, from 1,214 tokens down to 294 per task.

Here is where Caveman earns unusual trust: the README prints an “honest number warning” in its own voice. The skill only shrinks output tokens. Input and reasoning tokens are untouched, and the skill itself adds roughly 1 to 1.5k input tokens per turn. As a result, whole-session savings run smaller than the output number, and on already-terse workloads they can go net-negative. The project states plainly that the real win is readability and speed, with cost savings as the bonus, and it documents when Caveman wins and loses in docs/HONEST-NUMBERS.md.

⚠️ Warning: If your sessions are short or your prompts already produce terse answers, the skill’s per-turn input overhead can exceed what it saves. Measure with /caveman-stats before assuming a win.

Caveman 2: compressing what the agent reads

Version 2.0.0, published 2026-08-11, adds the input side. Caveman Proxy sits under your existing agent, while Caveman Engine powers the compression and stores every moved byte for exact recovery. In a pinned Claude Code benchmark, the README reports 33.2% fewer provider-reported input tokens, labeled benchmark_counterfactual, the project’s term for a controlled benchmark rather than a production savings claim.

How the engine treats different payloads

According to the third-party product page, the engine ships structural compressors for JSON, logs, ASTs, and tool schemas, so each payload type keeps the parts answers depend on instead of crossing the provider boundary in full. The README’s own framing matches: tool catalogs, MCP results, logs, repeated files, and skill bodies ride upstream again and again, and the proxy catches them before the next model call.

Byte-exact recovery through CCR

Safety is the design constraint. The release notes for v2.0.0 describe a real run where a 40-record JSON came out 93% smaller, byte-safe and fully recoverable via CCR, the content-addressed store the engine writes to before any lossy transform goes upstream. The same notes stress that savings are “inferred,” measured on your machine rather than projected, which is the same evidence labeling the README uses for its benchmark claims.

Installing Caveman on macOS, Linux, and Windows

Caveman is three separate installs, and each works alone. The README’s advice: start with the skill, because it needs no account, proxy, Go toolchain, or code changes.

One-line install for the skill

On macOS or Linux, run the installer:

curl -fsSL https://raw.githubusercontent.com/JuliusBrussee/caveman/v1.10.0/install.sh | bash

On Windows, use PowerShell 5.1 or newer:

irm https://raw.githubusercontent.com/JuliusBrussee/caveman/v1.10.0/install.ps1 | iex

The installer needs Node.js 18+, finds every supported agent already on your machine, skips the rest, and is safe to rerun.

ℹ️ Note: The install script above pins v1.10.0 because that is what the README still references. The repository metadata lists v2.0.0 (2026-08-11) as the current release, so check the releases page for the latest tag before installing.

Installing for one agent only

If you prefer a single-agent install, each supported agent has its own path:

# Claude Code
claude plugin marketplace add JuliusBrussee/caveman && claude plugin install caveman@caveman

# Gemini CLI
gemini extensions install https://github.com/JuliusBrussee/caveman

# Codex, Cursor, Windsurf, Cline, and other skills-compatible agents
npx skills add JuliusBrussee/caveman --skill '*' -a codex --yes  # replace codex with your agent profile

The full 30+ agent matrix, dry run, flags, verification, and uninstall steps live in the repository’s INSTALL.md.

Adding the proxy and CLI

When input compression becomes worth the extra setup, install the CLI and signed local binaries:

npm install -g @caveman-ai/cli && caveman setup --install

That brings the proxy, engine, MCP recovery, and memory binaries, plus the optional browse and shrink tools. Then one command wraps your agent:

caveman claude

In addition, the README advertises seven native wrap profiles, although the truncated portion of the documentation is where the per-agent details live, so check INSTALL.md for the current list.

Pixel mode and the skill compressor

The README’s navigation points to two further tricks: a pixel mode and a skill-to-PNG compressor, and the repository tree carries matching engine directories (engine/pixel/ with golden test data, plus a caveman-compress skill). However, the fetched portion of the README ends before those sections, so the specific figures and model gates behind them are not something this article can state. Treat them as advertised features to evaluate in the repository’s docs rather than as measured results.

Licensing and what the numbers do not say

Caveman uses a split license, spelled out in the v2.0.0 release notes. The skill, CLI, SDKs, kit, evals, contracts, catalog, and extension shell are MIT. The engine, proxy, MCP, shrink, cavemem core, and platform are BSL-1.1: you can self-host your own traffic, including production, for free, and only reselling Caveman-as-a-service needs a commercial license. Meanwhile, the BSL code sunsets to Apache-2.0 in roughly four years, and the repository ships LICENSE, LICENSE.BSL, and LICENSING.md files to back that up.

As for popularity, the GitHub API reports 97,654 stars and 5,629 forks, with 476 open issues and pull requests combined (the API counts both under one number, and the Issues tab alone shows a smaller figure). Those numbers describe attention, not correctness. Therefore the more meaningful signal is the project’s own evidence labels, inferred and benchmark_counterfactual, which keep measured-on-your-machine results separate from settled fact.

Where Caveman goes from here

The repository sits at the center of a small ecosystem. The third-party product page lists seven entries: the skill, Caveman Proxy, an Agent SDK, CaveGemma (compression baked into Gemma’s weights), Caveman Cloud (in development), Caveman Code (a terminal coding agent), Cavemem (persistent memory over MCP), and Cavekit (a spec-driven build loop). A directory listing on EveryDev.ai describes the same suite and notes a browser extension for non-developer users.

Meanwhile, the sharpest opinion the project offers is its own restraint. The README warns you when the skill loses, the release notes call their own savings “inferred” rather than verified, and the honest-numbers doc is linked right under the benchmark table. For a tool born as a meme, that is a serious engineering posture, and it is the main reason the 65% claim is worth taking seriously rather than on faith.

🎯 What you now know about Caveman

Caveman is an open-source skill by Julius Brussee that makes 30+ AI coding agents answer in compressed prose, cutting output tokens by an average of 65% (range 22 to 87%) while keeping code and errors byte-exact.
The skill is MIT and installs with one curl or PowerShell line; control it with /caveman and its lite, full, ultra, and wenyan modes.
Version 2.0.0 (2026-08-11) adds a local proxy and engine that compress input too, with 33.2% fewer provider-reported input tokens in a pinned Claude Code benchmark.
Every lossy transform is backed by byte-exact CCR recovery, and results are honestly labeled inferred or benchmark_counterfactual, never verified.
The skill adds roughly 1 to 1.5k input tokens per turn, so already-terse workloads can go net-negative; measure with /caveman-stats first.

Additional Resources

This article was produced with the help of artificial intelligence.