AI Agent Frameworks (2026 Update): 8 SDKs Compared + the Claude Agent SDK Primitive Reference

What Changed in 2026 (Framework Releases and Updates)

If you read a framework comparison written before 2026, most of the dates and versions below are now wrong. Here is what actually shipped, with sources verified as of June 2026.

The single most material change for production teams: starting June 15, 2026, Agent SDK usage and non-interactive claude -p runs on subscription plans draw from a monthly Agent SDK credit separate from interactive limits ($20 on Pro, $100 on Max 5x, $200 on Max 20x). When exhausted, usage flows to standard API rates if enabled, otherwise requests stop. Unused credit does not roll over. Budget for this if you run Claude-based agents in CI or scheduled jobs.

Framework Comparison Table

The landscape splits into two categories: provider-native SDKs (Claude, OpenAI, Google) that are optimized for one model family, and independent frameworks (LangGraph, CrewAI, Smolagents, Pydantic AI, AutoGen) that work across providers. Neither category is universally better. The right choice depends on whether you prioritize depth of integration or model flexibility.

1. Claude Agent SDK (Anthropic)

Anthropic renamed the Claude Code SDK to the Claude Agent SDK in early 2026. The rename reflects a broader ambition: the SDK builds agents that go beyond code. Email assistants, research agents, customer support bots, finance analyzers. But the core design philosophy remains the same: give the agent a computer.

The SDK provides built-in tools for file system and shell access, eliminating the boilerplate that other frameworks require. Its MCP integration is the deepest of any framework. Playwright, Slack, GitHub, and hundreds of other MCP servers connect with a single configuration line. The @tool decorator supports typing.Annotated for per-parameter descriptions, which means your tool schemas stay close to your function signatures.

Architecture

Claude Agent SDK centers on hooks and subagents. Hooks intercept agent behavior at lifecycle points (before tool calls, after responses, on errors). Subagents handle task delegation through child agents, each with their own context window and tool set. This gives precise control over what an agent can and cannot do, which matters in production where unconstrained agents are a liability.

Strengths

• Deepest MCP integration of any framework: 200+ servers, single-line config
• Built-in file system and shell access (no custom tool wrappers needed)
• Extended thinking for complex reasoning chains
• Hooks system for lifecycle control (pre-tool, post-response, error handling)
• Session management with custom session IDs and context usage tracking

Weaknesses

• Locked to Claude models (no model swapping without rewriting tool schemas)
• No native A2A/ACP support for cross-vendor agent communication
• Python and TypeScript only (no Java, Go, or .NET)

When to use: You are building coding agents, research agents, or any system that needs deep OS-level access. You want the simplest path from "I have an idea" to "the agent is editing files and running commands." You are committed to Claude models.

Claude Agent SDK Primitive Reference: Core Primitives, Lifecycle, Hooks, Schema, Streaming

Most framework comparisons stop at "Claude Agent SDK is good for coding." This section is the documentation-grade reference for the primitives, lifecycle, governance schema, streaming model, agent isolation, and token handling, verified against code.claude.com docs as of June 2026.

Installation and authentication

TypeScript: npm install @anthropic-ai/claude-agent-sdk (it bundles a native Claude Code binary as an optional dependency, so no separate Claude Code install is needed). Python: pip install claude-agent-sdk, which requires Python 3.10 or newer. Auth defaults to export ANTHROPIC_API_KEY=...; for third-party providers set CLAUDE_CODE_USE_BEDROCK=1, CLAUDE_CODE_USE_VERTEX=1, or CLAUDE_CODE_USE_FOUNDRY=1. Using claude.ai login auth inside third-party SDK products is not permitted.

Core primitive: the query() generator

The SDK is built on one async generator, query(). You iterate the messages it yields. TypeScript:

for await (const message of query({
  prompt: "Refactor the auth module",
  options: { allowedTools: ["Read", "Edit", "Bash"] }
})) {
  // handle streamed message
}

