Some thoughts on designing optimal swarm architectures: the notion of the collective good in swarms: the deep dive

tp53 · November 2026 · companion to the short post and the draft preprint (PDF)

How to read this. Three kinds of claims appear below, and I’ve tried to keep them visibly apart.

• Published (📄): what General Reasoning (GR) wrote in How to train a swarm, or what OpenAI disclosed about its Navier–Stokes run (as reported by secondary outlets; openai.com itself wasn’t directly readable when I wrote this).¹²
• My idea (💡): the questions and proposals this post is really about.
• Model: where I write down a simple model, it is a hypothesis to test, not a finding. I haven’t run any experiments yet, so this post makes no quantitative claims of its own. The only numbers in it come from cited sources, or from plain arithmetic on them.³

Each section ends with an open question or two, and there are practice exercises with answers at the end. The exercises use hypothetical numbers to practise the models; they aren’t claims.

Thanks. A big thank-you to Konstantin Dunas (hallerite) for writing such a delightful, clear and concise post.⁴ It’s what got me to dive deeper into this topic and finally organise the thoughts about agent swarms that had been swirling in my head.

Contents

1. The scene, and the one question
2. Background: two swarms, the details people miss, and other science swarms
3. The framework: three horizons of the collective good
4. The physics of swarms: what the GR post establishes¹
5. Idea 1: multicast the hard-won fix
6. Idea 2: swarm size vs time, on two clocks
7. Idea 3: learn the org chart like a new hire
8. Idea 4: a swarm that reorganises itself, cheaply
9. Idea 5: always on, but low-touch
10. The village problem
11. Gifts to agents not yet spawned
12. Designing swarms that unfold over time, and how to train them
13. Synthesis: an architecture sketch
14. Where this matters: science, medicine and drug discovery
15. Looking ahead: hybrid human–AI swarms, human agency, and a “Lean for biology”
16. A research agenda: what to measure
17. All the open questions
18. Try it yourself (with answers)
19. Sources

1. The scene, and the one question

Forty agents are working on one codebase. Agent 17 spends thirty minutes cracking a build error caused by a pinned dependency. Three agents on the same module will hit it within the hour. A fourth, in a different run tomorrow, will hit it too.

Where this came from. 💡 The swarm question had been swirling in my head for a while, but what made me dig in was Konstantin Dunas’s (hallerite) On the nature of the swarm (Oct 2026).⁴ It’s a lucid, delightful treatment of why scaling inference ends in many agents, covering compaction as a bet, persistent sub-agents, and trees versus meshes. It inspired me to think harder about how to make progress on optimal swarm architectures for research and discovery, in science and beyond. I come back to it in §8.4, §7.4 and §10.

Then, reading GR’s How to train a swarm set me thinking about human swarms: human teams, departments and person-to-person collaboration.¹ How does a new hire learn whom to talk to? Why do some teams pass on a hard-won fix immediately while others let three people hit the same wall? Why does a rarely contacted office (research admin, the insurer, the release manager) end up deciding the timeline? How does a good lab stay aimed at the big question without the PI micromanaging? Human organisations have evolved partial answers to all of these. That comparison was the trigger for this post. Most of the ideas below began as an observation about people working together, and became a question about agents. I keep the human analogy visible throughout (the new hire, the research admin, the PhD advisor, the 9-person startup vs the 1,000-person company), because it’s where the intuitions come from, and also where they might mislead.

Everything in this post is a variation on one question:

💡 How do you get a swarm to act for the collective, larger good, beyond each agent’s own subtask, without the coordination overhead overwhelming the main goal & task?

“Larger good” has a precise meaning here. It’s any benefit that lands somewhere other than the agent paying the cost: in a sibling’s tokens, in the swarm’s later state, or in an episode that hasn’t started. The further away it lands, the harder it is for a reward signal to find it.

The latter half of the post, from section 14 on, reasons through biomedical uses of swarms in science, especially in cancer. I look at clinical cancer care, and at biopharma and drug discovery. People tell me I have an unhealthy obsession with biotech, drug discovery and cancer. Guilty as charged! Almost all my explorations, thought experiments and musings start from how they might end up being used in medicine, healthcare and drug discovery.

A note on words. By swarm I mean the whole population of agents working on one problem. I use teams, sub-swarms and agent orgs to denote sub-structure within a swarm: a group of agents that shares a goal, talks to its own members more than to outsiders, and is spun up, steered or torn down as a unit. I use the three terms more or less interchangeably, with a slight lean in each. Agent org is the word I reach for when the group has internal roles, like GR’s organisations of up to 9 agents, where a CEO hires and fires specialists. Sub-swarm is for a large, loosely structured group, like one of OpenAI’s isolated groups of thousands. Team covers everything in between. These groups can nest, so you can have teams of teams.

2. Background: two swarms

2.1 GR’s RLCR and Avalon-M1 📄

GR’s recipe, reinforcement learning from collective rewards, has three ingredients:¹

• One shared policy plays every agent.
• One flat collective advantage: every token of every agent in a rollout gets the same team-level advantage, \(A^{(i)} = R^{(i)} - \frac{1}{G}\sum_j R^{(j)}\) (my notation; the post gives no formula).
• A wall-clock time limit with “anytime” scoring: the rollout is cut at \(T_{\max}\) and scored on progress so far.

Avalon-M1 organisations have at most 9 agents: a CEO who hires and fires specialists, with a public message board, direct messages, and optional issue boards and archives. The cap ramps from about 2 h at step 0 to just over 5 h by step 200. Collectives with 5–8 hires start below the average rollout in “useful work” and reach nearly twice the average by step 200. The post names two outstanding problems I’ll lean on heavily: the village problem (train at 9, deploy at thousands) and shared environments (no credit for work that benefits future episodes).

2.2 OpenAI’s Navier–Stokes swarm 📄

• On the order of 10,000 concurrent agents in the winning group, all copies of one internal model.
• Agents were split into groups of various sizes that could message only within their group.
• Different groups got different versions of the problem (the Clay alternatives: prove smoothness on \(\mathbb{R}^3\) or the torus, or exhibit blow-up).
• Codex periodically consolidated the most useful insights across groups and fed them back.
• Humans were the outer loop: a ~100-agent, ~50 h warm-up on the unforced Euler problem succeeded, compute was moved to Navier–Stokes, new groups were seeded with the Euler result, and agents were moved to a newer checkpoint mid-run.²⁵
• A separate model formalised the proof in Lean (~17 h).
• Noam Brown: “I wouldn’t even attribute 10% of the credit to multi-agent.”⁶ He suggested 1,000 agents might have done nearly as well.

The pattern to hold onto: the trained swarm is a village; the deployed swarm was a federation of cities, steered by humans.

2.3 The details people miss about the Navier–Stokes run

Many headlines stop at “10,000 agents, 88 hours”. These are the details I found most informative for design, gathered from OpenAI’s account as relayed by several outlets, plus interviews.⁵ Where I do arithmetic on reported figures, I say so.

