Aditya Vikram Singh

18 November 2026

The Million-Tendril Problem

A swarm that runs in parallel is not a swarm that learns.

A few months ago, in The Universe Is Not a Machine. It's a Mirror., I wrote about what happens when you take the observer problem seriously. Cosmology, consciousness and computation stop being three subjects and become one question.

Once you take that question seriously, you can't stay in philosophy. You end up trying to build it.

That is what I have been doing full-time at Waking Matter. Stated without hedging, the long-term ambition is a combined mind: a person, and a very large swarm of AI trajectories, thinking together and compounding.

Black ink in water on warm paper. Fine filaments branch and mostly end. One filament crosses a gap and touches a separate branch.
Most of them end. One crosses.

The picture I work from is ordinary. You are in the middle of something hard. Halfway through a thought, you wonder whether some property could be used another way. A real thinking partner would, before you finished the sentence, send out thousands of exploratory threads. I call them tendrils. Each one tests where its idea leads. The dead ends drop. What survives comes back into the next thought.

People are running swarms. Hundreds of agents, a search over branches, the logs poured into a shared database, and the result called collective intelligence. Most of what I have seen is stateless map-reduce with a bigger API bill. Each agent works alone, reports a score up the chain, and forgets. Tomorrow's run starts from zero.

The question I actually want answered is narrower than the ambition. When one tendril encounters a state, how does that update the priors of another tendril that does not share the same tree?

A finding went to the wrong worker

In one of our runs, a manuscript audit checked 1,162 claims and reran zero models. The second fact is the one that matters, and it is easy to miss if you are not the worker who needs it.

One worker was about to certify that more than a thousand claims had been checked. Another was about to call the audit an independent replication. A router picked up "zero reruns" and handed it to the first worker, who withdrew a certification that had been right. The second worker, the one the fact would have changed, never saw it.

Same finding. The words overlapped just enough to look like a match, and the consequence ran the other way.

The finding reached the worker who did not need it 1,162 claims checked 0 models rerun Certifying the count received "0 reruns" withdrew a correct certification About to call it a replication received nothing
One run. The finding reached the worker who did not need it.

This is the ordinary case. Discovery does not stay inside the branch where it happens. One tendril, off on its own problem, notices that a timestamp records when the data was collected, not when the event happened. Another tendril is three steps into a decision that depends on that timestamp, and is calling it when the outage started. They do not share a task, a search tree, or a vocabulary.

The second tendril cannot search for the fact. It does not know there is anything to search for. You cannot write a query for a blind spot you do not know you have.

We tried sending it to everyone

In a small pilot of 36 pending decisions, we broadcast one verified measurement to every worker. It rescued all seven whose decisions depended on it. It also flipped ten others, who changed course because of a fact that had nothing to do with them. The swarm got worse.

In our routing pilot, a keyword router scored 25 of 36. A router told the right recipients in advance scored 26. Keyword matching works when both sides use the same words. It fails when they don't, which is when you needed the connection.

The first half of the problem is knowing who a finding is for, including the worker who does not know to ask, and staying quiet for the rest.

The worker kept the bug

A billing worker was shown its own code. The code charged 67 credits for a transaction the ledger priced at 39. It had two chances to fix it. It kept the bug.

The finding had arrived. It was about the worker's own output. The worker did not update.

Most of what I read about swarms stops at delivery. Raise the retrieval score, widen the window, paste the fact into the prompt. A tendril can be handed the fact that falsifies its next action and still take the action. Getting a finding into an agent's thinking, rather than into its context, is the open part. It is also the part I least want to pretend we have solved.

What has to hold

Something has to notice which tendril needs a finding it did not ask for. Something has to withhold that finding from the tendrils it would only disturb. And the tendril that receives it has to be able to change its mind, including about a conclusion it has already started to defend.

Under that sits a duller requirement. If a bad claim gets picked up by more than one other agent before anyone checks it, the error spreads faster than you can clean it up. A swarm that reads its own outputs will do this unless influence is gated. An observation is not yet a conclusion, and a conclusion is not yet an instruction. When the evidence behind a conclusion breaks, the conclusion has to break with it.

One of the first things I built, for that reason, was Agent Memory Contracts. It draws a boundary between what was observed, what an agent wants to infer, and what it is allowed to treat as state. The code is public. It is the immune system, not the mind.

I also don't believe this works if you throw away the original record. A compression chosen before you know which distinction will matter will throw away the distinction. The raw evidence has to stay, so a later surprise can send you back to it. Our first paper is about that. I'll link it when it is public.

The next run

Hold the model weights fixed. On the next run, does the organism reach the right decision faster, with fewer false alarms and less compute, because of what it lived through?

In the early experiments, a router that had accumulated experience did no better than one we reset. "Why swarms don't learn yet" is a claim about a measurement, and so far the measurement says the experience is not yet doing any work.

If you are building swarm infrastructure, or decision models for open-ended discovery, and you have hit the same wall, write to me. I would rather compare notes with someone who has the failures.

hello@wakingmatter.com