The Cache Wars 2: An Empirical Study of Prompt-Cache Efficiency
in Six LLM Agent Harnesses

Keywords: prompt caching, LLM agents, agent harness, cost measurement, cache TTL, context management, subscription access, reproducibility

PDF version · Artifacts & raw counters · Original paper [1]

1  Introduction

Autonomous and semi-autonomous LLM agents operate in a loop: the harness assembles a request containing a system prompt, tool schemas, the full conversation history, and the newest user message; the model responds; the cycle repeats. Because the entire context is re-transmitted on every call, cumulative input tokens grow quadratically with turn count. For multi-hour, tool-heavy sessions this term dominates total cost.

Anthropic and OpenAI both offer prompt caching: previously processed prefix tokens are re-served at a fraction of list price (10% on Anthropic [2]; 10% on OpenAI's published cached-input rate [3]). Realized reuse depends on the harness and provider routing/cache state. Three client-side decisions matter on Anthropic: (a) whether cache-control markers are emitted at all; (b) the TTL selected per marker (Anthropic: 5 minutes at a 1.25× one-time write premium, or 1 hour at 2× [2]); and (c) whether the serialized prefix remains byte-identical across turns, since provider caches are exact-prefix matches — any earlier-byte mutation invalidates everything after it.

Vendor documentation describes intended behavior; it does not establish what shipped binaries do under realistic use. Our July 2026 study [1] measured that directly for the releases then current. This paper is the second installment of The Cache Wars: it repeats the protocol of [1] on the current releases of the same six harnesses, on the subscription-authenticated provider paths that most users actually run, and on both provider families. Our contributions:

• A reproducible pause-test protocol that cleanly discriminates 5-minute from 1-hour cache retention using a ≥390 s idle gap, unchanged from [1].
• Per-turn billing telemetry for six production harnesses on byte-identical workloads across two subscription-authenticated provider paths (13 configurations, 65 requests), with instrumentation guards that abort on any validity violation.
• A re-examination of the two cost pathologies identified in [1]: Claude Code's per-turn scaffolding injection has fallen from 6,817 to 40 tokens, and Hermes' intra-burst cache leak is gone; the default-TTL trap persists in three harnesses, each of which survives once its documented retention option is set.
• A parametric cost model, fit to the measurements at current Sonnet 5 list prices, projecting one-hour and multi-hour session costs, and its composition into monthly and annual per-seat spend under three usage profiles.
• A complete artifact set enabling third-party replication.

2  Background: Prompt-Cache Semantics and Pricing

Anthropic. A request may carry up to four cache_control breakpoints. Marking a content block caches the serialized request prefix up to and including that block. Each marker carries a TTL: ephemeral 5 m (default) or 1 h. Billing for Claude Sonnet 5 (list, per 10⁶ tokens): base input $2.00; cache read $0.20 (0.1×); 5 m cache write $2.50 (1.25×); 1 h cache write $4.00 (2.0×); output $10.00 [2]. Cache hits refresh the TTL. Caching is exact-prefix: a single differing byte at position N invalidates all cached content at positions ≥ N.

OpenAI. Caching is automatic: requests sharing a sufficiently long prefix report cached_input_tokens at a discount. Since [1], OpenAI publishes explicit cache prices; for GPT-6 Astra (list, per 10⁶ tokens, standard short-context): input $10.00; cached input $1.00 (0.1×); cache write $12.50 (1.25×); output $50.00 [3]. No Anthropic-style cache markers are used in this track. Current Platform model-specific retention settings and their distinction from the subscription path are described below [12]. Codex CLI relies exclusively on this mechanism [4], and every Codex-path receipt in this study reports zero cache-write tokens.

We use premium tokens to denote tokens billed at ≥1× list (uncached input plus cache writes) and cached tokens for those billed at 0.1×. For a harness with zero overhead, steady-state premium per turn equals the size of the newest message.

2.1  Codex caching semantics and explicit price list

Codex caching is automatic prefix reuse, not Anthropic cache_control markers. OpenAI’s Platform documentation for GPT-5.6 and later specifies prompt_cache_options.ttl = 30m as the default and only supported minimum lifetime; older model families expose different retention controls [12]. This is a Platform API contract, not proof that the subscription backend exposes every control. In these subscription runs, five paths retained cache across the measured pause; the OMP burst miss demonstrates that eligible retention and an actual hit are not the same thing.

For Codex, total input I already contains cached input C; premium or non-read input P = I − C. The raw AGNT provider event uses input_tokens_details.cached_tokens, while Codex CLI reports cached_input_tokens. OMP, OpenClaw and Hermes expose normalized exclusive-input shapes that must be combined with their cache reads once, not twice. No accepted Codex request reports separately billed cache-write tokens. API-equivalent comparisons use $10/M uncached and $1/M cached input for these short-context measured requests. Subscription fees and quota meters are separate (§8).

3  Systems Under Test

The tested versions were resolved on 2026-09-08; the AGNT build is identified by the source fingerprints in the artifact set (OMP under Bun 1.3.14; OpenClaw under Node 24.20.0; Hermes from its tagged source with Python 3.13 and its declared dependencies; AGNT's provider code under Node 22.16.0). Anthropic-path harnesses used model claude-sonnet-5; Codex-path harnesses used gpt-6-astra. Every arm authenticated with a subscription credential rather than a metered API key — the Claude subscription for Anthropic paths and the ChatGPT subscription for Codex paths (§8). OpenClaw and Hermes were driven through their public entry points (openclaw agent --local --session-id … --json with all tools denied; Hermes' documented AIAgent API with run_conversation(…, conversation_history=…) and an empty toolset), each on the provider path where its caching demonstrably engages, so results reflect each system's best case, not a degraded default. OMP was driven through its own omp -p --mode json --continue print mode; its per-turn agent_end usage block reports a native per-TTL split (cttl:{ephemeral5m, ephemeral1h}), and it was measured on both its shipping default (5 m) and its PI_CACHE_RETENTION=long path (1 h). OpenClaw and Hermes were likewise measured on both their defaults and their documented 1-hour options (cacheRetention: long; prompt_caching.cache_ttl: 1h). Claude Code ran through claude -p --output-format json --resume with tools disabled; Codex CLI through codex exec --json / exec resume. AGNT was driven through its own orchestrator handler and provider adapters on an isolated loopback host, carrying its resident instruction context and tool schemas with tool execution disabled; on the Codex path OpenClaw was run on its embedded runtime rather than the separately available Codex app-server runtime, so that its cache behaviour is its own.

4  Experimental Design

4.1  Workload

Each turn t sends the message “CACHE-WARS RUN ⟨run id⟩ / TURN t: This is a fixed-output cache benchmark. Reply with exactly OKt, nothing else. Do not use tools. Ignore the synthetic data below.” followed by the filler F(t), a deterministic function producing 260 rows and 7,878 UTF-8 bytes per turn (Listing 1) — ≈5,265 tokens under the Sonnet 5 tokenizer and ≈4,455 under GPT-6 Astra. The deterministic numeric-row structure follows [1]; byte identity is asserted only for this edition’s shared within-track workload files, not the earlier edition’s different runner inputs. Payloads are byte-identical across harnesses within a provider track (each track carries its own run identifier). Instructing fixed, short replies (OKt: five billed output tokens on Claude, six on Codex) minimizes output-side confounds; every accepted reply is exactly OKt.

Listing 1 — deterministic per-turn filler (JavaScript; Python port identical)
function filler(t) {
  let s = '';
  for (let i = 0; i < 260; i++)
    s += `row ${t}-${i} a=${(i*7919)%104729} b=${(i*104729)%7919} c=${i%13}; `;
  return s;
}

4.2  Protocol: the pause test

Four turns are issued back-to-back (inter-turn latency ≪ 5 m), followed by an idle period of at least 390 s, followed by turn 5. AGNT's measured gaps are 390.002 s (Claude) and 390.010 s (Codex); the other arms' gaps span 394.8–498.7 s, recorded from runner completion to next runner start (provider-visible inactivity is longer by client start-up). The idle length is chosen to strictly exceed the 5-minute TTL while remaining far below the 1-hour TTL, so post-pause telemetry classifies each harness's effective retention with no ambiguity: a 5 m cache must report cache_read_input_tokens = 0 on turn 5; a 1 h cache must report a full-prefix read.

4.3  Instrumentation and validity guards

Ground truth is the provider's own per-request accounting: Anthropic's usage block (input_tokens, cache_read_input_tokens, cache_creation_input_tokens, and the per-TTL split cache_creation.ephemeral_{5m,1h}_input_tokens); OpenAI's input_tokens with input_tokens_details.cached_tokens. These reach the runner through each harness's native telemetry — Claude Code's --output-format json result blocks, Codex's turn.completed usage events, OMP's agent_end usage with its cttl split, OpenClaw's lastCallUsage, and Hermes' canonical session-usage deltas with exactly one API call per turn (Hermes does not expose the per-TTL split, so its write tier is taken from its configured policy and corroborated by the post-pause read). For the AGNT arm the provider's raw usage events (message_start/message_delta; response.completed) were captured on every request and reconciled with the harness's own counters: all ten agree exactly.

Driver scripts enforce three fail-loud invariants; violation aborts the run and discards its data: (G1) identity — every turn's reply must be exactly OKt and the reported model must be the requested model (defeats silent fallback to another model or a cached reply); (G2) payload — the SHA-256 of each outgoing prompt must equal the workload digest, byte-identical across every arm of a track (defeats drift in the controlled variable); (G3) continuity and timing — the session identifier is held constant across turns, provider-reported context must grow by the payload each turn (defeats non-accumulating history), inter-turn gaps inside the burst must be below 300 s and the gap before turn 5 at least 390 s. Every accepted record carries the raw usage object of its source so the transformations can be re-run offline (§10).

4.4  Cross-harness comparability

Harnesses ship system prompts and tool schemas of different sizes (6.6k–34.1k tokens at turn 1 on the Claude path; AGNT was measured with its full resident instruction context and tool schemas, the other harnesses in isolated, reduced-tool configurations), so absolute token counts are not comparable across systems. We therefore compare only: (i) the post-pause cache-hit ratio (dimensionless); (ii) steady-state premium tokens per turn against the known 5,265-token payload, which decomposes each bill into user payload + harness overhead; and (iii) dollar figures from applying each harness's measured marker strategy — its TTL policy and per-turn overhead — to fully identical content (§5.3, §6).

As an internal consistency check, per-turn context growth must equal the payload plus any harness self-injection. Measured deltas (turns 2–4, tokens/turn, Claude path): AGNT +5,265; OMP +5,265; Hermes +5,264; OpenClaw +5,285; Claude Code +5,305. The constant ≈5,265 component appearing in all five confirms workload identity to within tokenizer noise; the excess (+20 OpenClaw, +40 Claude Code) is measured harness overhead (§5.4). On the Codex path (GPT-6 Astra tokenizer) the payload is 4,455 tokens: AGNT, OMP and Hermes grow by 4,454–4,455 per turn, OpenClaw by 4,470, and Codex CLI by 4,455–6,344 (a mean +1,364 tokens/turn of its own turn scaffolding).

4.5  Codex-specific controls

The Codex track compares AGNT, Codex CLI, OMP, OpenClaw and Hermes on gpt-6-astra using one shared five-prompt file. Claude Code has no Codex arm in this study. The same 390-second minimum idle is retained for comparability, but it does not distinguish Codex TTL categories. The response is OKt (six billed output tokens); no tool execution is performed. The four measured growth increments, cache counters, prompt hashes and gaps are retained for every path. The native session footprints are reported separately from common-content projections, and a burst miss is never erased or converted into an estimated miss frequency.

5  Results

5.1  Per-turn billing telemetry

AGNT's per-TTL split reports ephemeral_5m_input_tokens = 0 on every Claude turn (all writes 1 h); its turn-1 counters include a 3,949-token shared-prefix read the provider already held, as do Claude Code's (3,289). Every Anthropic-path harness bills a constant two uncached tokens per turn beside its writes. Claude Code's 1 h split is native (ephemeral_1h_input_tokens); OMP's is native (cttl); OpenClaw's is native (cacheWrite1h). OMP's Claude counters (both TTL paths) are reported separately in §5.6 (Table 5), since its default and opt-in configurations must be distinguished; OpenClaw's and Hermes' 1-hour options are in §5.7 (Table 6). On the Codex path Codex CLI already read 12,288 tokens on its first request (a provider-side warm prefix), whereas AGNT read zero; OMP's turn 4 is a complete miss between two hits, retained as observed.

5.2  Pause survival

The result partitions exactly along declared TTL, consistent with Anthropic's contractual expiry semantics: all three 5 m defaults lost 100% of cache across the pause, re-billing 27.6k–35.0k tokens at the write premium, while every 1 h configuration read its entire prior context at 0.1× — AGNT's 49,909-token read is 99.996% of its previous request. AGNT's ratio is the highest measured on both paths (90.45% Claude, 88.42% Codex), 5.52 points above the next Claude configuration (OpenClaw with its 1 h option) and 2.99 points above Codex CLI. The five Codex-path survivals are single observations of an explicitly unguaranteed mechanism and are not generalizable.

5.3  Controlled cost (identical content)

Applying the two marker strategies to identical content (§4.4: the 34,114-token first-turn prefix measured for AGNT — system prompt, tool schemas and the turn-1 payload — plus 5,265 tokens per subsequent turn) for the 5-turn protocol yields, at Sonnet 5 list prices: all-1 h strategy (AGNT, Claude Code layouts) $0.254; 5 m strategies (OMP-default, OpenClaw, Hermes layouts) $0.286 (+13%, driven by the post-pause re-write); no-cache control $0.446 (+76%). Verification: all-1 h writes 34,114 + 4×5,265 = 55,174 tk × $4/M = $0.221; reads 168,046 tk × $0.20/M = $0.034; total $0.254. ✓ 5 m writes 34,114 + 3×5,265 + (34,114 + 4×5,265) = 105,083 tk × $2.50/M = $0.263; reads 118,137 tk × $0.20/M = $0.024; total $0.286. ✓

5.4  Pathology I revisited — per-turn scaffolding injection (Claude Code)

In [1], Claude Code 2.1.126 grew its context by 12,003 tokens/turn against a 5,186-token payload: 6,817 tokens/turn (2.31× payload) of self-injected system reminders and related scaffolding, re-billed at the 1 h write premium every turn. Claude Code 2.1.263 grows by 5,305 tokens/turn against the 5,265-token payload: 40 tokens/turn (0.8% of payload). The earlier large excess is not reproduced in this reduced-tool workload. Its steady-state premium (5,307 tokens/turn) is now within 40 tokens of AGNT's (5,267), and the perfect marker discipline it already showed in [1] now coexists with payload-clean spend. The residual is small enough that it is invisible in dollar terms (§6, $0.851 vs $0.846 per one-hour session).

5.5  Pathology II revisited — intra-burst cache leak (Hermes)

In [1], Hermes 0.18.0 leaked within the rapid burst: cached reads decreased (22,837 → 17,339) while premium writes grew (5,186 → 15,869 → 21,054), because rolling message-marker placement never extended the cached prefix over accumulated history. Hermes 0.21.1 shows the opposite, correct behaviour: cached reads grow with the conversation (6,553 → 11,817 → 17,081) while premium writes stay pinned at the payload (5,266, 5,266, 5,266). Its read volume extends with the accumulated history; the earlier leak pattern is not present in these receipts. Hermes still loses the remainder at the pause on its 5 m default (h = 0%, 27,611-token re-write) and survives with prompt_caching.cache_ttl: 1h (C₅ = 22,347, h = 80.9%).

5.6  OMP — clean spend, but a default-TTL trap

oh-my-pi bills premium tokens equal to the user payload with zero self-injection (5,265 tokens/turn, measured; Table 2-consistent delta +5,265), as it did in [1]. On the tested subscription path OMP 18.1.14 emits 5-minute markers by default and fails the pause test identically to OpenClaw and Hermes (h = 0%, full 30,119-token re-write; verified per-TTL as ephemeral5m in its agent_end usage). With PI_CACHE_RETENTION=long it emits 1-hour markers and survives (C₅ = 24,851, h = 82.5%; verified ephemeral1h). OMP demonstrates that payload-clean billing and the 5-minute default trap are independent axes: a harness can perfect the former and still forfeit the pause on the latter.

5.7  OpenClaw and Hermes — the same trap, the same cure

OpenClaw 2026.9.2 and Hermes 0.21.1 ship the same 5-minute default and fail the pause the same way (34,986 and 27,611 tokens re-written at 1.25×). Each documents a one-line retention option — OpenClaw's per-model cacheRetention: long [5], Hermes' prompt_caching.cache_ttl: 1h [6] — and each survives with it set (h = 84.9% and 80.9%), with first-turn writes within 106 (OpenClaw) and 2 (Hermes) tokens of the defaults'. The counters of both configurations are given in Table 6; premium is the payload (plus OpenClaw's constant 20 tokens) on every non-expiry turn.

