AI Agent Frameworks Compared: Which Ones Ship?

Last month I needed to build a customer support agent. Voice calls, tool use, persistent memory, deployed to production within two weeks. I had nine frameworks to choose from and a spreadsheet with 47 rows of feature comparisons pulled from blog posts that all said "it depends."

It does depend. But not on what most comparison articles focus on.

After shipping agents with four of these frameworks across voice, chat, and API channels, I can tell you the real differentiator isn't GitHub stars or benchmark scores. It's this: how much of the system the framework actually handles, and how much you're still building yourself.

Every framework solves the conversation loop. The LLM thinks, calls tools, observes results, responds. That part works in all nine. What separates them is everything around that loop: how tools get managed, how memory persists across sessions, how you test before deploying, and how you know something broke at 2 AM on a Saturday.

This article compares nine frameworks across the criteria that actually matter for shipping. Not toy demos. Not "hello world" agents. Production systems that handle real users, real failures, and real money.

The nine frameworks that matter

There are dozens of agent libraries floating around in 2026. These nine have production traction, active maintenance, and enough community that you won't be debugging alone when something breaks.

LangGraph (Python/JS, 25K stars, 34.5M monthly downloads) is LangChain's graph-based orchestration layer. It models agent workflows as state machines with explicit nodes and edges. Uber, Klarna, LinkedIn, JPMorgan, and 400+ other companies run it in production. Klarna's AI assistant handles support for 85 million users, reducing resolution time by 80%. The learning curve is the steepest of any framework here, but the persistence, checkpointing, and LangSmith observability story is the most mature.

CrewAI (Python, 46K stars) uses a role-based abstraction. You define agents with backstories, goals, and tools, then organize them into crews that collaborate on tasks. It's the fastest path from idea to working prototype. Over 100,000 developers are certified through their community courses. Native MCP and A2A support shipped in v1.10.

Vercel AI SDK (TypeScript, now at v6) is the default for TypeScript teams building web applications with AI. Streaming, tool calling, and first-class React/Svelte/Vue/Angular integration. Version 6 added a proper Agent abstraction with stopWhen controls, tool approval flows, full MCP support, and DevTools. If your agent lives behind a web UI, this is probably where you start.

Mastra (TypeScript, 22K stars, 300K weekly npm downloads) comes from the team behind Gatsby. It graduated Y Combinator W25 with $13M in funding. A higher-level framework with built-in RAG, memory, workflows, and agent abstractions. Replit and WorkOS use it in production. If Vercel AI SDK is the engine, Mastra is the assembled car with seats and a dashboard.

OpenAI Agents SDK (Python, 19K stars) is the production evolution of Swarm. Four primitives: Agents, Handoffs, Guardrails, and Tools. The least opinionated framework here. It now supports 100+ models through the Chat Completions API, not just OpenAI, though tracing and Responses API features are optimized for OpenAI infrastructure.

Google ADK (Python, 17K stars) is Google's entry, optimized for Gemini but model-agnostic through LiteLLM. Strong on multi-agent collaboration with Workflow agents (Sequential, Parallel, Loop). Tightly integrated with Vertex AI, Cloud Run, and Cloud Trace. If your infrastructure is GCP, this eliminates weeks of plumbing.

Microsoft Agent Framework (Python/.NET, 28K stars as Semantic Kernel) merges AutoGen's conversational multi-agent patterns with Semantic Kernel's enterprise features. Release Candidate hit February 2026. Native A2A and MCP support, OpenTelemetry, Azure Monitor, Entra ID authentication. If you're an enterprise on Azure, this is Microsoft's answer.

Pydantic AI (Python, 16K stars) is the type-safety play. It leverages Python's type system and Pydantic's validation to catch agent logic errors at development time. Structured outputs, dependency injection, model-agnostic design. The "dark horse" of 2026, growing fast among teams that refuse to ship code that fails at runtime from type mismatches.

