Introduction to AI Agent Development: Multi-Agent Design Patterns and Implementation Guide

What is an AI Agent?

An AI agent is a software system that autonomously observes its environment, makes decisions, and takes action. Unlike traditional AI applications that perform one-directional processing of “input to output,” an AI agent can set its own goals, utilize various tools as needed, and complete tasks through multiple steps.

Particularly since 2024, with the advancement of large language models (LLMs), LLM-based agents that can execute complex tasks given natural language instructions have gained significant attention. ChatGPT’s plugin functionality and various AI assistant services are concrete manifestations of this agent concept.

The basic components of an agent are the following four:

• Prompts (Defining instructions and roles)
• Memory (Short-term and long-term memory)
• Tool Utilization (API calls, search, calculations, etc.)
• Planning Ability (Task decomposition and determining execution order)

What is a Multi-Agent System?

While some tasks can be completed by a single agent, complex business processes often present scenarios where one agent alone is insufficient. This is where multi-agent systems come into play.

A multi-agent system is a system where multiple AI agents cooperate and collaborate to achieve a common goal. It is analogous to a human organization where the sales department, development department, and marketing department each leverage their expertise to advance a single project.

Each agent has an independent role and expertise, communicating with other agents to execute the overall task. This architecture has clear advantages and disadvantages.

Advantages:

• Separation of responsibilities simplifies the design of individual agents.
• Improvements to individual agents have minimal impact on the overall system.
• Parallel processing enables acceleration.
• Fault tolerance allows other agents to cover if one fails.

Disadvantages:

• Communication overhead between agents occurs.
• A coordination mechanism is needed to maintain overall consistency.
• Debugging and monitoring become more complex.
• Token consumption increases, leading to higher costs.

Key Design Patterns for Multi-Agent Systems

When designing multi-agent systems, several established design patterns exist. Here, we explain six representative patterns.

1. Orchestrator Pattern

In this pattern, a single master agent (the orchestrator) controls the entire system, assigning tasks to multiple worker agents. The orchestrator aggregates the outputs of each agent to produce the final deliverable.

This pattern heavily depends on the master agent’s ability to grasp the overall task and decompose it appropriately. It is suitable for tasks with clear steps, such as report creation or research.

For example, in a case of creating a market research report, the orchestrator decomposes the task into subtasks like “market size research,” “competitive analysis,” and “trend analysis,” assigning each to a specialized agent. After receiving the results from each agent, the orchestrator integrates and outputs the final report.

2. Pipeline Pattern (Sequential Processing Pattern)

In this pattern, tasks are processed in a linear flow. The output of one agent becomes the input for the next, and processing advances stage by stage. It is analogous to a factory production line.

Using a content creation workflow as an example, the flow would be: a research agent gathers information, an outline agent creates the structure, a writer agent drafts the body, and an editor agent proofreads.

The advantage of the pipeline pattern is that the input and output of each step are clear, making it easy to debug and allowing specific steps to be easily swapped out.

3. Router Pattern (Distribution Pattern)

This pattern routes tasks to the appropriate agent based on the content or type of input. It has representative use cases like customer support automation.

The system analyzes the user’s inquiry content and routes it: technical questions go to a technical support agent, billing questions go to a billing support agent, and general questions go to a FAQ agent. By selecting the optimal agent based on the nature of the inquiry, response quality can be improved.

4. Debate Pattern

In this pattern, multiple agents present opinions from different perspectives and engage in discussion to reach a better conclusion. One agent can complement perspectives that another agent might overlook.

It is effective in scenarios requiring multifaceted validation, such as decision support or code review. For example, regarding a certain investment decision, a “bullish agent” and a “bearish agent” each present their rationale, and finally, a judge agent makes a comprehensive judgment.

5. Hierarchical Pattern

This pattern arranges agents in a hierarchical structure like an organizational chart. Middle-management agents manage multiple worker agents, and a top-level agent oversees the entire system above them.

It is suitable for large-scale project management or automating complex software development projects. Its feature is high scalability, as each hierarchy can manage tasks at an appropriate level of granularity.

6. Swarm Pattern

This pattern has no specific controlling agent; each agent makes autonomous decisions and communicates locally with adjacent agents. It draws inspiration from the behavioral principles of ant colonies or bird flocks.

Agents specialized for specific tasks dynamically collaborate, and optimal overall behavior emerges. The Swarm framework released by OpenAI is an experimental tool designed to implement this pattern.

Major Multi-Agent Frameworks

Several frameworks have been released for efficiently building multi-agent systems. Here, we compare the major frameworks.

AutoGen (Microsoft)

An open-source framework developed by Microsoft. It provides a mechanism for multiple LLM-based agents to cooperate in a conversational format. It also supports Human-in-the-loop, allowing humans to participate in conversations between agents.

Its distinctive feature is the conversation-driven programming model. By modeling interactions between agents as “conversations,” multi-agent workflows can be designed intuitively. It also has built-in code execution capabilities, making it useful for data analysis and programming tasks.

CrewAI

A framework specialized for role-based multi-agent orchestration. It creates a team of agents called a “Crew,” defining each agent’s “Role,” “Goal,” and “Backstory.”

CrewAI’s strength lies in its simplicity and intuitive API. With basic Python knowledge, multi-agent systems can be built with concise code. Integration with LangChain and LangGraph is also straightforward.

LangGraph (LangChain)

A stateful multi-agent construction framework provided as part of the LangChain ecosystem. Its graph-based workflow definition allows expressing complex conditional branches and loops.

