# Agent Swarm Economics: Why Caching Was 78% of Our Bill

> Source: <https://verial.xyz/posts/agent-swarm-economics>
> Published: 2026-11-17 21:10:31.298417+00:00

# Agent Swarm Economics: Why Caching Was 78% of Our Bill

November 17, 2026

Caching looks cheap, but in a long agent loop it quietly becomes most of your token bill. A million-token context window is mostly a trap.

I ran our agents in a naive loop and measured what it cost. At API list prices, 78% of the Claude Code bill was caching<sup>[1](#user-content-fn-fleet)</sup>.

## TL;DR: The Principles

1. [**Loops shouldn't have indefinitely increasing context.**](#principle-1) A loop that keeps adding to one session re-reads its whole, ever-growing context on every turn, so the longer it runs, the more each turn costs. The simplest fix is a context limit. What we do instead: a[handoff](https://verial.xyz/glossary#handoff) skill writes down the current priorities, and a fresh session starts over from that.
2. [**Long context is for one-shot questions, not loops.**](#principle-2) A big[context window](https://verial.xyz/glossary#context-window) is great for one big read. In a loop, every turn re-reads all of it.
3. [**The system prompt is a tax on every turn.**](#principle-3) Pruning what our sessions start with would save about $93 a day in API spend, and up to about $155 with a leaner orientation.
4. [**Swarm structure decides how many tokens go to useless work.**](#principle-4) A badly shaped swarm burns tokens on messages, approvals and handoffs that don't move the work forward.
5. [**Structure agent teams like human teams.**](#principle-5) Communication channels multiply as teams grow<sup>[2](#user-content-fn-brooks1975)</sup> . Small, isolated teams that don't need outside approvals move faster, and for agents they also cost less. Build the system modular so the teams can be modular: an[inverse Conway maneuver](https://verial.xyz/glossary#inverse-conway-maneuver)<sup>[3](#user-content-fn-conway1968)</sup><sup>[4](#user-content-fn-thoughtworks2014)</sup> .

*Our agent fleet · 24 h measurement windows between 2026-11-15 and 2026-11-17 · Claude Opus 5.5, API list prices · measured with `atc cost`*[1](#user-content-fn-fleet)

## Loops Are a Common Pattern, but at What Cost?

As models get more powerful, we're moving from one agent to many. Agents work with each other in language, the same way people on a team do, so a lot of what we know about human communication carries over. Some of it doesn't. The biggest difference is that you pay for every [token](https://verial.xyz/glossary#token), and at scale that is a very significant cost. From an engineering perspective, that makes it worth optimizing. Below are the formulas we use, and they're written so you can point your agents at them.

The simplest version is the [Ralph loop](https://verial.xyz/glossary#ralph-loop), named by Geoffrey Huntley<sup>[5](#user-content-fn-huntley2025)</sup>: a bash loop that feeds the same prompt to a coding agent forever.

```
while :; do cat PROMPT.md | claude-code ; done
```

Claude Code now has this built in. `/loop` re-runs a prompt on an interval, or at its own pace if you leave the interval out<sup>[6](#user-content-fn-cc-loop)</sup>:

```
/loop 5m check the deploy
/loop 20m /review-pr 1234
```

Under the hood it is a scheduler. A fixed interval becomes a cron job, and the self-paced version sets a wakeup. Either way, each run prompts the **same conversation** again. That is the key difference from the original Ralph loop, which started a fresh session every time and kept its memory in files and git. With `/loop`, every run adds to one context that keeps growing.

[↩](#tldr-1)

A loop that keeps adding to one session re-reads its whole, ever-growing context on every turn, so the longer it runs, the more wasteful each turn gets. The simplest fix is a context limit. What we do instead: a handoff skill writes down the current priorities, and a fresh session starts over from that. The rest of this post is the math for when to do it.

Inside each run, the agent loop works the same way: send the conversation, get a tool call, run it, append the result, send the conversation again. Most coding agents work this way. The catch is in "send the conversation again". The model API is stateless, so **each request processes the whole retained context**: the system prompt, every tool definition, every file the agent read, every test log it kept.

[Prompt caching](https://verial.xyz/glossary#prompt-caching) softens this<sup>[7](#user-content-fn-caching)</sup>. A cached token costs 5% of a fresh input token to read<sup>[8](#user-content-fn-pricing)</sup>. That sounds like the problem is solved. It isn't, because 5% of a very large number, paid on every turn, is still a large number.

To see how large, we measured our own agent fleet. The numbers in this post come from our own development runs: one day of session logs from 10 to 30 Claude Code and Codex agents running around the clock, priced at API list rates<sup>[1](#user-content-fn-fleet)</sup>. The dollar figures cover the Claude Code sessions; Codex usage doesn't show up in those logs. Here is what that day cost:

### Where the Money Went

**Caching was 78% of the bill.** Output was 22% of the bill. For 21.7 million tokens out, our agents reread 4.8 billion cached tokens.

Even cache *writes* ($556: $451 on the 1-hour cache, $105 on the 5-minute) cost more than output ($434). A write is cheaper per token than output ($8 versus $20 per million), but across all 31,724 turns (main sessions and their subagents) each turn wrote about 2,400 new tokens to the cache (tool results, file contents, logs) against about 680 output tokens.

## Every Token You Keep, You Pay For Again

A token that enters the context costs one cache write ($8 per million on the 1-hour cache). After that it is **re-read on every later turn** at $0.20 per million. Take a 2,000-token test log. After 40 cached rereads, you've paid its original write cost again. Keep it through the rest of a 100-turn session and carrying it can cost more than writing it.

Over a session the reread cost grows with the square of its length. Context grows a little every turn, and every turn pays for all of it. That pushes you toward short sessions. But each fresh session has a fixed cost too: it boots, re-reads its brief, re-orients, and only then does useful work; at the end, the old session spends turns writing the handoff. Across 220 sessions that ran to a handoff on our two machines, getting to the first edit cost a mean $1.17, and writing the handoff a mean $0.58 over a median 7 turns.

Restart too often and you keep paying to get oriented. Wait too long and you keep paying to reread the session. Inventory managers have the same problem with holding costs and order costs, and there's a formula for it: the [economic order quantity](https://verial.xyz/glossary#economic-order-quantity)<sup>[9](#user-content-fn-harris1913)</sup>.

- H*
- context at which to start writing the handoff
- B
- context at the first edit (mean 95.7k)
- g
- context added per productive turn (mean 1.41k)
- K
- cost of the turns that do no work: orienting ($1.17) plus writing the handoff ($0.58), $1.75 in all
- r
- cached read price ($0.20 per million tokens)

A productive turn is one between the first edit and the start of handoff writing. All four inputs are means from the same 220 sessions.

With our numbers, **H* ≈ 250k tokens**. The context cost per productive turn is `f(H) = r(B+H)/2 + K·g/(H−B)`: the reads of an average productive turn plus the session's start-up and wind-down cost spread over its productive turns. At the optimum it is `r·B + √(2·K·g·r)`, about $0.051 per productive turn.

Our agents are asked to hand off at 180k and start writing at a median 203k (p10 184k, p90 249k); averaged over those sessions, they run 6.4% above the optimum. If the same 23k lag holds, moving the ask to 225k puts the median start near 248k.

Three things stand out. First, the bottom of the curve is **flat**: anywhere from about 202k to 329k is within 5%. Second, both sides climb: hand off too early and you pay the start-up cost too often; run too long and every turn re-reads a huge context. A million-token window invites you to walk up the right side. Third, the model prices cost only; whether answers get worse in a very long context was not measured here.

[↩](#tldr-2)

A big window is valuable for one big read. For a session left to run toward its limit it is a trap: every turn pays to re-read all of it, and quality drops as context grows<sup>[10](#user-content-fn-chroma2025)</sup>.

The research agrees. At 32k tokens, 11 of 13 models that advertise 128k or more fell below half their short-context score<sup>[11](#user-content-fn-nolima2025)</sup>. Only half of 17 long-context models held up at 32k<sup>[12](#user-content-fn-ruler2024)</sup>. All 18 models in Chroma's tests got worse as input grew<sup>[10](#user-content-fn-chroma2025)</sup>. And the same tasks spread over several turns instead of one scored 39% lower on average<sup>[13](#user-content-fn-laban2025)</sup>. Anthropic calls this [context rot](https://verial.xyz/glossary#context-rot) and treats context as a finite attention budget<sup>[14](#user-content-fn-anthropic2025)</sup>.

### The Fresh-Start Tax

Before the first edit, the agent has already packed its bag, and that bag is the B in the formula. **Every turn pays to reread what it packed.** Our sessions booted at a median 41k tokens and held a median 73k at the first edit or turn 20, whichever came first; the 220 sessions that ran to a handoff held a mean 95.7k at their first edit.

[↩](#tldr-3)

Everything a session starts with is paid for again on every turn it takes. Cutting our startup context from about 41k to 26k tokens would save about $93 a day, roughly 5% of our daily spend. A proposed 10k cut to orientation could take that to about $155, roughly 8%.

| What a session starts with (median of 200 boots) | Tokens | 
|---|---|
| Claude Code system prompt and tool definitions | 25.2k | 
| [Skill](https://verial.xyz/glossary#skill) list | 4.4k | 
| Project CLAUDE.md | 3.5k | 
| Memory index | 2.8k | 
| Other (prompt, [subagent](https://verial.xyz/glossary#subagent) list, MCP, deferred tools) | 5.3k | 
| **Boot** | **41.2k** | 
| Difference between the boot and first-edit-or-turn-20 medians | +32k | 
| **Context at the first edit or turn 20 (median)** | **73k** | 

If about 73k of startup and orientation context stays in every session, its cached reads across about 23,000 main-session turns a day cost **about $336 a day, about 17% of our daily spend.** In 260 sessions on both machines, commands starting with `cd` and `cat` brought in an estimated 7k to 12k tokens per session before the first edit, against a mean growth of 45k to 53k from boot to first edit; skill bodies added about 3k to 4k and the session's brief under 0.5k. The rest of orientation is not broken down here. The biggest cuttable piece of the boot itself is the skill list: every session lists all 36 to 135 installed skills (9.6k tokens on one machine), while about 10 skills do almost all the work.

### Pruning the Startup Context

Call it the **startup context**: everything a session holds before its first message. That means the system prompt, the tool definitions, the list of available skills, the project instruction file (CLAUDE.md), and the agent's memory index. Claude Code's `/context` command breaks it down. You don't write most of it, so it's easy to forget you're paying for it on every turn.

Its daily cost has a simple form. If the startup context is `S` tokens, it is written once per session and read on every turn:

- S
- startup context, in tokens
- turns
- turns per day (~23,000 for us)
- sessions
- fresh sessions per day (~200 for us)
- r
- cached read price ($0.20 per million tokens)
- w
- 1-hour cache write price ($8 per million tokens)

At our volume, **every 1k tokens of startup context costs about $6.20 a day.** This assumes the startup context stays in context for the whole session.

We ran `claude -p` in an empty folder and stripped the startup context down one setting change at a time. Each run was a one-liner using supported settings:

| Probe | Startup tokens | Saved | 
|---|---|---|
| Default | 26.2k |  | 
| Turn off 5 tools our agents never call ( `--disallowedTools` ) | 23.4k | −2.8k | 
| Hide user skills outside a 15-skill allowlist ( `skillOverrides` ) and turn off automatic memory | 22.2k | −1.2k | 
| Turn off built-in skills ( `CLAUDE_CODE_DISABLE_BUNDLED_SKILLS` ) | 20.2k | −2.0k | 
| Turn off plugins the agents don't use | **16.6k** | −3.6k | 
| No skills at all (the floor, for reference) | 13.8k |  | 

Disabling bundled skills and plugins removed 5.6k tokens; the skill allowlist plus the memory change removed 1.2k, and their individual contributions were not isolated. The five unused tools were only 2.8k. Agents load about 10 to 15 skills in practice (7 days of transcripts), yet every session lists them all. The probe saved 9.6k tokens. Our scenario adds a lean project instruction file and a pruned memory index to take the fleet's startup context from about **41k to about 26k**. A further 10k orientation reduction is a proposed scenario. Both are proposals until a pilot confirms them.

The startup scenario saves about $93 a day, roughly 5% of our $1,954 daily spend. Adding the proposed 10k orientation cut gives about $155 a day (roughly 8%) only if each removed token avoids one $8/M write per session and all 23,000 modeled cached reads; avoided orientation reads have not been measured yet. Over a month that's about $2,800 to $4,700 at API prices, if quality holds. We've run the empty-folder test. The pilot is ready for one agent, with quality checks in place. It still has to show whether the savings hold across the fleet.

## Every Message You Send, Someone Pays to Read

Everything above prices one agent's context. A fleet adds a second bill: **the messages between agents**. One agent can spend a turn on a status ping. The ping can make another agent reread its whole session. I'd judge that exchange by how much useful work it buys per dollar, with quality as the floor and speed after that.

Some vocabulary first. Our fleet is organized like a small engineering org. **Builders** do the hands-on work: writing code, running tests. Each team has a **lead** that coordinates its builders. A **PM** agent sits above the leads. Builders report to their lead, and leads report to the PM.

A message costs the receiver more than the sender. It can trigger extra turns for the receiver, and each turn re-reads the receiver's whole context. Then the message's tokens sit in that context for every turn until the next handoff.

[↩](#tldr-4)

Every message can trigger turns for its receiver, and each turn re-reads the receiver's whole context. A badly shaped swarm burns tokens on messages, approvals and handoffs that don't move the work forward.

- nⱼ
- turns the message triggers
- Cⱼ
- the receiver's context size without the message
- t
- the message's size in tokens
- Tⱼ
- the receiver's turns left before its handoff
- r
- cached read price

For an otherwise idle receiver, cached reads only (writes and output are extra).

The receiver's context size sets the price. In our research, leads and builders carry similar mean contexts (leads 119k to 146k, builders 108k to 163k), so one cached read of a receiver's context costs about 2 to 3.3 cents wherever a message lands, before any writes or output. What differs is how much work it starts and who waits on the receiver. Messages also raise the receiver's growth per turn (g), and the cost at the optimum rises with √g, so a busy inbox makes every one of the receiver's turns more expensive.

### Managers Are Queues

A lead can clear only so many requests in an hour. Call that rate μ. Requests come in at rate λ, so the load is ρ = λ/μ. In the simplest queueing model<sup>[15](#user-content-fn-kleinrock1975)</sup> (a single server with random arrivals and service times, M/M/1), the expected wait in the queue is ρ/(1−ρ) times the mean service time: 4 times at 80% load, 19 times at 95%. Messages sent up to a manager don't just burn the manager's tokens. Everyone queued behind the manager waits too. Our PM agent once received about 105 agent prompts a day; approval counts and waiting order were not measured here.

[↩](#tldr-5)

Communication channels multiply as teams grow. Small, isolated teams that don't need outside approvals move faster, and for agents they also cost less. Build the system modular so the teams can be modular.

That last move is the inverse Conway maneuver. Conway's law says a system ends up mirroring the communication structure of the team that builds it<sup>[3](#user-content-fn-conway1968)</sup>. Run it in reverse: draw the module boundaries you want, then give each module its own isolated team, and the communication structure, and the token bill, follow<sup>[4](#user-content-fn-thoughtworks2014)</sup>.

### What to Measure

Network science already has the vocabulary<sup>[16](#user-content-fn-newman2004)</sup>. Treat agents as nodes and messages as directed edges, then track a few numbers:

| Measure | In plain terms | Aim for | 
|---|---|---|
| [Modularity](https://verial.xyz/glossary#modularity) Q | How much of the talk stays inside teams | Higher is better | 
| Cross-team share | Messages from one team to another | Lower is better | 
| Upward share | Messages sent up to a manager | Lower is better | 
| [Betweenness](https://verial.xyz/glossary#betweenness)<sup>[17](#user-content-fn-freeman1977)</sup> | How much traffic has to pass through one manager | Lower is better | 
| Load ρ | How busy a manager is: requests arriving vs. requests handled | Below 0.8 | 
| $ per edge | What each sender-to-receiver pair costs | Spent on decisions, not status | 

**The right information at the right time** has a precise meaning here: send a message when the chance it changes the receiver's decision, times what that decision is worth, beats its cost. A status line almost never changes a decision but can still cost a wake. That's why status goes to a log the receiver reads when it chooses, and only asks and answers interrupt.

### What We Measured: One Day of Wakes

We built a tool to test this on our own fleet (`atc graph`). It reads the agent transcripts our launcher tracks on both of our machines and finds each **wake**: anything that starts an agent's turn, whether a message, a background job finishing, a handoff or a watcher's ping. We put every turn on that wake's tab until the next wake. To find who sent a message, we match its text to the send command in the sender's transcript.

| What woke the agent | Wakes | $ | Share | $ per wake | 
|---|---|---|---|---|
| Its own background job finishing | 1,318 | $823 | 36% | $0.62 | 
| A message from another agent | 1,021 | $755 | 33% | $0.74 | 
| A handoff to a fresh session | 258 | $464 | 20% | $1.80 | 
| Our own watchers and scheduler | 388 | $192 | 8% | $0.49 | 
| Unattributed | 137 | $83 | 4% | $0.61 | 

Four things stand out.

1. **A wake's dollars are mostly the work that follows it.** Only 14% of job wakes and 8% of message wakes ended after one turn. The mean context at a wake was about 155k tokens, about $0.031 for one fully cached read.
2. **Direction changes what follows a message.** A message down to a builder was followed by about 13 turns ($0.93 per message, 356 a day). A message up to a lead was followed by 3.4 turns and $0.36 (275 a day). Upward-message intervals had fewer attributed turns and lower attributed dollars; the cost they don't show is the lead's queue.
3. **Teams are fairly well isolated.** Among 715 messages between agents on our org chart, Q was 0.4754, far above random routing; cross-team share was 25.5%, upward share 38.5%, and skip-level share 4.8%.
4. **Handoff wakes cost the most per wake.** $1.80 each, 258 a day: the fresh session's turns up to its next wake, which includes orienting and some real work.

*Method notes: one fleet, one day, two machines: the Mac (1,046 wakes, $483) and a build server (2,076 wakes, $1,833), read for the same window and matched across machines. A wake's dollars are the receiver's turns until its next wake, subagents included, so a wake that is quickly followed by another gets less. The sender of 974 of 1,021 messages comes from its actual send command; 47 from a name in the text; 137 wakes, 4.4% of the total, were classified as unattributed. Not seen: Codex runs (their usage is not in Claude transcripts), sessions our launcher does not track, and watcher executions that leave no trace (watcher-triggered activity visible in tracked transcripts is counted under watchers). 306 messages involve an agent missing from our org chart: they count in the dollars, but modularity and the team shares rest on the other 715. Earlier, routing approvals to team leads and status lines to a log cut prompts into our PM agent from about 105 a day to about 31, and cost per merged PR fell 26%; that fits the model, but the same run changed other things, so it does not prove it.*

## Evaluate Your Loops

Start with the transcripts you already have.

1. **Measure the split.** Pull usage per turn from your transcripts: cache reads, cache writes, output. If reads and writes are most of the bill, your loop shape is the cost driver, not the model's output.
2. **Hand off on purpose.** Compute H* for your numbers, with B as the context once the agent is oriented and K as the full cost of orienting plus writing the handoff, and check where your sessions actually start writing the handoff (ours: asked at 180k, they start at a median 203k, 6.4% above a cost optimum near 250k on average; we are moving the ask to 225k). Make the handoff carry the thread: the operator's words, each decision with its why, and a pointer to the previous session. A cheap handoff that loses the plot is not cheap.
3. **Shrink the fresh start.** Disable tools the agent never uses, load only the skills its role needs, keep instruction files short and point to detail instead of including it. Then shrink orientation: measure what the agent pulls in before its first edit (in our fleet, shell commands and file dumps are a visible part of it). Every token cut here is saved on every turn of every session.
4. **Trim what enters the context.** New input per turn (g) is the largest lever in the formula: it is written once and re-read for the rest of the session. Prefer grep hits and line ranges over whole files, and tails of logs over full logs.
5. **Shape the message graph.** Keep teams isolated, let builders talk to their own lead and leads to the manager, and send status to a log instead of a prompt. Measure what wakes your agents and what each wake costs, modularity, upward share and each manager's load.
6. **Keep quality as the constraint, not a weight.** Change one dial at a time, on one agent first, and keep a change only if defects, rework and reopened work hold at or below baseline.

At the optimum, holding K fixed and re-optimizing the handoff point, halving g saves about $0.0092 per productive turn in reads and amortized start-up cost; if each removed growth token also avoids one 1-hour cache write, another $0.0056, about $0.015 in all, or about $335 a day. Halving B (95.7k) saves about $0.0096 per productive turn in reads, about $217 a day, with K held fixed. Daily figures use an estimated 22,638 productive turns, derived from assumed start-up and writing turn counts. The handoff limit barely matters anywhere near its optimum, and ours already lands there. Across agents, measured: an agent's own jobs (36%), messages from other agents (33%) and handoffs (20%) start the turns behind most of the attributed spend.

*Method and caveats. One fleet, three overlapping 24 h windows (cost split: 2026-11-15 16:41Z to 11-16 16:41Z; wakes: 11-15 23:50Z to 11-16 23:50Z; handoff sample: to about 11-17 04:30Z), Claude Opus 5.5 at API list prices (cache read $0.20/M, 1-hour write $8/M, 5-minute write $5/M, output $20/M). The handoff model assumes linear context growth, warm cache reads and a fixed start-up cost, and plugs means into a nonlinear formula (an approximation); its inputs are means over 220 sessions that ran to a handoff on both machines in the 24 h to about 2026-11-17 04:30Z, measured at the first edit and at the start of handoff writing. It leaves out quality (thread lost at a handoff, answers at large context), which we treat as a constraint and test by pilot. The 73k fresh-start figure is a median across sessions; its daily cost is an estimate from main-session turns. Turn counts and mean context are main-session turns; the window's cache reads (4.8B) also include 4,286 subagent turns, so dividing one by the other overstates context per turn.*

## Footnotes

1. 
Verial internal measurements (November 2026). Session transcripts from our own development runs: a multi-agent fleet of Claude Code and Codex agents, 10 to 30 running concurrently around the clock across two machines (a Mac and a build server), analyzed with our in-house tools `atc cost` and`atc graph` . The cost figures cover the Claude Code sessions only, since Codex usage does not appear in Claude transcripts. Dollar figures are API list prices applied to the per-turn token usage in the logs.[↩](#user-content-fnref-fleet)[↩<sup>2</sup>](#user-content-fnref-fleet-2)[↩<sup>3</sup>](#user-content-fnref-fleet-3)
2. 
Brooks, Frederick P. (1975). *The Mythical Man-Month: Essays on Software Engineering* . Addison-Wesley. Chapter 2, "The Mythical Man-Month". Communication paths grow as n(n-1)/2 with team size, the root of Brooks's law: adding people to a late project makes it later.[↩](#user-content-fnref-brooks1975)
3. 
Conway, Melvin E. (1968). ["How Do Committees Invent?"](http://www.melconway.com/Home/Committees_Paper.html) .*Datamation* .[Conway's law](https://verial.xyz/glossary#conway's-law) : organizations design systems that copy their own communication structure.[↩](#user-content-fnref-conway1968)[↩<sup>2</sup>](#user-content-fnref-conway1968-2)
4. 
["Inverse Conway Maneuver"](https://www.thoughtworks.com/radar/techniques/inverse-conway-maneuver) .*Thoughtworks Technology Radar* (2014). Deliberately shaping team and system boundaries together, so the communication structure you want produces the architecture you want.[↩](#user-content-fnref-thoughtworks2014)[↩<sup>2</sup>](#user-content-fnref-thoughtworks2014-2)
5. 
Huntley, Geoffrey (2025). ["Ralph Wiggum as a 'software engineer'"](https://ghuntley.com/ralph/) .*ghuntley.com* . The original "Ralph" technique: a coding agent run in an endless bash loop against a fixed prompt, with a fresh context each iteration.[↩](#user-content-fnref-huntley2025)
6. 
["Scheduled tasks"](https://code.claude.com/docs/en/scheduled-tasks) .*Claude Code Docs* . Documents`/loop` , fixed-interval and self-paced modes, and the session-scoped scheduler behind them.[↩](#user-content-fnref-cc-loop)
7. 
["Prompt caching"](https://platform.claude.com/docs/en/build-with-claude/prompt-caching) .*Claude Docs* . How cached prefixes work, their 5-minute and 1-hour lifetimes, and the price multipliers for cache writes and reads.[↩](#user-content-fnref-caching)
8. 
["Pricing"](https://platform.claude.com/docs/en/about-claude/pricing) .*Claude Docs* . Claude Opus 5.5 lists input at $4 and output at $20 per million tokens; cache reads are $0.20 (5% of input), 5-minute cache writes $5 (1.25x) and 1-hour cache writes $8 (2x).[↩](#user-content-fnref-pricing)
9. 
Harris, Ford W. (1913). "How Many Parts to Make at Once". *Factory, The Magazine of Management* 10(2): 135-136, 152. Reprinted in[*Operations Research* 38(6) (1990)](https://doi.org/10.1287/opre.38.6.947) . The origin of the economic order quantity model, which balances holding cost against ordering cost.[↩](#user-content-fnref-harris1913)
10. 
Hong, Kelly; Troynikov, Anton; Huber, Jeff (2025). ["Context Rot: How Increasing Input Tokens Impacts LLM Performance"](https://www.trychroma.com/research/context-rot) .*Chroma Technical Report* . Across 18 models, performance consistently degrades as input length increases, even on simple tasks.[↩](#user-content-fnref-chroma2025)[↩<sup>2</sup>](#user-content-fnref-chroma2025-2)
11. 
Modarressi, Ali; et al. (2025). ["NoLiMa: Long-Context Evaluation Beyond Literal Matching"](https://arxiv.org/abs/2502.05167) .*ICML 2025* . At 32k tokens, 11 of 13 models claiming at least 128k context drop below 50% of their short-context baselines.[↩](#user-content-fnref-nolima2025)
12. 
Hsieh, Cheng-Ping; et al. (2024). ["RULER: What's the Real Context Size of Your Long-Context Language Models?"](https://arxiv.org/abs/2404.06654) .*COLM 2024* . Of 17 models claiming 32k or more, only half perform satisfactorily at 32k; almost all drop sharply as length grows.[↩](#user-content-fnref-ruler2024)
13. 
Laban, Philippe; Hayashi, Hiroaki; Zhou, Yingbo; Neville, Jennifer (2025). ["LLMs Get Lost In Multi-Turn Conversation"](https://arxiv.org/abs/2505.06120) .*arXiv preprint* . Over 200,000 simulated conversations, tasks given across several turns score 39% lower on average than the same tasks given in one turn.[↩](#user-content-fnref-laban2025)
14. 
Rajasekaran, Prithvi; et al. (2025). ["Effective context engineering for AI agents"](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents) .*Anthropic Engineering* . Describes context rot and context as a finite "attention budget", with compaction and fresh context as the levers for long-horizon agents.[↩](#user-content-fnref-anthropic2025)
15. 
Kleinrock, Leonard (1975). [*Queueing Systems, Volume I: Theory*](https://www.wiley.com/en-us/Queueing+Systems%2C+Volume+1%3A+Theory-p-9780471491101) . Wiley. The standard text on queueing theory; the single-server (M/M/1) queue gives the ρ/(1-ρ) growth in waiting time used here.[↩](#user-content-fnref-kleinrock1975)
16. 
Newman, M. E. J.; Girvan, M. (2004). ["Finding and evaluating community structure in networks"](https://doi.org/10.1103/PhysRevE.69.026113) .*Physical Review E* 69: 026113. Defines the modularity measure Q.[↩](#user-content-fnref-newman2004)
17. 
Freeman, Linton C. (1977). ["A Set of Measures of Centrality Based on Betweenness"](https://doi.org/10.2307/3033543) .*Sociometry* 40(1): 35-41. Defines betweenness centrality: how many shortest paths run through a node.[↩](#user-content-fnref-freeman1977)