AutoGen (Python, 36K stars) pioneered conversational multi-agent systems. Agents debate and collaborate in group chats. It's being merged into Microsoft Agent Framework, so new projects should start there. Still useful for research and group decision-making scenarios, but expensive at scale: a 4-agent debate with 5 rounds burns 20+ LLM calls minimum.

The comparison table

This is the table I wish existed when I started. Every cell reflects the current stable release as of March 2026, not roadmap promises.

Three things jump out from this table.

Tool calling is commoditized. Every framework does it. The differentiation has moved to everything around tool calling: how you manage 50 tools across agents, how credentials rotate, how you test tool interactions before deploying. If you're wrestling with tool management, see what happens when you add the 20th tool.

MCP adoption is accelerating. Native support shipped in CrewAI, Vercel AI SDK, Mastra, and Microsoft Agent Framework within the last six months. The remaining frameworks have community adapters. Build your tools as MCP servers and they'll work everywhere.

Memory is the biggest gap. Only CrewAI, Mastra, and Google ADK ship genuine built-in memory. LangGraph has checkpointing (state persistence, not semantic memory). Everyone else says "manual," which means you're building a memory system from scratch. For what that involves, see AI agent memory: from session context to long-term knowledge.

Same agent, three frameworks

The best way to feel the difference is to build the same thing three times. Here's a customer lookup agent: it takes a name, finds the customer in a database, returns their account status. Identical task, three frameworks.

LangGraph (Python)

from langgraph.graph import StateGraph, END
from langchain_openai import ChatOpenAI
from langchain_core.tools import tool
from langchain_core.messages import ToolMessage
from typing import TypedDict, Annotated
import operator
 
class AgentState(TypedDict):
    messages: Annotated[list, operator.add]
 
@tool
def lookup_customer(name: str) -> str:
    """Look up a customer by name and return their account status."""
    customers = {"Alice": "active", "Bob": "past_due"}
    status = customers.get(name, "not_found")
    return f"Customer {name}: {status}"
 
model = ChatOpenAI(model="gpt-4o").bind_tools([lookup_customer])
 
def agent_node(state: AgentState):
    response = model.invoke(state["messages"])
    return {"messages": [response]}
 
def tool_node(state: AgentState):
    last = state["messages"][-1]
    results = []
    for call in last.tool_calls:
        result = lookup_customer.invoke(call["args"])
        results.append(ToolMessage(content=result, tool_call_id=call["id"]))
    return {"messages": results}
 
def should_continue(state: AgentState):
    last = state["messages"][-1]
    return "tools" if getattr(last, "tool_calls", None) else END
 
graph = StateGraph(AgentState)
graph.add_node("agent", agent_node)
graph.add_node("tools", tool_node)
graph.set_entry_point("agent")
graph.add_conditional_edges("agent", should_continue)
graph.add_edge("tools", "agent")
 
app = graph.compile()
result = app.invoke({"messages": [("user", "Look up Alice's account")]})

That's 37 lines. You define state, nodes, edges, and transitions explicitly. It's verbose, but every step of the agent's execution is visible and debuggable. You could add checkpointing with two more lines, persistence with four. When your agent breaks at step 12 of a 15-step workflow, you'll appreciate that explicitness.

Vercel AI SDK 6 (TypeScript)

import { openai } from "@ai-sdk/openai";
import { agent, tool } from "ai";
import { z } from "zod";
 
const lookupCustomer = tool({
  description: "Look up a customer by name and return their account status",
  parameters: z.object({ name: z.string() }),
  execute: async ({ name }) => {
    const customers: Record<string, string> = { Alice: "active", Bob: "past_due" };
    return `Customer ${name}: ${customers[name] ?? "not_found"}`;
  },
});
 
const result = await agent({
  model: openai("gpt-4o"),
  tools: { lookupCustomer },
  system: "You are a customer support agent. Look up accounts when asked.",
  prompt: "Look up Alice's account",
  maxSteps: 5,
});
 
console.log(result.text);