5.8  Codex — per-turn telemetry and complete session accounting

Table 3 contains the full cached/non-read pairs for all five Codex paths; Figure C1 gives the corresponding five-line trajectory. Tables C2 and C3 separately identify whole-sequence reuse, final-request reuse and actual context volume. Higher cache share is better for reuse; lower uncached tokens and API-equivalent dollars are better at the stated footprint. These are different rankings.

AGNT ranks first on the Codex pause metric at 88.42%, 2.99 percentage points ahead of Codex CLI. It uses 4,593 uncached tokens versus 6,462 for the CLI on that request. Across the full sequence, however, Codex CLI has the higher weighted cache share (80.12% versus 73.83%), in part because its first request reads 12,288 shared-prefix tokens while AGNT’s reads zero. Hermes’ smaller native context has the lowest full-sequence API equivalent. None of these results is hidden by the primary endpoint.

5.9  Codex — context growth and burst misses

OMP’s fourth request contains 20,028 total input tokens and zero reads; its fifth reads 19,840 tokens. The missed read increases the observed sequence cost. One miss in one sequence cannot estimate a reliable miss probability. We therefore use the same retained-prefix assumption for all harnesses in the growth-based projection and show loss after each break only as a separate sensitivity scenario (§6.2).

6  Cost Model and One-Hour Extrapolation

