Multi-Agent Systems

Simple orchestrator-worker multi-agent pattern using the Anthropic API directly

import anthropic

client = anthropic.Anthropic()
MODEL = "claude-sonnet-4-6"  # use the same model or different models per role

def run_agent(role: str, system: str, task: str) -> str:
    """Run a single agent with a role and task."""
    response = client.messages.create(
        model=MODEL,
        max_tokens=2000,
        system=system,
        messages=[{"role": "user", "content": task}]
    )
    return response.content[0].text

def multi_agent_research(topic: str) -> dict:
    """
    Three-agent pipeline:
    1. Researcher  — finds key facts and claims
    2. Critic      — identifies gaps, biases, and errors
    3. Synthesizer — produces a final balanced summary
    """
    # Agent 1: Researcher
    research = run_agent(
        role="researcher",
        system="You are a thorough researcher. List the most important facts, mechanisms, and evidence on the given topic. Be specific and cite specific papers or data where you know them. Output as a numbered list.",
        task=f"Research: {topic}"
    )
    print(f"[Researcher]\n{research[:300]}...\n")

    # Agent 2: Critic — reviews the research
    critique = run_agent(
        role="critic",
        system="You are a rigorous scientific critic. Review the following research summary. Identify: (1) factual errors, (2) important gaps or omissions, (3) potential biases, (4) claims that need more evidence. Be specific.",
        task=f"Critique this research summary:\n\n{research}"
    )
    print(f"[Critic]\n{critique[:300]}...\n")

    # Agent 3: Synthesizer — combines research + critique into final output
    final = run_agent(
        role="synthesizer",
        system="You are a skilled science communicator. Given a research summary and a critique, produce a balanced, accurate, well-structured final summary that addresses the critic's concerns.",
        task=f"Research summary:\n{research}\n\nCritique:\n{critique}\n\nProduce the final summary."
    )

    return {"research": research, "critique": critique, "final": final}

result = multi_agent_research("The current state of world models in AI as of 2026")
print(f"[Final Summary]\n{result['final']}")

1. What are the key coordination challenges in multi-agent AI systems that do not exist in single-agent systems? (Answer: (1) Communication overhead: agents must share state, plans, and results — coordination protocols needed. (2) Conflicting objectives: agents may optimise locally in ways that harm global performance. (3) Credit assignment: which agent's action caused a good/bad outcome when agents act jointly? (4) State consistency: multiple agents acting on shared state can cause race conditions or inconsistencies. (5) Trust and verification: how does one agent know another's output is correct? (6) Fault tolerance: one failing agent can cascade failures to others. Single-agent systems have none of these challenges.)
2. What is the AutoGen framework and what use cases is it designed for? (Answer: AutoGen (Microsoft Research 2023): enables multi-agent conversations where AI agents can converse with each other, execute code, interact with humans, and call tools. Key patterns: (1) AssistantAgent + UserProxyAgent: AI solves tasks iteratively with human-in-the-loop. (2) GroupChat: multiple specialised agents collaborate (coder + reviewer + tester). (3) Nested chats: orchestrator agent spawns sub-conversations. Use cases: complex coding tasks requiring iteration, research with web search + synthesis, data analysis pipelines, multi-step task automation. AutoGen competes with LangGraph, CrewAI, and Anthropic's agent architectures.)
3. What is the difference between a hierarchical multi-agent system and a peer-to-peer one? (Answer: Hierarchical: orchestrator agent decomposes tasks, assigns subtasks to specialised worker agents, aggregates results. Clear authority structure, easier to debug. Examples: a project manager agent delegating to coding, testing, and documentation agents. Peer-to-peer: agents communicate directly, negotiate, and jointly solve problems without a central coordinator. More resilient to single-agent failure, but harder to control and debug. Most production multi-agent systems use hierarchical patterns for predictability and controllability.)
4. What is tool use in agentic AI and how does it differ from traditional API calls? (Answer: Traditional API calls: deterministic, single-turn, application code calls API, processes response. Agentic tool use: the AI decides WHEN to call a tool, WHAT arguments to pass, and WHAT to do with the result — iteratively, based on intermediate results. The AI may call a search tool, examine results, decide to search again with refined query, then synthesise. The control flow is determined by the AI's reasoning rather than hardcoded application logic. This enables complex, adaptive workflows but introduces unpredictability and requires careful oversight.)
5. What are the failure modes unique to multi-agent systems that teams should test for? (Answer: (1) Prompt injection via inter-agent messages: a compromised agent injects instructions into messages to other agents. (2) Infinite loops: Agent A delegates to Agent B, which delegates back to A. (3) Context window overflow: passing full conversation history between agents bloats token counts. (4) Hallucinated tool results: one agent fabricates a tool result rather than actually calling the tool. (5) Cascading errors: incorrect output from Agent A propagates and amplifies through subsequent agents. (6) Deadlock: two agents waiting for each other's results. Production systems must have timeout, circuit-breaker, and human-escalation mechanisms.)