That's 20 lines. The agent() function handles the tool-calling loop internally. Zod validates tool inputs at compile time. Adding streaming to a React UI is one more hook: useChat(). The tradeoff is less visibility into the execution graph. When something goes wrong, you're debugging a black box.

CrewAI (Python)

from crewai import Agent, Task, Crew
from crewai.tools import tool
 
@tool
def lookup_customer(name: str) -> str:
    """Look up a customer by name and return their account status."""
    customers = {"Alice": "active", "Bob": "past_due"}
    return f"Customer {name}: {customers.get(name, 'not_found')}"
 
support_agent = Agent(
    role="Customer Support Specialist",
    goal="Look up customer accounts and report their status accurately",
    backstory="You are an experienced support agent with full access to customer records.",
    tools=[lookup_customer],
)
 
lookup_task = Task(
    description="Look up Alice's account status and report back.",
    expected_output="A clear statement of the customer's current account status.",
    agent=support_agent,
)
 
crew = Crew(agents=[support_agent], tasks=[lookup_task])
result = crew.kickoff()
print(result)

That's 22 lines. The character of the code is completely different. You're describing who the agent is (role, backstory, goal), not how it executes. CrewAI handles the tool loop internally. This abstraction feels like overkill for a single agent, but add a second agent that verifies the first one's work, and the role-based model clicks immediately.

What the code reveals

All three produce the same result. The differences surface when things get complicated:

LangGraph gives you the most control but demands you define every transition. When your agent needs branching based on tool results, retry logic on failure, or mid-conversation checkpointing, that explicitness pays off. The cost is boilerplate.

Vercel AI SDK optimizes for the web. Streaming tokens to a React component, handling tool approval in a dialog, managing conversation state across page reloads. If your agent's primary interface is a browser, nothing else comes close.

CrewAI optimizes for teams of agents. One agent here feels like using a sledgehammer on a nail. Three agents collaborating on a research task, each with a distinct role and goal, is where the model shines. The cost is opacity when agents miscommunicate.

Connected Integrations12 active

Salesforce

Slack

Google

Stripe

HubSpot

Intercom

Zapier

Shopify

GitHub

Jira

Gmail

PostgreSQL

The framework vs. infrastructure split

Here's the uncomfortable truth about every framework comparison, including this one: the framework handles maybe 30% of what you need for a production agent. The other 70% is infrastructure that exists outside the framework entirely.

The conversation loop is the solved problem. An LLM thinks, calls a tool, reads the result, decides what to do next. Every framework here does this well. The hard parts are everything that loop depends on.

Tool management. Your agent starts with 3 tools. Then 10. Then 30. Now the LLM picks the wrong one half the time, API keys need rotation, and a third-party endpoint that worked yesterday returns 500s today. For a deep dive into what breaks at scale, see your agent has 30 tools and no idea when to use them.

Memory. Your agent forgets who the customer is between sessions. Or it remembers too much and drags irrelevant context into every response. Memory needs to work across channels (voice, chat, API), survive framework upgrades, and handle privacy constraints like GDPR deletion requests.

Testing. You can't unit test a conversation. You need scenario-based testing: "Customer calls about a billing error, agent should look up the account, find the overcharge, and offer a refund." That requires test personas, expected behavior definitions, and automated scoring. No framework provides this. Scenario testing does.

Observability. Which tool calls are failing? What's the average response latency? Are customers getting stuck in loops? You need real-time monitoring that works regardless of which framework generated the conversation.

Prompt management. Your agent's system prompt changes weekly. You need versioning, A/B testing, rollback capability. Prompts are infrastructure, not framework config.

This is why the "which framework" question, while important, is only the first question. The second, harder question is: what handles everything the framework doesn't?

The decision flowchart

After shipping agents with multiple frameworks, here's how I'd narrow the field.

Start with your language. This eliminates half the options. TypeScript team? Your real choices are Vercel AI SDK and Mastra. Python? You're choosing between LangGraph, CrewAI, Pydantic AI, OpenAI Agents SDK, and Google ADK. .NET? Microsoft Agent Framework is your only serious option.