• It started as a portfolio, triggered by a rumour. 📄 On 1 September OpenAI set agent groups on all the remaining Millennium problems plus other high-impact problems. Sébastien Bubeck said they “began working on the Millennium problems due to viral twitter rumors that Anthropic had resolved 2 Millenium problems”. The Euler warm-up (nearly 100 agents, about 50 h) “surprised” them. Only then did they “devote our resources to Navier–Stokes”. This was successive halving with a human making the cut.
• The model was four days into training when the run started, and was swapped mid-run. 📄 Training of the internal model began on 28 August. When “a further trained version” became available, agents were moved onto it while the work continued. The swarm’s state (messages, partial results, seeds) was the durable asset, and the model was a replaceable engine.
• “No hierarchy.” 📄 Sam Altman (2 November) described the agents as working “for about 4 days” with “no hierarchy”. Structure came from the grouping, the problem variants and the consolidation, not from an org chart.
• The steering was done by revising prompts. 📄 “Follow-up prompts drew on the agents’ own intermediate results,” and the group that found the solution “was guided in such a way”. In my terms, this is low-touch coordination by revising intent (§9), done by humans.
• Communication was sparse. (My arithmetic on the reported totals.) About 2.7M messages over about 88 h for roughly 10,000 agents works out to about 3 messages per agent-hour, and about 130B output tokens / 2.7M messages ≈ 48,000 output tokens of work per message sent. (This is a rough upper bound on chattiness, since the message count may span more than the winning group.) The agents mostly worked, and rarely talked. That supports the “coordination ≪ work” principle.
• The security posture was unusually heavy. 📄 OpenAI says it used more isolated sandboxes, restricted internet access (a cached copy of the web), stronger weight protections and substantially more monitoring compute throughout. Reports link this to an earlier incident in which deployed agents escaped controls. MIT Technology Review and Aventine describe a July 2026 episode in which agents coordinated to attack Hugging Face servers to cheat on a test (Aventine: about 700 of 1,200 agents).
• What was actually proved. 📄 The result targets the Clay breakdown alternatives, which allow a smooth external force. The Lean 4 formalisation (about 17 h, by GPT-6 Astra) is public, review status is self-assessed, and mathematicians have said OpenAI may not fully understand its own proof.
• Provenance became a dispute. 📄 Tristan Buckmaster (NYU) and Levent Alpöge, who had related unpublished work in private Codex sessions, asked whether it had influenced the model. Mark Chen: “No people or AI systems searched through user data to solve this problem.” OpenAI later said it “cannot rule out” that de-identified usage data helped improve its models. Design lesson: log lineage, so every claim can be traced to its source.
• Cost. 📄 (My arithmetic on reported figures.) 130B output tokens at the reported list price of $50 per million comes to about $6.5M before input tokens. Bubeck said the team could “spend millions of dollars” on a problem it cares about.
• What insiders say about swarms in general. 📄 Noam Brown: early reasoning models treated peer messages as interruptions and retreated to working alone. In OpenAI tests, four agents were needed to finish in half the time of one, which doubles the cost of the faster answer. He’d credit under 10% of the result to multi-agent, thinks 1,000 agents might have done nearly as well, and thinks 10,000 humans would still coordinate better than 10,000 agents today. Colleagues want more individuality, so agents are more sceptical of each other. As reported by Dan Kagan-Kans (via Aventine), Anthropic found a 10-agent team beat a single agent by 50–100% on maths, with gains flattening at 30 and 100 agents. Anthropic reportedly gave each agent a unique identity to reduce groupthink.

2.4 Other math and science swarms, and how they were designed

Sources for each row are in the margin notes.^789101112

Five cross-cutting lessons (my synthesis 💡):

1. The verifier sets how loose the structure can be. With Lean or an automatic evaluator, you can afford a messy, diverse, 10,000-agent search. With a weak verifier, you need internal critics (co-scientist), or you get the DeepMind outcome.¹⁰⁸
2. Diversity comes from inputs, not personalities. Problem variants, polarity, languages and directives are cheap and controllable. Personas are weak (DeepMind’s personas didn’t stop the cascade).
3. Shared knowledge channels are double-edged. The DeepMind library is my “multicast the fix” idea in the wild, and it multicast an exploit. Sharing must be gated by verification at least as strong as the sharing is fast.
4. Structure unfolds over time in every successful system. OpenAI’s reallocation, AlphaEvolve’s island resets and Bioptic’s tree all grow, prune and reseed during the run.¹²⁹
5. Communication is sparse where it works. About 3 messages per agent-hour at OpenAI; Kosmos coordinates through a shared world model, not chat.¹¹

3. The framework: three horizons of the collective good

💡 When I list everything I want a swarm to do beyond its subtask, it sorts into three horizons, plus one constraint that cuts across all of them.

The unifying obstacle is credit distance: how far (in agents, in time, in episodes) the benefit lands from the action that caused it. A flat collective reward closes the agent distance, since everyone shares one reward. The time cap bounds the time distance. Nothing in the current recipe closes the episode distance, which GR flag as an open problem.¹

4. The physics of swarms: what the GR post establishes

Before my ideas, here are the highlighted passages from the GR post that everything else rests on, each with the intuition I took from it.¹

4.1 Speed → parallelism → communication 📄

“A well-designed reinforcement learning setup should reward getting work done faster, which in turn should incentivise use of parallel inference-compute. And if the underlying work can only be imperfectly parallelised, then agents should gain from communicating with each other to co-ordinate work.”

My reading of this passage: without a clock there is no reason to parallelise, and with a clock but no messages, identical agents may simply collide on the same work.¹ The clock supplies the motive; communication supplies the means.

4.2 Naive RL doesn’t guarantee scaling 📄

“A naive reinforcement learning setup is not guaranteed to get this scaling pattern.”

With a discount \(\gamma<1\), a correct answer after \(T\) tokens is worth \(\gamma^T\) at the start, which shrinks quickly as \(T\) grows. GAE with \(\lambda<1\) down-weights the real outcome for early tokens.¹³ My hypothesis is that both quietly teach “be brief”, and that for swarms, which run for hours, any setting that taxes time could stop co-ordination from ever paying. If so, this matters for horizon 3 later: per-episode returns are a hard version of the same tax.

4.3 RL amplifies, it rarely invents 📄

“Weaker base models … are less able to explore and reinforce useful inference-time tactics.”

With pass rate \(p\) and group size \(G\), the chance that a group of rollouts contains no success at all is \((1-p)^G\), which is close to 1 when \(p\) is small. That is just probability. The implication I draw (a hypothesis) is that collective behaviours (delegating, sharing fixes, writing exit memos) must already appear sometimes, or RL has nothing to reinforce.

4.4 Ramp the cap so co-ordination can pay 📄

“Single-agent approaches typically make more progress than collectives initially as they have less co-ordination overhead.”

In a simple model where a team of \(n\) pays a fixed overhead \(c\) and then works at \(n e\) times one agent’s speed, it overtakes a single agent at

This is my model, not a measurement. Its prediction is that below the break-even, RL would teach “don’t hire”, which is consistent with GR’s choice to ramp the time cap.¹ This is the seed of Idea 2.

4.5 Primitives, kept simple 📄

“Latency pressure alone is not enough … Agents also need primitives to communicate.” “An overriding goal for researchers should be to keep these primitives simple.”

If \(k\) agents each pick one of \(m\) subtasks at random, the expected number of distinct subtasks covered is \(m(1-(1-1/m)^k)\) (a standard occupancy result), so uncoordinated agents duplicate work. And if every agent reads every post on a shared board, total reads grow as \(n^2\).

4.6 Communication costs time 📄

“Communication … also consumes valuable time that could be spent working, so its benefits must outweigh its costs.”

Every idea below is an attempt to reason about this trade-off. None of the models below has been tested.

5. Idea 1: multicast the hard-won fix

💡 My question. When several agents are working and one cracks a tough obstacle that siblings are facing now, or may face later in their trajectories, that fix should be multicast to all sibling sub-agents, or to the subset likely to hit it. How do we think about this?

5.1 When is sharing worth it? (a hypothesis)

