Introduction
Getting multiple AI agents to work together at scale is one of the toughest challenges in modern engineering. As highlighted by Intuit's Chase Roossin (group engineering manager) and Steven Kulesza (staff software engineer), coordinating agents in a complex system requires careful design, robust communication, and continuous iteration. This guide distills their insights into a practical, step-by-step approach. Whether you're building a swarm of chatbots, a fleet of robotic process automation (RPA) bots, or a mix of reasoning agents, these steps will help you create a cohesive multi-agent environment.
What You Need
- Basic understanding of AI agent architecture – Familiarity with agent loops, APIs, and message passing.
- Access to agent development frameworks – e.g., LangGraph, AutoGen, CrewAI, or your own microservices.
- Observability tooling – Logging, tracing (e.g., OpenTelemetry), and monitoring dashboards.
- A shared state or context store – e.g., Redis, distributed database, or message queue like Kafka.
- A modular codebase – Agents should be independently deployable units.
- Time for experimentation – Expect multiple iterations to tune behavior.
Step-by-Step Guide
Step 1: Define Clear Agent Boundaries and Responsibilities
Before any code is written, map out what each agent will own. Avoid overlapping responsibilities. For example, one agent might handle data extraction, another for context reasoning, and a third for response generation. Use domain decomposition techniques: break your overall task into independent sub-tasks that can be assigned to separate agents. Document these boundaries in a shared design doc.
Step 2: Establish a Communication Protocol
Agents need to talk to each other. Choose a protocol that balances simplicity and scalability. Standard options:
- Event-driven messaging – Agents publish events (e.g., "task_completed") to a message broker. Others consume relevant events.
- Request-reply over HTTP/gRPC – Good for synchronous data exchange but can cause tight coupling.
- Shared memory / knowledge graph – Agents read/write to a central store, often used in Retrieval-Augmented Generation (RAG) pipelines.
Whichever you pick, enforce a schema (e.g., JSON, Protobuf) and use versioning from day one.
Step 3: Implement a Control Mechanism (Orchestrator or Autonomy)
Decide if you need a central orchestrator to coordinate agents or if you can rely on emergent coordination. Chase and Steven note that at Intuit, they lean toward a hybrid approach: a lightweight router that delegates tasks to specialized agents, which then operate autonomously within guardrails. Build a state machine that tracks which agent is active and what transitions are allowed. This prevents circular dependencies and deadlocks.
Step 4: Design for Observability and Debugging
When multiple agents run concurrently, tracing a single request becomes complex. Instrument every agent with:
- Structured logging (include agent ID, request ID, timestamp).
- Distributed tracing (use OpenTelemetry to propagate trace context across agent boundaries).
- Metrics: task duration, error rates, queue lengths.
Create a central dashboard where you can replay agent interactions. This will be your best friend when things go wrong.
Step 5: Handle Failures Gracefully with Retry and Fallback Logic
Agent failures are inevitable. Each agent should implement a retry policy (exponential backoff) for transient errors. For critical failures, define a fallback: either escalate to a human or delegate to a simpler rule-based agent. Use circuit breakers to prevent cascading failures: if agent A is down, stop sending it tasks until it recovers. Also, design agents to be idempotent when possible so that retries don't cause duplicate work.
Step 6: Validate and Iterate on Agent Interactions
Once the system is running, collect data on how agents interact. Use this data to refine boundaries, adjust timeouts, and improve prompts (if using LLM-based agents). Run "chaos engineering" drills: kill an agent, introduce latency, or corrupt messages. Observe how the system behaves and patch weak spots. Chase and Steven emphasize that multi-agent systems evolve: what works at 10 agents often breaks at 100. So treat your architecture as a living system.
Step 7: Implement Safety Guardrails and Governance
At scale, rogue behavior from a single agent can corrupt the entire system. Build guardrails:
- Content filters – Prevent agents from generating harmful or off-topic responses.
- Rate limiting – Control how many requests an agent can send per second.
- Human-in-the-loop – For high-stakes actions, require human approval before execution.
Define a clear policy for agent updates: all modifications should go through a staging environment first. Use feature flags so you can roll back problematic agent behavior quickly.
Tips for Long-Term Success
- Start small – Proof of concept with two agents before scaling up.
- Invest in shared context – A common knowledge base or memory reduces duplicate work and keeps agents consistent.
- Monitor cost – Multiple LLM calls can spike expenses. Cache common results and consider using smaller models for simple tasks.
- Foster cross-team collaboration – The engineers managing different agents must align on protocols and priorities.
- Document every decision – Agent behaviors can become opaque; write down why certain thresholds were chosen.
- Embrace asynchronous communication – Synchronous dependencies kill scaling. Use queues to decouple agents.
By following these steps, you'll be well on your way to building a multi-agent system that doesn't just "play nice" but thrives under scale. As the field evolves, keep learning from practitioners like the ones at Intuit – their experience shows that no single solution fits all, but a structured approach makes the challenge manageable.