6.1  Claude cost model and one-hour projection

Let the session comprise n messages of payload m tokens, partitioned into bursts by breaks longer than the TTL. With prefix c₁ = first-turn write and per-turn overhead o, and prices r = $0.20/M (read), w₅ = $2.50/M, w₁ = $4.00/M, u = $2.00/M:

where prefix(t) = c₁ + (t−2)(m+o) is the cached context preceding message t, and rewrite_b = c₁ + (s_b−1)(m+o) is the full context re-purchased at the first message s_b of each burst after the first. Cache hits refresh the TTL, so the 1 h prefix persists across every break shorter than one hour. Because absolute footprints are incomparable across harnesses (§4.4), the model is instantiated over identical content — c₁ = 34,114, m = 5,265 — with each harness's measured marker strategy: its shipping TTL and its per-turn overhead o. For n = 20 with four breaks (after messages 4, 8, 12, 16; breaks > 5 m, session ≤ 1 h):

Extending the same model to longer sessions (a break after every fourth message, ≈12 min apart, at 20 messages/hour) yields the multipliers of Table 8. AGNT's and Claude Code's are monotone decreasing — the 2× build premium amortizes into 0.1× reads. OMP's, OpenClaw's and Hermes' flatten: every break re-charges a full, ever-larger re-write. The model is conservative for 5 m harnesses: it assumes zero intra-burst expiry; the frequency of real-world pauses was not measured here, so the size of the modeled gap depends on the stated schedule. OMP, OpenClaw and Hermes are reported on their shipping 5-minute defaults; with their opt-in 1-hour options each collapses onto the AGNT curve ($0.846 at one hour for OMP =long, identical to AGNT to the token) — but that is not out-of-box behavior, so the default is used for the headline, consistent with the treatment of every other harness. Codex has its own price list, retention scenarios, one-hour projection and multi-hour multipliers in §6.2; its monthly, annual, team and tool-latency analyses follow in §7.4–7.6.

