Frameworks, MCP & A2A — Connecting Agents, Tools, and Each Other
TL;DR:
Production agent stacks in 2026 settled around two complementary protocol layers: MCP for agent-to-tool access, and A2A for agent-to-agent coordination — both under neutral, cross-vendor governance. Layered on top, orchestration frameworks (LangGraph, CrewAI, AutoGen, OpenAI Agents SDK) decide how agents hand off work, share state, and recover from failure. This course compares them head-to-head and gives you a production checklist so a multi-agent system doesn't become a multi-agent cost spiral.
This course is for developers and technical leads who have already built (or evaluated) a single agent and are now facing the harder question: how do multiple agents, tools, and vendors work together without turning into an unmaintainable mess? It's also for architects and product managers deciding which protocol and framework commitments to make for a growing agent platform.
You should already be comfortable with the basics from AI Agents Explained (what an agent is, the Perceive-Reason-Plan-Act-Learn loop, and single-agent frameworks). This course builds on that foundation rather than repeating it.
One Agent vs Many
Recognize when a single well-prompted agent beats a multi-agent system — and when it genuinely doesn't.
The Protocol Stack
Understand what MCP and A2A each solve, why they're complementary, and what happened to earlier competing protocols.
Framework Comparison
Compare LangGraph, CrewAI, AutoGen, and OpenAI Agents SDK on coordination model, state handling, and time-to-first-agent.
Coordination Topologies
Choose between supervisor/worker, hierarchical, and peer-to-peer patterns for a given multi-agent problem.
Production Guardrails
Apply progressive autonomy, human oversight checkpoints, and cross-agent input validation before shipping.
Observability & Cost
Instrument multi-agent traces and understand why coordination overhead multiplies cost and latency.
Academy review: October 6, 2026
Model names and capabilities change frequently. We use provider families (GPT, Claude, Gemini) in Academy copy — verify current tiers on provider sites or our LLM Model Family Guide.
For live model picks, cross-check with our AI Agents Explained.
October 2026 protocol status: MCP and A2A are the stable mental model
The useful split is now clear: MCP connects agents to tools and data, while A2A connects agents to other agents across vendors or organizations. MCP's 2026-07-28 spec also matters operationally: stateless protocol core, header-based routing, authorization hardening, and deprecations for Roots, Sampling, and Logging.
Primary sources: Agentic AI Foundation, Linux Foundation A2A project, and MCP 2026-07-28 specification notes.
Living document — protocols and frameworks move fast
A single agent has one failure mode you have to manage: it does the wrong thing. A multi-agent system has that same failure mode, multiplied by every agent in the chain, plus a new category of problems that don't exist with one agent at all:
This is exactly why the industry converged on separating concerns: a protocol for reaching tools (MCP), a protocol for reaching other agents (A2A), and a framework layer that decides the actual coordination logic (LangGraph, CrewAI, AutoGen, and others). Module 2 covers the protocols; Modules 3–4 cover the frameworks and topologies built on top of them.
Before you add a second agent
Before 2026, every agent framework invented its own way of calling tools and its own way of letting agents talk to each other. The ecosystem has since consolidated around two complementary, vendor-neutral protocols:
Vertical: agent ↔ tools and data.
One standard way to expose capabilities (read files, query a database, call an internal API) so any MCP-compatible agent can use any MCP server, regardless of who built either side.
Horizontal: agent ↔ agent.
A peer-to-peer standard for agent discovery and task hand-off, so a “team” of specialized agents built on different frameworks — or by different companies — can delegate work to each other.
The two protocols sit under separate but related Linux Foundation efforts — a detail many secondary sources get wrong. MCP is hosted by the Agentic AI Foundation (AAIF), a directed fund launched in December 2025 and co-founded by Anthropic, Block, and OpenAI, alongside Block'sgoose agent framework and OpenAI's AGENTS.md standard. A2A, by contrast, is its own Linux Foundation–hosted project — Google contributed it in mid-2025, and by its one-year mark it had grown to over 150 supporting organizations, up from roughly 50 at launch. Different governing bodies, same underlying goal: keep the plumbing vendor-neutral. A third protocol, ACP (Agent Communication Protocol), was consolidated into A2A rather than continuing as a competitor — a useful reminder that this stack is still settling, and a course claiming three separate competing standards today is already out of date.
MCP's largest specification revision since launch removed the protocol-level connection handshake and session tracking entirely. Practically, this means:
Older MCP features — Roots, Sampling, and Logging — are being deprecated in favor of tool parameters, direct provider APIs, and standard telemetry streams, respectively. If you're maintaining an existing MCP server, check the protocol's official changelog before your next upgrade; exact version dates are exactly the kind of detail that goes stale fastest.
| Dimension | MCP | A2A |
|---|---|---|
| Connects | Agent to tools & data | Agent to agent |
| Architecture | Client–server (host, client, server) | Peer-to-peer task delegation |
| Typical use | Read a database, call an API, fetch a file | Hand a sub-task to a specialist agent on another stack |
| Governance | Hosted by the Agentic AI Foundation (AAIF), alongside goose and AGENTS.md | Separate Linux Foundation project; 150+ supporting organizations |
| Production status | Widely adopted across hosts, clients, and thousands of servers | Live in Azure AI Foundry, AWS Bedrock AgentCore, Google Cloud — supply chain, finance, insurance, IT ops |
| Use both? | Yes — this is the recommended default, not an either/or choice. | |
Protocols move data between agents and tools; frameworks decide the actual coordination logic — who runs when, how state is shared, and how a failure is handled. Four frameworks dominate the orchestration conversation:
| Framework | Mental model | Best for | Effort to first agent |
|---|---|---|---|
| LangGraph | Graph of nodes (actions) and edges (control flow); state persists across steps | Complex, stateful, or cyclic workflows; enterprise-scale systems | Higher — more control, more code |
| CrewAI | A “crew” of role-playing agents, each with a role, goal, and backstory | Workflows that map cleanly onto named roles and tasks | Lowest — fastest working prototype |
| AutoGen / AG2 | Conversational agents that message each other, with optional human-in-the-loop turns | Research, review, and debate-style multi-agent patterns | Moderate |
| OpenAI Agents SDK | Explicit handoffs between agents as the core orchestration primitive | Low-overhead prototyping on OpenAI-native stacks | Low |
Semantic Kernel, LlamaIndex agents, and no-code platforms like Dify or n8n cover more specialized niches (enterprise .NET stacks, RAG-heavy pipelines, and visual no-code building respectively) — see AI Agents Explained for the full framework rundown at the single-agent level.
Can you describe your workflow as named roles with clear handoffs? → Start with CrewAI.
Does your workflow branch, loop, or need durable state across long-running steps? → Reach for LangGraph.
Are you validating an idea quickly on OpenAI models specifically? → Use the OpenAI Agents SDK.
Is the core pattern “agents debate or review each other’s work”? → AutoGen/AG2 fits naturally.
Whichever framework you choose, you're really picking a topology — the shape of how agents hand off work. Four topologies cover most real systems:
1. Supervisor / Worker
One orchestrator agent breaks down the task and delegates subtasks to worker agents, then assembles their results. The most common starting topology.
2. Hierarchical
Multiple levels of supervisors — a top-level orchestrator delegates to mid-level supervisors, who each manage their own workers. Used when a single supervisor would need too many direct reports.
3. Peer-to-peer (A2A-native)
Agents discover and negotiate directly with each other rather than through a central orchestrator — the topology A2A was purpose-built for, especially across organizational or vendor boundaries.
4. Evaluator-Optimizer loop
One agent produces a draft, a second agent critiques it against explicit criteria, and the loop repeats until the critic is satisfied. Adds latency and cost, but catches errors a single pass would miss.
Topology is not free
Full autonomy is no longer the goal for production multi-agent systems. The framework and observability layer are genuinely independent choices — pick any orchestration framework and pair it with a tracing and evaluation layer that understands multi-step agent spans, not just single API calls. A few principles hold regardless of which framework or protocol you use:
Cost and latency deserve the same instrumentation as correctness: track cost per request and per agent hop in real time, so a silently looping agent shows up as a budget alert, not a surprise invoice.
A customer-support system is a good example because it needs real coordination, not orchestration for its own sake:
Notice what this topology does not do: it doesn't use five agents where two would work, and it doesn't give every agent every tool. Scope each agent's tool access to exactly what its role needs.
I'm designing a multi-agent system for [USE CASE].
Current single-agent approach (if any): [DESCRIPTION]
Why it's not enough: [SPECIFIC LIMITATION — e.g. needs distinct tool permissions, needs parallelism, context window too large]
Please help me:
1. Propose the smallest number of agents that solves this (don't over-split roles)
2. Recommend a coordination topology (supervisor/worker, hierarchical, peer-to-peer) and justify it
3. List which tools/data each agent needs — scoped to least-privilege
4. Flag every point where a human approval gate should exist before an irreversible action
5. Estimate the cost/latency multiplier vs. a single-agent baseline
6. Suggest what to log at each agent hand-off for debuggingExplore orchestration frameworks, protocol-compatible platforms, and observability tools in our directory.
Role-based multi-agent collaboration framework — the fastest path to a working agent crew.
Open-source visual builder for agent and orchestration workflows, MCP-compatible.
Workflow automation platform increasingly used to orchestrate agent hand-offs.
Data-centric agent framework — strong fit for retrieval-heavy multi-agent pipelines.
Know these before you go further.
In a multi-agent system, one agent's hallucinated output becomes another agent's "trusted" input. A single bad tool result or misread instruction can propagate through a supervisor-worker chain and compound into a confidently wrong final answer.
What this means for you
Validate outputs at each handoff boundary, not just at the end of the pipeline. Add a lightweight critic/evaluator step between agents for high-stakes workflows.
Every extra agent hop adds a full model call (or several) plus tool round-trips. A 3-agent pipeline is not "3x slower" in practice — coordination overhead, retries, and re-planning often make it 5-10x slower and more expensive than a single well-prompted agent.
What this means for you
Benchmark a single-agent baseline before adding orchestration. Only add agents when the task genuinely needs distinct roles, tools, or parallelism — not because multi-agent sounds more sophisticated.
Tool outputs and inter-agent messages are attacker-controllable surfaces. A malicious or compromised document fetched by a "research" agent can contain instructions that hijack a downstream "action" agent, especially when protocols like MCP and A2A move data between components a human never directly reviews.
What this means for you
Treat every message crossing an agent or protocol boundary as untrusted input. Sanitize tool outputs, and require human approval before an action-taking agent executes anything irreversible based on another agent's output.
The orchestration and protocol landscape (MCP, A2A, LangGraph, CrewAI, and others) is still consolidating. Deep integration with one framework's state model or one protocol's specific version can mean expensive rewrites when the ecosystem shifts — as it already has with earlier protocols being absorbed into newer standards.
What this means for you
Keep orchestration logic decoupled from any single framework where practical, and track the protocol's official changelog before upgrading production integrations.
Complete this quiz to test your understanding of MCP, A2A, orchestration frameworks, and coordination patterns.
Loading quiz...
Don’t reach for multiple agents until a single, well-prompted agent genuinely can’t do the job — coordination overhead multiplies cost (Anthropic measured about 15x the tokens of a chat for its multi-agent research system).
The protocol layer has settled into two complementary standards: MCP connects agents to tools, A2A connects agents to each other — use both, watch specification versions, and expect the specific frameworks built on top (LangGraph, CrewAI, Microsoft Agent Framework, OpenAI Agents SDK) to keep evolving.
Production-grade orchestration means progressive autonomy, human approval gates before irreversible actions, and treating every tool output and inter-agent message as untrusted input — regardless of which framework or protocol version you’re on.