Best AI Agent Frameworks in 2026

The Short Answer

For most teams the choice comes down to language and failure model. Choose LangGraph when an agent must survive crashes and wait for human approval, the OpenAI Agents SDK or Claude Agent SDK when you are committed to one model vendor and want the shortest path, Google ADK or Microsoft Agent Framework when your cloud or language (Go, Java, .NET) decides for you, and Pydantic AI or Mastra when type safety in Python or TypeScript matters most.

You face a crowded field: twelve serious open-source options, each with a different idea of what an “agent” is. This guide compares them on the same axes, uses GitHub numbers fetched on Nov 12, 2026, and says plainly where a claim could not be verified from the vendor's own pages. Frameworks are only the code layer; where the agent runs and how you trace it are covered in our agent hosting platforms and LLM observability and eval tools comparisons.

A third-party video walkthrough comparing OpenAI Agents SDK, CrewAI, LangGraph and AutoGen. It is not from the vendors, and its details may lag the releases below.

Quick Picks

“Best budget” is not a meaningful axis here. Every framework in this list is free to install, and the costs that matter are model tokens, hosting and any paid control plane. No price pages are quoted in this article, so check each vendor for the paid layers (LangSmith, CrewAI AMP, Agno AgentOS, Logfire) as of the day you buy.

Master Comparison Table

Stars and releases come from the GitHub API on Nov 12, 2026. For monorepos with several packages, the release shown is the main package. “Not stated” means the vendor page I fetched did not mention it, which is not the same as “unsupported”.

To install any of them, the commands below come straight from each project's README or docs.

# Install commands from each project's README or docs (as of Nov 12, 2026)
pip install -U langgraph                 # LangGraph
pip install openai-agents                # OpenAI Agents SDK (Python 3.10+)
pip install claude-agent-sdk             # Claude Agent SDK (Python 3.10+)
pip install google-adk                   # Google ADK (Python 3.11+)
uv tool install crewai                   # CrewAI CLI (Python >=3.10, <3.14)
pip install agent-framework              # Microsoft Agent Framework (Python)
uv add pydantic-ai                       # Pydantic AI
npm create mastra@latest                 # Mastra
pip install llama-index-core             # LlamaIndex core
pip install "smolagents[toolkit]"        # smolagents

How the Pieces Differ

Three design choices separate these frameworks more than any feature checklist. The first is who owns the loop. In the OpenAI Agents SDK, Claude Agent SDK, Pydantic AI and the Vercel AI SDK's ToolLoopAgent, the library runs a model-and-tools loop for you and you tune it with instructions, tools and guardrails. In LangGraph and the workflow layers of Microsoft Agent Framework and Mastra, you draw the control flow yourself and the model fills in steps. CrewAI and Google ADK sit between the two, offering role-based or hierarchical agents plus explicit workflow types.

The second is where state lives. A pure in-memory loop loses everything when the process dies. LangGraph checkpoints, Pydantic AI hands the run to Temporal or DBOS, Mastra suspends and resumes from storage, and Agno's AgentOS wraps agents as services with scheduling and approvals. If your agent runs for minutes and calls paid tools, pick a framework with a stated persistence story and test it by killing the process.

The third is protocol support. MCP (Model Context Protocol) lets an agent use external tools through a standard interface, and most frameworks here support it. A2A (agent-to-agent) is thinner: Google ADK documents it with quickstarts, and Microsoft Agent Framework lists it in hosting samples. If you plan to expose MCP servers to your agents, our guides to top MCP servers and best MCP servers for Claude Code (EN) list good starting points.

Maintainer type is a fourth, quieter factor. Four of the twelve come from model vendors (OpenAI, Anthropic, Google, Microsoft), and their roadmaps follow those vendors' models and clouds: expect the best support for their own models first, with other providers listed as supported. Three come from infrastructure or developer-tool companies (LangChain, Pydantic, Vercel), whose commercial products (LangSmith, Logfire, the AI Gateway) sit next to the open-source code. The rest are independent startups or communities (CrewAI, Mastra, Agno, LlamaIndex) or a research-oriented lab (Hugging Face for smolagents). None of this makes one group better. It tells you where the paid upsell is likely to appear and whose model gets the first-class integration.

It also helps to separate a framework from a harness. Several of the newer docs use the word. Microsoft Agent Framework includes a Harness Agent with planning and todo tracking, context compaction and tool approval; Pydantic AI has a Harness with SubAgents; the Claude Agent SDK is described as Claude Code packaged as a library, and Mastra's scaffold creates a harness with a local workspace, shell tools, memory and scheduled tasks. A harness is an opinionated agent you configure, while a framework gives you parts to assemble. If your goal is a coding or research agent that works on long tasks, a harness saves weeks. If your goal is a bespoke business process with fixed steps, a graph or workflow layer is the better fit.