6.2  Codex cost model and one-hour projection

The Codex model uses common initial context c₁ = 21,845 and increment m = 4,455, both from the measured AGNT sequence, to avoid comparing unequal native system prompts. Let g = m + o; o is the nonnegative mean excess input growth measured for a harness. Tiny negative residuals for OMP/Hermes are set to zero only in the model, never in the receipts. Every projected session starts cold. Let qₜ = 1 when the whole previous prefix is retained and qₜ = 0 when it is unavailable. Input Jₜ = c₁ + (t−1)g; reads Cₜ = qₜ[Jₜ−g] for t > 1, C₁ = 0; uncached input Uₜ = Jₜ − Cₜ.

The input-only projection sets W = O = 0, matching zero separately reported writes and excluding identical fixed-output replies. The measured-dollar table includes output. The retained case sets q = 1 after the first request. The break-loss case sets q = 0 on requests 5,9,13,17 and so on, with retained prefixes between breaks. That is an assumed miss schedule, not a measured Codex expiry interval. No-cache sets q = 0 throughout. All five harnesses receive the retained assumption in the primary growth comparison.

At one hour the retained zero-extra-growth model costs $2.242; assumed loss after each fourth request costs $4.472; uncached costs $12.834. AGNT, OMP and Hermes tie in the common-content retained model after tokenizer-scale residuals are rounded to zero. Codex CLI’s higher measured mean growth raises its projection to $2.734. AGNT’s measured pause-ratio win must not be recast as an exclusive price advantage when content and cache availability are identical.

