Nate B. Jones’s 15 token rules are written as single-agent hygiene. At fan-out, every per-agent overhead is paid N times — which promotes a habit into an architectural constraint. This is the translation, plus the anti-pattern it explains.
Links: The Substrate Is the Governing Mechanism, Method — a library of good procedure, The Anchor Method, The Context Cache Hierarchy, Claude Code Skill Engineering, Working With Claude, Praxis Agent Teams, Comments and the Distance to an Oracle — inline coordination is a per-agent overhead paid N times; the crossover question restated for comments
Source: Nate B. Jones — 15 rules to stop running out of tokens (YouTube), ingested 2026-08-26. Companion page: The Substrate Is the Governing Mechanism.
Jones’s framing is a desk you have to keep clean, and the whole video is addressed to one person in one chat. The load-bearing fact he gives is the one that changes character under fan-out:
A typical setup with several tool servers connected — GitHub, Slack, Sentry, Grafana — burns roughly 55,000 tokens in tool definitions before the model does anything at all.
For one agent that’s an annoyance. For a twelve-agent fan-out it is 660,000 tokens spent before any work begins, and none of it is task-specific. Every per-agent constant — tool definitions, standing instructions, the system preamble, whatever context the orchestrator copies down — is multiplied by the width of the fan-out.
That is the whole translation rule: in a swarm, a per-agent overhead is a per-agent overhead times N, and anything you can move from per-agent to shared-once is a structural win, not a tidiness win. Habits you can afford to skip solo become the difference between a fan-out that runs and one that dies on limits.
Numbering caveat: the video states rules 1–7, 9, 10 and 14 aloud. Rule 8 is never spoken — he goes straight from 7 to 9; it presumably exists in the written Substack version, which was not fetched. The bracketed ones below are positioned by ordering in the transcript, not by a stated number.
| Rule (single-agent form) | Swarm form |
|---|---|
| 1. Edit your mistake, don’t argue with it | Orchestrator re-issues a corrected task to a fresh agent rather than negotiating with a confused one. A wrong agent is cheaper to replace than to convince. |
| 2. Batch related questions; name the output shape | One agent per coherent unit of work — not per question. And name the return shape, which at fan-out means a schema, not a request. |
| 3. Start a clean task when the job changes | The definition of an agent boundary. Fresh context scoped to one task is what a subagent is; it’s Jones’s most-resisted rule made structural. |
| 4. Carry the answer, not the argument | The single most important one. Pass each stage’s artifact to the next, never its transcript. |
| 5. Ask for only the answer you need | Output is billed twice — once written, then forever as input. In a pipeline it’s billed again at every downstream stage that carries it. Bound every agent’s return. |
| 6. Search the file yourself; don’t make the model search | The orchestrator scouts and hands each agent the located path or passage. Otherwise N agents each re-run the same search. |
| 7. Send the lightest useful form | Pass paths and extracted text, not whole files, and never the original PDF. |
| (8 — not stated in the video) | — |
| 9. Keep answers somewhere retrievable | The shared workspace. This is the swarm rule; see the substrate page. |
| 10. Load only the tools the job can use | Scope tools per agent. This is the 55k × N line — the highest-leverage single change in a wide fan-out. |
| [11] Compaction / context editing | For long-running agents that can’t restart mid-task. Note his honest caveat: you are continuing against an approximation of the original context. |
| [12] Use the dumbest model that still works | Per-agent model and effort tiering — cheap mechanical stages small, adversarial/judge stages large. |
| [13] Prompt caching | A stable shared prefix across agents is a cache hit N times instead of a cold start N times. Actively rewards uniform preambles. |
| 14. Enforce hard limits | Cap request and response size per agent so one runaway can’t eat the budget for the whole fan-out. |
| [15] Answer from the store without a model call | The cache-hit case: if the shared workspace already holds an accepted answer, serve it and skip the agent entirely. 100% of the call saved. |
The observed failure — agents were instructed to do tasks, had no shared workspace, and each received the entire context copied to it instead of a focused task — is rules 3, 4, 6 and 10 failing simultaneously, and it has a single root cause.
Without a durable shared artifact, there is nothing to point at, so every agent must be handed the whole history. Copying context isn’t the mistake; it’s the symptom of having no substrate. The costs compound in two directions at once:
Which is the point where this note and the substrate page meet: a swarm without a shared workspace is simultaneously maximally expensive and maximally opaque. Both are fixed by the same move. This is context-cache-hierarchy.md’s prediction confirmed against a real failure — “memory coherence precedes parallelism… parallel agents over an unregistered, re-deriving substrate just multiply the drift.”
Worth knowing before building anything custom — several of these are already structural in Claude Code’s Workflow tool, which is a reason to reuse rather than rebuild:
pipeline() passes each stage’s return value to the next, not the conversation. That is rule 4, enforced by the API shape.schema option forces a subagent through a structured-output tool and validates it. That is rule 2’s “name the output shape” and the prescribe-the-protocol governance move from the substrate page — the same act satisfies both.opts.model and opts.effort are rule 12 per agent.The gap the harness does not close is rule 9: there is no shared writable workspace between agents by default. Stages hand results forward, but nothing durable accumulates beside the pipeline for later agents to read. That’s the piece to build, and it should be built as a named, schema’d directory — not as an incidental scratch area, per the substrate page’s argument about unowned channels.
This is the half of the two-video ingest that is verifiable locally, with no external fetching and no policy surface. Same task, two fan-out shapes:
Measure tokens and wall-clock. That turns “we hit this wall once” into a number the vault can cite, and it’s a measurement against a lower artifact rather than a second opinion — the verification-independence standard. Until it’s run, everything on this page is a well-argued prediction, not a result.