---
title: "Introducing Caveman Code"
description: "Caveman Code is the most efficient coding agent. On the same model, it finished Terminal-Bench 4 for 21% less than Codex and 14% less than Claude Code, and day-long work across connected apps for 76% less than Claude Code."
canonical: https://caveman.so/news/introducing-caveman-code
last-updated: 2026-11-12
---

# Introducing Caveman Code

Caveman Code is the most efficient coding agent. On the same model, it finished
Terminal-Bench 4 for **21% less than Codex** and **14% less than Claude Code**,
and day-long work across connected apps for **76% less** than Claude Code. Today
it is available for Mac and in the browser, free on the subscriptions and keys
you already have.

> Same model. Same work. Few token. Small bill.

**The same work on the same model**

| Work | Model | Their harness | Caveman Code | Change | Tokens | Result |
| --- | --- | --- | --- | --- | --- | --- |
| Terminal-Bench 4: 48 tasks, 4 runs each, at high reasoning | GPT-6.1 Sol | Codex, $1.52 per solved task | $1.21 per solved task | 21% less | 31% fewer (3.2M to 4.7M per solved task) | 90 of 192 runs solved, both |
| Terminal-Bench 4: 45 tasks, 4 runs each, at high reasoning | Claude Opus 5.5 | Claude Code, $6.04 per solved task | $5.19 per solved task | 14% less | 22% fewer | 97 of 180 runs solved, to Claude Code's 83 of 177 |
| Connector tasks: 24 tasks that reach other apps through MCP servers, 2 runs each | Claude Opus 5.5 | Claude Code, $0.431 per task | $0.127 per task | 71% less | 81% fewer (74k to 383k per task) | 48 of 48 runs passed, to Claude Code's 46 |
| Three working days: three day-long sessions, each one conversation of 15 to 17 requests across four connected apps, run once | Claude Opus 5.5 | Claude Code, $7.65 per session | $1.83 per session | 76% less | 83% fewer (3.7M to 21.6M per session) | 48 of 48 steps passed, to Claude Code's 46 |

Each pair ran one model on the same tasks: the lab's own harness, then ours. Cost is at list price: per solved task on Terminal-Bench 4, per task on connector tasks, per session on the working days.