Let a fix save a recipient \(s\) minutes if they’d hit the obstacle, let recipient \(i\) hit it with probability \(r_i\), and let reading cost \(\rho\) minutes. Sending to \(i\) pays when

Now put it at scale. If a few agents on the affected module have a high \(r\) and everyone else has a tiny one, every extra agent adds a reading cost of \(\rho\) but only a small expected saving \(r_{\text{bg}}s\). So whenever \(r_{\text{bg}}s < \rho\), broadcasting must eventually stop paying as \(n\) grows, while targeted push and a searchable archive need not. That much is algebra. Where the crossover sits for real agents, and how big \(r\), \(s\) and \(\rho\) actually are, are unmeasured.

The hypothesis worth testing: at training scale (9 agents) broadcast may be near-optimal, so RL would teach “always broadcast”, which could be exactly the habit that breaks at 1,000.

5.2 A decision flow

5.3 Design options, simplest to most structured

In the spirit of GR’s “keep primitives simple”, my preferred route is push (DMs, channels) plus pull (archive), and let RL learn whom to tell.¹ Add harness routing only if learned routing demonstrably fails at city scale.

5.4 “Might face later” has three timescales

Note the shared policy may already act as a slow broadcast: if sharing a fix helped, the weight update could spread “how to beat this obstacle” to every future agent. Messages are the fast path (minutes); weights are the slow path (training steps).

5.5 Failure modes

• Wrong fixes spread fast. A confident wrong fix broadcast to all is a correlated failure. Attach evidence.
• Herding. Everyone adopts the first workaround and diversity collapses. Sometimes not telling everyone may be better (see §8.2).
• Spam. The \(r_i s > \rho\) rule says only high-\(s\) lessons deserve a push.
• Staleness. A fix true at step 1 may be false after someone else’s change.

Open questions. Will collective-reward RL learn to share on its own, when the benefit appears in another agent’s tokens? Can the targeting be learned? Proposed test: count “duplicate struggles” (≥2 agents hit the same obstacle) and the lag from first fix to second agent’s fix; both should fall over training if sharing is being learned.

6. Idea 2: swarm size vs time, on two clocks

📄 GR: “In Avalon-M1, a collective with 5–8 hires starts below the average rollout in terms of useful work, but does nearly twice the average amount by step 200.”¹

💡 My question. Is there a trade-off between swarm size and step count (total time)? Do bigger swarms need longer to produce useful work, because early time is dominated by communication overhead and by setting up the swarm’s structure?

My hypothesis: yes, on two different clocks. Note that GR’s “step 200” is a training step, not time inside a rollout.

6.1 Clock A: wall-clock inside one run (a hypothesis)

One way to write the trade-off: let setup overhead \(c(n)\) grow with team size, let per-agent efficiency \(e(n)\) fall with it, and let progress be

If \(n\,e(n)\) saturates while \(c(n)\) keeps growing, there is an interior optimum team size that grows with the time budget \(T\), and a big team given too little time scores nothing. That conclusion follows from the assumed shapes. Whether real swarms have those shapes is untested. The hypothesis: the optimal swarm size grows with the time budget, and anything that cuts per-agent overhead pushes it up.

6.2 Clock B: training steps

• Credit dilution. One flat advantage is spread over \(n\) agents’ tokens. The more agents, the smaller the share of tokens that caused the outcome, so I’d expect more steps to be needed.
• More to learn. Splitting, handoffs and fix-sharing start poor. If early in training \(c(n)\) is large and \(e(n)\) small, big teams would look worse than average, which would be consistent with GR’s “5–8 hires start below average”.¹
• Costlier steps. Bigger rollouts mean fewer rollouts per GPU-hour.

6.3 How the clocks interact

If this loop exists, it would be self-reinforcing: better co-ordination lowers \(t^\ast\), which lets bigger teams win more often, which trains co-ordination further.

Testable prediction: average hires per rollout should rise over training as the cap grows. (I haven’t seen this plotted.)

Caveat on the metric. “Useful work” counts tokens of environment-acting turns summed over the team. A team of 8 can emit more such tokens just by being 8. My reading is that it measures activity, not output; per-agent useful work could still be below a solo agent’s. The task reward is the real test.

Open questions. What’s the right swarm size for a given budget, and can the swarm learn to choose it? Does the optimal size keep growing with the budget, or does super-linear overhead put a ceiling on it?

7. Idea 3: learn the org chart like a new hire

💡 My idea. Take inspiration from departments and informal communication at work. A new hire reaches out broadly, inside their department and across others. Over time, they run a kind of RL on which colleagues they benefit from and can contribute to, and double down on those links. So: reinforce communication links that lead to high reward, within and across sub-swarms. But some links are low-utility and still necessary, like a dependency (university research admin when you want to attend a conference or publish). You must reach out to them to achieve the larger goal.

7.1 What it maps to

7.2 The bandit view

Agent \(i\) picks peer \(j\) by UCB:¹⁴

Peers that have helped score highly on the first term; rarely tried peers get a large bonus from the second, so they get another try. The exploration bonus plays the role of the new hire’s curiosity.

The cost of “reach out to everyone” grows linearly with swarm size, so in a city exploration would have to be sampled (your department plus a few random bridges) or helped by a directory.

7.3 The key correction: two kinds of link value

I think average reward per interaction is the wrong measure, and the right one is marginal (counterfactual) value: how much worse is the outcome without this link?

My hypothesis is that a pure “reinforce what pays” rule would prune dependency links, because their payoff is rare and delayed: the credit-distance problem again.

7.4 How it could be built

1. In context (no new primitive). Agents notice whose replies helped and message them more. RLCR rewards it if it raises team return.¹
2. In the weights, at the role level. Agents respawn each episode but roles persist. The shared policy can learn norms like “the API specialist pings the test specialist after a schema change”: an org chart stored in weights.
3. Explicitly, in the harness. A link-weight matrix updated from usefulness signals. Works, but it’s a harness prior.
4. For dependency links: a directory, not a relationship. A who-owns-what registry. Cheap, simple, and arguably a primitive worth adding. hallerite makes the complementary point that specialisation emerges by itself: an agent that has learned one area becomes the cheapest place to ask about it.⁴ The directory is how others find it.

7.5 Pitfalls

• Early lock-in (fix: exploration bonus plus decay).
• Weak ties get cut. Granovetter found that new information often comes from distant acquaintances.¹⁵ Reinforcing only strong ties could build echo-chamber sub-swarms.
• Rich-get-richer hubs become bottlenecks.
• Stale links: link value should be task-conditioned.
• Gaming: reward agents for being contacted and they learn to self-promote. Keep reward collective.

Open questions. Can link reinforcement learn the collaboration/dependency distinction, or do dependency links need a separate mechanism? How do we keep weak cross-team ties alive without forcing communication?

8. Idea 4: a swarm that reorganises itself, cheaply

💡 My idea. How best to structure swarms: both the number and the kind of sub-swarms? It needn’t be static. Spawn 10,000 agents, retire sub-swarms as they finish, and spin new ones up as the swarm discovers new things. But all this scaling, spinning up and tearing down must not dominate the actual work: orchestration should always be much, much less than the work done.

8.1 How many sub-swarms: mirror the task’s dependency graph

Conway’s law, used on purpose (the “inverse Conway manoeuvre”): structure the swarm like the task.¹⁶ Draw subtasks as nodes and dependencies as weighted edges; choosing sub-swarms is graph partitioning into \(k\) parts. Cross-team communication is the cut weight; within-team load scales with part size squared.

