The default architecture for multi-agent systems has a boss. One orchestrator decomposes the task, assigns work to agents, collects the results, and decides what's true. It's easy to reason about, and it inherits the classic problems of any central coordinator: it's a bottleneck, a single point of failure, and, more subtly, a ceiling — the system can never be smarter than the component doing the assigning.
In the TUM × SAP practical course, our team of six spent a semester on the opposite bet. Mycellium is an orchestrator-free multi-agent system: agents self-organize through shared state and local decision rules, with nobody in charge. I was product owner and architecture lead, so I got to see both the design and the "explain this to industry stakeholders" side of it.
Three mechanisms instead of one boss
Removing the orchestrator doesn't remove its responsibilities. Task assignment, information sharing, and deciding what's true all still have to happen; they just have to happen without central control. Mycellium splits them into three mechanisms.
An auction instead of an assigner. Work is decomposed into contracts and threads, and agents bid on them. Bids are weighted by capability and by trust, so an agent that has historically delivered on a type of task wins similar tasks more often. Nobody assigns anything; agents self-select, and the weighting keeps self-selection from being a free-for-all.
A blackboard instead of a message router. All shared state lives on an append-only blackboard. The tool suite agents get is deliberately small: post a finding, cite someone else's, vote, mention another agent. Append-only matters more than it sounds — nothing is ever silently edited or deleted, so the full history of how the swarm reached its output is always inspectable.
Citations instead of a judge. This was the part I found most interesting. When agents post findings, other agents working on adjacent threads either build on them or don't. A claim that earns independent citations gains standing; a claim nobody builds on quietly fades. Consensus doesn't need a judge, it needs a threshold. There is no final arbiter agent deciding what's true, and the system converges anyway.
The simulator was not optional
An emergent system is hard to trust precisely because nobody decided its behavior. The single most valuable thing we built for adoption wasn't in the protocol at all: a visual canvas where you configure an agent network, run it, and replay the swarm step by step — every bid, post, citation, and vote in order.
When we presented to SAP stakeholders, the replay did more persuading than the architecture slides. "Emergent coordination" sounds like hand-waving until you can scrub through a run and watch a wrong claim get posted, attract zero citations, and drop out of the result. The same tooling made our own reviews faster: when a run went sideways, we could find the exact step where it did.
Where I'd be careful
I don't think orchestrator-free is the right default for every system. The approach earns its complexity when tasks are decomposable enough for an auction to make sense and when you care about not having a single point of failure. For a narrow pipeline with three fixed steps, an orchestrator is simpler and simple wins.
The general lessons transferred anyway, orchestrator or not: give agents explicit contracts and small tool surfaces, make shared state append-only so behavior is auditable, and invest in replay tooling early. Those three carried over directly into how I think about the agentic systems I work on in enterprise settings.
The project has a live demo if you want to watch a swarm run yourself. If you're building multi-agent systems and have strong opinions on coordination, I'd genuinely like to hear them.