Terminal-Bench 4 ran four times per task: 48 tasks against Codex 0.163 on
GPT-6.1 Sol, 45 against Claude Code 2.1.309 on Claude Opus 5.5. Connector
tasks are 24 tasks run twice, and the working days are three day-long
sessions. Our own runs, November 2026. Each run and its method is on
[the Caveman Code page](/code#benchmarks).

Caveman Code is one app for every agent you use. Claude Agent, Codex, Cursor
and Caveman, our own agent, work side by side in tabs and splits. Your Claude
plan runs as Claude Agent and your ChatGPT plan as Codex, each on its own
login, and Caveman takes any API key, coding plan or gateway you add.

![Caveman Code after a sample task: four files changed and a summary of the fix.](/home/code.webp)

You can [download it for Mac](/download), or [sign in](https://app.caveman.so/signup)
and run it in your browser.

## Savings on the same model

Every comparison holds the model fixed. Both sides get the same tasks, the
same reasoning effort and the same limits, and the bill is what the provider
charges at list price. No router ran, and no smaller model stood in for the
one being measured. What is left to differ is the harness: the prompt, the
tools and the loop around the model.

| Work | Model | Their harness | Caveman Code | Change | Tokens | Result |
| --- | --- | --- | --- | --- | --- | --- |
| Terminal-Bench 4: 48 tasks, 4 runs each, at high reasoning | GPT-6.1 Sol | Codex, $1.52 per solved task | $1.21 per solved task | 21% less | 31% fewer (3.2M to 4.7M per solved task) | 90 of 192 runs solved, both |
| Terminal-Bench 4: 45 tasks, 4 runs each, at high reasoning | Claude Opus 5.5 | Claude Code, $6.04 per solved task | $5.19 per solved task | 14% less | 22% fewer | 97 of 180 runs solved, to Claude Code's 83 of 177 |
| Connector tasks: 24 tasks that reach other apps through MCP servers, 2 runs each | GPT-6.1 Sol | Codex, $0.109 per task | $0.069 per task | 37% less | 49% fewer (88k to 173k per task) | 48 of 48 runs passed, both; cheaper on 24 of 24 tasks |
| Connector tasks: 24 tasks that reach other apps through MCP servers, 2 runs each | Claude Opus 5.5 | Claude Code, $0.431 per task | $0.127 per task | 71% less | 81% fewer (74k to 383k per task) | 48 of 48 runs passed, to Claude Code's 46 |
| Three working days: three day-long sessions, each one conversation of 15 to 17 requests across four connected apps, run once | Claude Opus 5.5 | Claude Code, $7.65 per session | $1.83 per session | 76% less | 83% fewer (3.7M to 21.6M per session) | 48 of 48 steps passed, to Claude Code's 46 |

On Terminal-Bench 4, Caveman solved as many runs as Codex and more than Claude
Code, and spent less on each one it solved. It did that on fewer tokens: 31%
fewer than Codex and 22% fewer than Claude Code for each solved task, and 83%
fewer than Claude Code over a working day. The gap is widest on work that
reaches other apps, where the harness decides how much of every tool result
the model has to read again.

## Where the token go

Caveman began as a joke: one markdown file that made Claude talk like a
caveman, so it would say less. Then we measured where an agent's money goes.

Every request to a model sends everything that came before it. A run's bill is
the number of requests it makes, times what each one carries, plus what the
model writes back. On Claude Opus 5.5 at high effort, output is 43% of that
bill, and 78% of the output is reasoning. The talking, the part the joke went
after, is under a tenth. Reading the conversation again is 32%, and adding to
it is 25%.

Two things follow. Anything added early is paid for on every later request, so
the first request matters far more than its size suggests. And a large tool
result costs twice: once when it enters the conversation, and again every time
the conversation is sent.

**Size of the first request**

| | tokens, before any work is done |
| --- | --- |
| Claude Code | 16.7k |
| Caveman, Opus 5.5 | 2.7k |
| Codex | 11.8k |
| Caveman, GPT-6.1 Sol | 3.4k |

## The Caveman harness

The harness is built on one idea, the same one the joke was about: the model
should only read again what it needs in order to think.

**A small start.** The system prompt and the tool definitions are kept short,
so the part of the conversation that every later request repeats starts under
four thousand tokens.

**Tool results stay in a program.** When work reaches a connected app, the
model writes a short program instead of making one tool call at a time. The
program calls the tools, keeps what it needs, and returns its answer. The raw
results never enter the conversation.

In the same harness on the same model, that one change took a connector task
from $0.380 to $0.127. Over a working day it compounds, because the
conversation that gets sent again stays small.

**Prompt size at the end of a day-long session**

| | tokens, Claude Opus 5.5 |
| --- | --- |
| Claude Code | 318k to 601k |
| Caveman Code | 79k to 113k |

**A cache that stays warm.** A provider's prompt cache expires after a few
minutes without a request. A long build or a wait lets it lapse, and the next
request pays to write the whole history again. The harness keeps it alive
through those gaps.

The model you chose does all of the thinking. The harness does not edit what
the model wrote and does not trim its reasoning. It only decides what has to
be read again.

## Reasoning is not the place to save

Most of what Opus writes is reasoning: 78% of its output. That made the
model's own earlier reasoning the obvious thing to drop from the history, so
we built it. Reading the conversation again fell by 68%. The cost of an
attempt went up 19% and the agent solved 12.5 points fewer tasks, because the
model reasoned twice as much on every request to rebuild what we had removed.

We did not ship it. A harness should spend less reasoning by removing
mechanical steps, never by starving the model, and it should be judged on cost
per solved task rather than on tokens.

## What is in the app

- **Bring what you already pay for.** Caveman Code is free on your own keys
  and logins. Your subscriptions keep working as they do today.
- **A Chief runs your chats.** Tell it what you want done. It starts the
  chats, answers their questions, reports back, and goes ahead on its own when
  you don't answer in time.
- **A guide to every pull request.** Written before you open it: a one-line
  TL;DR, the one call that is yours, then each change as before, after and
  why.
- **Agents that use a computer.** On a Cloud computer, in beta, an agent
  drives a desktop and a browser to check its own work. Watch it live, take
  over, hand it back.
- **Close the lid. It keeps going.** Working chats continue on a Cloud
  computer when your laptop closes, and a chat can move to your other Mac.

## Try Caveman Code

[Download Caveman Code for Mac](/download), or [sign in](https://app.caveman.so/signup)
to use it in the browser.

If you already work in Claude Code or Codex, the open-source Caveman CLI makes
that agent cheaper where it runs:

```sh
npm i -g @caveman-ai/cli && caveman setup --install
```

We tune the harness for each model as it arrives. A terminal app on the same
harness is next, and Caveman Cloud will be the place to deploy what you build
with it.

> Why use many token when few do trick.