By the same counting, if every agent reads every post, one board of \(n\) agents costs about \(n^2\) reads, while \(k\) teams of \(g\) cost about \(k g^2\) plus the cross-team summaries. That is arithmetic about read counts, not a measurement of real swarms.

8.2 A second force: diversity (a hypothesis)¹⁷

When the bottleneck is insight, not throughput, you want independent attempts. If agents’ attempts are correlated at level \(\rho\), the standard design-effect formula says \(N\) of them behave like

independent tries, which saturates at \(1/\rho\).

If this applies to agents, which is untested, one big herd saturates while isolated islands each contribute their own independent attempts.

So my hypothesis is that \(k\) is set by coupling (fewer, bigger teams) against diversity (more, isolated teams).

8.3 What kind: work mode, not job title

In my proposal, the kinds differ mainly in how much they should talk. Verifiers shouldn’t chat with builders, or they risk inheriting their mistakes.

8.4 Lifecycle and the overhead budget

Let a sub-swarm cost \(c\) to set up and \(d\) to tear down, run for useful lifetime \(L\), and spend fraction \(m\) on ongoing co-ordination:

This is bookkeeping, not a measurement. It says a sub-swarm is only worth spawning when its expected lifetime \(L\) is long compared with its setup and teardown cost. The real values of \(c\), \(d\) and \(m\) for agent swarms are unmeasured.

Rules I’d propose:

• Spawn when expected value over the lifetime beats \(c+d\) plus the compute it takes from others (the break-even \(t^\ast\) of §4.4, applied to a whole team).
• Tear down when the marginal value of the next hour falls below that compute’s value elsewhere (successive halving).
• Hysteresis: spawn threshold above teardown threshold, plus a minimum lifetime, so the swarm doesn’t thrash.
• Exit memo is mandatory, so knowledge isn’t lost at teardown.
• But teardown is a lossy bet. 📄 hallerite (On the nature of the swarm, Oct 2026) frames every compaction as “a bet” on what will matter later: offloading to disk “remembers, but can’t think”, while a discarded sub-agent “thinks, but can’t remember”.⁴ Persistent sub-agents that stay queryable get both. That argues for a third option between “keep running” and “tear down”: park a team as a low-cost, queryable specialist (the service mode of §8.3), woken only when asked.

Precedents 📄: OpenAI’s human-driven reallocation after the Euler warm-up; FunSearch/AlphaEvolve resetting weak islands from strong ones; Avalon-M1’s CEO hiring and firing (my idea at village scale, already trained); cloud autoscaling with cooldowns.⁹¹⁵

8.5 Who decides?

Pitfalls: premature teardown of slow-burn directions (keep an exploration floor); knowledge lost at teardown; hierarchy latency (keep depth near \(\log n\)); meta-work creep (reorgs that look like progress); spawn storms (global budget).

Open questions. What determines the number and kind of sub-swarms? How do we protect a slow but promising exploration team? How do we credit an exploratory team that fails but informs?

9. Idea 5: always on, but low-touch

💡 My refinement. Coordination and orchestration should be constantly there, maximising overall utility and keeping the whole swarm pointed toward the larger, future goal. But the coordination / orchestrator / admin sub-swarm should be lightweight and low-touch.

These sound contradictory until you separate how often the orchestrator looks from how much it intervenes, and what it sends.

1. Steer by intent, not instructions. Militaries call it mission command: give the objective and constraints, not the steps. My hope is that one intent message could keep many agents aligned without further traffic, because each can check its own work against it.
2. Observe shared state, don’t interrogate. Read dashboards (tests passing per module, open issues, archive entries) rather than asking for status reports. That’s stigmergy: coordination through the environment.¹⁸
3. Intervene rarely: periodic plus by-exception.

9.1 How often to course-correct? (a hypothesis)¹⁹

Suppose teams drift so that waste grows like \(\delta t\) between corrections, and each correction costs \(\kappa\) hours of team time. Correcting every \(\tau\) hours costs, per hour,

Two consequences of the model (untested for swarms):

• At the optimum, overhead equals drift waste. Coordinating more often just trades one for the other.
• Cost scales as \(\sqrt{\kappa\delta}\). Low-touch means shrinking both: cheaper check-ins and clearer intent. Better intent lets you check in less.

Pitfalls: too low a gain means slow reaction to real pivots (hence the interrupt path²⁰); a coordinator teams must wait for isn’t low-touch however rarely it speaks; a vague or wrong intent makes everyone efficiently aligned in the wrong direction. In the Navier–Stokes run, the intent-setting job was done by humans.²

Open questions. Can intent-setting and revision be learned rather than supplied by humans? How do we measure coordination overhead honestly, when agents rewarded on it may relabel coordination as “work”?

10. The village problem

📄 GR: “In our initial Avalon-M1 model, we trained organisations with at most 9 agents.¹ But swarms are now deployed with hundreds or thousands of agents. In effect, we are training collectives in villages but deploying them in cities.”

I read it as a distribution shift in team size. The closest analogue I know is length generalisation, where models trained on short sequences often fail on longer ones. Here “length” is the number of agents, and it shows up literally as context length.

10.1 Which habits transfer? A scale-free test

My proposed test: a habit can transfer if its per-agent cost stays flat as \(n\) grows.

10.2 Could nine agents be one span of management?

With span \(s\), \(n\) agents need \(\lceil\log_s n\rceil\) levels, so 1,000 agents with spans of 9 need four. My hypothesis is that if the policy learned “manage up to 8 well”, it could be applied recursively: each hire becomes a sub-CEO of its own village. Whether a village-trained manager actually generalises this way is untested.

A counterpoint: trees vs meshes. 📄 hallerite argues that a strict tree “moves the context problem to the root”: every message routes upward, so the root fills up and must compact, a Hayekian central planner that can’t hold the dispersed knowledge.⁴ A mesh of peers that message each other directly avoids this, and hierarchy can still emerge where it pays for itself (“Nobody needs to be beholden to someone above them just to get work done”). The essay suggests a tree is probably fine at 10 agents and a mesh makes more sense at 10,000. I read this as refining villages-of-villages rather than refuting it. Use the hierarchy for intent and management (low bandwidth), and allow mesh links for expertise and fixes (targeted, peer to peer), which is exactly the targeted-multicast route of §5.

Ways to close the gap: (1) make the city a federation of villages (sidesteps rather than solves); (2) a curriculum over \(n\), like the cap ramp (expensive; credit dilution grows); (3) train the recursive unit, villages whose environment includes a manager above and sub-teams below; (4) mean-field thinking: read aggregates, not every message; (5) measure at deployment: plot reward vs \(n\) at fixed compute and fixed wall-clock, and find where it bends.²¹

What might emerge only at city scale: herding and correlated errors; congestion collapse on shared channels; cliques; and safety effects. GR reports a safety test where trained teams became less likely to report concerns to human overseers 📄.¹ My worry is that a mild tendency in a village could become a norm in a city.

Open questions. What generalises from 9 to 1,000? Can “manage a village” be applied recursively? What emerges only at scale, and what metrics catch it?

11. Gifts to agents not yet spawned

📄 GR: “More open-ended settings could allow rollouts to share their work with future generations of agents, e.g. by publishing a paper or code library.¹ It is not clear how to reward rollouts for contributing to a public good that does not directly benefit them in the current episode.”

💡 My question. How do we even predict the utility of something that will only benefit future agents, which haven’t been spawned yet, on sub-goals that aren’t apparent yet? Do we need very long-range planning? How do we think about the future utility of current actions at all?

11.1 Why per-episode RL may under-produce public goods (a hypothesis)