Then match complexity to abstraction.

For simple agents (single agent, a few tools, straightforward request-response): OpenAI Agents SDK or Vercel AI SDK. Minimal boilerplate, fast to ship.

For multi-agent systems (agents collaborating, delegating, routing to each other): CrewAI for rapid prototyping, LangGraph for production state machines. Or see multi-agent orchestration patterns for building your own.

For web applications with chat UIs: Vercel AI SDK. Nothing else comes close for streaming to React/Svelte/Vue with typed hooks and server rendering.

For enterprise on specific cloud platforms: Google ADK if GCP, Microsoft Agent Framework if Azure. The ecosystem integration saves weeks of wiring.

For type-safe, correctness-first Python teams: Pydantic AI. If your team already uses Pydantic for data validation and wants compile-time guarantees on agent behavior, this fits naturally.

How Chanl fits (regardless of framework)

Chanl isn't a framework. It doesn't replace LangGraph, Vercel AI SDK, or CrewAI. It's the infrastructure layer that sits underneath any framework, handling the 70% that frameworks don't.

Your framework handles the conversation loop. Chanl handles:

• Tools you manage, version, and monitor centrally, exposed to any agent via MCP
• Memory that persists across sessions, channels, and framework upgrades
• Scenarios that test your agent before you deploy, with AI personas simulating real customer behavior
• Monitoring that watches quality in production and alerts when something degrades

The integration is SDK calls, not framework lock-in:

import { ChanlClient } from "@chanl-ai/sdk";
 
const chanl = new ChanlClient({ apiKey: process.env.CHANL_API_KEY });
 
// Get agent config (works with any framework)
const agent = await chanl.agents.get("support-agent-id");
 
// List available tools (expose to any framework via MCP)
const tools = await chanl.tools.list({ agentId: agent.id });
 
// Run scenario tests before deploying (framework-agnostic)
const result = await chanl.scenarios.run("billing-dispute-scenario-id");
console.log(`Score: ${result.score}/100`);

The framework decides how your agent thinks. The infrastructure decides what it can do, how it gets tested, and how you know it's working. Pick any framework from this article. The infrastructure layer works the same way underneath all of them.

What to watch for the rest of 2026

Three trends are reshaping the framework landscape faster than any comparison table can capture.

MCP is becoming table stakes. Six months ago, MCP support was a differentiator. By mid-2026, frameworks without native MCP will feel incomplete. Build your tools as MCP servers now and you won't need to rebuild when you switch frameworks. For advanced patterns, see the MCP deep-dive on tool integration.

The framework layer is thinning. AI SDK 6's Agent abstraction is 20 lines to build what took 200 lines two years ago. As model providers add native multi-turn tool calling, streaming, and state management, the framework compresses toward thin wrappers around model APIs. The thick layer is shifting to infrastructure: testing, monitoring, memory, tool management.

Multi-agent is going mainstream, but most teams don't need it yet. Gartner reported a 1,445% surge in multi-agent system inquiries. But a single well-prompted agent with good tools outperforms a poorly designed three-agent crew. If you're considering multi-agent, read when to split a single agent into multiple before reaching for CrewAI's crew abstraction or LangGraph's graph nodes.

Wrapping up

The framework you pick matters less than you think and more than you'd hope. Less, because every framework solves the core conversation loop competently. More, because the choice cascades into your team's velocity, your debugging experience, and your operational overhead for years.

Pick based on three things: your language (TypeScript or Python), your complexity (single agent or multi-agent), and your deployment target (web UI, backend pipeline, or cloud platform). Then invest twice as much energy into the infrastructure around the framework: tools, memory, testing, monitoring. That's where production agents actually succeed or fail.

The conversation loop is the easy part. Everything else is the job.

Aprende IA Agéntica

Una lección por semana: técnicas prácticas para construir, probar y lanzar agentes IA. Desde ingeniería de prompts hasta monitoreo en producción. Aprende haciendo.

Subscribe

500+ ingenieros suscritos