Europe 2026
From Chaos to Choreography: Multi-Agent Orchestration Patterns That Actually Work — Sandipan Bhaumik
Overview
This talk addresses the challenges of scaling multi-agent AI systems beyond a single agent, emphasizing that complexity grows exponentially, turning simple AI problems into distributed systems challenges. It introduces key patterns for coordination, state management, and failure recovery, arguing that robust system design, not just AI capabilities, is crucial for production-grade multi-agent applications. The core thesis is that adopting established distributed systems principles is essential for building reliable and valuable multi-agent systems.
Who should watch
- AI Engineers building multi-agent systems
- Product Managers overseeing AI projects
- Developers transitioning from single-agent to multi-agent architectures
- Anyone experiencing coordination problems, race conditions, or cascading failures in AI workflows
- Teams needing to build reliable, production-grade AI systems rather than just demos
Key takeaways
- Scaling from one to five agents increases complexity not linearly, but exponentially, creating coordination and state synchronization problems akin to distributed systems.
- Choreography (event-driven, decentralized coordination) offers high autonomy and scalability but requires robust observability for debugging.
- Orchestration (centralized control via a workflow manager) provides better control, state management, and easier debugging, making it suitable for complex, stable workflows.
- Shared mutable state leads to race conditions and stale data; immutable state snapshots with versioning, stored as an append-only log, prevent these issues.
- Data contracts between agents are critical for ensuring compatibility and preventing errors when data is passed between them.
- The circuit breaker pattern protects systems from cascading failures by temporarily disabling agents that repeatedly fail, allowing for graceful degradation or retries.
- Compensation patterns (Saga pattern) enable rollback and recovery by defining undo operations for each agent's execution, ensuring systems can return to a consistent state after partial failures.
- Production-grade multi-agent architectures typically involve a central orchestrator managing state, agent calls, and observability, with agents exposed via serving layers that enforce failure policies.
Notable quotes
*The problem was we built a distributed system without distributed system thinking. And that's what kills multi-agent projects, not bad AI, but bad architecture.*
*You are not just building five agents, you are building a coordination problem across multiple relationships and across and and possibility to have multiple failure modes.*
*Agent chaos is inevitable. When you scale past one agent, you will you will hit coordination problems, race conditions, cascading failures. That's guaranteed.*
Unofficial community note. Prefer the recording for nuance.