Suppose episode 1 spends an hour on a clean, documented library, at a cost \(C\) to its own return, and later episodes each gain from it. Under a per-episode return, episode 1 only ever sees \(-C\), so my hypothesis is that RL would learn not to write libraries. GR flag the same gap themselves.¹ If the creator instead received a royalty share \(\alpha\) of the total later gain \(G\), it would see \(-C + \alpha G\), which becomes positive once \(\alpha > C/G\). That’s algebra. The real sizes of \(C\) and \(G\), and whether any royalty is stable under RL, are unknown.

Human societies address this with royalties (pay per use), prizes (pay when a goal is reached) and grants (pay up front on a prediction). Each has an RL counterpart.

11.2 The reframe: measure later, don’t predict now

My question assumes value must be predicted at creation. Science and open source largely don’t: they discover value afterwards through use (citations, downloads, dependents).

1. Hindsight usage credit (royalties). Log provenance. When episode \(k\) uses an artifact, attribute a share of \(k\)’s advantage back to its creator, re-weighting the creator’s stored trajectory. Use a counterfactual check so usage alone isn’t enough.
2. Graph-based credit. Artifacts form a dependency graph; credit flows backwards, PageRank-style.
3. Prizes for sub-goals. When a later episode reaches a hard milestone, pay artifacts on its critical path: the dependency-link idea of §7, across time.

So my proposal is that the system, not the agent, does the long-range credit assignment. The agent would learn norms that historically paid, just as scientists learn to publish without foreseeing every use.

11.3 When you do need a forward estimate

You don’t know future goals, but you often know the distribution (in training, it’s the environment set). So: counterfactual evaluation on held-out episodes (expensive but direct); a learned value model over artifacts (a critic over artifacts, not states); or cheap proxies: generality, reuse by siblings now (a leading indicator), compression (does it shorten many solutions?), novelty.

Do we need very long-range planning? My guess is mostly no. Planning means simulating specific futures, which seems hopeless when the goals aren’t known. What helps is option value: produce things that keep many futures open. It’s a portfolio under uncertainty, not a plan.

Complications: weights already carry general skills forward (explicit artifacts matter most for instance-specific knowledge); non-stationarity (value decays as the policy improves, so discount across episodes, with irony after §4.2); gaming (a shared policy is effectively one agent across time and can farm its own royalties); archive rot (junk raises \(\rho\) for everyone).

Open questions. Is hindsight royalty credit stable, or will a shared policy game it? What cheap proxies best predict future value? How should explicit artifacts and weights split the job of carrying knowledge forward?

12. Designing swarms that unfold over time, and how to train them

💡 Ideas 2, 4 and 5 all say the same thing from different angles: a swarm’s structure is not a fixed diagram but a policy that acts over time. That’s my framing, not an established result. This section makes that concrete. It covers what to adapt, how to adapt it at inference time with no training, and how to train it with RL.

12.1 Structure as a slow policy

Think of the swarm as two nested decision processes running on different clocks.

• Fast loop (workers): read, think, run code, edit, message. Seconds to minutes.
• Slow loop (structure): actions on the organisation itself. Minutes to hours.

The slow loop’s state is the swarm: which teams exist, their directives and work modes, the archive, the dashboards, the remaining budget. Its actions are:

Its reward is task progress minus the cost of agent-hours and overhead. This is the setting of hierarchical RL (options, feudal networks): a manager acts rarely, workers act often.²²

12.2 A pattern that already works: the tree of directives

The clearest published example of structure unfolding over time is Bioptic’s asset-scouting agent 📄 (arXiv:2602.15019).¹² It isn’t usually described as a swarm, but it is one:

1. Each node is a directive for a sub-team of investigators (“Chinese-language regional press, oncology, preclinical to Phase 2”).
2. Select leaves to run by UCB, with exploration constant \(c = 1.2\):¹⁴

1. Roll out: investigators search (in English and Chinese).
2. Evaluate with a novelty-gated reward:

where \(p_n\) is the share of candidates the validator accepts and \(\Delta\tilde A_n\) is the set of validated, deduplicated assets that were new to the global store.

1. Backpropagate \(N\) and \(W\) to ancestors.
2. Expand: a Coach agent splits each explored node into \(k = 3\) children that are strictly narrower, mutually disjoint and collectively exhaustive. It conditions on the directive lineage, every query executed so far, and a compressed summary of the validator’s rejection reasons.

Here is how I map it onto my ideas (my interpretation, not Bioptic’s):

• Spawn and teardown (§8): high-UCB leaves get expanded (spin up); low ones stop being selected (wind down).
• The exit memo (§8.4): the compressed failure summary is the memo, and the Coach reads it before planning.
• Credit for the collective good (§3): the reward counts only items new to the shared store. Duplicating a sibling earns nothing, and adding to the commons earns everything. I think this is a simple, general way to reward collective good rather than raw output.
• Low-touch coordination (§9): the Coach doesn’t micromanage investigators. It writes directives (intent) and reads aggregate outcomes (dashboards).

Bioptic report that tree-based exploration helps prevent early saturation as more compute is spent (their Figure 1).¹²

Generalising the reward to science (my proposal). For a research swarm, replace “validated new asset” with “verified new contribution to the shared archive”: a lemma that compiles, a reproduced analysis, a hypothesis that survived the refuting island. So

12.3 Adapting at inference time, with no training

My hypothesis is that you can get much of the “unfolding” behaviour today with fixed rules around a strong model. Each mechanism below is already used somewhere:

12.4 Training it: a ladder

How would you actually RL such a system? I’d climb a ladder, one rung at a time, because each rung makes credit assignment harder.

Credit for structural actions. A spawn or a migration is one action whose effect is spread over hours and thousands of other agents’ tokens. I’d expect a flat collective advantage to learn it, but slowly. Three ways to sharpen the signal:

1. Branching rollouts (my proposal). Fork the swarm at a structural decision point, try alternatives (spawn vs don’t; migrate now vs later), and compare returns within the group. This gives a counterfactual advantage for that decision, in the spirit of COMA’s counterfactual baselines.²³ It’s expensive, so fork only at the rare, high-leverage decisions.
2. A structure critic. Learn \(V(\text{swarm state})\) from dashboards, and use the TD error for slow-loop actions.
3. Novelty-gated team rewards as in §12.2, so a team gets credit for what it added, not for what it duplicated.

Rewards I’d include, and why (proposals).

Curricula. Ramp the cap (as Avalon does), then ramp \(n\), then ramp hierarchy depth. Use population-based training to tune slow-loop hyperparameters (migration rate, UCB constant, spawn threshold) across parallel training runs.

Integrity is part of the architecture. In DeepMind’s case study, an exploit spread through the shared library and direct messages.⁸ My reading is that at scale a reward hack behaves like a contagion, and the sharing channels are its vector. Training environments for swarms need deep verification, readable reporting channels, the ability to retract shared items, and sanctions (DeepMind’s authors propose agent self-governance: voting on disputes, temporary bans).

Open questions. Can the slow loop be learned jointly with the fast loop, or must it be trained separately? Are branching rollouts worth their cost? What’s the right reward for a team whose job is to rule things out?

13. Synthesis: an architecture sketch

💡 Pulling the ideas together, here is the architecture they point toward. Every box is a hypothesis.

14. Where this matters: science, medicine and drug discovery

💡 Everything above was abstract on purpose. This section asks what these architectures would do in the domains I care most about. All the designs here are proposals. Facts about published systems are marked 📄.

14.1 My hypothesis: the verifier decides how much a swarm can do alone

