In the last article, Small Models, Many Attempts, I argued that the strongest model does not always make the strongest system. Many inexpensive workers can outperform one frontier model when the work can be divided, the attempts are genuinely different and the system can verify the results.
That leaves an architectural question: if the workers are small, numerous, and replaceable, where does the system’s intelligence reside?
My answer is simple: the colony has the goal, not the ant.
1. Ants are excellent coworkers, with one awkward HR policy
Ants remove dead coworkers from the nest. I would like to tell you this is because a corpse near the break room is bad for morale. The biological explanation is less entertaining but more useful. The behavior is called necrophoresis, and it protects the colony from contamination. In one 50-day experiment with common red ants, adult workers survived significantly better when the colony could remove corpses normally. (Biology Letters study) Entertaining, but not really part of my analogy—unless you have this problem at work. In that case, stop reading right now and get help.
Here is another fact that sounds suspiciously like a networking paper: arboreal turtle ants can repair a broken trail through a tangled canopy without a central map. Individual ants have little memory, use local information and leave chemical signals on the branches they traverse. Many ants explore; the colony gradually reinforces a working route and prunes the others. In simulations based on field observations, searching from both sides of a broken trail succeeded about 70 percent of the time, compared with 14 percent for a one-sided search. (Scientific Reports)
No ant opens a project plan. No ant understands the entire network. The queen is not standing over a tiny whiteboard handing out assignments. Yet the colony forages, adapts, repairs routes and cleans up after itself.
That is why ants keep appearing in conversations about agentic architecture. Their strength comes from bounded local behavior, role specialization, indirect coordination and information that survives outside any one worker. The useful unit of intelligence is not the ant. It is the system formed by the ants, their interactions and their environment.
The analogy is not perfect—our agents use databases rather than pheromones, and our databases should probably decay less quickly—but it gives us a strong place to begin.
2. Disposable workers, persistent colony
A worker agent should have a small and fairly boring life:
- Receive a bounded assignment. It gets a task identifier, objective, tools, budget, constraints and definition of done.
- Attempt the work. It explores one path without pretending it owns the whole problem.
- Report evidence. It returns artifacts, sources, measurements, failed tests and costs—not merely “I finished.”
- Terminate. Its context can disappear because anything worth keeping has been written somewhere durable.
This pattern works because it limits the blast radius of failure. A confused worker loses one assignment, not the entire mission. A stalled worker can be replaced. A task can be retried with a different model, prompt or tool. Workers can run in parallel because their assignments have clear boundaries. Fresh contexts also reduce the chance that yesterday’s bad assumption quietly becomes today’s inherited wisdom.
The opposite pattern is the immortal generalist: one long-lived agent plans the mission, performs every task, remembers everything, changes state, evaluates its own work and decides when it is finished. That can be convenient for a small sequential job. At scale, it becomes a junk drawer.
The context fills with old plans, partial results, contradictory instructions and tool output. The agent becomes both the author and the judge. Restarting it means losing the history; preserving it means carrying every mistake forward. One failure can poison the whole run because the plan, execution history and definition of success live in the same place.
The disposable-worker pattern avoids that trap, but it creates a requirement we cannot ignore: if the worker is temporary, the memory of the work cannot live inside the worker. Hold on to that thought. It is the difference between a swarm and a crowd.
3. A hundred amnesiacs do not make a genius
Disposable workers alone do not create system intelligence. Launching one hundred agents with no shared state may give you one hundred copies of the same search, one hundred slightly different guesses, or one hundred confident declarations that somebody else probably checked the answer.
The architecture becomes intelligent only when something above the workers can preserve progress, assign different work, compare results and decide what should happen next.
This pattern predates LLMs. Google’s original MapReduce design divided large jobs into many small tasks, tracked their state in a master and rescheduled work when a machine failed. During one operation described in the 2004 paper, network maintenance made groups of 80 machines unreachable at a time. The master re-executed the missing work and the job continued. Workers disappeared; the computation did not forget what it was doing. (MapReduce paper)
Agentic systems add an important wrinkle. MapReduce workers were mostly interchangeable. Agent swarms often are not. An orchestrator plans, search workers explore, tool specialists act, a verifier judges and a budget controller decides whether another attempt is worth buying.
In the previous article I called this role-based scale-out. We scale capacity by adding workers, but we scale intelligence by separating responsibilities. The worker pool is only one part of the design. The colony also needs a durable place to keep the mission and everything it has learned.
4. Where the colony keeps its brain
Ants often leave useful state in their environment. A pheromone trail is not a meeting transcript. It is a compact signal that says, “Other workers found this route promising.” Turtle ants can use those local signals to repair a damaged network even though an individual ant cannot remember the whole graph.
An agentic harness needs the digital equivalent, although we can be more explicit than an ant. I would keep six durable objects above the worker pool:
The objective record
This is the colony’s mission: the goal, authorized scope, constraints, completion criteria and current plan. A worker receives a slice of it, not permission to reinterpret all of it.
The evidence ledger
This stores sources, tool output, measurements, artifacts and provenance. Conclusions should point back to evidence. “Agent 17 felt good about it” is not provenance.
The attempt register
This records what was tried, by whom, with which method, at what cost and with what result. It prevents a retry from becoming an accidental reenactment.
The hypothesis backlog
This keeps unresolved questions, promising leads, dependencies and abandoned paths. A failed attempt may close one path while opening two better ones.
The budget and priority state
This tracks tokens, time, tool costs, concurrency and escalation limits. It gives the orchestrator a way to stop spending simply because more workers are available.
The verification ledger
This stores the tests, rubric version, verifier, result and supporting evidence for every accepted or rejected claim. Verification is a recorded event, not a mood.
Workers can come and go. The colony state remains the source of truth.
The terminology matters because these same six objects give us a clean way to recognize failure. Repeated work appears in the attempt register. Unsupported assumptions appear in the evidence ledger. Runaway chatter appears in the budget state. False victories appear in the verification ledger. Confusion about success points back to the objective record. Forgotten leads belong in the hypothesis backlog.
The ant analogy still holds: the individual worker does not carry the colony’s complete memory. The analogy also has a boundary. Pheromones are intentionally temporary; some of our records must be durable, versioned, queryable and auditable. We are not trying to imitate ants perfectly. We are stealing the useful parts.
5. Six ways to build a very expensive anthill
These failures are not theoretical. A 2025 Berkeley-led study examined more than 1,600 execution traces from seven multi-agent frameworks and organized 14 failure modes into system-design problems, inter-agent misalignment and task-verification failures. (MAST paper) Anthropic has described early versions of its own research system spawning 50 subagents for simple questions, searching endlessly for sources that did not exist and distracting one another with excessive updates. (Anthropic engineering)
The encouraging part is that the failure modes below leave fingerprints. If the harness records its work, we can measure them.
1. Repeated work
What it looks like: Several workers run the same query, inspect the same files or test the same hypothesis because their assignments were vague or they could not see prior attempts. Anthropic reported subagents performing the exact same searches when delegation lacked clear boundaries.
How to see it: Measure duplicate task identifiers, repeated tool calls, overlapping sources and semantically similar attempts in the attempt register. A useful starting metric is duplicate attempts divided by total attempts.
2. Workers copying one another’s assumptions
What it looks like: One worker makes an unsupported claim. Later workers inherit it as context and cite one another instead of independent evidence. The swarm appears to reach consensus because everyone received the same mistake.
How to see it: Follow provenance in the evidence ledger and cluster failures by shared premise. Diversity cannot be inferred from agent count. An ICML 2025 study of more than 350 models found that, on one leaderboard dataset, models agreed 60 percent of the time when both were wrong. Different workers can still produce correlated errors. (ICML paper)
3. Excessive conversation
What it looks like: Agents send status updates, acknowledge the updates, summarize the acknowledgements and wait for permission to continue. The token bill grows while the evidence ledger does not.
How to see it: Track coordination tokens, messages per verified result, queue wait time and time spent blocked on other agents in the budget state. Anthropic reports that its agents use about four times the tokens of chat interactions and its multi-agent system about fifteen times the tokens of chats. That cost can be worthwhile—but only when it buys coverage or speed.
4. Unreliable self-reporting
What it looks like: A worker declares success, but the artifact is missing, the test was never run or an independent verifier rejects the result.
How to see it: Compare worker success claims with the verification ledger. The claim-rejection rate—rejected success claims divided by total success claims—should be visible by worker role, model, tool and task type.
5. No shared definition of success
What it looks like: One worker optimizes for speed, another for completeness and a third for an unstated interpretation of “secure.” All complete their assignments, but the pieces do not solve the original problem.
How to see it: Record which version of the objective record and acceptance rubric each worker received. Watch for verifier disagreement, completed tasks that are reopened and outputs that pass local tests but fail the end-to-end evaluation.
6. Coordination costs more than execution
What it looks like: The orchestrator spends more effort decomposing, routing, waiting and summarizing than a capable worker would have spent doing the task. Adding agents lowers verified yield.
How to see it: Track the coordination-cost ratio, wall-clock time, tool calls, idle time and verified results per million tokens in the budget state. Plot them as worker count rises. If coordination climbs while verified yield stays flat, the colony has become a meeting with an ant problem. (I know—I love that line. Nobody needs an ant problem.)
None of these measurements guarantees a good swarm. They do something more practical: they keep a bad swarm from failing invisibly.
6. Ant colonies, bands and teams all know the same secret
We have pushed the ant analogy fairly hard, so let us see whether it survives contact with other systems.
An ant colony coordinates with local signals and information embedded in the environment. Individuals follow bounded rules. Trails reinforce useful routes, unsuccessful routes fade and no single worker needs a global map. The analogy breaks where our requirements become more exact: ants do not maintain versioned acceptance criteria, cryptographic provenance or an audit log. We should.
A band has a song, key, tempo and arrangement that survive any one note. Each musician has a role and room to improvise inside it. The drummer does not stop after every measure to ask whether the bass player is aligned. They rehearse the interfaces, share a structure and listen for evidence that the whole thing is working. If everyone solos at once, that is not emergence. It is Tuesday night in Uncle Charlie’s garage, where everyone thinks they need to overplay their instrument to show off.
A high-performing technical team uses the same pattern. The mission lives in a shared plan. Work lives in tickets. Evidence lives in code, test results, incident timelines and research notes. People specialize, but the team knows where expertise and history can be found. Researchers call this a transactive memory system—a formal term for “we know who knows what.” A 2026 meta-analysis covering 44 studies found a moderate positive relationship between transactive memory and team outcomes. (Group & Organization Management)
Across all three examples, strength does not require every participant to know everything. It requires a shared objective, useful specialization, reliable signals, durable learning and a way to correct the route when reality disagrees with the plan.
7. Keep the worker replaceable and the memory durable
The point of a swarm is not to create a crowd of digital employees who attend meetings forever. It is to create a system that can make many bounded attempts without losing the mission or paying repeatedly for the same lesson.
If you are building an agentic harness, remember these five things:
- Bound the work. Every worker needs a specific assignment, budget and definition of done.
- Persist evidence, not just conclusions. Future workers must be able to inspect why the colony believes something.
- Separate attempts from judgment. A worker may propose success; an independent verifier records it.
- Measure coordination as a cost. More agents are useful only while they increase verified yield, coverage or speed.
- Let workers disappear. Restarting or replacing one should not erase the mission, repeat the search or corrupt the record.
Ants have had millions of years to discover that no worker needs to be the hero. We do not have to wait that long.
If you remember only one line, make it this:
The worker can be disposable. The evidence cannot be.
The next article in this series, Cybersecurity Is a Search Problem, will apply this architecture to the work that inspired much of it: exploring attack paths, testing hypotheses and preserving evidence inside an authorized security environment.
tkonsecurity.com 