We built Mycellium — an orchestrator-free multi-agent system — over a semester at TUM. Before that, I'd spent time inside orchestrated systems at Allianz and BCG. Both fail. Just in different ways.
The default architecture is orchestration: one coordinator decomposes the task, hands out work, collects the results, decides what's true. It's clean, it's legible, and it's also a bottleneck by design. The coordinator has to be smart enough to correctly decompose the entire problem up front. Get that wrong and every downstream agent inherits the mistake — confidently.
Emergent systems flip that. Agents self-organize, converge on an answer through something like consensus, and no single node is "in charge." It sounds better right up until something goes wrong. A broken orchestrator is at least easy to interrogate — you can point to the step that failed. An emergent system that quietly converges on a wrong answer is much harder to debug, because there's no single decision to trace back to.
Here's the distinction that actually matters in practice
Use orchestration when the task has a natural hierarchy — step 1, then 2, then 3 — and each step is independently verifiable. Data validation pipelines, content moderation workflows, anything where you know the shape of the solution in advance.
Use emergence when the problem is decomposable but you don't know the right decomposition ahead of time — open-ended research tasks, or creative problems where you actually want agents to wander into threads you didn't anticipate.
The thing nobody talks about
Both architectures fail without serious investment in observability. Orchestration gives you logs for free. Emergence gives you nothing for free — you have to build replay yourself. We built a step-by-step replay tool for Mycellium before the architecture itself was production-ready, and that tool ended up mattering more than the design it was inspecting.
The lesson I've carried into BCG is to stop arguing orchestration vs. emergence as if it's a philosophical choice. Build the system, then spend real effort making it inspectable. A transparent orchestrator will beat a mysterious emergent system every time — not because orchestration is better, but because you can't trust what you can't see.
See the Mycellium project in detail: Orchestrator-Free Multi-Agent Swarm System