What does fanning out 100 AI subagents cost? A calculation from measured runs
What cost scenarios do recorded CLI calls and worker attempts support for 10, 100 and 500 units?
Published · 3 charts · Download the data or a carousel
$0.36
The answer
Calculation, not a run. We started no parallel subagents. At list price, 100 small Sonnet calls cost $0.36 using the median (15 calls; per-call range $0.0034 to $0.0102). Sonnet passed 12/15 (Wilson 95% interval 54.8% to 93.0%). This is cost per call, not per correct answer. At the mean notional cost, 100 full worker attempts cost $280.72 (33 attempts; per-attempt range $0.89 to $4.83). For Claude Code minimal replies, 100 × median input tokens gives 676,100 tokens (n = 5; token range unavailable). Input-only Sonnet price scenarios give $0.16, $1.35 or $2.70, with different cache assumptions. The corrected Codex aggregate reports 17,051 inclusive input tokens, including 13,184 cache-read tokens. We add no Codex input or cost projection. Serial scenarios use N × median duration. We do not know the parallel completion time.
Key numbers
6,761
Minimal-reply input tokens, Claude Code (median, Haiku 4.5)
n = 5
2.53s
Recorded: Claude Code minimal-reply wall time (median)
n = 5
6.00s
Recorded: Codex CLI minimal-reply wall time (median)
n = 5
676,100
100 minimal replies × median input tokens (calculation)
n = 5
$1.35
100 minimal replies, plain input (calculation)
n = 5
$0.16
100 minimal replies, first writes, later calls read (calculation)
n = 5
$2.70
100 minimal replies, every call writes (calculation)
n = 5
0 of 4
Later Claude sessions with first-turn cache reads greater than writes (proxy)
n = 4
18.7%
Recorded: Claude Code first-turn cache-read share (mean; calculation from reported first-turn counters)
n = 6
55.5%
Recorded: Codex CLI first-turn cache-read share (mean; calculation from reported first-turn counters)
n = 3
$0.0036
Recorded: Claude Code · Claude Sonnet 5.5, median per-call cost (calculation)
n = 15
12/15
Recorded: Claude Code · Claude Sonnet 5.5, strict validator pass rate
95% CI 55%–93% · n = 15
$0.0069
Recorded: Claude Code · Claude Opus 5.5, median per-call cost (calculation)
n = 15
15/15
Recorded: Claude Code · Claude Opus 5.5, strict validator pass rate
95% CI 80%–100% · n = 15
$0.69
100 calls, Claude Code · Claude Opus 5.5 (calculation)
n = 15
$0.0057
Recorded: Claude Code · Claude Haiku 4.5, median per-call cost (calculation)
n = 15
15/15
Recorded: Claude Code · Claude Haiku 4.5, strict validator pass rate
95% CI 80%–100% · n = 15
$0.57
100 calls, Claude Code · Claude Haiku 4.5 (calculation)
n = 15
$0.0099
Recorded: Claude Code · Claude Fable 5.1, median per-call cost (calculation)
n = 15
15/15
Recorded: Claude Code · Claude Fable 5.1, strict validator pass rate
95% CI 80%–100% · n = 15
$0.99
100 calls, Claude Code · Claude Fable 5.1 (calculation)
n = 15
$0.0102
Recorded: Codex CLI · GPT-6.1 Sol (medium), median per-call cost (calculation)
n = 15
15/15
Recorded: Codex CLI · GPT-6.1 Sol (medium), strict validator pass rate
95% CI 80%–100% · n = 15
$1.02
100 calls, Codex CLI · GPT-6.1 Sol (medium) (calculation)
n = 15
$2.81
Full worker attempt, mean notional cost (calculation)
n = 33
9.6min
Full worker attempt, median wall time
n = 33
49.5
Full worker attempt, mean model calls
n = 33
$28.07
10 full worker attempts (calculation)
n = 33
$280.72
100 full worker attempts (calculation)
n = 33
$1403.60
500 full worker attempts (calculation)
n = 33
16.0 h
100 worker attempts, serial duration scenario (calculation)
n = 33
4,945
100 worker attempts × mean calls (calculation)
n = 33
The charts
Hover or focus a row for its exact value, interval and sample. Each chart has a Table view.
Plain input, no cache surcharge
First writes; all later calls read the whole prefix
Every call writes the whole prefix (1-hour price)
One panel per series, all on the same axis.
| Item | Plain input, no cache surcharge | First writes; all later calls read the whole prefix | Every call writes the whole prefix (1-hour price) | n |
|---|---|---|---|---|
| 10 subagents | $0.14 | $0.039 | $0.27 | 5 |
| 100 subagents | $1.35 | $0.16 | $2.70 | 5 |
| 500 subagents | $6.76 | $0.7 | $13.52 | 5 |
List-price calculation, not a run. 3 rows, 3 series: Plain input, no cache surcharge, First writes; all later calls read the whole prefix, Every call writes the whole prefix (1-hour price). Plain input, no cache surcharge: highest 500 subagents $6.76 (n 5). Lowest 10 subagents $0.14 (n 5). First writes; all later calls read the whole prefix: highest 500 subagents $0.7 (n 5). Lowest 10 subagents $0.039 (n 5).
Notesn = 5 per row
N × 6,761 median input tokens, repriced at Sonnet 5.5 rates
Calculation, not a bill. n = 5 minimal replies on Haiku 4.5, one at a time. Sonnet 5.5 prices: $2.00 input, $0.20 cache read and $4.00 1-hour write per million tokens (2026-09-21). These scenarios use assumptions, not measured bounds. These scenarios exclude output and orchestration costs. No empty-prompt control isolates the CLI prefix. The corrected Codex aggregate reports 17,051 inclusive input tokens, including 13,184 cache-read tokens. Cached input is a subset, not an additional count. We omit its input and cost projections; different models and a minimal reply do not isolate a common startup prefix.
Sources: Fan-out cost and serial time scenarios (calculation), Routing overhead runs: policy microbenchmark and CLI start-up, Anthropic list prices (Claude models)
Claude Code minimal reply (Haiku 4.5; Sonnet 5.5 price)
Claude Code · Claude Sonnet 5.5
Codex CLI · GPT-6.1 Sol (medium)
Full worker attempt · Crewshal · Sonnet 5.5
One panel per series, all on the same axis; whiskers are the lowest–highest run (not an interval).
| Item | Claude Code minimal reply (Haiku 4.5; Sonnet 5.5 price) | Claude Code · Claude Sonnet 5.5 | Codex CLI · GPT-6.1 Sol (medium) | Full worker attempt · Crewshal · Sonnet 5.5 | Range (lowest–highest run) | n |
|---|---|---|---|---|---|---|
| 10 subagents | $0.14 | $0.036 | $0.1 | $28.07 | Claude Code · Claude Sonnet 5.5: $0.034–$0.1; Codex CLI · GPT-6.1 Sol (medium): $0.054–$0.27; Full worker attempt · Crewshal · Sonnet 5.5: $8.90–$48.27 | 5 |
| 100 subagents | $1.35 | $0.36 | $1.02 | $281 | Claude Code · Claude Sonnet 5.5: $0.34–$1.02; Codex CLI · GPT-6.1 Sol (medium): $0.54–$2.69; Full worker attempt · Crewshal · Sonnet 5.5: $88.98–$483 | 5 |
| 500 subagents | $6.76 | $1.80 | $5.09 | $1,404 | Claude Code · Claude Sonnet 5.5: $1.71–$5.11; Codex CLI · GPT-6.1 Sol (medium): $2.70–$13.43; Full worker attempt · Crewshal · Sonnet 5.5: $445–$2,414 | 5 |
List-price calculation, not a run. 3 rows, 4 series: Claude Code minimal reply (Haiku 4.5; Sonnet 5.5 price), Claude Code · Claude Sonnet 5.5, Codex CLI · GPT-6.1 Sol (medium), Full worker attempt · Crewshal · Sonnet 5.5. Claude Code minimal reply (Haiku 4.5; Sonnet 5.5 price): highest 500 subagents $6.76 (n 5). Lowest 10 subagents $0.14 (n 5). Not all run ranges overlap. Claude Code · Claude Sonnet 5.5: highest 500 subagents $1.80 (range $1.71–$5.11, n 15). Lowest 10 subagents $0.036 (range $0.034–$0.1, n 15). Not all run ranges overlap.
NotesLines: lowest–highest run (not an interval)n 5–33 per row
Small calls use medians; worker attempts use the mean. Each workload comes from a different run.
We ran no parallel workload. Whiskers multiply observed per-unit cost ranges by N; they are scenario spreads, not confidence intervals. Small-call costs include non-passes: Sonnet 12/15, Sol 15/15. These are per-call costs, not costs per correct answer. Each call includes its own CLI prompt, at the size used in that run. Models, flags and prompts differ across these runs. We did not test the cause of the cost difference. Do not add these bars together. Worker costs include all 33 attempts, including failures.
Sources: Fan-out cost and serial time scenarios (calculation), Routing overhead runs: policy microbenchmark and CLI start-up, Caching sessions and repeated prompts (Claude Code and Codex CLI), Provider head-to-head: Claude Code models vs Codex efforts, Crewshal on SWE-bench Verified, campaign 1 (25 instances), Crewshal on SWE-bench Verified, campaign 2 (8 compiled-extension instances), Anthropic list prices (Claude models), OpenAI list prices
Serial scenario, 10 units
Serial scenario, 100 units
Serial scenario, 500 units
One-unit median reference (not a parallel bound)
One panel per series, all on the same axis; whiskers are the fastest–slowest run (not an interval).
| Item | Serial scenario, 10 units | Serial scenario, 100 units | Serial scenario, 500 units | One-unit median reference (not a parallel bound) | Range (lowest–highest run) | n |
|---|---|---|---|---|---|---|
| Claude Code minimal reply (Haiku 4.5; Sonnet 5.5 price) | 25.3 s | 253 s | 1,265 s | 2.5 s | Serial scenario, 10 units: 22.7 s–33.8 s; Serial scenario, 100 units: 227 s–338 s; Serial scenario, 500 units: 1,137 s–1,691 s; One-unit median reference (not a parallel bound): 2.3 s–3.4 s | 5 |
| Claude Code · Claude Sonnet 5.5 | 23.1 s | 231 s | 1,155 s | 2.3 s | Serial scenario, 10 units: 21.7 s–77.3 s; Serial scenario, 100 units: 217 s–773 s; Serial scenario, 500 units: 1,087 s–3,863 s; One-unit median reference (not a parallel bound): 2.2 s–7.7 s | 15 |
| Claude Code · Claude Opus 5.5 | 27.5 s | 275 s | 1,373 s | 2.7 s | Serial scenario, 10 units: 24.7 s–89.1 s; Serial scenario, 100 units: 247 s–891 s; Serial scenario, 500 units: 1,235 s–4,457 s; One-unit median reference (not a parallel bound): 2.5 s–8.9 s | 15 |
| Claude Code · Claude Haiku 4.5 | 44.3 s | 443 s | 2,214 s | 4.4 s | Serial scenario, 10 units: 31.6 s–236 s; Serial scenario, 100 units: 316 s–2,357 s; Serial scenario, 500 units: 1,582 s–11,785 s; One-unit median reference (not a parallel bound): 3.2 s–23.6 s | 15 |
| Claude Code · Claude Fable 5.1 | 19.4 s | 194 s | 972 s | 1.9 s | Serial scenario, 10 units: 14.1 s–98.3 s; Serial scenario, 100 units: 141 s–983 s; Serial scenario, 500 units: 705 s–4,914 s; One-unit median reference (not a parallel bound): 1.4 s–9.8 s | 15 |
| Codex CLI · GPT-6.1 Sol (medium) | 56.5 s | 565 s | 2,825 s | 5.6 s | Serial scenario, 10 units: 41 s–255 s; Serial scenario, 100 units: 410 s–2,546 s; Serial scenario, 500 units: 2,048 s–12,731 s; One-unit median reference (not a parallel bound): 4.1 s–25.5 s | 15 |
| Full worker attempt · Crewshal · Sonnet 5.5 | 5,754 s | 57,540 s | 287,700 s | 575 s | Serial scenario, 10 units: 978 s–32,454 s; Serial scenario, 100 units: 9,780 s–324,540 s; Serial scenario, 500 units: 48,900 s–1,622,700 s; One-unit median reference (not a parallel bound): 97.8 s–3,245 s | 33 |
| Codex CLI minimal reply (default model) | 60 s | 600 s | 3,000 s | 6 s | Serial scenario, 10 units: 53.7 s–65.1 s; Serial scenario, 100 units: 537 s–651 s; Serial scenario, 500 units: 2,684 s–3,253 s; One-unit median reference (not a parallel bound): 5.4 s–6.5 s | 5 |
List-price calculation, not a run. 8 rows, 4 series: Serial scenario, 10 units, Serial scenario, 100 units, Serial scenario, 500 units, One-unit median reference (not a parallel bound). Serial scenario, 10 units: slowest Full worker attempt · Crewshal · Sonnet 5.5 5,754 s (range 978 s–32,454 s, n 33). Fastest Claude Code · Claude Fable 5.1 19.4 s (range 14.1 s–98.3 s, n 15). Not all run ranges overlap. Serial scenario, 100 units: slowest Full worker attempt · Crewshal · Sonnet 5.5 57,540 s (range 9,780 s–324,540 s, n 33). Fastest Claude Code · Claude Fable 5.1 194 s (range 141 s–983 s, n 15). Not all run ranges overlap.
NotesLines: fastest–slowest run (not an interval)n 5–33 per row
Serial = N × median. We did not measure parallel completion time.
A serial total is a sum of durations. N × the median is a scenario, not its measured total or expected value. Whiskers show observed per-unit ranges, scaled by N for serial scenarios. They are not confidence intervals. Simultaneous completion depends on the maximum duration, not the median. The slowest recorded worker attempt took 54.1 min. We did not measure rate limits, machine limits or contention.
Sources: Fan-out cost and serial time scenarios (calculation), Routing overhead runs: policy microbenchmark and CLI start-up, Provider head-to-head: Claude Code models vs Codex efforts, Crewshal on SWE-bench Verified, campaign 1 (25 instances), Crewshal on SWE-bench Verified, campaign 2 (8 compiled-extension instances)
Tables
Per-unit inputs, costs and durations
| Workload | n | Strict passes, with Wilson 95% interval | Input tokens (median; worker mean) | List-price cost (calculation; worker mean, others median) | Observed cost range (calculation) | Median wall time | Observed time range |
|---|---|---|---|---|---|---|---|
| Claude Code minimal reply (Haiku 4.5; Sonnet 5.5 price) | 5 | not scored here | 6,761 | $0.014 | Token range absent; input-only scenario | 2.5 s | 2.27 s to 3.38 s |
| Claude Code · Claude Sonnet 5.5 | 15 | 12/15; 54.8% to 93.0% | 2,081 | $0.0036 | $0.0034 to $0.0102 | 2.3 s | 2.17 s to 7.72 s |
| Claude Code · Claude Opus 5.5 | 15 | 15/15; 79.6% to 100.0% | 2,077 | $0.0069 | $0.0059 to $0.0223 | 2.8 s | 2.47 s to 8.91 s |
| Claude Code · Claude Haiku 4.5 | 15 | 15/15; 79.6% to 100.0% | 3,789 | $0.0057 | $0.0051 to $0.0180 | 4.4 s | 3.16 s to 23.57 s |
| Claude Code · Claude Fable 5.1 | 15 | 15/15; 79.6% to 100.0% | 3,229 | $0.0099 | $0.0049 to $0.0584 | 1.9 s | 1.41 s to 9.83 s |
| Codex CLI · GPT-6.1 Sol (medium) | 15 | 15/15; 79.6% to 100.0% | 12,124 | $0.01 | $0.0054 to $0.0269 | 5.7 s | 4.09 s to 25.46 s |
| Full worker attempt · Crewshal · Sonnet 5.5 | 33 | not scored here | 4,935,189 | $2.81 | $0.89 to $4.83 | 575 s | 1.6 min to 54.1 min |
N × per-unit scenarios (calculation)
| Assumed units (not sample n) | Workload | Measured sample n | List-price cost scenario | N × observed per-unit cost range | Serial scenario: N × median |
|---|---|---|---|---|---|
| 10 | Claude Code minimal reply (Haiku 4.5; Sonnet 5.5 price) | 5 | $0.14 | Token range absent | 25.3 s |
| 10 | Claude Code · Claude Sonnet 5.5 | 15 | $0.036 | $0.0342 to $0.10 | 23.1 s |
| 10 | Claude Code · Claude Opus 5.5 | 15 | $0.069 | $0.0592 to $0.22 | 27.5 s |
| 10 | Claude Code · Claude Haiku 4.5 | 15 | $0.057 | $0.0513 to $0.18 | 44.3 s |
| 10 | Claude Code · Claude Fable 5.1 | 15 | $0.099 | $0.0490 to $0.58 | 19.4 s |
| 10 | Codex CLI · GPT-6.1 Sol (medium) | 15 | $0.1 | $0.0540 to $0.27 | 56.5 s |
| 10 | Full worker attempt · Crewshal · Sonnet 5.5 | 33 | $28.07 | $8.90 to $48.27 | 5,754 s |
| 100 | Claude Code minimal reply (Haiku 4.5; Sonnet 5.5 price) | 5 | $1.35 | Token range absent | 253 s |
| 100 | Claude Code · Claude Sonnet 5.5 | 15 | $0.36 | $0.34 to $1.02 | 231 s |
| 100 | Claude Code · Claude Opus 5.5 | 15 | $0.69 | $0.59 to $2.23 | 275 s |
| 100 | Claude Code · Claude Haiku 4.5 | 15 | $0.57 | $0.51 to $1.80 | 443 s |
| 100 | Claude Code · Claude Fable 5.1 | 15 | $0.99 | $0.49 to $5.84 | 194 s |
| 100 | Codex CLI · GPT-6.1 Sol (medium) | 15 | $1.02 | $0.54 to $2.69 | 565 s |
| 100 | Full worker attempt · Crewshal · Sonnet 5.5 | 33 | $281 | $88.98 to $482.74 | 57,540 s |
| 500 | Claude Code minimal reply (Haiku 4.5; Sonnet 5.5 price) | 5 | $6.76 | Token range absent | 1,265 s |
| 500 | Claude Code · Claude Sonnet 5.5 | 15 | $1.80 | $1.71 to $5.11 | 1,155 s |
| 500 | Claude Code · Claude Opus 5.5 | 15 | $3.44 | $2.96 to $11.13 | 1,373 s |
| 500 | Claude Code · Claude Haiku 4.5 | 15 | $2.83 | $2.56 to $9.02 | 2,214 s |
| 500 | Claude Code · Claude Fable 5.1 | 15 | $4.93 | $2.45 to $29.22 | 972 s |
| 500 | Codex CLI · GPT-6.1 Sol (medium) | 15 | $5.09 | $2.70 to $13.43 | 2,825 s |
| 500 | Full worker attempt · Crewshal · Sonnet 5.5 | 33 | $1,404 | $444.91 to $2413.72 | 287,700 s |
Method
- The calculation uses separate CLI processes and complete Crewshal worker attempts. It does not measure Claude Code’s built-in subagents within a session.
- Minimal replies: 5 calls per CLI on one Mac, one at a time. Claude Code used Haiku 4.5; Codex used its default model. Wall time includes the answer and process exit. Claude input tokens include all cache categories.
- The current public Codex aggregate reports 17,051 inclusive input tokens, including 13,184 cache-read tokens. Cached tokens are a subset; they must not be added again. We do not project a common startup cost across different models and prompts.
- Small calls: 5 short tasks, 15 calls per selected configuration. We price the reported tokens at list rates, with recorded cache reads and writes. Failed validators remain in cost and time summaries. Pass rates use Wilson 95% intervals.
- Worker costs: all 33 SWE-bench attempts, including failures, from 2 campaigns on 2 platform builds. We use recorded notional totals, including compaction, rather than reprice only the main-call tokens.
- Cost scenarios multiply per-call medians or the mean worker cost by N. Serial duration scenarios multiply the median duration by N. Neither predicts a new workload.
- First-turn cache shares (calculation from reported first-turn counters): Claude 18.7%, n = 6, range 18.7% to 18.7%; Codex 55.5%, n = 3, range 47.7% to 59.3%. These are process-level means, not pooled token shares.
Caveats
- Nothing ran in parallel. We did not measure rate limits, shared-host contention, machine limits or orchestration costs. One-unit medians are reference times, not parallel lower bounds.
- These are subscription calls priced at API list rates, not invoices. We did not measure subscription capacity or billing at scale.
- Minimal-reply calls do not isolate the CLI prefix. No empty-prompt control establishes tokens sent before work. Tools, prompts, flags and models differ across runs.
- Claude’s minimal-reply input median is 6,761; whole Sonnet calls have a median 2,081. Times also differ: 2.53 s versus 2.31 s. We did not test the cause. Each small call includes its own CLI prompt, not the separately measured minimal-reply prefix.
- Cache costs are scenarios, not bounds. Complete reuse assumes a cache write finishes before later calls start and their prefixes match. Actual writes can exceed plain-input prices.
- The 4 later Claude processes read fewer first-turn cache tokens than they wrote. Counters do not identify which ledger tokens they read. Claude used a shortened ledger; Codex used the earlier longer ledger.
- Pre-call protocol declaration is unverified from the selected public extracts. File times and final protocol text do not establish what was declared before the calls. This calculation supplies no new experiment or advance-declaration proof.
- The linked minimal-reply, head-to-head and cache extracts retain final protocol text with advance-declaration headings. No preserved pre-call protocol versions were supplied for these extracts. Their public summary labels this missing provenance before publication; historical raw records and review verdicts stay unchanged.
- The small task set is easy and selected, not a representative coding sample. Sonnet has three exact-text format misses with correct final numbers. Other selected configurations passed every call and hit a ceiling. Small n and overlapping cost ranges do not support a ranking.
- Other work shared the Mac and subscription accounts. Timing may include shared load; different dates, models and harnesses prevent causal comparisons.
- The worker sample has 33 attempts. Costs range from $0.89 to $4.83 and times from 1.6 min to 54.1 min. Campaigns used different platform builds and include replacement instances. New tasks may require different tokens and outcomes.
- These publication-label corrections need a fresh source and text recheck before publication. They do not establish advance declaration or replace the historical failed source review.
Sources
Fan-out cost and serial time scenarios (calculation)
N times recorded per-call median or worker mean cost. Serial duration uses N times median. Cache scenarios are assumptions, not bounds; one-unit medians are references, not parallel lower bounds. No parallel workload or capacity was measured.
Routing overhead runs: policy microbenchmark and CLI start-up
In-process timing of the deterministic routing policy (20,000 timed decisions), CLI start-up with a one-word prompt (5 runs per CLI), and decision counts read from recorded bench runs. LLM router timings are reused from the routing runs.
Caching sessions and repeated prompts (Claude Code and Codex CLI)
Part 1: 5-turn CLI sessions over a fixed synthetic ledger, with the cache counters each provider reports per turn. Part 2: three prompts with deterministic validators, 10 repetitions per model. Declared protocols, validator controls before inference, every attempt kept; answers are published as ordinal ids, never as text.
Provider head-to-head: Claude Code models vs Codex efforts
Five short tasks with deterministic validators, declared protocol, every attempt kept.
Crewshal on SWE-bench Verified, campaign 1 (25 instances)
Stratified sample of 25 Verified instances (seed 20261004), one attempt each, official grading harness. Fixed model claude-sonnet-5-5, platform build f0ac3a8a.
Crewshal on SWE-bench Verified, campaign 2 (8 compiled-extension instances)
The 6 compiled-extension instances that campaign 1 could not run, plus 2 replacement candidates. One attempt each, platform build 236c0d3f.
Anthropic list prices (Claude models)
Prices as listed by the vendor on 2026-09-21 and recorded in the product price table. Cache reads at the listed rate, one-hour cache writes at twice the input price.
Token prices as listed by the vendor on 2026-10-03.
Download the data
The study as JSON (with its sources), every chart point as CSV, or the whole public dataset. Free to reuse under CC BY 4.0: credit Crewshal and link the study.
Share it as a carousel
Square slides made in your browser from the charts on this page, with the same numbers, intervals and notes, and a captions file for alt text.
Cite as: Crewshal public benchmarks, “What does fanning out 100 AI subagents cost? A calculation from measured runs”, updated October 6, 2026, https://agent.sasid.ai/benchmarks/subagent-fan-out-cost.
Write-ups on this study
What does fanning out 100 AI subagents cost? A calculation from measured runs
Calculation from separate CLI calls and Crewshal worker attempts. List-price cost scenarios for 100 units; no parallel run was measured.
More studies
All benchmarksHow much of an AI bill is thinking? Reasoning tokens by model and effort
Reasoning tokens in 378 recorded calls by model and effort: share of output, list-price cost per call and per pass, and time. Calculations.
Does a new Claude Code session reuse the prompt cache of an earlier one?
30 calls: later Claude Code sessions showed near-full turn-1 cache reads with a fixed folder, but not with new folders in this sample. Codex CLI tested too.
Where the seconds go: first text, output speed and prompt size for 6 LLMs
60 calls on 6 models: time to first text, tokens per second, and what a 1k, 16k or 64k prompt adds. Claude Code and Codex CLI.