We ran an identical conversation through five popular AI agent tools, measured every token billed, and projected it onto a realistic hour of work. Read the first chart and you know the answer.
Same conversation, same AI model (Claude Sonnet 4.5), projected from measured per-turn billing. Shorter bar = cheaper.
| Scale it up | AGNT | OMP | OpenClaw | Hermes | Claude Code |
|---|---|---|---|---|---|
| 1 person · 1 hour | $1.07 | $1.51 | $1.98 | $2.09 | $2.32 |
| 1 person · 1 hr/day · month | $22 | $32 | $42 | $44 | $49 |
| Team of 10 · month | $225 | $317 | $416 | $439 | $489 |
| Team of 100 · year | $27k | $38k | $50k | $53k | $59k |
Providers discount repeated conversation content by 90% — but only while the discount stays alive. OpenClaw and Hermes use the 5-minute version: any longer pause and you re-buy the entire conversation at a premium. Our hour has 4 breaks — 4 full re-purchases, growing each time.
Claude Code keeps its discount alive (1-hour version) — but silently adds 6,817 tokens of its own scaffolding to every message, and bills you for it. Your ~5,200-token message costs 12,000 tokens. Every turn.
1-hour discount that survives every break, and zero added overhead — you pay for your message and nothing else. The only tool in the test that gets both right.
Effective cost multiplier vs. running the same hour with no caching at all ($4.02). Lower is better — default configuration, measured behavior. (This ranks cost only; the overall scorecard is further down.)
The defining pattern: AGNT's line falls as its one-time cache-build cost amortizes into 90%-discounted reads. Everyone else's flattens high or rises — coffee breaks and overhead keep re-charging them. Projected from measured per-turn billing; breaks every ~15 minutes.
Same measured per-turn billing, composed over a working month (22 workdays). Each session starts cold and evolves exactly as measured; multipliers from the session-length curve above. Three usage profiles: Light = 2 h/day (2×1h sessions), Moderate = 4 h/day (2×2h), Heavy = 8 h/day (2×4h). Full model in whitepaper v1.1, §7.
| Monthly cost per seat | AGNT | OpenClaw | Hermes | Claude Code | No caching |
|---|---|---|---|---|---|
| Light · 2 h/day (44 h/mo) | $47 | $87 | $92 | $102 | $177 |
| Moderate · 4 h/day (88 h/mo) | $74 | $166 | $195 | $191 | $354 |
| Heavy · 8 h/day (176 h/mo) | $120 | $325 | $410 | $368 | $708 |
AGNT is ~1.9× cheaper than the pack at light usage — and 2.7–3.4× cheaper at heavy usage. Its multiplier keeps falling in long sessions (0.27 → 0.17) while everyone else's flattens or rises.
Claude Code is the priciest survivor at light usage (bloat tax dominates short sessions) — but Hermes overtakes it at heavy usage. Its leak grows with context: the only tool whose per-token cost rises the longer you work.
The model assumes breaks only every ~15 min, a fixed leak rate, and synthetic-size payloads. Real work pauses more, leaks more, and sends bigger payloads — every bias widens the gap. These are lower bounds.
| The cache tax vs. AGNT · heavy seat | $ / month | $ / year | Where the money goes |
|---|---|---|---|
| OpenClaw | $205 | $2,462 | Re-buys the whole context at premium after every >5-min break |
| Claude Code | $248 | $2,971 | 6,817 tokens/turn of self-injected scaffolding, billed at 1-h premium |
| Hermes | $290 | $3,481 | Pause re-buys plus the intra-burst leak |
| No caching | $587 | $7,046 | Everything at list price, always |
Each tool marks segments of the conversation as cacheable with a lifetime. Green (1-hour) survives coffee breaks. Orange (5-minute) dies while you think. This one design choice decides the bills above.
| # | Tool | Score /60 | One-line summary |
|---|---|---|---|
| 🥇 | AGNT v0.6.4 | 59 | Survives breaks + zero overhead + works with 5 AI providers. The only clean sweep. |
| 2 | OMP | 44 | Zero overhead like AGNT and 40+ providers — but ships a 5-minute default that loses the coffee break (1h only on opt-in). |
| 3 | Claude Code | 38 | Great caching, but a 2.3× bloat tax on every message and locked to one provider. |
| 3 | OpenClaw | 38 | Clean spending — until any pause over 5 minutes wipes it out. Repeatedly. |
| 5 | Codex CLI | 33 | Decent automatic caching, but no control, no guarantee, OpenAI-only. |
| 6 | Hermes | 20 | Leaks money even while its cache works, then loses it all at every break. |
Everything above traces to provider billing counters from real installs. Expand what you want to verify. Full technical whitepaper: cache-wars-whitepaper.pdf.
• Real installs: AGNT v0.6.4 · Claude Code CLI 2.1.126 · Codex CLI 0.130.0 · OpenClaw 2026.5.12 (npm i -g) · hermes-agent 0.18.0 (pip install) · oh-my-pi (OMP) 16.3.11 (bun install -g @oh-my-pi/pi-coding-agent). No simulations.
• Identical workload: same user messages byte-for-byte, each turn adding the same ~5,186-token payload. Verified in billing counters: every harness's context grew by exactly the payload per turn (+ any tokens the harness itself injects — reported as its overhead).
• Protocol: 4 rapid turns → 6½-minute pause → turn 5. The pause exceeds Anthropic's 5-minute cache TTL but not its 1-hour TTL.
• Best case for everyone: each harness ran on the provider path where its caching works best — Anthropic-direct with a funded API key for OpenClaw and Hermes (Hermes' own log confirmed: "Prompt caching: ENABLED").
• Ground truth: Anthropic usage blocks / OpenAI session telemetry, captured per-call via logging proxies with fail-loud guards (calls bypassing the proxy or non-growing history abort the run).
cached = re-read at 10% price (good) · premium = billed at full/premium price (the real bill; ideal = your ~5.2k message, flat).
AGNT v0.6.4 cached / premium Claude Code cached / premium t1: 0 / 17,809 t1: 18,537 / 19,469 t2: 17,809 / 5,186 t2: 38,006 / 12,003 ⚠ +6.8k bloat t3: 22,995 / 5,186 t3: 50,009 / 12,003 ⚠ t4: 28,181 / 5,186 t4: 62,012 / 12,003 ⚠ ── 6.5 min pause ── ── 6.5 min pause ── t5: 33,367 / 5,191 ✓ t5: 74,015 / 12,009 ✓ but taxed OpenClaw cached / premium Hermes cached / premium t1: 0 / 29,982 t1: 0 / 22,837 t2: 29,982 / 5,189 t2: 22,837 / 5,186 t3: 35,171 / 5,189 t3: 17,339 / 15,869 ⚠ leak t4: 40,360 / 5,189 t4: 17,339 / 21,054 ⚠ leak ── 6.5 min pause ── ── 6.5 min pause ── t5: 0 / 50,743 ✗ t5: 0 / 43,583 ✗ cache dead Codex cached / premium OMP (default 5m) cached / premium t1: 2,432 / 18,677 t1: 0 / 8,821 t2: 20,864 / 7,730 t2: 8,821 / 5,186 ✓ zero overhead t3: 28,544 / 7,535 t3: 14,007 / 5,186 t4: 35,712 / 7,852 t4: 19,193 / 5,186 ── 6.5 min pause ── ── 6.5 min pause ── t5: 43,392 / 7,659 ✓ t5: 0 / 29,570 ✗ 5m cache died OMP best-case (PI_CACHE_RETENTION=long / OAuth -> 1h TTL): t1: 0/8,841(1h) t2: 8,841/5,186 t3: 14,027/5,186 t4: 19,213/5,186 ── 6.5 min pause ── t5: 24,399/5,191(1h) ✓ SURVIVED (Codex survived its pause, but OpenAI documents no retention guarantee.)
Key patterns: AGNT's premium column is pinned at the message size — the only clean bill that also survives the pause. OpenClaw is equally clean until the pause kills it. Claude Code pays +6,817/turn for self-injected scaffolding. Hermes' cache shrinks while its premium quadruples mid-session (bad marker placement), then dies at the pause.
Scenario: 20 messages over 1 hour, coffee breaks (>5 min) after messages 4, 8, 12 and 16. Each message ≈ 5,186 tokens (as measured). Sonnet 4.5 list prices: input $3/M · cache read $0.30/M · 5-min cache write $3.75/M · 1-hour cache write $6/M.
AGNT v0.6.4 (1h TTL, survives all breaks, zero overhead):
writes: 17,809 + 19×5,186 = 116,343 tk @ $6/M = $0.70
reads: Σ growing prefix = 1,225,177 tk @ $0.30/M = $0.37
TOTAL ≈ $1.07 (0.27× of uncached)
Claude Code (1h TTL, survives breaks, +6,817/turn bloat):
writes: 19,469 + 19×12,003 = 247,526 tk @ $6/M = $1.49
reads: Σ (bloated prefix) = 2,793,164 tk @ $0.30/M = $0.84
TOTAL ≈ $2.32 (0.58×)
OpenClaw (5m TTL — full re-write after each of 4 breaks):
re-writes at burst starts: 29,982+50,743+71,470+92,214+112,958
= 357,367 tk @ $3.75/M = $1.34
in-burst writes: 15×5,189 @ $3.75/M = $0.29
reads (in-burst only) ≈ $0.35
TOTAL ≈ $1.98 (0.49×)
Hermes (5m TTL + measured leak ≈14k premium/turn in-burst):
re-writes at burst starts ≈ 321k tk @ $3.75/M = $1.21
leaky in-burst writes ≈ 210k tk @ $3.75/M = $0.79
reads (plateaued) ≈ $0.09
TOTAL ≈ $2.09 (0.52×)
OMP default (5m, o=0): 4 breaks force full re-writes
re-writes 251,545 + in-burst 77,790 = 329,335 tk @ $3.75/M = $1.23
reads 910,215 tk @ $0.30/M = $0.27
TOTAL ≈ $1.51 (0.38x) [best-case 1h flag: $0.96, 0.24x]
No caching (control): 1,341,520 tk @ $3/M = $4.02
OMP note: its smaller system prompt (8.8k vs AGNT's 17.8k) makes its opt-in 1h best case ($0.96) marginally cheaper than AGNT — but its shipping API-key default is 5-minute ($1.51), so the headline uses the default, consistent with how every other harness is reported on out-of-box behavior.
Session-length curve: same model at 15/30/60/120/240 min (breaks every ~15 min). AGNT's multiplier: 0.62 → 0.40 → 0.27 → 0.21 → 0.17 (build cost amortizes into 10%-price reads). OpenClaw: 0.69 → 0.55 → 0.49 → 0.47 → 0.46. Claude Code: 0.75 → 0.64 → 0.58 → 0.54 → 0.52. Hermes: 0.72 → 0.60 → 0.52 → 0.55 → 0.58 (leak compounds).
Codex: excluded from dollar charts — OpenAI-only, different price list. Token-wise it bills ~7.7k premium/turn vs AGNT's 5.2k (+48% overhead); cache survival is undocumented and unguaranteed.
Conservative bias: assumes 5m caches survive perfectly within bursts and die only at the 4 breaks. Real usage pauses more often — widening the gap in AGNT's favor.
Model: the session-level model composes linearly across sessions — a month is a sequence of independent sessions, each starting cold (first-turn cache build). Costmonth = D × Σ M(L) · L · Ru, with D = 22 workdays, Ru = $4.02/h uncached burn (20 msgs/h × ~5,186 tk at Sonnet 4.5 list), and M(L) the measured session-length multiplier from the curve above.
Profiles: Light 2 h/day = 2 x 1h sessions -> uses M(1h)
Moderate 4 h/day = 2 x 2h sessions -> uses M(2h)
Heavy 8 h/day = 2 x 4h sessions -> uses M(4h)
Multipliers M(1h / 2h / 4h): AGNT .27/.21/.17 OpenClaw .49/.47/.46
Hermes .52/.55/.58 Claude Code .58/.54/.52
Monthly $/seat (Light / Moderate / Heavy):
AGNT 47 / 74 / 120
OpenClaw 87 / 166 / 325
Hermes 92 / 195 / 410 <- overtakes CC at heavy (leak grows)
Claude Code 102 / 191 / 368
No caching 177 / 354 / 708
Cache tax vs AGNT, heavy seat: OpenClaw $205/mo ($2,462/yr)
Claude Code $248/mo ($2,971/yr) - Hermes $290/mo ($3,481/yr)
Team of 5, heavy, annual: AGNT $7,220 - OpenClaw $19,528
Claude Code $22,075 - Hermes $24,622 - uncached $42,451
Stated biases — all three push against the headline gap: (1) breaks assumed only every ~15 min, real work pauses more (each extra pause penalizes only 5-min-TTL tools); (2) Hermes' leak rate held at its 4-hour value though it grows with context; (3) real payloads (tool results, files) exceed the synthetic ~5.2k filler, scaling every re-write linearly. The OpenClaw and Hermes figures are lower bounds.
Note: the small "scale it up" table at the top of the page uses casual 1-hour-session usage (1 h/day); this section models sustained professional usage — that's why the per-seat numbers are larger.
AGNT OMP CC OpenClaw Codex Hermes Pause survival (meas.) 10 2 10 2 7 2 Premium spend (meas.) 10 10 4 9 7 2 Retention control 10 10 8 9 2 5 Context discipline 10 9 5 6 8 3 Provider coverage 9 10 2 9 2 7 Out-of-box defaults 10 3 9 3 7 1 TOTAL 59 44 38 38 33 20
OMP (oh-my-pi 16.3.11) ties AGNT on premium spend (5,186/turn, zero overhead — measured), retention control (explicit per-request dual-TTL + PI_CACHE_RETENTION env + OAuth auto-upgrade), and providers (40+). It loses on the two axes that decide the report: its API-key default is 5-minute (verified in anthropic.ts:424: retention = cacheRetention ?? (isOAuthToken ? "long" : resolveCacheRetention()), which returns "short"), so it fails the coffee-break test (measured: 0 read post-pause). With PI_CACHE_RETENTION=long it survives (24,399 read) — but that is opt-in, not the shipping default.
Pause survival & premium spend are measured; the rest scored from documented behavior (retention knobs, history rewriting/compaction, supported providers, default settings).
Driven via omp -p --mode json --continue, Anthropic-direct (API key). OMP natively reports the per-TTL split cttl:{ephemeral5m, ephemeral1h}.
DEFAULT (API-key path -> 5m TTL): t1: read=0 write=8,821 (5m) t2: read=8,821 write=5,186 (5m) <- premium = payload exactly, zero overhead t3: read=14,007 write=5,186 (5m) t4: read=19,193 write=5,186 (5m) PAUSE 6.5 min t5: read=0 write=29,570 (5m) <- CACHE DIED, full re-write BEST-CASE (PI_CACHE_RETENTION=long -> 1h TTL): t1: read=0 write=8,841 (1h) t2: read=8,841 write=5,186 (1h) t3: read=14,027 write=5,186 (1h) t4: read=19,213 write=5,186 (1h) PAUSE 6.5 min t5: read=24,399 write=5,191 (1h) <- SURVIVED Source: packages/ai/src/providers/anthropic.ts:424 retention = cacheRetention ?? (isOAuthToken ? "long" : resolveCacheRetention()) resolveCacheRetention() -> PI_CACHE_RETENTION==="long" ? "long" : "short"
Captured live — a third-party harness with a valid Claude subscription OAuth token was rejected:
"Third-party apps now draw from your extra usage, not your plan limits. Add more at claude.ai/settings/usage"
OpenClaw and Hermes users must buy metered API credits on top of any Claude subscription. Claude Code and AGNT retain subscription billing.
• Anthropic prompt caching (pricing & TTLs):
platform.claude.com/docs/build-with-claude/prompt-caching
• OpenAI prompt caching (automatic, no guarantee):
developers.openai.com/api/docs/guides/prompt-caching
• Hermes caching docs (5m TTL — matches measurement): hermes-agent.nousresearch.com/docs
• OpenClaw retention docs (default "short" = 5m — matches measurement):
docs.openclaw.ai/reference/prompt-caching
Limitations: one trial per cell (Anthropic TTLs are contractual; Codex's survival is a single observation) · one pause length (6½ min; pauses >1 hour defeat every tool tested) · extrapolation assumes breaks every ~15 min (real usage pauses more, widening gaps) · raw token counts aren't compared across harnesses (different system-prompt sizes); all cross-tool claims use ratios, per-message overhead, or identical-content replays.
All artifacts preserved: per-harness results JSON, proxy logs (every call verified), and runner scripts. Re-run them and you'll get the same numbers.
AGNT does the same hour of work for $1.07 — half the cost of every alternative ($1.98–$2.32) and a quarter of the uncached ceiling ($4.02). It's the only tool whose cost multiplier keeps falling the longer you work, the only one that survives coffee breaks and charges nothing beyond your own messages. The gap compounds with every break and every hour — over a working month, that's $120 vs. $325–$410 per heavy seat: a $205–$290/month cache tax, or ~$17,400/year for a five-person team, recoverable by client-side engineering alone.