LangGraph

LangGraph describes itself as a low-level orchestration framework and runtime for long-running, stateful agents. You model a workflow as a graph of shared state, nodes and edges, and you can mix deterministic steps with LLM-driven ones in the same graph. It does not prescribe prompts or an agent architecture. The docs place LangChain as the higher-level agent framework, with LangGraph as the runtime underneath and Deep Agents as a harness built on top.

Strengths. Durable execution is a headline capability: state is saved at checkpoints so a run can resume after a failure or a pause. You can inspect and edit state mid-run, stream tokens and state updates, and keep both short-term thread memory and longer-term memory across sessions. LangSmith adds tracing, evaluation and managed deployment around it.

Weaknesses. A graph is more code than a prebuilt loop, and you decide the architecture. The overview page does not cover multi-agent patterns or MCP, so confirm those in the linked docs. Reaching for LangGraph on a single-tool chatbot is overkill.

# Excerpt from the LangGraph overview docs (a minimal graph)
graph = StateGraph(MessagesState)
graph.add_node(mock_llm)
graph.add_edge(START, "mock_llm")

If you are weighing the observability side of the LangChain ecosystem, our LangSmith BYOC on AWS guide (EN) covers self-hosted tracing.

OpenAI Agents SDK

The OpenAI Agents SDK keeps its surface small: agents (an LLM with instructions and tools), handoffs and agents-as-tools for delegation, guardrails that run in parallel with the agent, sessions for conversation history, human-in-the-loop hooks and built-in tracing. Newer additions include sandbox agents that work inside an isolated container with resumable sessions, plus realtime and voice agents. It uses the Responses API by default for OpenAI models.

Strengths. The four-line hello world below is the shortest in this comparison. Function tools get automatic schema generation with Pydantic validation, remote MCP tools sit alongside them, and tracing is built in with links to OpenAI's evaluation and fine-tuning tools.

Weaknesses. The docs page I fetched does not describe a workflow-engine style of durable execution; sessions and resumable sandbox state are the closest features. Provider neutrality is only briefly mentioned, so a multi-vendor model strategy needs testing. For a deeper walkthrough of sandboxes and memory, see our OpenAI Agents SDK sandbox, memory and coding guide (EN).

from agents import Agent, Runner

agent = Agent(name="Assistant", instructions="You are a helpful assistant")

result = Runner.run_sync(agent, "Write a haiku about recursion in programming.")
print(result.final_output)

Claude Agent SDK

The Claude Agent SDK packages the agent loop, tools and context management that power Claude Code as a library for Python and TypeScript. Anthropic's docs list built-in tools (read, write and edit files, run commands, search the web), hooks, subagents, MCP, permissions, sessions you can resume or fork, skills and plugins. The Python package bundles the Claude Code CLI, so there is no separate install.

Strengths. You get a production-tested toolset and a permission model out of the box, so a code-fixing agent needs very little glue. Custom tools can be exposed as in-process MCP servers, and hooks let you block an action such as a risky Bash command before it runs.

Weaknesses. It is built around Claude, and Anthropic states it does not allow third-party developers to offer claude.ai login or rate limits for their products unless previously approved; use API key authentication. The docs I fetched do not name a tracing backend or durable workflow engine. For where it fits among coding tools, see best AI coding agents 2026 (EN).

import anyio
from claude_agent_sdk import query

async def main():
    async for message in query(prompt="What is 2 + 2?"):
        print(message)

anyio.run(main)

Google ADK

Agent Development Kit is Google's open-source framework. Its docs list Python, TypeScript, Go, Java and Kotlin, which is the widest language range in this comparison. Multi-agent systems are composed as hierarchies, and workflow agents come as sequential, loop and parallel templates. The docs cover sessions, state, memory, an A2A section with quickstarts for exposing and consuming agents, and MCP tools, including exposing an agent as an MCP server.

Strengths. Documented A2A and MCP, built-in evaluation through adk eval, Cloud Trace integration on Google Cloud, and a model list that includes Gemini, Gemma, Claude, OpenAI, Ollama, vLLM and LiteLLM. Weaknesses. The deepest tooling assumes Google Cloud, and non-Python SDKs have separate repositories with their own release cadence (the JS repo had 1,477 stars on Nov 12, 2026).