Python:

async for message in query(
    prompt="Refactor the auth module",
    options=ClaudeAgentOptions(allowed_tools=["Read", "Edit", "Bash"]),
):
    ...  # handle streamed message

Built-in tools include Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch, and AskUserQuestion. You scope what the agent may call through allowedTools.

Lifecycle hooks (in-process callbacks)

SDK hooks are in-process callbacks, not shell commands like the Claude Code CLI hooks. Register them on options.hooks. Available events include PreToolUse, PostToolUse, Stop, SessionStart, SessionEnd, and UserPromptSubmit. TypeScript:

options.hooks = {
  PostToolUse: [{ matcher: "Edit|Write", hooks: [callbackFn] }]
}

Python:

hooks={"PostToolUse": [HookMatcher(matcher="Edit|Write", hooks=[fn])]}

Matcher syntax mirrors Claude Code: "*" or omitted matches all; letters, digits, underscores, and pipes are an exact or pipe-separated list ("Edit|Write"); anything else is treated as a JavaScript regex ("mcp__memory__.*"). MCP tools are named mcp__<server>__<tool>.

Governance: permission modes and the schema

The permissionMode option accepts the same modes as the CLI: default (prompts on first use), acceptEdits (auto-accepts file edits and in-dir file ops), plan (read-only exploration), dontAsk (auto-denies anything not pre-approved), and bypassPermissions (skips prompts). PreToolUse hooks can deny, force a prompt, rewrite tool input via updatedInput, or allow, but a hook decision never overrides a deny permission rule. Evaluation order across scopes is deny, then ask, then allow, and a deny at any level cannot be re-allowed by another. The settings schema is published at json.schemastore.org/claude-code-settings.json.