7  Monthly and Annual Extrapolation

The Claude monthly analysis retains the original paper’s fixed-work-per-hour normalization: a one-hour reference burn rate multiplied by session-length cache-efficiency factors. It is a rate-normalized budget scenario, not the exact token sum of extending one growing transcript to 80 requests. Each scenario assumes cold starts and the stated marker policy. Let Rᵤ = $3.37/h denote the uncached burn rate of the reference workload (20 messages/h at 5,265 tokens each over the 34,114-token prefix) and M_X(L) the session-length-dependent cost multiplier of harness X from §6 (Table 8). The rate-normalized monthly budget over D workdays with a fixed daily session schedule S is

We instantiate three usage profiles at D = 22 workdays (Table 9) and evaluate with the measured multipliers (Table 10).

Two structural effects emerge at monthly scale. First, the TTL gap widens with load: because the 1-hour multipliers are monotone-decreasing in session length (0.25 at 1 h → 0.14 at 4 h) while the 5-minute defaults flatten (0.41 → 0.40), AGNT's advantage over the 5-minute-default harnesses grows from 1.6–1.7× (light) to ≈2.8× (heavy). Second, the ranking has compressed since [1]: with both pathologies gone, Claude Code now tracks AGNT to within $0.57/month at the heavy profile, and the three 5-minute-default harnesses cluster within $0.77/month of one another — the dominant difference in this specified default-policy model is retention.