from google.adk import Agent

root_agent = Agent(
    name="greeting_agent",
    model="gemini-3.5-flash",
    instruction="You are a helpful assistant. Greet the user warmly.",
)

CrewAI

CrewAI organizes work around Crews, teams of role-based agents that delegate to each other, and Flows, event-driven workflows with state, conditional branching and decorators such as @start(), @listen() and @router(). The README presents Crews running as steps inside Flows as the framework's main strength. It is the most-starred repository in this comparison at 60,803.

Strengths. The Crew, Agent and Task vocabulary is quick to read, the CLI scaffolds a project (crewai create crew <name>), and the README lists MCP/A2A support alongside memory, knowledge and checkpointing. Weaknesses. Observability beyond logs sits in the paid control plane; the open-source framework sends anonymous telemetry that you can disable with OTEL_SDK_DISABLED=true. The README gives no detail on how MCP or A2A are configured, so verify against the docs.

Microsoft Agent Framework

Microsoft Agent Framework is described by Microsoft as the direct successor to Semantic Kernel and AutoGen, created by the same teams. It combines AutoGen's agent abstractions with Semantic Kernel's enterprise features (session state, type safety, middleware, telemetry) and adds graph-based workflows. The overview lists agents, a harness agent for long multi-step tasks, workflows and integrations, with model providers including Microsoft Foundry, Anthropic, Azure OpenAI, OpenAI and Ollama.

Strengths. Sequential, concurrent, handoff and group orchestration; checkpointing, streaming, human-in-the-loop and time-travel; built-in OpenTelemetry; MCP clients; A2A in hosting samples; and migration guides from both predecessors. Weaknesses. The Go SDK is a preview that does not implement declarative agents, CodeAct or functional workflows, and the snippets assume a Foundry project. Microsoft also warns that third-party systems you connect are used at your own risk. See our Microsoft Agent Framework and GitHub Copilot guide (EN) for a hands-on build.

from agent_framework import Agent
from agent_framework.foundry import FoundryChatClient
from azure.identity import AzureCliCredential

agent = Agent(
    client=FoundryChatClient(
        project_endpoint="https://your-foundry-service.services.ai.azure.com/api/projects/your-foundry-project",
        model="gpt-5.4-mini",
        credential=AzureCliCredential(),
    ),
    name="HelloAgent",
    instructions="You are a friendly assistant. Keep your answers brief.",
)

result = await agent.run("What is the largest city in France?")
print(f"Agent: {result}")

Pydantic AI

Pydantic AI brings the Pydantic validation model to agents: you declare an output_type and the framework validates the model's answer against it, with tools registered by decorator. Its docs describe MCP as a built-in capability, human-in-the-loop tool approval, Pydantic Evals for grading outputs and tool-call trajectories, and Pydantic Graph for typed graph control flow when one agent loop is not enough.

Strengths. The widest list of durable-execution integrations here, typed outputs, a Harness with SubAgents, and instrumentation that works with any OTLP backend. Weaknesses. Python only, and the docs pages I fetched do not mention A2A. The example below uses the model string exactly as the README shows it.

from typing import Literal

from pydantic import BaseModel, Field

from pydantic_ai import Agent, RunContext


class Sentiment(BaseModel):
    label: Literal['positive', 'negative', 'neutral']
    score: float = Field(ge=-1, le=1)


agent = Agent('openai:gpt-6.1-sol', output_type=Sentiment)


@agent.tool
def recent_reviews(ctx: RunContext, product: str) -> list[str]:
    """Fetch recent review snippets for a product."""
    return ['The new release fixed everything I complained about!']


result = agent.run_sync('How are people feeling about the Extract app?')
print(result.output)

Mastra

Mastra is a TypeScript framework for agents and apps. Agents are defined with an id, instructions and a provider/model string, tools use createTool() with zod schemas, and a Mastra instance registers everything. The README lists graph workflows (.then(), .branch(), .parallel()), memory including Observational Memory, MCP server authoring, evals, built-in observability and suspend/resume with state kept in storage.

Strengths. One package covers agents, workflows, memory and evals, plus a Studio UI and framework guides. Weaknesses. The dual license needs a read before you use anything under ee/; the docs pages I fetched do not mention A2A.

// From the Mastra quickstart: call a registered agent
const agent = mastra.getAgentById('weather-agent')
const response = await agent.generate('Weather in SF')
console.log(response.text)

LlamaIndex Workflows and Agents