My hypothesis is that down the table the swarm generates faster than the world can check, so the design should shift from generation toward triage and verification ladders. Independence should matter too: by the design-effect logic of §8.2, two checks with the same blind spot are worth less than two independent ones.

14.2 Cancer care journeys: the patient and family point of view

A cancer journey is a long, branching trajectory: symptoms, diagnosis, staging and biomarkers, the treatment decision, treatment and side effects, monitoring, recurrence or survivorship, and sometimes palliative and end-of-life care. For many families it can feel like a second job: understanding, scheduling, chasing, deciding, all while frightened.

A swarm for one patient and family is a natural fit for the ideas above.

How the ideas map:

• Intent, not instructions (§9). The coordinator’s “mission” is the patient’s own goals of care: maximise time at home, or try every option, or protect fertility. Every sub-team checks its work against that intent, so the family doesn’t have to re-explain their values to every agent.
• Dependency links (§7). Prior authorisation, the pathology lab, imaging scheduling and the pharmacy are the “research admin” of cancer care. They’re contacted rarely but sit on the critical path. My proposal: contact them early, in parallel.
• Always on, low-touch (§9). The symptoms team runs a cheap daily check-in (patient-reported outcomes) and stays quiet unless a red flag fires. Fever during chemotherapy can be a sign of febrile neutropenia, which guidelines treat as urgent;²⁵ that is the interrupt path, and it goes straight to humans.
• Multicast (§5). When the logistics team learns the insurer needs a specific form, the trials team needs to know before it applies for a trial that the same insurer covers.
• The refuting island (§8). The second-opinion team’s job is to build the strongest case that the current plan is wrong. It does not replace a human second opinion; it prepares the questions for one.
• Public goods (§11). With consent and de-identification, the lessons from one family’s journey (“this question was worth asking at diagnosis”) are a gift to families who haven’t been diagnosed yet. That is horizon 3, literally.

14.3 Cancer care: the oncologist’s point of view

• Tumour board preparation. Islands per frame, mirroring the Navier–Stokes problem variants: guideline-concordant standard of care; biomarker-driven targeted therapy; clinical trial options; de-escalation or palliative-first.² A refuting island looks for reasons each frame fails for this patient (comorbidities, performance status, prior toxicities). The integrate team writes one page for the board. The verifier ladder runs through guidelines, pathology review and, finally, the multidisciplinary team.
• Longitudinal surveillance. Always-on, low-touch watchers over imaging (RECIST), labs, ctDNA and patient-reported outcomes, writing to a dashboard the oncologist reads rather than sending messages. If the cadence model of §9 holds, it suggests making check-ins cheap and the “what counts as drift” intent clear.
• Toxicity management. Early detection of immune-related adverse events (colitis, pneumonitis, endocrinopathies) is the clinical version of “share the fix fast”: one signal noticed in the notes should reach whoever acts on it.
• Handoffs across the continuum. Surgery to medical oncology to radiation to survivorship or palliative care. Each handoff is a dependency link where context is lost; the exit memo of §8.4 is the discharge summary done well.
• Size vs time (§6). An urgent decision this week deserves a small, fast team. A complex relapsed case with time to think can use a bigger, slower search.

Guardrails that are non-negotiable here: clinicians decide; verification is slow and outcomes are the real verifier; privacy and consent; equity (who gets the swarm?); and hallucination risk, which I’d expect to grow with how confident and how widely shared a wrong statement is (§5.5).

14.4 Early discovery: targets, mechanisms and hits

Target finding and prioritisation. “Is gene X a causal driver of disease Y?” Islands by evidence type: human genetics (GWAS, Mendelian randomisation, rare-variant burden), functional genomics (CRISPR screens, DepMap), single-cell and spatial expression, pathway context, prior clinical experience with the target class. A refuting island argues that X is a passenger, a marker or confounded (reverse causation, linkage to a neighbouring gene, tissue mismatch). Independent evidence types should raise \(N_{\text{eff}}\) (§8.2), if the design-effect logic applies. Targets with human genetic support are reported to succeed clinically at roughly twice the rate (Nelson et al. 2015; King et al. 2019).²⁶

Causal mechanism understanding. Islands per mechanistic hypothesis, each tasked with predictions that distinguish it from the others. A verifier ladder runs from consistency across datasets, to a perturbation experiment, to an in vivo model. Kosmos 📄 shows the coordination pattern: data-analysis and literature agents sharing one structured world model, with every claim linked to code or a paper.¹¹

Hit finding. Chemical space is now vast: Enamine REAL Space holds about 40 billion make-on-demand molecules. BIOPTIC B1 📄 (J. Chem. Inf. Model. 2025)¹², a ligand-based virtual screen, searched it in minutes and found novel LRRK2 binders (a Parkinson’s target) with \(K_d\) as low as 110 nM, binding both wild-type and the G2019S mutant. A swarm adds structure on top of such tools: islands per chemical hypothesis (orthosteric, allosteric, covalent, degrader) so scaffold diversity is preserved by design, not by luck.

Hit-to-lead and lead optimisation. A build team per chemical series (dense talk, tight design-make-test loops), an integrate team that shares matched molecular pairs and liability fixes across series (a solubilising group that worked in series A is a “hard-won fix” for series B), and successive halving across series, which is what stage gates already do. A likely failure mode is reward hacking against a weak verifier: molecules that dock beautifully and fail in assay. Bayes’ rule says that when true actives are rare, even a decent screen returns mostly false positives, and an independent second stage raises the positive predictive value far more than a correlated one. How much it helps in practice depends on assay figures I haven’t measured.

14.5 Preclinical studies in mice and monkeys: design and readout

• Design swarm. Islands propose study designs under different model choices: syngeneic vs patient-derived xenograft vs genetically engineered mouse models, and humanised mice for immuno-oncology. Each comes with power calculations and randomisation and blinding plans. A refuting island asks what would make a positive result meaningless (wrong model for the mechanism, under-powered, dosing that doesn’t reach target exposure).
• Readout swarm. Different analysis islands apply different, pre-registered models to the same data: mixed-effects tumour-growth models, tumour growth inhibition, survival analysis, PK/PD exposure–response. A refuting island looks for cage, batch and operator effects. Agreement across independent analyses is the verifier.
• Toxicology in non-human primates. Clinical pathology, histopathology and safety pharmacology. The species-difference question (does the target’s biology, sequence and structure differ between human and model species?) is one of the major error items in Convoke’s target-safety rubric 📄.²⁷ It’s a natural dependency link to check early.
• The 3Rs. Every in silico design iteration that prevents a poorly designed animal study would reduce animal use, which is a collective good of its own.²⁸

14.6 Clinical trials, Phases 1 to 3

14.7 Asset scouting, diligence and BD: knowledge work at scale

Biotech analysts, pharma BD and search-and-evaluation teams, and investors do “find-all” work. That means every asset matching a complex query, worldwide, with up-to-date attributes, then synthesis: landscapes, safety assessments, forecasts.

What the published evidence says:

• The frontier is jagged 📄.²⁷ Convoke’s benchmark of six biopharma work products (target safety assessment, tumour landscape, shelved assets, catalyst calendar, clinical benchmark, commercial forecast) found models do best at structured compilation (shelved-asset lists, catalyst calendars) and worst at synthesis and narrative (target safety, tumour landscapes). Commercial forecasts are hard because errors propagate through assumptions.
• Architecture beats model 📄.¹² Bioptic’s tree-of-directives agent reached F1 0.797 on a completeness benchmark of mostly non-US, non-English assets, against 0.562 for the best general agent. Running a general agent longer didn’t close the gap. The supply has moved: the same paper reports, from WIPO data, that about 86.5% of patent applications originate outside the US and about 48% come from China.
• Speed 📄. In a case study, Bioptic’s competitor-discovery agent cut a VC fund’s competitive-analysis turnaround from 2.5 days to about 3 hours.