7.1  The cache tax

Define the cache tax of harness X as Cost_X − Cost_AGNT for identical work on the identical model. At the heavy profile (Table 11), the tax is $150 per seat per month; a heavy OMP, OpenClaw or Hermes seat on its shipping default spends AGNT's entire monthly budget by approximately day 8.

7.2  Team scale

Annualized over a five-seat team at the heavy profile: AGNT $5,123; Claude Code $5,157; OMP (default) $14,104; Hermes $14,104; OpenClaw $14,150; uncached $35,537. The OpenClaw-vs-AGNT delta alone is ≈$9,027/year for byte-identical work — the cost of one configuration bit, not a model upgrade.

Three properties of this extrapolation bias it against the headline gap rather than for it: (i) the session model assumes breaks only every ≈12 minutes, more frequent pauses would add re-write events to the 5 m scenario but were not measured here; (ii) the identical-content prefix is held at the measured first-turn size, though real agent contexts grow with tool results and file contents, scaling every re-write linearly; and (iii) the model charges the 5 m harnesses nothing for intra-burst expiry. These are scenario sensitivities, not proved lower bounds for real workloads.

7.3  The agentic amplifier: tool latency as involuntary pause

The pause test models the idle gap as a human pause, but nothing in the mechanism requires a human. An agent turn is a chain of model calls separated by tool executions, and any tool that runs longer than the marker TTL expires the cache mid-turn: build systems and test suites (2–20 min), media-generation polling (5–10 min per asset), rate-limit backoff, CI and deployment waits, sub-agent delegation, and approval gates all routinely exceed five minutes with no user absent. On a 5 m-TTL harness, every such tool forces a full-context re-write at 1.25× for the next model call in the same turn.

The per-event cost scales with working-context size. At a realistic agentic context of 100k tokens (Sonnet 5 list, $2/M input), one post-expiry re-write bills 100k × $2/M × 1.25 = $0.25. An autonomous workload executing 30 long-running tools per day on a 5 m-TTL harness therefore pays ≈$7.50/day — ≈$165/month per seat — in gross post-expiry input charges; under the stated sub-hour gaps a retained one-hour read would be charged at the read rate instead, in addition to the human-pause modeling above, and growing linearly with context length. The exposure is thus largest precisely where agent harnesses do their most valuable work: long-context, tool-heavy autonomous sessions. The inversion noted in [1] stands: the harnesses marketed most explicitly for autonomous multi-step operation (OpenClaw, Hermes) still ship the TTL least compatible with it.

7.4  Codex monthly and annual extrapolation

For Codex the same light, moderate and heavy profiles are evaluated as 44 independent sessions per month with 20, 40 or 80 requests per session. Monthly cost is the exact per-session sum multiplied by 22 days × 2 sessions/day; annual cost is 12 times monthly. This includes the full-request long-context threshold. It is not a fixed one-hour burn rate applied after the context has grown.

7.5  Codex cache-loss tax and team scale

For the heavy common-content profile, retained-prefix input costs $1,213.60/seat/month; assumed break loss costs $3,319.47; no reuse costs $10,250.00. The break-loss difference is $2,105.87 per seat per month. A five-seat team scales the annual difference by 60, as shown above. This quantifies exposure to misses, not a claim that any particular Codex client experiences that pattern.

7.6  Codex agentic amplifier

At 100,000 input tokens, a completely uncached GPT-6 Astra request has a $1.00 input API equivalent, versus $0.10 if that entire existing prefix is read from cache. The incremental loss is $0.90 per event; 30 such events per day over 22 days would be $594 per month. No extra $12.50/M cache-write charge is added because the observed subscription counters report none. Unlike the Claude five-minute setting, a five-minute tool wait is not itself evidence of Codex expiration. This scenario applies only when reuse is actually lost; it is not a measured tool-loop bill or a separate additive charge if those same misses are already counted in the session model.

8  Ancillary Finding: Subscription Access