LlamaIndex began as a data and retrieval framework and now describes itself as an open-source framework for agentic applications. Prebuilt agents such as FunctionAgent take plain Python functions as tools, using their names, docstrings and type hints, and the docs describe AgentWorkflow as an agent that manages multiple agents. Document-focused products (LlamaParse, Extract, Index) live on a separate platform.

Strengths. Deep retrieval and integration coverage, with separate guides for MCP tools, state and observability. Weaknesses. The release cadence is slower than its peers (last release Sep 21, 2026 as of the fetch), and the pages I fetched did not detail multi-agent patterns, durable state or MCP, so check the linked guides. For the retrieval layer itself, see best vector databases for AI agents.

# Abridged from the LlamaIndex agents tutorial
llm = OpenAI(model="gpt-4o-mini")

workflow = FunctionAgent(
    tools=[multiply, add],
    llm=llm,
    system_prompt="You are an agent that can perform basic mathematical operations using tools.",
)

response = await workflow.run(user_msg="What is 20+(2*4)?")
print(response)

Vercel AI SDK

The AI SDK is a TypeScript toolkit whose agent entry point is ToolLoopAgent, which manages the loop, message context and stopping conditions. Models are addressed by a provider/model string. For durable, long-running agents the docs point to eve, an open-source framework built on the AI SDK that runs on Vercel or self-hosted.

Strengths. It is the lightest TypeScript option and sits close to UI streaming. Weaknesses. It is a toolkit, so state, durability and multi-agent orchestration are things you assemble or take from eve. The agents overview I fetched does not describe MCP support, so verify it in the MCP docs. If you route model traffic through Vercel, see our Vercel AI Gateway guide (EN).

// Excerpt from the AI SDK agents overview
const weatherAgent = new ToolLoopAgent({
  model: "anthropic/claude-sonnet-5.5",
  // ...tools and instructions
});

const result = await weatherAgent.generate({
  prompt: 'What is the weather in San Francisco in celsius?',
});

Agno

Agno pairs an agent library (agents, teams, workflows, memory, knowledge) with AgentOS, a runtime that serves agents as durable services with an API, authentication, role-based access, human approvals and scheduling. The README says AgentOS includes a built-in MCP server so agents can be used from Claude and ChatGPT.

Strengths. Teams that delegate, workflows with routing, loops and parallel steps, and tracing of runs and tool calls. Weaknesses. The README shows no hello-world snippet and I found no A2A mention, so I do not include code here rather than invent it.

smolagents

Hugging Face's smolagents is deliberately small. Its CodeAgent writes its actions as Python code, so a tool call becomes a function call. Tools can come from any MCP server, agents can form hierarchies, and tools and agents can be shared through the Hugging Face Hub. Code can run in sandboxes such as E2B, Blaxel, Modal or Docker; the README says the built-in LocalPythonExecutor is not a security sandbox.

Strengths. Minimal abstractions and a readable codebase. Weaknesses. The latest release is about five months old as of Nov 12, 2026, the README does not mention tracing, and it does not state a durability story. Executing model-written code demands a real sandbox; our best AI agent sandboxes comparison covers the options.

from smolagents import CodeAgent, WebSearchTool, InferenceClientModel

model = InferenceClientModel()
agent = CodeAgent(tools=[WebSearchTool()], model=model, stream_outputs=True)

agent.run("How many seconds would it take for a leopard at full speed to run through Pont des Arts?")

Production Checklist

The frameworks differ in syntax, but the failures that hurt in production are the same across all of them. This checklist is our own engineering advice, not a vendor claim, and each item maps to a feature the vendors document so you can check it before you commit.

Two habits pay off across every framework. First, keep the number of tools small and their descriptions precise, because every framework here (LlamaIndex says so explicitly) relies on tool names, docstrings and type hints for the model to pick the right one. Second, write an evaluation set before you tune prompts. Pydantic Evals, adk eval and LangSmith evals all exist for this, and our observability and eval comparison goes deeper on the tooling.

Security deserves its own line. An agent with shell, file or browser tools is a remote-code-execution surface driven by text. Run it with the least privilege that works, keep secrets out of the model's context, and use the permission systems the frameworks provide rather than a prompt that says “do not delete files”. If the agent executes generated code, follow the sandbox guidance in our sandboxes comparison.

Switching and Migration Notes

Frameworks in this space move fast, so plan for the possibility that you will change. A few facts make that cheaper. Microsoft's overview names Agent Framework as the direct successor to both Semantic Kernel and AutoGen and links migration guides for each, so teams on either should read those guides rather than start from scratch. LangChain's docs describe LangGraph as the runtime beneath LangChain agents and Deep Agents, which means moving from a high-level LangChain agent down to LangGraph is a change of abstraction level, not of ecosystem.