The SDK loads filesystem config from .claude/ and ~/.claude/ by default (skills at .claude/skills/*/SKILL.md, commands, and CLAUDE.md memory). Restrict that with settingSources in TypeScript or setting_sources in Python.

Streaming

Streaming is the default consumption model: query() is an async generator, so each assistant message, tool call, and tool result arrives as it is produced rather than after the full turn completes. The first message is an init system message; capture its session_id if you intend to resume the session later.

Subagents, agent isolation, and token handling

Define subagents through options.agents. TypeScript:

options.agents = {
  "code-reviewer": {
    description: "Reviews diffs for correctness",
    prompt: "You are a strict code reviewer.",
    tools: ["Read", "Glob", "Grep"]
  }
}

Python uses agents={"code-reviewer": AgentDefinition(...)}. Include "Agent" in allowedTools to auto-approve invocations. Each subagent runs with its own context window and its own tool set, which is the isolation boundary: a subagent cannot read or pollute the parent context, and its narrower tool list limits blast radius. Subagent messages carry parent_tool_use_id for attribution and cost tracking. Sessions resume by capturing session_id from the init system message and passing options.resume.

MCP and tool integration

MCP servers attach via options.mcpServers, for example {playwright: {command: "npx", args: ["@playwright/mcp@latest"]}}. That single line of config is the deepest MCP integration of any framework in this guide and connects the agent to any of the 200-plus MCP servers (GitHub, Slack, Postgres, Notion, and others). For tool integration patterns where you need to run untrusted generated code, route Bash and code execution through an isolated sandbox rather than the host shell.

2. OpenAI Agents SDK

OpenAI shipped the Agents SDK in March 2025 as Swarm's production successor. Where Swarm was an experimental sketch of multi-agent patterns, the Agents SDK is what you deploy. The core primitives: Agents (LLMs with instructions and tools), Handoffs (transferring control between agents), Guardrails (input/output validation), and Tracing (built-in debugging).

The handoff model is the cleanest in the ecosystem. When Agent A decides to delegate to Agent B, it executes a specialized tool call (transfer_to_agent_b) that passes control along with conversation history. No shared state bus, no message queues. The simplicity is the point.

Architecture

The SDK runs an agentic loop: the agent receives input, calls tools or makes handoffs, and the loop continues until the agent produces a final output or a guardrail trips. Guardrails run in parallel with agent execution by default. If a guardrail fails, execution stops immediately, even mid-generation. Three guardrail types: input (validates user messages), output (validates final responses), and tool (wraps individual tool calls).

Strengths

• Cleanest handoff model: agent-to-agent delegation as typed tool calls
• Three-tier guardrails (input, output, tool) running in parallel by default
• Built-in tracing with the OpenAI Traces dashboard for debugging
• Voice agent support via gpt-realtime with interruption detection
• Lightweight: very few abstractions, fast to prototype

Weaknesses

• No built-in state persistence (you manage checkpointing yourself)
• Handoffs are linear chains, not arbitrary graph topologies
• No native A2A support for cross-vendor agent discovery
• Voice features lock you into OpenAI-specific models

When to use: You need a lightweight framework where multi-agent coordination is handled through explicit handoffs, not complex orchestration graphs. Customer service routing, triage systems, and pipeline-style workflows where Agent A always hands off to Agent B or Agent C.

3. Google ADK (Agent Development Kit)

Google ADK launched with a clear thesis: agent development should feel like software development. The framework is model-agnostic and deployment-agnostic, though it is optimized for Gemini and the Google Cloud ecosystem. What sets it apart: four language SDKs (Python, TypeScript, Java, Go), native A2A support, and a visual Agent Designer in the Google Cloud console.

ADK Java 1.0 and ADK Go 1.0 both shipped in early 2026. This matters because most AI agent frameworks are Python-only, which forces enterprise Java and Go teams to maintain separate stacks. ADK lets a Python agent talk to a Java agent via A2A without either side knowing the other's language.

Architecture

ADK builds hierarchical agent trees. A parent agent delegates to child agents, each with their own tools and capabilities. The to_a2a() function auto-generates Agent Cards (JSON capability descriptions) from your ADK agent, enabling discovery by external agents. The Agent Designer provides low-code visual design for prototyping before transitioning to code.

Strengths

• Four language SDKs: Python, TypeScript, Java, Go (widest language support)
• Native A2A protocol with auto-generated Agent Cards
• Agent Designer for visual low-code prototyping
• OpenTelemetry integration for distributed tracing
• Deploys to Vertex AI Agent Engine for managed scaling

Weaknesses

• Heavy Google Cloud dependency for production deployments
• More manual plumbing for security compared to provider-native SDKs
• MCP support is through adapters, not native integration
• Community is smaller than LangChain or CrewAI ecosystems

When to use: Enterprise teams that need multi-language agent systems. Organizations already on Google Cloud. Any project that requires cross-vendor agent discovery via A2A. If your agents need to advertise capabilities and be discovered by agents you did not build, ADK's A2A support is the most mature.

4. LangGraph (LangChain)

LangGraph treats agents as state machines. Nodes are functions. Edges are transitions (conditional or unconditional). State is immutable and checkpointed after every step. This is the framework you reach for when your agent workflow has branches, retries, human approval gates, and needs to survive server restarts.

The persistence layer is the real differentiator. MemorySaver, SqliteSaver, and PostgresSaver checkpoint state after every node execution. If your agent crashes mid-workflow, it resumes from the last checkpoint. Time-travel debugging lets you roll back to any previous state and replay with different parameters. No other framework in this list offers comparable crash recovery out of the box.

Architecture

Directed acyclic graphs (or cyclic, if your workflow loops) with typed state that flows through nodes. Each node can modify state, call tools, or invoke sub-graphs. Conditional edges route based on state values. LangSmith provides observability with trace visualization, token tracking, and latency breakdowns.

Strengths

• Persistent checkpointing with automatic crash recovery
• Time-travel debugging: roll back and replay from any state
• Graph visualization for complex multi-step workflows
• Human-in-the-loop gates at any node (pause, wait for approval, resume)
• LangSmith observability with tracing, evaluation, and monitoring

Weaknesses

• Overkill for simple single-agent use cases
• Graph-based design requires more upfront architectural thinking
• LangChain dependency adds weight (you get the full abstraction stack)
• Debugging graph state transitions is harder than debugging linear code

When to use: Complex workflows with branching logic, retries, and human approval steps. Document review pipelines, multi-step research tasks, or any agent system where "what happens when it crashes at step 7 of 12" is a real concern. If you need checkpointing and recovery, LangGraph is the default choice.

5. CrewAI

CrewAI models multi-agent collaboration as a team. You define agents with roles, backstories, and goals, then assemble them into a crew with tasks. A Researcher agent gathers data. A Writer agent drafts content. A Reviewer agent checks quality. The metaphor is intuitive, and that is both its strength and its limitation.

At 52,400+ GitHub stars and roughly 5 million monthly downloads (27 million-plus on PyPI overall), CrewAI has the largest community among multi-agent frameworks. Version 1.14.6 (May 2026) ships native MCP support through crewai-tools[mcp] and A2A task delegation. The framework manages connection lifecycle, transport negotiation (Stdio, SSE, Streamable HTTPS), and tool discovery automatically.

Architecture

Role-based agents execute sequential or parallel tasks within a crew. The framework handles task dependency resolution: if Task B depends on Task A's output, CrewAI ensures execution order. A2A support allows agents in one crew to delegate to agents in another, which is useful when different teams maintain different agent systems.

Strengths

• Fastest setup: define agents with natural language role descriptions
• Native MCP and A2A protocol support
• 52,400+ GitHub stars, ~5M monthly downloads (largest community)
• Automatic task dependency resolution and execution ordering
• ~2 billion agent executions across the prior 12 months

Weaknesses

• Role-playing abstraction adds performance overhead (extra LLM calls for "staying in character")
• Less control over execution flow than graph-based alternatives
• Debugging multi-agent interactions is opaque (hard to trace why Agent A delegated to Agent B)
• Python only

When to use: Rapid prototyping of multi-agent workflows where the team metaphor maps naturally to your problem. Content generation pipelines, research teams, QA workflows. Avoid for latency-sensitive systems where the role-playing overhead matters.

6. Smolagents (Hugging Face)

Smolagents is the minimalist entry. The entire agent logic fits in roughly 1,000 lines of code (agents.py). The key insight: instead of generating JSON tool calls, CodeAgent writes Python code snippets that invoke tools directly. This approach reduces LLM calls by about 30% compared to standard tool-calling methods on complex benchmarks.

At 26,000+ GitHub stars with active commits through March 2026, Smolagents has grown fast. It is model-agnostic: local Transformers models, Ollama, OpenAI, Anthropic, and others via LiteLLM. For security, code execution runs in sandboxed environments through E2B, Modal, Docker, or Pyodide+Deno WebAssembly.

Architecture

Two agent types: CodeAgent (generates Python tool invocations) and ToolCallingAgent (uses standard function calling). CodeAgent is the default and the reason to choose Smolagents. The agent generates a code snippet, the framework executes it in a sandbox, captures the output, and feeds it back. Multi-agent support through agent hierarchies where a manager agent delegates to specialized sub-agents.

Strengths

• ~1,000 lines of core logic (easiest to understand and modify)
• Code-generating agents reduce LLM calls by ~30% vs tool-calling
• Model-agnostic: local models, cloud APIs, or any LiteLLM-supported provider
• Sandbox execution via E2B, Modal, Docker, or WebAssembly
• Free Hugging Face Agents course for onboarding

Weaknesses

• No built-in persistence or checkpointing
• Multi-agent capabilities are basic compared to CrewAI or LangGraph
• Code execution agents have a larger attack surface than tool-calling agents
• Python only

When to use: You want the simplest possible agent framework, prefer code generation over JSON tool calling, or need to run agents on open-source models locally. Research teams and prototypers who want to understand every line of agent logic. Not ideal for complex multi-agent orchestration.

7. Pydantic AI

Pydantic AI is not a multi-agent framework. It is a type-safe agent framework built by the Pydantic team, the same people whose validation library powers OpenAI, Anthropic, Google, and LangChain under the hood. The design philosophy mirrors FastAPI: type hints drive everything, and your IDE catches errors before runtime.

Three structured output methods: Tool Output (tool calls produce typed results), Native Output (model generates JSON matching a schema), and Prompted Output (schema injected into instructions, plain text parsed). Streamed structured output with immediate validation means you get typed data as it generates, not after.

Architecture

Single-agent by design. You define an agent with a system prompt, result type (a Pydantic model), and tools. The framework handles schema generation, validation, retries on malformed output, and streaming. No orchestration layer, no multi-agent primitives. If you need multi-agent, compose Pydantic AI agents manually or use it inside another framework.

Strengths

• Fully type-safe: IDE autocompletion and type checking catch errors at write-time
• Three structured output methods (tool, native, prompted) with automatic fallbacks
• Streamed structured output with real-time validation
• Model-agnostic: OpenAI, Anthropic, Gemini, Mistral, Ollama, Groq
• 16k+ GitHub stars, built by the Pydantic team (trusted validation layer)

Weaknesses

• No multi-agent orchestration (single-agent only)
• No MCP or A2A protocol support
• Python only
• Not suited for complex workflows (no state persistence, no graph execution)

When to use: You need reliable structured output from LLMs and type safety is a priority. Data extraction pipelines, form processing, classification tasks, or any use case where "the model must return data matching this exact schema" is the core requirement. Pair with LangGraph or CrewAI if you also need orchestration.

8. AutoGen / Microsoft Agent Framework

AutoGen pioneered the multi-agent conversation pattern: agents talk to each other in group chats, debate solutions, and reach consensus. A 4-agent debate with 5 rounds is 20 LLM calls minimum. That cost is the trade-off for AutoGen's unique strength: human-in-the-loop conversations where an agent can pause, ask a human for input, and resume.

The major 2026 development: Microsoft merged AutoGen and Semantic Kernel into the Microsoft Agent Framework. Release Candidate shipped February 19, 2026, and 1.0 GA shipped April 3, 2026 with stable APIs and a long-term-support commitment. AutoGen continues to receive bug fixes and security patches, but new features go into the unified framework. Greenfield projects should target Microsoft Agent Framework 1.0 directly.

Architecture

AutoGen v0.4 introduced an asynchronous, event-driven architecture with stronger observability. Agent Framework 1.0 keeps AutoGen's simple agent abstractions and adds Semantic Kernel's enterprise features (session-based state, type safety, middleware, telemetry, Azure AI integration), plus graph-based workflows and the orchestration patterns sequential, concurrent, handoff, group chat, and Magentic-One. It ships native MCP and A2A support across .NET and Python. Agents communicate through conversation turns with configurable termination conditions (max turns, keyword triggers, human approval).

Strengths

• Best human-in-the-loop support: agents pause for human input mid-conversation
• GroupChat pattern for multi-agent debate and consensus building
• Agent Framework 1.0 (GA April 3, 2026) merges AutoGen + Semantic Kernel
• Python and .NET support with native MCP and A2A (Azure ecosystem)
• Graph-based workflows plus sequential, concurrent, handoff, and Magentic-One patterns

Weaknesses

• Token cost: every agent turn in GroupChat is a full LLM call with accumulated history
• AutoGen is in maintenance mode (new features go to Microsoft Agent Framework 1.0)
• Existing AutoGen and Semantic Kernel projects still need a migration pass to 1.0
• Production deployment leans on the Azure ecosystem

When to use: Systems where agents need to deliberate, humans need to intervene mid-workflow, or you are already in the Microsoft/Azure ecosystem. Research applications where multi-agent debate produces better results than single-agent reasoning. Avoid for latency-sensitive pipelines where 20+ LLM calls per interaction is too expensive.

Protocol Layer: MCP, ACP, and A2A

Frameworks define how you build agents. Protocols define how agents connect to the outside world and to each other. Three protocols matter in 2026, and understanding the boundary between them prevents you from using the wrong tool for the wrong problem.

MCP (Model Context Protocol)

Created by Anthropic. MCP standardizes how AI models access tools, APIs, and data sources. JSON-RPC client-server interface with typed data exchange. Think of it as "USB for AI tools." Connect once, works everywhere that speaks MCP. Over 200 server implementations exist: GitHub, Slack, Google Drive, PostgreSQL, Notion, Jira, Salesforce, and more.

MCP handles vertical integration: application-to-model. It answers "how does my agent call this tool?" It does not answer "how do two agents talk to each other." MCP is stateless at the protocol level, though individual servers can implement their own state.

ACP (Agent Communication Protocol)

Developed by IBM Research as part of the BeeAI platform. ACP introduced REST-native messaging, multimodal agent communication, and asynchronous streaming for agent-to-agent coordination. Agents could discover each other, delegate tasks, and exchange information in a shared local environment.

In late 2025, the ACP team joined Google's A2A protocol under the Linux Foundation. The merger preserved ACP's RESTful simplicity while incorporating A2A's enterprise features. New projects should target A2A directly. ACP's contribution lives on in A2A's REST-native endpoints and multimodal message format.

A2A (Agent-to-Agent Protocol)

Google's protocol, now the unified standard for agent-to-agent communication under the Linux Foundation. A2A enables peer-to-peer task outsourcing through Agent Cards: JSON documents that describe an agent's identity, capabilities, skills, and authentication requirements. Any agent can discover any other agent by reading its Agent Card.

A2A handles horizontal integration: agent-to-agent. Three state management levels: session-level context, agent-level internal state, and task-level persistence through TaskStore. 50+ launch partners including Google, Salesforce, SAP, and others.

Which frameworks support which protocols?

MCP support is widespread. Claude Agent SDK has the deepest integration. CrewAI supports it natively via crewai-tools[mcp]. LangGraph integrates MCP servers as tools via adapters. Google ADK, Smolagents, and OpenAI products all have some level of MCP compatibility.

A2A support is narrower. Google ADK has native A2A with auto-generated Agent Cards. CrewAI added A2A task delegation in 2026. Most other frameworks have no A2A support yet. If cross-vendor agent interoperability matters to your architecture, this limits your choices to ADK or CrewAI.

Multi-Agent Patterns That Actually Ship

The 2026 multi-agent landscape organizes into four patterns. Each framework excels at one or two. None does all four well.

Anthropic's research found multi-agent architectures outperform single-agent benchmarks by up to 90% when parallel sub-agents are coordinated by a lead planner. Cognition measured that coding agents spend 60% of their time on search, not generation. These numbers argue for specialization: a search agent, a generation agent, and an orchestrator.

The pattern you choose determines your cost profile. Subagents are cheap (one LLM call per delegation). Conversations are expensive (N agents x M rounds). Handoffs land in the middle. Match the pattern to the problem, not the other way around.

When to Use Each Framework

Decision trees are more useful than feature matrices. Here is how to pick based on what you are actually building.

Running Open-Source Models Underneath the Framework

The framework routes intent. A model executes it. Most of the frameworks here (LangGraph, CrewAI, Smolagents, Pydantic AI) are model-agnostic, which means the bigger lever on agent cost and quality is the inference endpoint you point them at, not the orchestration library. For agents built on open-source models like DeepSeek, two things decide output quality: whether the provider quantizes, and whether the inference stack is tuned for code.

For coding agents specifically, Morph runs codegen-tuned speculative decoding plus custom low-level inference kernels built for code generation. These are not a general-purpose menu; they make Morph the fastest and highest-quality option for code agents in particular. morph-v3-fast applies code edits at ~10,500 tok/s.

Morph is framework-agnostic. Point Claude Agent SDK, LangGraph, CrewAI, or OpenAI Agents SDK at the endpoint and the API does not care which framework dispatched the request. See Models and Pricing for the full catalog.

FAQ

What is the best AI agent framework in 2026?

There is no single best. Claude Agent SDK for coding agents with deep OS access. OpenAI Agents SDK for lightweight handoff chains. Google ADK for multi-language enterprise systems. LangGraph for stateful workflows with persistence. CrewAI for rapid prototyping. Microsoft Agent Framework 1.0 (GA April 3, 2026) for .NET and Azure. The best framework is the one that matches your specific orchestration pattern and deployment constraints.

What AI agent frameworks were released or updated in 2026?

Microsoft Agent Framework reached RC on February 19, 2026 and 1.0 GA on April 3, 2026, unifying AutoGen and Semantic Kernel with native MCP and A2A. Google shipped ADK Java 1.0 and Go 1.0 in early 2026, giving it four language SDKs. CrewAI reached 1.14.6 (52.4k stars) by May 2026. Anthropic's Claude Agent SDK began drawing subscription usage from a separate monthly Agent SDK credit on June 15, 2026.

What are the core primitives of the Claude Agent SDK?

The core primitive is the async query() generator that you iterate for streamed messages. Built-in tools include Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch, and AskUserQuestion, scoped through allowedTools. Lifecycle hooks (PreToolUse, PostToolUse, Stop, SessionStart, SessionEnd, UserPromptSubmit) are in-process callbacks registered on options.hooks. Subagents are defined on options.agents with their own context window and tools, and MCP servers attach via options.mcpServers. See the primitive reference section above for the full schema, streaming, and isolation details.

What is the difference between MCP, ACP, and A2A?

MCP (Model Context Protocol) handles vertical integration: connecting AI models to tools and data sources via JSON-RPC. A2A (Agent-to-Agent Protocol) handles horizontal integration: agents discovering each other and delegating tasks via Agent Cards and REST endpoints. ACP (Agent Communication Protocol) was IBM's REST-native standard for agent communication that merged into A2A under the Linux Foundation in late 2025. Use MCP for tool access. Use A2A for agent-to-agent coordination.

Which AI agent frameworks support MCP?

Claude Agent SDK has the deepest MCP integration. CrewAI supports MCP natively. LangGraph and Google ADK integrate MCP via adapters. OpenAI adopted MCP across its products. Smolagents supports MCP tool servers. Most major frameworks have some MCP compatibility, but depth of integration varies significantly.

Should I use a provider-native SDK or an independent framework?

Provider-native SDKs (Claude, OpenAI, Google) offer tighter model integration and simpler setup but create vendor lock-in. Independent frameworks (LangGraph, CrewAI, Smolagents) give model flexibility but add abstraction layers. For production systems where you need to swap models, use an independent framework. For maximum integration depth with one provider, use their native SDK.

Is ACP still relevant after merging with A2A?

ACP as a standalone protocol is no longer actively developed. Its contributions (RESTful simplicity, multimodal messaging) live on inside the A2A specification. New projects should target A2A directly. If you built on ACP, the migration path to A2A preserves the REST patterns you were already using.

How do I choose between LangGraph and CrewAI?

LangGraph for complex workflows where you need persistence, checkpointing, crash recovery, and fine-grained control over execution flow. CrewAI for rapid prototyping where the team/role metaphor maps naturally to your problem. LangGraph requires more upfront design. CrewAI gets you to a working prototype faster. Many teams prototype in CrewAI and migrate to LangGraph for production.