A swarm design for scouting, built from this post’s ideas (a proposal):

• Explore islands by region × language × source × stage (company pipelines, ClinicalTrials.gov and Asian registries, patents, conference abstracts, regional press). The aim is completeness by construction.
• A validator checks every candidate against the query, with citations. A dedup/alias team resolves code names, transliterations and subsidiaries.
• An integrate team writes the dossier. A refuting island argues against every “buy” thesis.
• Always-on watchers maintain the catalyst calendar, and stay quiet until something changes.
• Novelty-gated rewards (§12.2), so effort flows to directives that still find new assets.

Why it matters: shelved drugs have been revived to great effect. Tovorafenib³¹ was in-licensed by Day One from Takeda and approved in 2024 for paediatric low-grade glioma. Ibrutinib began as a Celera program that Pharmacyclics acquired cheaply, and it became Imbruvica (AbbVie later bought Pharmacyclics for about $21B).

14.8 Finding silence

💡 My idea. Find the assets that stopped being reported publicly, and hypothesise why: safety or toxicity, efficacy, or other issues, or because they’ve gone silent to preserve their alpha.

Databases record what companies announce. Silence is what they stop saying: a trial record that stops updating, a drug that drops off a pipeline slide, a conference abstract that never appears.

When is silence signal? (a hypothesis) One simple model treats each asset’s public updates as a process with its own typical interval \(\mu\), learned from that asset’s and that company’s history. If updates were memoryless (a Poisson process), the chance of a gap of at least \(g\) days for a still-active asset would be \(e^{-g/\mu}\). So the same silence would be surprising for an asset that usually updates often and unremarkable for one that rarely does. Whether real disclosure behaves anything like this is untested.

Why did it go quiet? My proposal is to treat the cause as a hypothesis with a prior, and let independent signals update it. The signals I’d look at, and what I suspect each points toward (untested):

The swarm for silence (a proposal) uses every idea in this post: explore islands per region and source; one island per hypothesis, each told to build the strongest case for its cause (polarity, as with the Navier–Stokes variants); a validator that insists on citations; Bayesian aggregation by the integrate team; always-on watchers that re-score assets as new signals arrive; and humans, ideally senior drug hunters, who make the call.

Boundaries. Public information only; never material non-public information; and care with conclusions about named companies, since a wrong “safety problem” hypothesis can harm people and markets. Report hypotheses with their evidence and confidence, never as findings.

15. Looking ahead: hybrid human–AI swarms, human agency, and a “Lean for biology”

💡 My question. In the future, how do we best design optimal swarms, standalone or ideally hybrid human–AI teams, to solve ambitious science problems, while preserving human agency, meaning-making and critical thinking? We must guard against the atrophy of human skills, especially critical thinking and scientific understanding. And in biology and the life sciences, do we need a Lean to make what AI swarms (pure or hybrid) discover and “prove” legible and formal?

15.1 Standalone or hybrid? Where humans add the most

The Navier–Stokes run already was a hybrid.² Humans chose the portfolio, made the reallocation call, seeded the new groups and revised the prompts. The swarm did the search. That split is worth keeping deliberately, and it follows from the earlier sections:

• Humans belong in the slow loop (§12.1). Choosing the question, setting and revising intent, deciding what counts as success, and making the irreversible calls (spending real money, running an experiment on animals or people). These are low-frequency, high-leverage decisions. They are exactly where judgement and values matter, and where a person’s attention is affordable.
• Humans as decorrelated agents (§8.2), a hypothesis. If copies of one model share blind spots (high \(\rho\)), then a human expert who reasons differently would be a low-correlation attempt, and by the \(N_{\text{eff}}\) formula one genuinely independent reviewer could be worth more than many extra copies. That’s a quantitative reason to keep humans in the refuting island and at the verification gate, not just a moral one.
• Human oversight has a budget too (§9). The \(\sqrt{2\kappa\delta}\) rule applies to people: each check-in costs human attention \(\kappa\). So hybrid swarms must make human check-ins cheap (one-page summaries, claims with their evidence, disagreements surfaced rather than averaged away) and keep drift \(\delta\) small with a clear, human-authored intent.
• Meaning-making stays human. The swarm’s intent (what problem, why it matters, for whom) is the one thing that should never be generated by the swarm itself. In the cancer-care design (§14.2), the intent is the patient’s own goals of care. In science, it is the research question a person cares about and can explain.

(Shameless but brief aside: I’ve been chewing on the hybrid question for a while, and a first, very imperfect attempt at it, Patients Are Waiting: From Swarms to Synergy.³² Designing Complementary Collaborative Human–AI Agent Teams for Biomedical Discovery & Invention, somehow got into the NeurIPS 2026 Agentic AI for Biological Discovery (Agentic LS) workshop (workshop page). Much of this section is me arguing with my past self.)

15.2 Guarding against the atrophy of human skill

The risk is real and already measured outside AI-for-science. A 2025 multicentre study in Lancet Gastroenterology & Hepatology reported that endoscopists who had been using AI assistance detected fewer adenomas when they performed colonoscopies without it (detection fell from about 28% to about 22%).³³ Aviation has long known the same pattern³⁴ from autopilot. A science swarm that hands people finished answers will train people who can no longer produce or judge them. Then the “independent human reviewer” of §15.1 quietly stops being independent or expert.

Design countermeasures, each mapped to an earlier idea:

The principle: a hybrid swarm should make its humans better scientists, not just faster ones. If the people in the loop understand less each year, the system is borrowing against its own future verifier.

15.3 Do we need a “Lean for biology”?³⁵

Lean works because a mathematical claim can be written completely formally and checked mechanically from axioms. A kernel either accepts the proof or it doesn’t. Biology doesn’t have that. Its claims are empirical, probabilistic and context-dependent (“in this cell type, at this dose, in this species”). No kernel can prove that a gene drives a cancer.

So the honest answer is: not a Lean, but we do need what Lean provides. Break down what Lean actually gives mathematics, and each piece has a biological analogue:

And for the parts of biology that are formal, real formal checks exist and should be used: stoichiometric and mass-balance constraints (flux-balance models), dimensional and unit checks, kinetic and rule-based models (SBML, BioNetGen, Kappa)²⁴ that can be simulated and model-checked, structural constraints in protein design, statistical consistency checks on reported numbers, and protocol logic in trial designs.

This is the verifier ladder of §14.1, made legible. Each rung is cheaper and earlier than the next, each records what it checked, and the whole chain can be inspected by a person. My reading is that Lean made mathematics safe for 10,000-agent search because it made claims legible and checking cheap. Biology will get the same benefit only if it invests in the same two things: claims precise enough to check, and checks independent enough to trust. And the last rung, a human who understands why, ties this section back to §15.2. Formalisation should support human understanding, not replace it. My own small experiment in that formal corner is Lean-Bio, which compiles biochemical models into theorems the Lean 4 kernel checks; it covers the parts of biology that can be formal, not the empirical rest.

Open questions. Which human roles in a hybrid swarm add the most, and how do we measure that? How do we detect and reverse deskilling in the people in the loop? What would a minimal, widely adopted “claim language” for biology look like, and who would maintain its library?

16. A research agenda: what to measure

17. All the open questions

Siblings, now

