Multi-agent orchestration, multiple servers in concert

One agent with one MCP server is the simple case. Serious work usually needs multiple roles at once. A researcher searches, a critic disagrees, an analyst compares with what's known. A coordinator (often called "CEO Agent") synthesizes. This lesson shows how that works technically.

The three classic workers, again

In Level 5 you met the three workers: Research, Critic, Analyst. The roles aren't my invention, they emerge naturally once you've built enough multi-agent systems. Now it's about how to implement them, not what they do.

The base pattern

Per worker you build an own script / server call. Each has:

• a clear role as system prompt
• access to the same tools (MCP servers) or specific subsets
• a defined input (the question / topic)
• a defined output (a Markdown file, a database row, a report)

The CEO calls the three in parallel, waits until all three reports are in, synthesizes them into a recommendation.

In pseudocode:

async function runAgents(topic) {
  const [researchReport, criticReport, analystReport] = await Promise.all([
    runResearchAgent(topic),
    runCriticAgent(topic),
    runAnalystAgent(topic),
  ]);
  return synthesize(researchReport, criticReport, analystReport);
}

That's the architecture. Simple. Almost everything you see in multi-agent setups is a variation of this.

The six common patterns

Once you start reading multi-agent code, you'll see the same six patterns. Here's the map:

| Pattern | Agent count | Core mechanic | Where it typically lives | |---------|:-:|---------------|-----| | Sequential pipeline | 1-3 | Linear chain A → B → C, each depends on prior output | All frameworks natively | | Flat supervisor | 3-5 | Central orchestrator delegates to workers, synthesizes outputs | LangGraph supervisor node, CrewAI Process.hierarchical, AutoGen GroupChatManager | | Hierarchical | 10-20+ | Recursive supervisor with multiple levels, context managed across layers | LangGraph nested subgraphs, AutoGen SocietyOfMind | | Parallel fan-out | 4+ independent | Multiple agents on subtasks in parallel, aggregator merges | Manual pattern, almost all frameworks | | Swarm | 5-15 | Decentralized, each agent can hand off to any other | OpenAI Swarm (deprecated), LangGraph handoffs | | Blackboard | Variable | Shared state, agents read + write typed schema | Rarely framework-native, mostly manual |

The practical threshold is clear: 1-3 agents run best as a sequential pipeline, no orchestrator overhead needed. 3-5 want a supervisor, that's the sweet spot. From 10 you need hierarchical, otherwise the orchestrator's context kills itself because its own history is dominated by all sub-agent round trips.

Parallel vs sequential

Parallel runs when the work is independent. Research doesn't need to know what Critic thinks, they see the same topic from different sides. That's fast and honest.

Sequential is worth it when agent B genuinely needs input from agent A. Example: agent A writes a blog post, agent B edits it. No parallelization possible there, B needs A's output as input.

Most analysis tasks are parallel. Most production pipelines are sequential. Combinations are normal: first three agents in parallel (research), then one agent that synthesizes their outputs (sequential).

In concrete seconds, so you have a feel for the numbers. A sequential chain with five agents and three seconds per agent takes fifteen seconds minimum, because each waits for the previous. A hierarchical setup with three layers and a two-second coordination call per layer needs six seconds before any worker starts, four layers eight. Parallel fan-out with four independent agents has total time = max of one agent + the aggregator, not the sum. That's the actual benefit of parallel: no summation.

The Neutrality Guard

One of the most important mistakes in multi-agent setups: the Critic sees the previous successes and starts confirming them instead of criticizing. That kills the entire value of the Critic.

The fix is the Neutrality Guard: the Critic only receives "Mistakes" and "Warnings" from shared memory, never "Confirmations". That's a filter on the memory tool call. The agent itself doesn't notice, it just sees no positive confirmations in its history.

In practice that means: if you have a shared memory store, you implement a per-agent view, not the whole store. The Researcher sees research findings, the Critic sees criticism history, the Analyst sees patterns. No cross-contamination.

The CEO agent

The coordinator is itself just an agent. Its system prompt is different though:

• It has the three reports as input.
• Its task is synthesis, not duplication.
• It's allowed to disagree if the three reports contradict.
• It gives a recommendation with reasoning, not just a summary.

Good CEO prompts contain sentences like: "When Research and Critic contradict, that's gold, make the contradiction visible and weight it."

Token budget per agent

Multi-agent setups get expensive if you're not careful. Each agent makes its own model calls, reads its own files, has its own tool calls. A setup with four agents and 25 turns per agent is quickly at 400,000 tokens per run.

Countermeasures:

• Hard max-turns per agent.
• Sonnet instead of Opus for simple agents (Critic mostly fine on Sonnet).
• Context budget, not the entire report history is pumped into every agent.
• Tool selection. Research gets research tools, Critic gets critic tools, not all the same.

