Coordinating multiple AI agents in a single system is now considered one of the hardest engineering challenges. Drawing from insights shared by Intuit's Chase Roossin and Steven Kulesza, this Q&A explores why agent teamwork is so difficult and what approaches can make them collaborate effectively at scale.

What makes coordinating multiple AI agents one of engineering's toughest problems?

When multiple AI agents must work together, they introduce emergent complexity that single-agent systems lack. Each agent has its own goals, models, and decision boundaries, and without careful orchestration, they can conflict, duplicate work, or create deadlocks. The problem is amplified by scale — as the number of agents grows, the possible interaction paths explode combinatorially. This means that simply adding more agents rarely improves performance; instead, it often degrades it unless the coordination framework is robust. Furthermore, agents may operate on incomplete or asynchronous information, leading to race conditions or inconsistent states. Engineers must design for fault tolerance and conflict resolution from the start, which requires a deep understanding of distributed systems and AI behavior.

How does system complexity scale when agents are added?

Complexity scales non-linearly with each new agent. For n agents, the potential interactions are on the order of O(n²) or even factorial, depending on how they communicate. In practice, this means that a system with two agents might be manageable, but with ten agents it becomes extremely hard to predict or debug. Additionally, agents often need to share resources — like access to APIs, databases, or compute — leading to contention. The coordination overhead itself becomes a bottleneck. To counter this, engineers can introduce layered hierarchies or shared state patterns that limit direct agent-to-agent communication. Another approach is to assign specialized roles, so each agent has a narrow responsibility, reducing the need for constant negotiation. However, any design choice must account for the fact that as scale increases, the probability of unexpected emergent behavior also rises.

What are the key challenges in designing multi-agent systems?

• Goal alignment: Agents may have sub-goals that conflict with system-wide objectives.
• Information asymmetry: Different agents have access to different data, leading to inconsistent decisions.
• Communication overhead: Excessive messaging can slow down the entire system.
• Failure propagation: A single agent's error can cascade if others depend on its output.
• Debugging difficulty: Tracing a bad outcome back to a specific agent's action is often nearly impossible.

Addressing these requires a combination of design patterns like the mediator pattern or blackboard architecture, and operational practices such as monitoring and logging at the agent level. Intuit's experience shows that treating agents as microservices can help, but only if the orchestration layer is carefully built to handle partial failures and timeouts.

How can engineers design agents to cooperate without constant conflict?

One effective strategy is to implement a centralized orchestrator that assigns tasks and resolves disputes. This takes the burden of negotiation off individual agents. Another tactic is to use contracts — predefined rules about which agent owns which data or process — so agents don't step on each other's toes. Additionally, engineers can design agents to be context-aware, meaning they can adapt their behavior based on the current system load or the actions of other agents. For example, a scheduling agent might delay its own task if it detects that a higher-priority agent is running. These approaches require careful trade-offs: centralized control can become a single point of failure, while fully decentralized systems may be chaotic. A hybrid solution, such as a hierarchical federation, often works best at scale.

What role does communication play in making agents work together?

Communication is the backbone of multi-agent coordination, but it must be efficient and purposeful. Sending raw data between agents is rarely useful; instead, agents should exchange high-level summaries or intentions. For instance, instead of sending an entire dataset, an agent might send a confidence score or a request for input. Message brokering (like using a queue) helps decouple agents and prevents them from being overwhelmed. Also important is the synchronization model: synchronous communication (requiring an immediate response) can create tight coupling and latency, while asynchronous messaging allows more flexibility but introduces eventual consistency issues. The best communication protocol depends on the application's tolerance for delay and inconsistency. In high-stakes systems, a mix of both — with priorities — often yields the best results.

Can you give a real-world example of a successful multi-agent system at scale?

Intuit's own internal systems provide a valuable case study. In their tax preparation and financial management products, multiple AI agents collaborate to process user data, suggest deductions, and validate entries. One agent might extract data from uploaded documents, another checks for errors, and a third provides personalized recommendations. These agents are coordinated through a shared state that each reads from and writes to, with a dedicated orchestration layer that ensures only one agent modifies a given piece of data at a time. This pattern prevents conflicts and maintains data integrity. The success of this system lies in its careful state management and role separation. Other industries, such as robotics (e.g., warehouse automation) and self-driving car fleets, use similar principles to coordinate multiple intelligent units in real time.

What future trends should engineers expect in multi-agent AI systems?

We are moving toward self-organizing agent collectives that can form temporary teams based on task requirements. Advances in reinforcement learning and multi-agent reinforcement learning (MARL) will allow agents to learn coordination strategies through trial and error, reducing the need for hand-coded rules. Additionally, federated learning will enable agents to share knowledge without exposing private data, a critical need in finance and healthcare. We may also see the rise of agent marketplaces where agents bid for tasks or resources, dynamically optimizing system load. However, with these advances come new challenges: accountability, explainability, and security. As agents become more autonomous, engineers will need robust meta-monitoring systems that watch the watchers, ensuring ethical and predictable behavior even in unexpected scenarios.