Google ADK states it works with almost any generative AI model, and Pydantic AI lets you swap models with a string, so the model layer is the easiest part to change in both. The hard part to move is anything stateful: checkpoints, sessions and memory stores are framework-specific, and a migration usually means replaying or abandoning in-flight runs. Keep your tools behind plain functions or MCP servers, since MCP is supported by most of the frameworks above, and your tool code survives a framework change with little edit.

Finally, pick a unit of change. If you are unsure between two frameworks, build one agent in each and keep the evaluation set the same. If the deciding factor is the language your team already writes, take that as a tie-breaker: Mastra and the Vercel AI SDK for TypeScript, Microsoft Agent Framework for .NET, Google ADK for Go, Java or Kotlin, and the Python-first group (LangGraph, Pydantic AI, CrewAI, LlamaIndex, Agno, smolagents) for everyone else. Choosing a framework your team can read at 2 a.m. matters more than a marginal feature difference.

Benchmarks and Independent Data

There is no neutral, widely accepted benchmark that ranks agent frameworks. Public leaderboards such as SWE-bench or GAIA measure a model plus its scaffold, so a framework result mixes model quality, prompts and tool design. I found no head-to-head benchmark from a neutral party that holds the model constant, and I did not run one. Treat any article that declares a framework “fastest” or “most accurate” without a reproducible harness as opinion.

The one independent signal I can offer is adoption data, which is public and dated. As of Nov 12, 2026 the GitHub star order is CrewAI (60,803), LlamaIndex (52,882), LangGraph (44,838), Agno (43,166), OpenAI Agents SDK Python (30,632), smolagents (30,327), Mastra (29,480), Vercel AI SDK (27,882), Google ADK Python (22,187), Pydantic AI (21,160), Microsoft Agent Framework (14,643) and Claude Agent SDK Python (8,528). Stars measure attention, not quality, and repositories of different ages are not comparable. Release recency is a better health signal: most repositories shipped within the last four weeks, while LlamaIndex (Sep 21) and smolagents (May 29) are quieter.

How to Choose

A practical way to decide is to build the same small task in your top two candidates: one tool call, one structured output, one forced crash mid-run. The framework whose recovery story you understand after an afternoon is usually the right one. Then choose where it runs from our agent hosting platforms guide, and decide how the agent remembers things with the agent memory tools comparison.

Common mistakes when picking a framework

The first mistake is choosing by star count. CrewAI leads this list with 60,803 stars, yet a stateful approval workflow may fit LangGraph or Microsoft Agent Framework better, and Claude Agent SDK (8,528) and Microsoft Agent Framework (14,643) have far fewer stars but are actively released. The second is treating a hello-world snippet as a proof of fit. Every snippet above runs a single model call; none of them demonstrates recovery, approvals or tracing, which are where the frameworks actually differ.

The third is ignoring terms and licenses. Most projects here are MIT or Apache-2.0, but Mastra's ee/ directories need a production license, and the Claude Agent SDK is governed by Anthropic's Commercial Terms of Service. The fourth is expecting one framework to do everything. A common, sensible stack uses one framework for the agent loop, a separate vector store or memory layer, an MCP server for tools, and an observability backend, each swappable. Keeping those seams clean is what makes a later migration survivable.

How We Evaluated

Stars, licenses and releases come from the GitHub API on Nov 12, 2026. Feature claims come from each project's README and official documentation, fetched the same day. Where a page did not mention a feature, the table says “not stated” instead of guessing. I did not run each framework in production, so strengths and weaknesses reflect documented capabilities, not load testing. Code snippets are taken or abridged from official pages, and the install commands appear exactly as published. There is no paid placement and no affiliate link in this ranking. Everything here is dated to Nov 12, 2026 and will drift; versions in particular change weekly.

FAQ

Sources

All fetched on Nov 12, 2026.

• GitHub REST API: stars, licenses and releases for the 15 repositories compared
• LangGraph README and LangGraph overview docs
• OpenAI Agents SDK docs and README
• Claude Agent SDK overview and Python README
• Google ADK docs and README
• CrewAI README
• Microsoft Agent Framework overview and README
• Pydantic AI overview and README
• Mastra docs and README and LICENSE.md
• LlamaIndex agents tutorial and README
• Vercel AI SDK agents overview and repository
• Agno README
• smolagents README
• YouTube: AI Agent Frameworks Explained (S3CloudHub)