In [1] we observed Anthropic reject a third-party harness presenting a valid Claude-subscription OAuth token (HTTP 400, “Third-party apps now draw from your extra usage, not your plan limits”), and every third-party arm had to be run on a funded API key. In this study every arm ran on a subscription credential: the Claude subscription for AGNT, OMP, Claude Code, OpenClaw and Hermes, and the ChatGPT subscription via Codex for AGNT, Codex CLI, OpenClaw, OMP and Hermes. The 65 accepted requests completed successfully on their subscription paths. The receipts establish successful service, not which plan allowance or any overage bucket funded it. The receipts do not reveal which allowance the usage was drawn from, and subscription usage is metered against plan limits rather than invoiced per token — Claude Code's own documentation states that its session dollar figure is an estimate, not the bill for included plan usage [11]. The dollar figures in §§5–7 are therefore API-list equivalents of the measured counters: what the same work costs at metered rates, not a measured conversion to subscription allowance. The caching results themselves are independent of the billing mode.

8.1  Codex subscription versus metered OpenAI access

The Codex sequences authenticated through the connected ChatGPT subscription on all five paths. This establishes technical access during these trials; it does not identify the account allowance from which usage was deducted, certify third-party product approval, or convert cached tokens to plan credits. The measured input/read/output counters and the published Astra price list support the API-equivalent tables. No OpenAI API top-up was required for these accepted Codex runs, and no separate API bill was measured.

8.2  Separate accounting for both provider families

The same distinction applies to Claude: subscription-authenticated successful usage is not proof that a locally estimated dollar amount was charged or saved as cash. A plan comparison must include actual subscription fees, included allowance, overage and workload quality. The paper’s Claude and Codex dollar models are in separate price units. A low-cost row on one provider must not be compared to another model as if model capability and account terms were held constant.

9  Threats to Validity

Single trial per cell. Anthropic TTL expiry is contractual and the observed partition follows it exactly, but each Codex-path survival is one sample of a load-dependent, unguaranteed mechanism, and OMP's Codex turn-4 miss is a single unexplained event.

Single idle duration. ≥390 s cleanly separates the two TTLs; gaps > 1 h would defeat every harness tested absent keep-warm traffic.

Synthetic payloads. Deterministic filler standing in for real work. Real sessions grow faster (tool results) and pause more often; both effects increase the measured gaps' magnitude, not their direction.

Footprint heterogeneity. Absolute token counts are incomparable across harnesses by construction — AGNT carried its full resident instruction context and tool schemas (34.1k first-turn prefix), the other harnesses isolated reduced-tool configurations (6.6k–13.8k); all cross-harness claims use ratios, payload-normalized overhead, or the identical-content model (§4.4).

Warm first turns. Provider caches cannot be flushed; AGNT and Claude Code read 3,949 and 3,289 shared-prefix tokens on turn 1, and Codex CLI 12,288. The pause test is unaffected (it compares turn 5 to turn 4), and the cost model starts every session cold.

Extrapolation assumptions. Fixed break schedule and payload size; the model is linear in measured per-turn parameters and stated in full (§6) so readers may re-parameterize.

Monthly extrapolation. §7 composes single-session measurements linearly across fixed daily profiles; real months vary payload size, schedule, and break structure. The measurements do not establish the distribution of real pause lengths, prompt growth or task quality; the monthly values are conditional projections.

Subscription telemetry. Dollar figures are list-price equivalents of counters obtained on subscription paths, not invoices (§8); ratios and token counts are unaffected.

Version pinning. Results describe the versions in Table 1 as of 2026-09-08; harness caching behavior can change across releases — as the disappearance of both pathologies of [1] demonstrates.

Codex projections use the current Platform price table with the 272,000-input-token threshold, but the subscription backend is a distinct access surface. The retained-prefix and break-loss schedules are assumptions, not forecast probabilities. Source fingerprints and recorded counter shapes identify what was observed; they do not establish a long-run error rate or universal cross-harness cost ordering.

10  Reproducibility

Codex replication assets have the same status as Claude assets: all five Codex paths, all 25 measured request receipts, original counter objects, prompt digests, and per-request price reconciliation are included. codex-scenario.json contains every request in each projection, including the short/long price multiplier; codex-figure-data.csv contains the measured chart rows. Figures C1–C6 and Tables C1–C8 are rebuilt from those files and verified independently.

All measurements derive from the published artifact set (browse · checksums):

Replication procedure: (1) install the six harnesses at the pinned versions; (2) authenticate each on its subscription path in an isolated home directory (Claude Code via CLAUDE_CONFIG_DIR, Codex via CODEX_HOME, OMP via PI_CODING_AGENT_DIR, OpenClaw via OPENCLAW_HOME, Hermes via HERMES_HOME; AGNT on a separately provisioned isolated host with its own data directory — never a production database); (3) run live_protocol.py --harness … --track … [--retention long], which issues four turns of Listing-1 payloads, sleeps 390 s, issues turn 5, and aborts on any guard violation; (4) run verify.py to re-derive every counter in Tables 2–6 from the receipts' raw usage objects and every cost-model quantity in Tables 7–11 and C5–C8 from §6–7; (5) run build.py --output NEW_DIRECTORY to regenerate this manuscript and its figures from the same data. Every number in this paper is either a raw counter from these files or an arithmetic combination shown in the text.

