MCP in a multi-agent workflow

Every other tutorial in this section is a single agent. This one wires MCP servers into a SequentialWorkflow, which is the more interesting case for a multi-agent framework: each agent gets only the server it needs, and the pipeline hands findings down the chain.

Stage	Server	Model
Researcher	DeepWiki — repo Q&A	`claude-opus-5`
Librarian	Context7 — current library docs	`gpt-5.4`
Reporter	none — synthesis only	`claude-haiku-4-5`

Three different models, chosen by what each stage actually does: the researcher reasons over an unfamiliar codebase, the librarian does lookup-and-compare, and the reporter only has to write well from material it was handed.

Why split the tools per agent?

You could give one agent both servers. Four reasons not to:


Focus	A model choosing among many tools for a narrow job picks wrong more often than one choosing among two.
Context	Tool schemas occupy the window on every call. Loading Context7’s schemas into the agent that only reads a repo is pure overhead.
Attribution	When the output is wrong you can tell which stage produced it.
Cost	The reporter needs no tools at all, so it never pays for them.

Build it

Install and set your keys

pip install -U swarms
export ANTHROPIC_API_KEY="sk-ant-..."
export OPENAI_API_KEY="sk-..."

Both servers used here are free and need no key of their own.

Stage 1 — the researcher, with DeepWiki only

from swarms import Agent

researcher = Agent(
    agent_name="Repo-Researcher",
    agent_description="Explains a repository's architecture using DeepWiki.",
    system_prompt=(
        "You map codebases. Use DeepWiki to establish what a repository "
        "actually does before describing it. Report the module layout, the "
        "entry points, and — most important for the next stage — the "
        "third-party libraries it depends on, named exactly. Be concrete "
        "about module and package names; a downstream agent cannot look up "
        "something you described only in prose."
    ),
    model_name="claude-opus-5",
    mcp_url="https://mcp.deepwiki.com/mcp",
    max_loops=2,
)

The last sentence of that prompt is the whole trick of chaining agents: stage one has to emit something stage two can act on. “It uses several HTTP libraries” is useless downstream; httpx, anyio is not.

Stage 2 — the librarian, with Context7 only

librarian = Agent(
    agent_name="Docs-Librarian",
    agent_description="Checks current library documentation via Context7.",
    system_prompt=(
        "You verify how libraries are *currently* meant to be used. Take the "
        "dependencies identified for you and look each one up — resolve the "
        "library id, then fetch its docs. Report the current recommended API "
        "for each, and flag anything deprecated or superseded, since that is "
        "the whole point of checking live docs rather than trusting memory. "
        "If a library cannot be found, say so and move on rather than "
        "inventing its API."
    ),
    model_name="gpt-5.4",
    mcp_url="https://mcp.context7.com/mcp",
    max_loops=3,
)

Three loops, because each dependency needs a resolve-then-fetch pair and there is usually more than one.

Stage 3 — the reporter, with no tools at all

reporter = Agent(
    agent_name="Report-Writer",
    agent_description="Turns research and docs findings into a brief.",
    system_prompt=(
        "You write engineering briefs for a technical lead who has five "
        "minutes. Open with the single most important conclusion, then the "
        "supporting detail. Preserve every concrete finding you were handed — "
        "package names, versions, deprecations — and invent none. Where the "
        "earlier stages disagreed or hedged, surface that rather than "
        "smoothing it into false confidence. End with specific next actions."
    ),
    model_name="claude-haiku-4-5",
    max_loops=1,
)

No mcp_url. There is nothing left to look up, and a tool here would only invite the model to re-do work the earlier stages already did.

Chain them

from swarms import SequentialWorkflow

workflow = SequentialWorkflow(
    agents=[researcher, librarian, reporter],
    max_loops=1,
)

result = workflow.run(
    "Review the modelcontextprotocol/python-sdk repository: map its "
    "architecture, identify its main third-party dependencies, check "
    "whether the APIs it relies on are current or deprecated, and write "
    "a brief for the maintainers."
)
print(result)

Sequential or concurrent?

These stages are genuinely dependent — the librarian looks up whatever dependencies the researcher found — which is why this is a chain. When stages don’t depend on each other, swap in ConcurrentWorkflow and they run in parallel. The constructor call is otherwise identical:

from swarms import ConcurrentWorkflow

workflow = ConcurrentWorkflow(agents=[repo_reader, web_searcher, security_scanner])
results = workflow.run("Assess this project.")

A useful test: if you can shuffle the agent list without changing the meaning of the run, it should be concurrent.

Other shapes worth trying

Structure	MCP fit
`ConcurrentWorkflow`	Independent sources queried in parallel, results merged.
`HierarchicalSwarm`	A director decides which tool-bearing specialist handles each subtask.
`MixtureOfAgents`	Several servers answer the same question; an aggregator reconciles them.

Source: examples/mcp/agents/13_mcp_sequential_workflow.py

Dynamic tool loading — when one agent really does need a large server.
Sequential workflow — the structure itself, without MCP.

Index

Basic Examples

Model Providers

Single Agent

Multi-Agent Examples

Auto Agent Builder

Scheduled Agents

Applications

Research

Technical Analysis

Use Cases

Finance

Voice Agents

Integrations

MCP Tool Integrations

Deployment

CLI

MCP in a multi-agent workflow

Why split the tools per agent?

Build it

Sequential or concurrent?

Other shapes worth trying

Next

​Why split the tools per agent?

​Build it

​Sequential or concurrent?

​Other shapes worth trying

​Next

Why split the tools per agent?

Build it

Sequential or concurrent?

Other shapes worth trying

Next