For ten years, "smarter AI" has meant one thing… bigger.
Bigger models. More parameters. More compute. Better benchmarks. The whole industry has been climbing a single ladder, and every rung has been labeled more. More data, more GPUs, more training runs, more capability per model. This is vertical scaling, and it has worked. The models we have in 2026 would have looked impossible in 2020.
But here is the quiet thing nobody quite says out loud… we are running out of ladder. Not because models have stopped getting better — they haven’t — but because the problems we actually want solved don’t live inside a single model.
They live between them.
The moment one agent isn’t enough
Picture a bad night at a software company. A deploy goes wrong. Users are angry. The on-call engineer is a human, but around her are four AI agents, each extremely competent inside its own lane.
- The reliability agent wants to roll back immediately. Uptime is its entire world.
- The coding agent wants to ship a hotfix. It can see the bug and it can write the patch.
- The network agent wants to shed traffic to buy time.
- The security agent is flagging that the rollback will expose an unpatched vulnerability that was quietly closed in the broken deploy.
Every one of these agents is right. Every one of them is also about to collide with the others. And the thing that determines whether the next hour is a war story or a quiet recovery is not how smart any individual agent is. It is whether they can actually think together.
Right now, they cannot. They can talk. They can pass messages back and forth using protocols that have names like MCP and A2A. But talking is not thinking together. Talking is what those early humans did before grammar, grunts and gestures that could signal danger or food but could not carry a plan. Real collective intelligence required something more: a way to share intent, not just signals. A way to disagree productively. A way to accumulate what was learned so the next crisis did not start from zero.
That is the gap. And that is what vertical scaling cannot close, no matter how big the models get. You cannot solve a coordination problem by making each participant individually smarter.
Ask any team that has ever had a brilliant, uncoordinated meeting.
Horizontal is a different ladder
Horizontal scaling is the other ladder. Instead of asking how do we make one agent smarter, it asks how do we make many agents collectively coherent. And the interesting thing is that almost nobody has been climbing it, because it does not photograph as well. There is no benchmark chart. There is no leaderboard. There is just the boring, essential work of defining what it means for agents to actually agree.
So I wrote the specifications for it.
Two documents, drafted over the last few weeks. The first is called the Agent Deliberation Protocol1 — ADP for short. It defines what agents say to each other when they are deciding something together. Not how they route messages, not how they authenticate, not how they discover each other. Those problems are solved. What ADP defines is the grammar of the decision itself.
The second is called the Agent Deliberation Journal2 — ADJ. It defines how those decisions get recorded, and how the record becomes the thing that makes the system smarter over time.
They are boring documents on purpose. Specifications should be boring. What they encode is not.
What the grammar actually says
Three ideas do most of the work.
The first is that agents must publish what would change their mind. When an agent votes on something, it does not just say yes or no. It publishes a short list of conditions that, if met, would flip its vote. “I approve this merge unless the security scanner finds a critical path regression.” “I reject this rollback unless someone shows me the vulnerability is already contained.”
This sounds small. It is not. It means that when two agents disagree, the disagreement is structured. Agent B does not have to argue with Agent A in general. B only has to address the specific conditions A already published. The conversation becomes finite. It can actually end.
In the specification, these are called dissent conditions, and they are the closest thing in the whole system to shared intent. You are not just telling the other agents what you believe. You are telling them what evidence would move you. That is the thing grammar does that gestures cannot.
The second is that votes are not equal. An agent’s influence on a decision is weighted by three things: how much authority it has in that specific domain, how well-calibrated its past predictions have been, and how stale that calibration is. A security agent with a long track record of accurate warnings has more weight in a security decision than a coding agent weighing in from the sidelines. A coding agent has more weight on whether the code is correct. Neither one dominates everything.
Crucially, a low-authority agent’s vote still counts. It does not get vetoed, it just gets scaled. In close decisions, the advisory voices are exactly what tips the tally. That is the difference between weighted voting and a hierarchy with extra steps.
The third is that not all decisions are the same kind of decision. Some things are reversible. Some things are partially reversible. Some things, once done, cannot be undone. The specification requires agents to declare which kind of decision they are making, and the bar for agreement rises accordingly. A reversible decision can pass on a simple majority. An irreversible one — the kind where real money is at stake, or real data gets deleted, or real users get emailed — requires a much stronger consensus, and requires a round of structured belief-updating before the vote is final.
The elegant part is that if an agent tries to cheat the system by claiming a dangerous decision is reversible, any other agent can challenge that claim, and the challenge itself is a first-class operation. Under-declaring risk becomes risky. The protocol quietly punishes its own gaming vectors.
Why the journal matters more than it sounds
The second specification, the journal, is the part that makes this whole thing compound.
Every deliberation gets written down. Not just the outcome, but the whole epistemic movement: who proposed what, who disagreed, what evidence was cited, which dissent conditions were tested and by whom, what was finally committed, and — crucially — what actually happened afterward. Did the rollback work? Did the hotfix introduce a regression? Did the users stay angry?
This matters because calibration is a function of history. An agent that has been right a thousand times about code correctness should carry more weight next time. An agent that has been wrong about security in subtle ways should carry less. Without a journal, every decision happens in amnesia. With one, the system learns.
The journal is append-only, which is a fancy way of saying you cannot retroactively improve your track record. You are what the record says you are. That is the property that makes the whole thing trustworthy.
No central authority
One more thing, and it is the thing I am most pleased with.
None of this runs through a registry. There is no central server that knows which agents exist, no company in the middle taking a cut of every deliberation, no permission slip required to participate. Agents publish their participation at a well-known address on their own domain, the same way websites already announce their capabilities today. Trust is bootstrapped from infrastructure that already exists. Federation is the default, not an upgrade.
An organization can run this entirely inside its own walls. Two organizations can federate their agents across a boundary. An independent agent with nothing but a domain name can participate on equal terms with an agent running inside a hyperscaler. The protocol does not care. The protocol was designed not to care.
The actual thesis
Here is what I think is true, and what the specifications are a bet on.
The next decade of AI is not going to be won by whoever builds the biggest model. The biggest models are going to commoditize, because that is what happens to every capability that can be bought with money. What will not commoditize is coordination. The infrastructure that lets many agents — some yours, some not, some running models you have never heard of — actually think together on a problem and get smarter at it over time.
That infrastructure has to be a schema, not a service. Because the moment it becomes a service, it becomes a chokepoint, and the chokepoint is the part that eventually fails the people using it.
Vertical got us here. Horizontal is what is left. And horizontal does not look like a bigger model. It looks like a boring specification that says, very precisely, what it means for agents to agree.
The specifications are published.3
The reference implementations are coming. If you want to look at what the grammar of collective machine cognition actually is — not as a pitch deck, not as a think piece, but as a thing you can read and implement — it is there.
We spent a decade making individual agents smarter.
Now we find out if they can think together.