Designing Multi-Agent Systems

The Evolution of AI Agents: From Solo Players to Orchestras

Remember when AutoGPT and BabyAGI first burst onto the scene? These early AI agents were like solo performers, built on two simple but powerful capabilities:

1. They could think (through LLM calls)
2. They could act (through tool calls)

This approach was later refined into what we now call the ReAct pattern – where the LLM decides the next best action at every step. It was groundbreaking because these agents could tackle all sorts of tasks without needing to be programmed specifically for each one.

Why Single Agents Aren’t Enough

But as we pushed these solo agents further, we started hitting some walls:

• Tool Scalability Constraints: LLMs struggle to select the right tools at the right time if they have too many tools at their disposal. Empirically, we have observed this issue pop up when there are more than 10 tools.
• Context Pollution: The outputs of all the intermediate steps may not be relevant for later steps. The presence of irrelevant information overwhelms the context window of LLMs which affects the agent performance.
• Jack of All Trades, Master of None: While LLMs are great at reasoning, they’re not specialists. Sometimes you need a dedicated planner, researcher, coder, or math whiz to get things done right.

Enter Multi-Agent Systems: The Power of Teamwork

This is where Multi-Agent Systems (MAS) come in. Think of it as moving from a one-person band to a well-coordinated orchestra. Here’s why this approach works better:

• Divide and Conquer: Each agent handles a manageable set of tools, keeping their workspace clean and focused
• Easy Maintenance: When something goes wrong, you can fix or upgrade individual components without disrupting the whole system
• Specialized Expertise: Agents can be tailored for specific capabilities, whether that’s planning, coding, or analyzing
• Predictable Flow: You get more control over how agents work together, rather than leaving everything up to the LLM

The Architecture Playbook: Different Ways to Build Multi-Agent Systems

Let’s look at the main patterns we’re seeing in the wild:

1. The Router Pattern

Think of this as a simple receptionist. When a user asks something, an LLM quickly decides “Who’s the best person to handle this?” and forwards the message. Simple but effective.

2. Agents as Tools Pattern

Remember ReAct? This is similar, but instead of calling tools, the main LLM calls other agents. It’s like having a project manager working with a team of interns. These interns need detailed clear instructions as they do not have the complete context of the entire project.

3. The Supervisor Pattern

Very similar to the previous pattern, but with shared context (chat history, and other variables). The supervisor shares the entire chat history and other state variables with all team members, which increases their efficacy.

4. The Coordinator Pattern

This one’s interesting – it’s like a democratic workplace where every agent gets to say “I think I can help with this!” or “Wait, there might be a problem here.” The coordinator then makes the final call on who does what.

5. The Network Pattern

This is the most free-form approach, where agents can talk to each other directly to get work done. This resembles an organization with completely flat hierarchy. Frameworks like CrewAI, Microsoft’s Autogen, and OpenAI’s Swarm follow this architecture.

While flexible, it comes with some challenges:

• Less predictable execution flow leads to unreliable outcomes
• Usually takes longer to complete tasks
• More expensive (all that agent chatter adds up!)

6. The Hierarchical Pattern

Perfect for complex systems with lots of tools. It’s like a corporate structure – groups of similar tools report to specialized agents, who report to higher-level managers. Keeps things organized and scalable.

7. Custom Patterns

When you know exactly what you need, sometimes the best approach is to design your own system. It might not be as flexible, but it can be perfect for specific use cases.

Agent to Agent Communication

Now that we’ve some color on the high level design of Multi-Agent Systems let’s dig deeper into the communication protocols which empower these architectures. Broadly there are broadly two paradigms in which agents communicate among each other:

1. Using Tool Call Parameters

In this design, the parent agent (Agent 1 in the diagram) calls the child agent (Agent 2) in the same way as it calls a tool. This means the child agent needs to reveal the exact syntactic structure of every parameter and their semantic description for the parent to be able to call the child agent effectively.

The main limitation is that the child agent is working “blind” – it only sees what was explicitly passed to it, without any broader context about why it’s being asked to do this task or what happened before.

2. Using Shared Context

This is more like having two people collaborate on a project where they both have access to the same information and can see the full history of what’s been done. The parent agent can simply say “hey, we need this done” and the child agent has enough context to understand what’s needed and why.

This approach is generally more flexible since agents can make more informed decisions with access to the full context. However, it does require more careful design to ensure agents don’t interfere with each other’s work.

What’s Next in the quest towards AGI?

With these patterns as building blocks, we’re seeing increasingly sophisticated systems that can tackle more complex challenges. In the pursuit of Artificial General Intelligence (AGI), researchers are currently exploring two innovative approaches:

1. Inference-time Compute: This strategy focuses on embedding agentic reasoning directly within the model architecture. OpenAI’s o1 model demonstrates that harnessing extra compute during inference leads to better reasoning capabilities.
2. MAS with Reinforcement Learning: Multiple studies have explored runtime learning capabilities for agents. By enabling agents to learn from experience – similar to human learning patterns – researchers aim to develop systems that improve their efficiency over time. Self-learning is a key stepping stone toward AGI.

The field of multi-agent systems and agent-to-agent communication are fascinating areas that are still evolving. And who knows? Maybe one day these agents will get so good at communicating, they’ll start their own AI comedy club – though I hear their current material is mostly binary humor and neural network knock-knock jokes.