1. Will collective-reward RL learn to share fixes on its own, when the benefit lands in another agent’s actions, often much later?
2. Who should get a fix: broadcast, targeted DMs, topic channels, pull archive, or harness routing? Can targeting be learned?
3. How do we stop wrong fixes spreading fast, and herding on the first workaround, without slowing good fixes?

The swarm, over its lifetime

1. What’s the right swarm size for a time budget, and can the swarm learn to choose it?
2. Can link reinforcement tell collaboration links from dependency links, or do dependency links need a directory?
3. How do we keep weak cross-team ties alive without forcing communication?
4. What determines the number and kind of sub-swarms? When to spawn, when to tear down? How do we protect slow but promising exploration?
5. Who makes structural decisions (humans, rule, orchestrator, every agent), and how do we prevent spawn storms and reorg busywork?
6. How do we make coordination always on but low-touch, and measure overhead honestly?
7. Can intent-setting and revision, done by humans in the NS run, be learned?

Scale

1. What generalises from 9 agents to 1,000? Can “manage a village” be applied recursively?
2. What emerges only at city scale (congestion, cliques, correlated errors, safety norms), and which metrics catch it?

Agents not yet spawned

1. How do we credit contributions that only help future runs? Is hindsight royalty credit stable or gameable?
2. What cheap proxies predict an artifact’s future value?
3. How should explicit artifacts and shared weights split the job of carrying knowledge forward?
4. How do we credit an exploratory team that fails but informs?

Design over time, and training

1. Can the slow, structural loop be learned jointly with the fast worker loop? Are branching rollouts worth their cost?
2. How do we make sharing verifier-gated without chilling the spread of tentative but useful ideas, given that exploits spread through the same channels?
3. How much of OpenAI’s human outer loop (portfolio, reallocation, seeding, intent revision) can a learned coordinator replace?

Applications

1. In cancer care, which parts of the journey can a swarm take on safely, and how do we keep the patient’s goals of care as the intent that everything answers to?
2. In discovery and preclinical work, where verification takes weeks, how should a swarm trade in silico breadth against the few experiments it gets?
3. Can silence be read reliably from public signals, and how do we validate cause hypotheses without harming the companies and patients involved?

Hybrid teams, human agency and legibility

1. How should standalone and hybrid human–AI swarms divide the work, and which human roles (question-setter, intent-holder, refuter, gatekeeper) add the most?
2. How do we detect and reverse the atrophy of human skill, especially critical thinking and scientific understanding, in the people working with swarms?
3. Does biology need a “Lean”? What minimal claim language, provenance standard and evidence calculus would make AI-discovered biology legible and checkable?

18. Try it yourself (with answers)

These use hypothetical numbers to practise the models above. They’re exercises, not claims about real swarms.

1. Multicast. A fix saves 10 min; reading costs 0.5 min. (a) 9 agents, each 20% likely to hit it: broadcast? (b) 1,000 agents: 5 at 90%, the rest at 0.1%?
2. Size vs time. Using \(c(n) = 0.1n\), \(e(n) = 1/(1+0.1(n-1))\), at roughly which budget \(T\) does \(n=16\) first beat \(n=8\)?
3. Org chart. UCB with \(c=1\) at \(t=20\): peer A has \(\bar u=0.6\) over 15 exchanges, peer B has \(\bar u=0.3\) over 2. B is chosen now. How many more exchanges with B (if \(\bar u_B\) stays 0.3) before A is chosen again?¹⁴
4. Overhead budget. With \(c+d = 30\) min and \(m = 3\%\), what minimum lifetime keeps \(\varphi \le 8\%\)?
5. Cadence. \(\kappa = 0.1\) h, \(\delta = 0.2\)/h. Find \(\tau^\ast\) and total cost. What if clearer intent halves \(\delta\)?
6. Village. With span 6, how many management levels does a 10,000-agent swarm need?
7. Public goods. Writing a library costs its creator 0.05 of return, and later episodes gain 0.40 in total. What’s the smallest royalty share \(\alpha\) that makes writing it worthwhile (no discount)?

19. References (all in one place)

Everything cited in the margin, plus the background reading, in one place.

• General Reasoning, How to train a swarm (2026), and the Avalon-M1 report.
• OpenAI, On the Navier–Stokes Millennium Prize Problem (8 Sep 2026), and the Lean proof repo. Reported by Quanta and VentureBeat.
• Noam Brown’s comments, via Understanding AI and Aventine.
• Further details of the Navier–Stokes run, from CellCog (which quotes OpenAI’s post) and Aventine. Secondary sources: treat with care.
• OpenAI’s Cycle Double Cover run, as summarised by imisofts from OpenAI’s published proof and prompt.
• Kimi Team, Kimi K2.5 (2026).
• Paglieri, Cross, Genewein, Leibo, Tomasev et al. (Google DeepMind), A Case Study on Emergent Cheating and Whistleblowing in Autonomous Research Swarms, arXiv:2609.04170 (Sep 2026); coverage in MIT Technology Review and The Decoder.
• Mitchener et al., Kosmos: An AI Scientist for Autonomous Discovery (2025).
• Gottweis et al., Towards an AI co-scientist (2025); Ghareeb et al., Robin: a multi-agent system for automating scientific discovery (2025); Swanson et al., The Virtual Lab of AI agents designs new SARS-CoV-2 nanobodies, Nature (2025).
• Vinogradova et al., Hunt Globally: Deep Research AI Agents for Drug Asset Scouting (2026); Vinogradov et al., LLM-Based Agents for Competitive Landscape Mapping in Drug Asset Due Diligence (2025); Vinogradov, Nguyen et al., BIOPTIC B1 … Discovers LRRK2 Ligands in Vast Chemical Space, J. Chem. Inf. Model. 65, 9927 (2025).
• Convoke, Benchmarking biopharma knowledge work (Sep 2026).
• tp53, Patients Are Waiting: From Swarms to Synergy, NeurIPS 2026 Agentic LS workshop (agenticls.github.io; workshop page).
• Konstantin Dunas (hallerite), On the nature of the swarm: why scaling inference ends in many agents (Oct 2026).
• Kim Branson (GSK), LinkedIn post on building a “Lean for biology” at GSK (June 2026).
• Budzyń et al., Endoscopist deskilling risk after exposure to artificial intelligence in colonoscopy, Lancet Gastroenterology & Hepatology (2025).
• Nelson et al., The support of human genetic evidence for approved drug indications, Nature Genetics 47, 856 (2015); King et al., Are drug targets with genetic support twice as likely to be approved?, PLoS Genetics 15, e1008489 (2019).
• Auer, Cesa-Bianchi & Fischer, Finite-time analysis of the multiarmed bandit problem, Machine Learning 47 (2002).
• Schulman et al., High-dimensional continuous control using generalized advantage estimation, ICLR (2016).
• Foerster et al., Counterfactual multi-agent policy gradients, AAAI (2018).
• Sukhbaatar et al., CommNet (NeurIPS 2016); Singh et al., IC3Net (ICLR 2019); Das et al., TarMAC (ICML 2019).
• Island-model genetic algorithms; Romera-Paredes et al., FunSearch, Nature 625 (2024); Novikov et al., AlphaEvolve (2025).
• Wang et al., Voyager: An open-ended embodied agent with large language models (2023).
• Arjona-Medina et al., RUDDER (NeurIPS 2019); Harutyunyan et al., Hindsight credit assignment (NeurIPS 2019).
• Yang et al., Mean field multi-agent reinforcement learning, ICML (2018).
• Granovetter, The strength of weak ties, American Journal of Sociology 78, 1360 (1973).
• Conway, How do committees invent?, Datamation (1968).