At StudioMeyer a full 3-agent run on Opus costs about 3-5 dollars. With Sonnet and a clean budget closer to 1 dollar. Manageable, but only if actively calibrated.

When multi-agent is the wrong solution

If a good single agent with a good prompt delivers the same result, don't build multi-agent. Complexity costs time, money, debugging. Multi-agent is worth it when:

• The roles really have different thinking styles (critic logic vs research logic).
• Parallel work significantly raises throughput.
• The task is too big for one context and you can split it sensibly.

Otherwise a single agent with clear system prompts and chain-of-thought is enough.

In June 2025, Anthropic published for their own research system that a setup with Claude Opus 4 (orchestrator) plus several Claude Sonnet 4 (sub-agents) beat single-agent Opus on research tasks by 90.2 percent. That's not hype, it's measured. The trick wasn't "more agents = better", but hard turn limits, explicit contribution rules and convergence criteria. Without those constraints, early variants spawned 50+ sub-agents and burned tokens with no result.

Framework landscape as of 2026

If you start comparing frameworks, you'll be overwhelmed by options that all sound the same. Honest categorization as of April 2026, since the market has consolidated strongly since late 2025.

The production survivors are LangGraph (Uber, LinkedIn, Klarna, Replit, Cisco and Elastic use it productively), CrewAI (good for rapid prototyping with good defaults), Microsoft Agent Framework v1.0 from April 7, 2026 (the merge of AutoGen and Semantic Kernel), OpenAI Agents SDK, and Anthropic's Claude Agent SDK. Those are the five you can seriously consider.

Deprecated and no longer recommended: OpenAI Swarm is officially dead. The repo's README explicitly says it's been replaced by the OpenAI Agents SDK. AutoGen runs only on bug-fix maintenance after being absorbed into Microsoft Agent Framework. If you find a guide recommending these two, it's old.

Notably, LangChain itself recommends LangGraph for all agent workflows in LangChain 1.0 and has deprecated initialize_agent and AgentExecutor. Since September 2025, LangChain agents internally run on LangGraph.

The independent aimultiple benchmark with 2000 runs across 5 tasks gave this order: LangChain is the most token-efficient, AutoGen has the lowest latency, LangGraph is close behind LangChain on token and latency, and CrewAI is the heaviest profile with about three times the token and latency cost compared to LangChain on single tool calls. CrewAI's overhead comes from "managerial deliberation" the agent does about five seconds before each action. Helpful in complex multi-step tasks, pure overhead on simple calls.

An honest warning on marketing claims: the CrewAI README claims "5.76x faster than LangGraph" and that's self-reported. The aimultiple benchmark found LangGraph 2.2x faster. Both are right in different dimensions. CrewAI's 5.76x refers to development speed (how fast you build the prototype), not execution speed (how fast it runs). When someone throws "X-fold faster", ask what was measured: setup, token, runtime or scaling.

Real-life example from StudioMeyer

Nex HQ (the internal orchestration repo) has 9 agents + a Conductor. The Conductor isn't a classic CEO agent, but a cron scheduler firing agents at fixed times (Guardian every 30 minutes, Daily Research once a day, etc.). Research/Critic/Analyst are called on-demand in parallel when Matthias says "/agent-research X".

Reports land in research/YYYY-MM-DD-{agent}-{topic}.md. Humans review, findings flow into the memory system. Next run the agents see the historical context (with Neutrality Guard where relevant).

It's a productive multi-agent system since February 2026, no downtime, manageable cost. If you want to build yours, model on it. The code isn't public, but the patterns are documented in this lesson and addressed in Level 5.

The first three steps for your own multi-agent stack

1. Start with two agents, not three. Research + Critic suffice for the start. Analyst comes when you need historical context.

2. Use the same MCP stack for all. Don't configure per-agent servers. Same memory, same web search, same code intelligence if relevant.

3. Reports land as Markdown files. Not directly into a database, not directly into a JSON API. Markdown is the right format because humans can read it and agents on the next run can read it as context.

Sources for further reading

If you want to dig deeper, here are the primary sources for the numbers in this lesson:

• Anthropic Engineering Blog: anthropic.com/engineering/built-multi-agent-research-system (June 2025, the 90.2 percent paper)
• LangChain Blog: blog.langchain.com/building-langgraph (architecture docs)
• Microsoft DevBlogs: devblogs.microsoft.com/semantic-kernel (Agent Framework v1.0 announcement, April 2026)
• AIMultiple Benchmark: aimultiple.com/agentic-frameworks (2000 runs, 5 tasks, independent)
• Augment Code Pattern Guide: augmentcode.com/guides/swarm-vs-supervisor (pattern thresholds)

Onwards

Level 6 Lesson 4 Deployment shows how you actually roll this agent architecture out as a service. And the playbook "Memory portable use" is the basis for your agents to share memory at all.