LangGraph’s greatest feature is its robust state management. It can persist the execution state of agents, enabling resumption from checkpoints and pausing/resuming with human intervention. It is a strong candidate when considering operation in production environments.

OpenAI Swarm

A lightweight multi-agent framework released experimentally by OpenAI. Designed for educational purposes, it is suitable for learning the basic concepts of multi-agents.

It consists of only two core concepts: “Agent” and “Handoff,” making task handover between agents very simple to implement. However, as it is an experimental project, its use in production environments is not recommended.

Implementation Guide: Building a Multi-Agent System with CrewAI

Here, we explain the steps to build a specific multi-agent system using CrewAI. The theme is an “Automated Blog Article Creation System.”

Step 1: Prepare the Environment

First, set up a Python runtime environment and install CrewAI. Python version 3.10 or higher is recommended. Install CrewAI and related packages using the pip command. Additionally, you need to obtain an LLM API key (e.g., OpenAI API key) in advance.

Step 2: Define the Agents

For the blog article creation system, we define the following three agents:

Researcher Agent: Gathers the latest information on a given topic and summarizes key points. It is configured to be able to use web search tools.

Writer Agent: Writes a readable blog article based on the researcher’s information. It requires SEO-conscious structure and engaging writing style.

Editor Agent: Proofreads the article created by the writer, correcting grammatical errors and logical inconsistencies. It plays the role of ensuring final quality.

For each agent, set the role, goal, and backstory. These three elements significantly influence the agent’s behavior.

Step 3: Define the Tasks

Next, define the tasks each agent will execute. Set a description and expected output format for each task.

Assign the research task to the researcher agent and the writing task to the writer agent. You can set dependencies between tasks, ensuring the writing task is executed after the research task is completed.

Step 4: Assemble and Execute the Crew

Combine the defined agents and tasks to create a “Crew.” You can select the process type as “sequential” or “hierarchical.”

When you call the crew’s kickoff method, the system automatically executes each agent in order, producing the final deliverable. During execution, you can monitor the thought process and tool usage of each agent on the console.

Step 5: Evaluate and Improve the Results

Check the results of the initial run and adjust each agent’s prompts and task definitions as needed. Key points to focus on are:

An agent’s backstory significantly influences its behavior. The more specific the instructions, the more stable the output quality. The task description also needs to clearly describe the expected deliverable format and constraints.

Best Practices for Multi-Agent System Development

Clearly Separate Agent Roles

Give each agent one clear role. Trying to create a “jack-of-all-trades” agent that can research, write, and analyze will complicate prompts and degrade the quality of each task. Like human teams, providing specialization improves overall quality.

Incorporate Error Handling and Retry Mechanisms

Since LLM output is probabilistic, results may not always meet expectations. Implement retry mechanisms and fallback strategies to handle communication errors between agents or tool call failures.

Particularly in cases where agents generate and execute code, execution in a sandbox environment and verification of execution results are essential.

Strictly Manage Costs

Multi-agent systems can sometimes consume several times more tokens than a single agent. Monitor the input/output volume of each agent and regularly check for unnecessary conversation exchanges.

A key cost-saving strategy is to use high-performance models (like GPT-4) only for agents requiring final judgment, and assign lightweight models (like GPT-3.5 or GPT-4o-mini) for intermediate processing like research or summarization.

Ensure Observability

Once the system operates in production, mechanisms to visualize agent behavior and quickly identify problems become crucial. Utilize tracing tools like LangSmith or Phoenix to record communication logs between agents and LLM call histories.

Increase Complexity Gradually

Instead of trying to build a complex multi-agent system from the start, begin with a simple configuration of 2-3 agents. The robust approach is to verify basic operation first, then gradually increase the number of agents and complexity of patterns.

Actual Use Cases for Multi-Agent Systems

Automating Software Development

A system where a requirements definition agent, coding agent, testing agent, and review agent collaborate to generate functional code from natural language requirements specifications. Projects like Devin and OpenHands are gaining attention in this field.

Research and Report Creation

Multiple research agents gather information in parallel, an analysis agent organizes the collected information, and a writer agent creates the final report. It is applicable in a wide range of fields, including market research and academic literature reviews.

Advanced Customer Support

An inquiry classification agent, knowledge base search agent, response generation agent, and quality check agent collaborate to achieve high-quality customer support. In cases requiring escalation, handover to a human operator is also automated.

Data Analysis Pipeline

Data collection, preprocessing, analysis, and visualization agents cooperate to automatically generate insightful reports from raw data. Its application in business intelligence settings is anticipated.

Future Outlook and Challenges

While multi-agent systems continue to evolve rapidly, several important challenges remain.

From a security perspective, measures are needed against prompt injection attacks in inter-agent communication and system takeover by malicious agents. Mechanisms to clearly define boundaries between trusted and untrusted agents and appropriately manage access permissions are required.

Establishing evaluation methods is also a critical challenge. While measuring the accuracy of a single task is relatively easy, how to evaluate the overall quality of a system with multiple cooperating agents is not yet standardized. The development of benchmark datasets and evaluation frameworks is expected.

On the other hand, movements toward standardizing inter-agent protocols are becoming active. Standard specifications to enhance interoperability between agents, such as MCP (Model Context Protocol) proposed by Anthropic and A2A (Agent-to-Agent) protocol promoted by Google, are being developed. If these standards become widespread, agents built with different frameworks will be able to collaborate easily.