11  Conclusion

Prompt-cache efficiency in deployed agent harnesses is determined by client-side engineering, and shipped behavior still diverges from what documentation implies — though less than it did two months ago. A single configuration bit — cache TTL — separates harnesses that resume an interrupted session at 10% of list price from harnesses that silently re-purchase their entire context after every human-scale pause. The two pathologies layered on top of it in [1] have been engineered away: Claude Code's per-turn scaffolding has fallen from 6,817 tokens to 40, and Hermes' marker placement now extends the cached prefix over history. What has not changed is the default: OMP, OpenClaw and Hermes still ship the 5-minute TTL that forfeits the pause, and each still requires a documented opt-in to survive it. AGNT v0.6.6 combines default one-hour Claude markers, Claude writes equal to the measured input increment, and successful Codex reuse — posting the highest post-pause cache-hit ratio on the Claude path (90.45%) and the Codex path (88.42%) in these trials. Under the stated Claude default-policy projection AGNT attains the lowest cost, tied with other zero-extra-growth one-hour configurations when those options are enabled. Codex cost projections are conditional on prefix availability; equal content and equal availability imply equal price, not an exclusive harness discount. Composed over a working month, the surviving mechanism compounds into a per-seat cache tax of $150/month ($1,796–$1,805/year) for the 5-minute-default harnesses, and ≈$9,027/year for a five-seat team in the worst measured case — recurring spend separable from model quality entirely, and recoverable by client-side engineering alone.

References

1. The Cache Wars: An Empirical Study of Prompt-Cache Efficiency in Six LLM Agent Harnesses. Technical Report v2.0, AGNT Labs, July 7, 2026. agnt.gg/whitepapers/the-cache-wars-prompt-cache-efficiency-llm-agent-harnesses
2. Anthropic. Prompt caching; Model and cache pricing. Claude Platform Documentation (accessed 2026-09-08). Sonnet 5: input $2.00/M; cache read $0.20 (0.1×); 5-minute write $2.50 (1.25×); 1-hour write $4.00 (2×). platform.claude.com/docs/en/build-with-claude/prompt-caching
3. OpenAI. API pricing. OpenAI Developer Documentation (accessed 2026-09-08). gpt-6-astra standard short-context: input $10.00/M; cached input $1.00; cache write $12.50; output $50.00. Automatic prefix caching; model-specific retention controls are documented separately [12]. developers.openai.com/api/docs/pricing
4. OpenAI. Using Codex with your ChatGPT plan. OpenAI Help Center (accessed 2026-09-08). help.openai.com/en/articles/11369540-using-codex-with-your-chatgpt-plan
5. OpenClaw. Anthropic provider; Model providers and runtime selection. Technical reference (accessed 2026-09-08). cacheRetention: none|short|long; “short” (5 m) seeded by default for Anthropic. docs.openclaw.ai/providers/anthropic
6. Nous Research. Hermes Agent release v2026.9.7 (0.21.1). GitHub release (accessed 2026-09-08). github.com/NousResearch/hermes-agent/releases/tag/v2026.9.7
7. oh-my-pi. @oh-my-pi/pi-coding-agent 18.1.14. npm registry record (accessed 2026-09-08). registry.npmjs.org/@oh-my-pi/pi-coding-agent/18.1.14
8. Anthropic. @anthropic-ai/claude-code 2.1.263. npm registry record (accessed 2026-09-08). registry.npmjs.org/@anthropic-ai/claude-code/2.1.263
9. OpenAI. @openai/codex 0.153.4. npm registry record (accessed 2026-09-08). registry.npmjs.org/@openai/codex/0.153.4
10. OpenClaw. openclaw 2026.9.2. npm registry record (accessed 2026-09-08). registry.npmjs.org/openclaw/2026.9.2
11. Anthropic. Claude Code: manage costs effectively. Claude Code documentation (accessed 2026-09-08). The session cost display is an estimate and does not reflect subscription billing. code.claude.com/docs/en/costs
12. OpenAI. Prompt caching. Platform model-dependent retention settings and automatic prefix reuse (accessed September 8, 2026). developers.openai.com/api/docs/guides/prompt-caching
13. OpenAI. GPT-6 Astra. Standard pricing and full-request long-context threshold above 272K input tokens (accessed September 8, 2026). developers.openai.com/api/docs/models/gpt-6-astra