Multi-Agent Systems

Why More Than One Agent?

Imagine a project manager, a researcher, a writer, and an editor all working on the same report. Each person has a specific job. The project manager coordinates. The researcher gathers facts. The writer drafts. The editor reviews. The whole output is better than any one person working alone, not because any individual is smarter, but because specialization reduces errors and allows work to happen in parallel.

Multi-agent systems work the same way. One agent handles planning. Another handles research. Another handles writing. Another checks the result. The division of labor produces better outcomes for complex tasks, and it allows parts of the work to run simultaneously rather than sequentially.

The Main Coordination Patterns

Orchestrator-worker is the most common pattern in enterprise agentic systems. A planning agent (orchestrator) accepts the top-level goal, breaks it into specific subtasks, and routes each subtask to a specialized worker agent. The research agent fetches data. The analysis agent processes it. The drafting agent writes the output. The orchestrator assembles the final result.

Critic-reviewer is particularly useful for high-stakes tasks where accuracy matters. Rather than trusting a single agent's output, you have a second agent review it specifically looking for errors, missing information, or flawed reasoning. The two agents argue the problem from different angles, which catches mistakes a single pass would miss.

A Concrete Example: Research Report

A consultant's team wants to produce a competitive intelligence report on a target company. A single general agent could do this, but it would work sequentially and might drift in focus. A multi-agent version works like this:

The orchestrator receives the request and creates a plan with four subtasks: search for recent news, pull financial filings, identify key executives, and compile analyst coverage. It assigns each subtask to a worker agent.

Four worker agents run in parallel. Each fetches its specific information, formats it according to the orchestrator's specification, and returns it.

The synthesis agent receives all four outputs, removes duplicates, resolves conflicts, and writes the structured report.

The critic agent reviews the synthesis for factual gaps, unsupported claims, and anything that requires citation. It returns a list of items to fix.

The synthesis agent incorporates the feedback and produces the final version. Total time: parallel execution means the research phase takes the duration of the slowest worker, not the sum of all workers.

Risks of Multi-Agent Systems

Error amplification. When Agent A makes a mistake, Agent B may rely on that mistake as a fact and build further mistakes on top of it. Errors compound across agent handoffs. A single bad data point can cascade into a confidently wrong final report.

Coordination failures. If the orchestrator assigns ambiguous subtasks, worker agents may make incompatible assumptions and produce outputs that cannot be cleanly combined. Clear task specifications between agents matter as much as clear prompts in single-agent systems.

Runaway cost. Each agent call costs tokens. A multi-agent system running many parallel workers on a long task can consume far more tokens than expected. Always estimate the token budget of a multi-agent workflow before deploying it.

A Second Analogy: The Kitchen Brigade

Professional restaurant kitchens operate using a brigade system developed in the 19th century. There is an executive chef (the orchestrator) who owns the menu, assigns stations, and checks every dish before it leaves. There is a sous chef who runs the floor. There are station chefs for sauces, meats, fish, and pastry, each a deep specialist. There is a garde manger for cold preparations. Each person focuses on their station and hands finished components to the next station or to the pass.

This is exactly the orchestrator-worker pattern. The executive chef does not cook every dish; coordinating is a full-time job. The station chefs do not think about the whole menu; execution at their station is enough. A single cook trying to do everything would either slow down or make mistakes at busy periods. Specialization is not just about quality, it is about throughput under load.

The parallel holds for multi-agent AI systems: parallelism is the throughput benefit, specialization is the quality benefit, and the orchestrator exists specifically so that coordination does not become the bottleneck.

A Manufacturing Example

A large automotive manufacturer uses agentic systems for quality control across its supply chain. When a parts shipment arrives, a multi-agent pipeline processes it: a logistics agent reads the manifest and updates inventory records, an inspection agent matches the parts against engineering specifications and flags dimensional outliers, a compliance agent checks that supplier certifications are current and that material compositions meet regulatory standards, and a procurement agent updates the ERP system with delivery confirmation and triggers payment processing. An orchestrator coordinates the four agents so that payment is not triggered until inspection and compliance have both returned clean results. Running these agents in parallel means the entire incoming-shipment workflow completes in a fraction of the time it would take sequentially, while the orchestrator ensures dependencies are respected: payment never precedes successful inspection.

import openai

def orchestrator(task: str) -> str:
    """Route a task to the right specialist agent."""
    task_lower = task.lower()
    if any(w in task_lower for w in ["research", "find", "search", "look up"]):
        return research_agent(task)
    elif any(w in task_lower for w in ["analyze", "compare", "evaluate"]):
        return analysis_agent(task)
    elif any(w in task_lower for w in ["write", "draft", "summarize", "report"]):
        return writer_agent(task)
    else:
        return general_agent(task)  # fallback

def research_agent(task: str) -> str:
    response = openai.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content":
             "You are a research specialist. Gather facts and cite sources."},
            {"role": "user", "content": task}
        ]
    )
    return response.choices[0].message.content

def analysis_agent(task: str) -> str:
    response = openai.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content":
             "You are an analysis specialist. Identify patterns and insights."},
            {"role": "user", "content": task}
        ]
    )
    return response.choices[0].message.content

def writer_agent(task: str) -> str:
    response = openai.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content":
             "You are a writing specialist. Produce clear, structured prose."},
            {"role": "user", "content": task}
        ]
    )
    return response.choices[0].message.content

def general_agent(task: str) -> str:
    response = openai.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": "You are a general-purpose agent."},
            {"role": "user", "content": task}
        ]
    )
    return response.choices[0].message.content

# Usage
result = orchestrator("Research the top three EHR vendors by market share")
print(result)