← Back to blog
AiAbout 6 min read

119,975 Stars for a Skill That Makes Agents Talk Like Cavemen

Published Nov 14, 2026
119,975 Stars for a Skill That Makes Agents Talk Like Cavemen

The repository has 119,975 stars and its pitch is a caption written in broken English: why use many token when few token do trick. The project is called Caveman, it is Apache-2.0, and it installs with one command. What it does is make coding agents write and read less.

That is the whole product. No new model, no new tool, no agent framework. A skill that rewrites how the agent talks, plus a proxy that trims what the agent reads, plus a handful of commands for choosing how hard to compress.

The before-and-after in the README is a fair summary. Asked why a React component re-renders, a normal agent writes 63 tokens: a new object reference is created on each render cycle, shallow comparison sees it as different, which triggers a re-render, and you should wrap the prop in useMemo. Caveman writes 20: new object ref each render, so React re-renders, wrap the prop in useMemo. Same fix. The tokens that disappeared were framing, hedging and restatement.

The numbers, and who checked them

The project's own measurements claim 33.2% fewer input tokens across whole sessions, from 54 Claude Code runs, with 18 of 18 answers correct. In Auto mode it reports 54% cheaper on 85 coding tasks against Opus 5.5 at xhigh. One test run went from 397 tokens to 76 compared with piping output through tail -20.

Self-reported numbers from a project with a viral incentive deserve suspicion, so the external checks matter more. Adobe Research published a paper, arXiv 2606.24083, measuring caveman-style output across eight models and finding it 1.4 to 2.4 times cheaper. JetBrains ran an A/B test and wrote it up in July. Elasticsearch Labs rebuilt the idea for their own assistant. The project also sat at number one on Hacker News and number one on GitHub Trending, which is how it got to six figures in stars.

Three independent groups reproducing a compression trick is unusual for this genre. Most token-saving claims come from a vendor's own dashboard.

Three levels of rudeness

The skill ships with three registers. /caveman gives you the 20-token answer. /ultracave cuts it to 14: inline object prop, new ref, re-render, useMemo. /megacave returns 13 tokens in Chinese, which is the joke landing properly, because Chinese is denser per token for this kind of sentence.

The registers exist because compression is not free. Strip enough connective tissue and you lose the reasoning that made the answer trustworthy. A 13-token reply is great when the fix is obvious and dangerous when the model is guessing. Giving users a dial instead of a fixed setting is the honest design choice, even if most people will leave it on the middle setting and never think about it again.

The reading side is less visible and probably bigger. The skill also changes what the agent pulls into context: less of the file, fewer surrounding paragraphs, tighter logs. One documented example is a test run that produced 397 tokens of output and became 76 after the skill rewrote the command it used. Anyone who has watched an agent paste forty lines of passing test output into a conversation knows where that bill comes from. The saving there is structural, the difference between reading a summary and reading a transcript.

Installation is one line, npx @caveman-ai/cli@latest, Node 22.13 or newer. The installer finds your agents and your logins, shows what it plans to change, and waits for you to press enter. After that, plain claude runs in caveman mode, and so do Codex, Gemini CLI, OpenCode and, per the README, more than 30 others. It runs locally, on your own keys and subscriptions. Nothing routes through a third-party server unless you choose the cloud option.

Why this works at all

Language models are trained on human prose, and human prose is redundant by design. When an agent answers a technical question, it reproduces the shape of a helpful blog post: restate the problem, explain the mechanism, recommend a fix, add a caveat. All of that is good writing and most of it is unnecessary when the reader is a developer who already knows the context.

The saving compounds on the input side, which is the part people forget. An agent that writes shorter replies also produces shorter history, and history is re-sent on every turn. A verbose agent pays for its own verbosity again on every subsequent request. Cut the reply length by a third and the saving compounds across the conversation instead of sitting inside one message.

That is also why the compression has to be stable. If the agent sometimes writes prose and sometimes writes caveman, the context becomes inconsistent and the model starts hedging about its own format. A skill that enforces a register is doing something a prompt suggestion cannot.

The free desktop app is the real business

Alongside the skill, the project ships Caveman Code, a free Mac app that puts every coding agent in one window. The marketing numbers are on Terminal-Bench 4: 21% cheaper than Codex per solved task, 14% cheaper than Claude Code while solving 97 tasks against 83, and 76% cheaper across a full workday with four apps connected. Same model on both sides of each comparison, list prices, November 2026, their own runs.

Read the third number carefully. A full workday with four apps is not a benchmark, it is a description of how people actually use these tools: several agents, long sessions, lots of context switching. That is where token overhead stops being a rounding error and becomes the bill.

The strategy is legible. Give away the thing that saves money, become the window everyone runs their agents in, then sell the coordination layer. It is the same play every IDE and terminal has run for two years, with a better joke.

Where it can go wrong

Compression removes information, and some of that information is load-bearing. Code comments written in caveman are worse for the next human. Commit messages written in caveman are worse for everyone. The skill is aimed at chat, and the README is explicit that code stays exact, but the boundary is enforced by a prompt and prompts leak.

There is also a measurement problem. Token counts are easy to report and cost per solved task is not. A model that saves 30% of tokens and needs one extra round of clarification has saved nothing. The 18-of-18 result addresses this for one narrow test, and 18 questions is not a benchmark.

Still, the core claim survives scrutiny, and it is the least glamorous claim in AI right now: a large share of what agents cost is spent on words nobody needed. Fixing that does not require a new model, a bigger context window or a GPU. It requires deciding that the agent should talk like a competent colleague who is busy.

Related articles

Google replaced the model behind Search, and the number that moved was a shell benchmark

Gemini 4 Hydrogen became the default on 12 November, taking over from Gemini 3.8 Flash across Search, the Gemini app and the developer API. It runs about 2.5 times faster, scores 57% on Terminal-Bench 4.1 where its predecessor scored 18.2%, and costs $1.50 in and $7.50 out per million tokens.

Three ways a coding agent wastes money, measured on 30 repositories

TokenEconomizer watches what an agent did in a repository you work in often, then stops it from rediscovering the same build command, loading tools it never uses and looping on one error. Across five agent and model combinations it cut mean cost by 18.4% to 30.9%, cheaper in all 30 repository cells, with Pass@1 up in four of five.

earshot gives coding agents 922 sounds, and every one is rendered from code

An agent can write a game, an interface or a film and never hear any of it. earshot answers requests like "three variations of a footstep on gravel" from a catalogue of 922 designs built from public-domain recordings, with no audio files in the repository at all. It runs on CPU, as a CLI, a Python package, an MCP server and a Claude Code plugin.

The agents stealing API keys were not sophisticated. The gateways were open.

Amazon's decoy servers spent October posing as inference APIs and logged agents built on ARTEX pulling provider keys out of LiteLLM, Dify, Langflow and Open WebUI. The way in was a default master key and a half-finished install. ARTEX itself ships with budgets, scope gates and evidence for every finding.