The Best Multi-Agent Architecture of 2026 Was Designed in 1975

The best multi-agent architecture of 2026 was designed in 1975.

It worked. Raw audio went in, sentences came out, and a team of experts collaborated with nobody in charge.

Then it died — for a reason that no longer exists.

Experts around a chalkboard

The system was HEARSAY-II, a speech recognizer from Carnegie Mellon, and its architecture was called the blackboard. Picture independent experts around a shared board. Nobody talks to anybody directly. Each expert watches, and when it sees something its knowledge applies to, it walks up and writes.

What one expert writes wakes another. One knew only phonemes, one only words, one only grammar — and audio climbed to a sentence through their alternating chalk marks. The solution emerged. No workflow, no supervisor, no graph of steps.

Two years earlier, Carl Hewitt had already defined the mechanics: the actor — private state, a mailbox, and three powers. Send messages. Create actors. Decide how to behave toward the next message. Erlang later built the world's most reliable telecom systems on exactly that model.

Blackboard systems spread through the eighties — Penny Nii's classic survey catalogued them — and then faded. Why? Because every expert had to be hand-programmed, and a good expert took years to build. The architecture was sound. The experts were unaffordable.

LLMs are the experts. The missing ingredient arrived fifty years late.

What the seventies knew, restated

Strip the blackboard and the actor to their bones and you get three properties. Here is the honest part: we did not start from them. We have been building Mozaik, our open-source TypeScript runtime where every agent is a participant on a shared event bus, from our own scars with agent systems — and only later discovered the seventies had arrived at the same shape. Two eras, same conclusion, independently. That is not a coincidence; that is what a sound architecture looks like. We wrote last week that agent interoperability is the next layer after MCP — these three properties are the definition we test every Mozaik design decision against:

interoperability = concurrency × awareness × adaptability

Concurrency: agents operate independently and do not block one another. Awareness: agents discover the other participants and can address them — Hewitt's mailbox, the experts seeing the board. Adaptability: agents change behavior according to what is happening at runtime — Hewitt's third power, under its original name.

It multiplies, not adds. A zero anywhere makes the product zero, and each zero is a system you already know: without concurrency, a sequential workflow. Without awareness, isolated workers. Without adaptability, hardcoded components.

Does it hold outside a slide?

We run baro, our autonomous software factory: you give it a goal in a git repo, and it returns a verified pull request. Its planner, architect, critic, and story agents are all Mozaik participants on one bus — and we run it on its own repository, daily. One receipt per vertex, all from logged runs.

Concurrency. Eight agents on one repo at once, scouts answering the architect while story agents write code in isolated worktrees. When an agent cannot proceed, it does not block and does not spin — it announces the dependency, suspends, and resumes when the dependency lands.

Awareness. Mid-run, a story agent needed an assertion that depended on a file it did not own. It asked on the bus who owned it. The owner answered, and the first agent narrowed its claim to what its own worktree could prove. Two agents negotiated a boundary with no coordinator adjudicating.

Adaptability. We once launched a run with a false premise in it — the goal cited files that did not exist in that checkout. Nobody on our side noticed. The architect noticed. It reported the contradiction, named exactly what was missing, proposed the closest real alternative, stated the cost, and let us decide. An agent that can tell you your premise is false is adaptability in its most underrated form.

Four questions every new technology must answer

Marshall McLuhan's laws of media give any new technology four questions: what does it enhance, what does it make obsolete, what does it retrieve, and what does it reverse into when pushed to its extreme. The triangle answers all four honestly.

It enhances parallel judgment. Not just parallel labor — several perspectives on the same problem at the same moment, plus peripheral vision: an agent sees events it never asked for, and some of them change its work.

It obsolesces the coordinator as the seat of truth. One context window as the shared memory of a whole system, one hub every message must squeeze through — and the human as the message bus, copying results from one agent session into another (the internet already has a name for that job: the meat proxy).

It retrieves the seventies: the blackboard, the actor — and something older. The workshop, where masters and journeymen work side by side and nothing ships without inspection. Collaboration with quality control is not a new idea; it is a retrieved one.

It reverses into a crowd. Pushed to the extreme, aware and adaptive agents agree each other into error, awareness becomes noise, adaptability becomes permanent replanning, and coordination overhead eats the parallel gain. We have measured pieces of this reversal in our own runs. It is real.

What is left to solve

The reversal is the work list. The triangle gives agents the capability of collaboration — these are the problems between capability and trust:

• Enforcement. Aware, adaptive agents drift unless something machine-checks what was promised. Contracts and merges blocked behind gates is how we hold the line in baro — that layer belongs above the runtime, and most of it is still unwritten for the general case.
• Join and leave. An agent should enter a running system, contribute, and exit without collapsing anything around it — with permissions scoped tightly enough that you would accept a third-party agent you did not write.
• Contracts, not just code. Many harnesses are open source, but open code is not a public contract. Their collaboration models are implicit in the implementation — readable, yet nothing outside that codebase can implement against them. Runtime interoperability needs explicit discovery, event, and permission contracts a foreign agent could satisfy — the layer where this meets MCP-style wire interoperability.
• The economics of the crowd. Knowing when three agents beat one, and when the overhead of coordination means the honest answer is a single strong agent. Restraint is a feature.

The triangle, once more

Concurrency enables independence. Awareness enables connection. Adaptability enables collaboration. The seventies proved the shape; LLMs supplied the experts; what remains is making the result worthy of trust.

Mozaik is a TypeScript runtime for interoperable AI agents — agents that operate concurrently, become aware of one another, and adapt their behavior at runtime.

Miodrag Todorović

Co-founder @ JigJoy

My passion is to tell the world the stories about the beautiful stuff we have built.

Different is better than better.