The best multi-agent architecture of 2026 was designed in 1975. That's not a metaphor or a stretch—Carnegie Mellon's HEARSAY-II speech recognition system pioneered an approach called the blackboard architecture, where independent experts collaborate around a shared space with nobody in charge. Raw audio went in, sentences came out. It worked. Then it died for fifty years because hand-programmed experts were unaffordable. LLMs finally changed that equation, and one team at JigJoy spent months rediscovering what the seventies already knew.

The Blackboard Model Returns

Picture a room with experts gathered around a shared chalkboard. Nobody talks to anybody directly. Each expert watches the board, and when it sees something its knowledge applies to, it walks up and writes. What one expert writes wakes another. One expert knew only phonemes, one only words, one only grammar—and audio climbed to a sentence through their alternating contributions. No workflow. No supervisor. No graph of steps. The solution emerged from collaboration without coordination. Two years before HEARSAY-II shipped, Carl Hewitt had already defined the underlying mechanics with his actor model: private state, a mailbox, and three powers—send messages, create actors, and decide how to behave toward the next message. Erlang later built the world's most reliable telecom systems on exactly that foundation. The architecture was sound. The experts were unaffordable. Until now.

The Interoperability Triangle

The JigJoy team spent their own "scars with agent systems" before discovering the seventies had already mapped this territory. They distilled it into what they call the interoperability triangle: concurrency × awareness × adaptability. These aren't nice-to-haves—they're multiplicative, not additive. A zero anywhere makes the product zero. Concurrency means agents operate independently and do not block one another—no sequential workflows where one failure cascades through everything. Awareness means agents discover participants and can address them directly—Hewitt's mailbox, the experts seeing the board. Adaptability means agents change behavior at runtime based on what's happening around them—Hewitt's third power under its original name. Each zero is a system you already recognize: without concurrency, you get sequential workflows. Without awareness, you get isolated workers who can't collaborate. Without adaptability, you get hardcoded components that break the moment reality changes.

Real-World Testing With Baro

JigJoy runs baro, their autonomous software factory: give it a goal in a git repo and it returns a verified pull request. Planner, architect, critic, and story agents are all Mozaik participants on one event bus—and they run it against their own repository daily. Eight agents work the same repo at once, with scouts answering the architect while story agents write code in isolated worktrees. When an agent can't proceed, it doesn't block or spin—it announces its dependency, suspends, and resumes when that dependency lands. One concrete example: mid-run, a story agent needed an assertion depending on a file it didn't 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. That's awareness in action—the system figured out collaboration without anyone pre-defining how. They also launched a run once with a false premise—goal cited files that didn't exist in that checkout. Nobody on their side noticed. The architect noticed, reported the contradiction, named exactly what was missing, proposed the closest real alternative, stated the cost, and let them decide. An agent that tells you your premise is wrong? That's adaptability at its most underrated.

What's Still Unsolved

The team applies McLuhan's laws of media to evaluate any new technology: what does it enhance, make obsolete, retrieve from history, and reverse into when pushed too far? The triangle scores well on enhancement—parallel judgment across multiple perspectives simultaneously. It obsoletes the coordinator as seat of truth, killing the "meat proxy" pattern where humans copy-paste between agent sessions. But the reversal is real: aware, adaptive agents can agree each other into error, awareness becomes noise, adaptability becomes permanent replanning, and coordination overhead eats all the parallel gains. They've measured pieces of this in their own runs. The open problems are enforcement (how do you hold agents accountable without central control?), join-and-leave dynamics (agents should enter and exit running systems without collapsing them), explicit contracts rather than implicit implementation assumptions, and the economics: knowing when three agents beat one versus when honest answer is a single strong agent.

Key Takeaways

  • The blackboard architecture from 1975 and Hewitt's actor model defined multi-agent collaboration fifty years before LLMs made it practical to implement
  • Interoperability requires all three properties of the triangle—concurrency, awareness, adaptability—with multiplicative rather than additive effects
  • Real implementations like JigJoy's baro prove these systems work for complex tasks like autonomous PR generation, but coordination overhead at scale remains an unsolved problem

The Bottom Line

We spent fifty years building single-agent systems and forgot what collaboration actually requires. The seventies had the shape right; we just lacked the experts. Now that LLMs fill that gap, it's worth remembering that good architecture doesn't expire—and neither should our institutional memory.