12 Best AI Agent Frameworks in 2026, Compared for Production

Last updated October 11, 2026. Licenses, release dates, GitHub stars, package downloads, hosting options, and prices were checked against each project’s repository, documentation, and pricing page on that date.

Building an agent demo takes an afternoon in any framework. Choosing the one your team will still trust after a year of production traffic is the harder call.

AI agent frameworks are libraries that run the model and tool loop for you, keep state between steps, and coordinate several agents when one is not enough. This guide compares 12 of them for production use on language, license, multi-agent model, durability, OpenTelemetry, MCP support, and managed hosting.

AgentStack is an independent publication for teams that build and run agents, and this guide anchors our Agent Frameworks hub. No vendor paid for placement or reviewed this page, per our editorial standards and disclosure policy.

LangGraph is the default for teams that need long-running, stateful control, and the cloud vendor SDKs win when your stack already lives on that cloud. The right choice also depends on your language: TypeScript teams should look at Mastra and the Vercel AI SDK first, and .NET teams at Microsoft Agent Framework.

The 12 Best AI Agent Frameworks at a Glance

The 12 best AI agent frameworks for production in 2026 are LangGraph, Microsoft Agent Framework, Google ADK, the OpenAI Agents SDK, the Claude Agent SDK, Strands Agents, CrewAI, Agno, Pydantic AI, LlamaIndex, Mastra, and the Vercel AI SDK. The table compares them on the eight questions a platform team asks before committing.

Framework	Language	License	Multi-agent model	State and durability	Observability and OTel	MCP support	Managed hosting	Best fit
LangGraph	Python, TypeScript	MIT	Graph nodes, supervisor and subagent patterns	Native checkpointers with durable execution	LangSmith native; OTel through LangSmith	Client through LangChain MCP adapters	LangSmith Deployment	Long-running, stateful agents
Microsoft Agent Framework	Python, .NET (Go in a separate repo)	MIT	Graph workflows: sequential, concurrent, handoff, group	Workflow checkpoints and time travel	Native OpenTelemetry	Client, plus A2A	Foundry Hosted Agents	Azure and .NET enterprises
Google ADK	Python, TypeScript, Go, Java, Kotlin	Apache 2.0	Agent hierarchies, graph workflows, A2A	Sessions and resumable workflows	Native OpenTelemetry	MCP tools	Agent Runtime, Cloud Run, GKE	Google Cloud and polyglot teams
OpenAI Agents SDK	Python, TypeScript	MIT	Handoffs and agents as tools	Sessions; durability through Temporal, Restate, DBOS, or Dapr	Built-in OpenAI tracing; 30+ external processors	Hosted, Streamable HTTP, SSE, and stdio	None for the SDK; you host it	Lean multi-agent apps
Claude Agent SDK	Python, TypeScript	Anthropic Commercial Terms (Python repo MIT)	Subagents	Sessions with resume and fork; file checkpointing	OpenTelemetry export	stdio, HTTP/SSE, in-process servers	Claude Managed Agents (separate product)	Agents that work on files, code, and shells
Strands Agents	Python, TypeScript	Apache 2.0	Agents as tools, swarm, graph, A2A	Session management	Native OpenTelemetry	MCP tools	Amazon Bedrock AgentCore, Lambda, Fargate	AWS teams
CrewAI	Python	MIT	Role-based crews plus event-driven flows	Flow state and checkpointing	Tracing; OTel on CrewAI AMP	stdio, SSE, Streamable HTTP	CrewAI AMP	Role-based business automation
Agno	Python	Apache 2.0	Teams and workflows	Sessions and memory in your own database	OpenTelemetry in AgentOS	MCP tools; AgentOS serves MCP	Self-hosted AgentOS plus paid control plane	Teams that want to own the runtime
Pydantic AI	Python	MIT	Delegation, subagents, Pydantic Graph	Durability through Temporal, DBOS, Prefect, or Restate	Native OpenTelemetry	Client and server	None for agents; Logfire for traces	Type-safe Python services
LlamaIndex	Python	MIT	AgentWorkflow handoffs and orchestrator agents	Event-driven Agent Workflows	Instrumentation module with integrations	MCP tools; workflows exportable as MCP	LlamaCloud	Document-heavy agents
Mastra	TypeScript	Apache 2.0 core; enterprise license for ee/ folders	Supervisor agents	Workflows that suspend and resume from storage	Built-in tracing; OTel exporter	Client and server authoring	Mastra Platform	TypeScript product teams
Vercel AI SDK	TypeScript	Apache 2.0	Tool loop agent with subagents	Durability through the Workflow SDK	OpenTelemetry through @ai-sdk/otel	Client through @ai-sdk/mcp	Vercel platform	Web apps adding agents

Choose LangGraph when an agent runs for minutes or hours, needs human approval mid-run, and must resume after a crash. Choose a cloud vendor SDK when your data, identity, and deployment already sit on Azure, Google Cloud, or AWS. Choose Mastra or the Vercel AI SDK when your product team writes TypeScript. No framework here replaces an observability tool and an eval suite, which you still need on top.

What Is an AI Agent Framework, and Do You Need One?

An AI agent framework is a library that runs the loop in which a language model picks a tool, the code executes it, and the result goes back to the model until the task is done. Production frameworks add saved state, retries, human approval, multi-agent coordination, and tracing, which a hand-written loop has to rebuild one bug at a time.

Framework, SDK, or platform

The labels blur in vendor marketing, so this guide uses three terms consistently. The distinction matters at procurement time, because the library is usually free and the platform is where the bill starts.

Term	What it is	Examples in this guide
Framework or SDK	An open library you import and run inside your own service	LangGraph, CrewAI, Pydantic AI, Mastra
Managed runtime	A hosted service that runs, scales, and persists agents built with a framework	LangSmith Deployment, Foundry Hosted Agents, Amazon Bedrock AgentCore, CrewAI AMP
Agent harness	A preassembled agent with file, shell, planning, and memory tools already wired in	Claude Agent SDK, Strands harness, Pydantic AI Harness, Deep Agents

A plain model API call is still the right tool for a single prompt with one or two function calls. Reach for a framework once an agent needs more than one tool call per request, state that survives a restart, or a second agent.

How We Chose These 12 Frameworks

We started from the frameworks named in top-ranking comparison pages and practitioner threads, then kept the ones with active releases in the last 30 days, public documentation, and real adoption in package downloads. Each profile rests on the project’s own repository, documentation, and pricing page, all reviewed on October 11, 2026.

1. Maintenance: every framework here shipped a release between September 21 and October 9, 2026, according to GitHub releases.
2. Adoption: GitHub stars plus last-month downloads from PyPI and npm.
3. Production features: saved state, durable execution, human approval, and multi-agent coordination.
4. Portability: native OpenTelemetry, MCP tool support, and model choice beyond one vendor.
5. Deployment path: what you can self-host, and what a managed runtime costs.
6. License: what the code license allows, and where commercial terms apply.

Framework	GitHub stars	Package downloads, last month	Latest release checked
LangGraph	43,057	44.8M PyPI (langgraph); 16.2M npm (@langchain/langgraph)	1.2.14, October 6, 2026
Strands Agents	8,765 (harness-sdk monorepo)	37.1M PyPI (strands-agents); 2.3M npm	Python 1.59.0, October 8, 2026
Claude Agent SDK	8,248 (Python repo)	29.8M PyPI; 51.7M npm	Python 0.2.165, October 8, 2026
OpenAI Agents SDK	29,963 (Python repo)	12.4M PyPI; 9.0M npm (@openai/agents)	0.23.1, October 2, 2026
Google ADK	21,776 (Python repo)	10.1M PyPI; 1.2M npm (@google/adk)	2.11.0, October 2, 2026
Pydantic AI	20,546	5.4M PyPI	2.55.0, October 9, 2026
LlamaIndex	52,463	2.9M PyPI (llama-index)	0.14.25, September 21, 2026
CrewAI	59,560	2.4M PyPI	1.15.27, October 9, 2026
Agno	42,663	1.8M PyPI	3.1.2, October 8, 2026
Microsoft Agent Framework	14,054	1.0M PyPI (agent-framework-core)	Python 1.21.0, October 8, 2026
Mastra	28,701	8.3M npm (@mastra/core)	@mastra/core 1.75.0, October 7, 2026
Vercel AI SDK	27,239	125.4M npm (ai)	ai 7.0.137, October 9, 2026

This is a documentation, repository, and pricing review, and we did not run hands-on benchmarks for this edition. The Vercel AI SDK figure covers every use of its general AI toolkit, so it overstates agent use, and Strands Agents and the Claude Agent SDK pull high numbers partly through other tools that depend on them.

What Changed in 2026: AutoGen, LangGraph Platform, and the Harness Turn

Three shifts reshaped the framework market between October 2025 and October 2026: Microsoft folded AutoGen and Semantic Kernel into Microsoft Agent Framework, LangChain renamed its hosting product, and several vendors started shipping preassembled agent harnesses alongside their libraries. Most comparison pages that rank today still predate at least one of these changes.

Change	What happened	What it means for buyers
AutoGen	README marks it as in maintenance mode, community managed, with no new features; last push April 15, 2026	Start new projects on Microsoft Agent Framework, and use the official migration guide for existing AutoGen code
Microsoft Agent Framework 1.0	Reached 1.0 for .NET and Python on April 3, 2026, after a February release candidate	Stable APIs with a long-term support commitment, combining Semantic Kernel foundations with AutoGen orchestration
LangGraph Platform	Renamed LangSmith Deployment, and LangGraph Studio renamed LangSmith Studio, in the week of October 13, 2025	Same deployments, APIs, pricing, and contracts; search and procurement documents may still use the old name
Strands Agents	The SDK repo moved into the strands-agents/harness-sdk monorepo, next to a new Strands harness	Its 8,765 stars understate its reach, so compare Strands on its 37.1 million monthly PyPI installs
LlamaIndex	README says the company’s primary focus has shifted to LlamaParse document processing	The open framework remains available, but weigh roadmap priority before betting a core agent on it
Mastra agent networks	Deprecated in favor of supervisor agents	New Mastra multi-agent code should use supervisor agents

The harness turn is the newest trend. Anthropic’s Claude Agent SDK, the Strands harness, Pydantic AI Harness, and LangChain’s Deep Agents all ship an agent with file access, shell, planning, and context management already assembled, so teams start from a working agent instead of an empty loop.

Production Orchestrators: LangGraph, Microsoft Agent Framework, and Google ADK

Graph orchestrators model an agent as nodes and edges with saved state between steps, which gives engineers explicit control over branching, retries, and human approval. LangGraph, Microsoft Agent Framework, and Google ADK all take this approach, and each one pairs it with a managed runtime from its parent company.

1. LangGraph

Verdict: LangGraph is the strongest default for long-running, stateful agents that need human approval and crash recovery in production.

LangGraph is LangChain’s MIT-licensed, low-level orchestration framework for stateful agents, available in Python and TypeScript. It was the most downloaded framework on PyPI among the 12 we checked, at 44.8 million installs in the last month.

Its durable execution saves a checkpoint after each step, so a run that fails or pauses for approval resumes where it stopped. For a faster start, LangChain’s Deep Agents package (30,118 stars) builds a planning agent with subagents and a file system on top of LangGraph.

Key features

• Checkpointers for durable execution, interrupts for human approval, and time travel through saved state.
• Short-term and long-term memory stores.
• Multi-agent patterns, including supervisor and subagent designs, documented in the LangChain multi-agent guide.
• MCP client support through LangChain’s MCP integration, which is marked beta from langchain 1.4.0.

Pricing and license

• The LangGraph library is free under the MIT license.
• LangSmith Plus costs $39 per seat per month and includes one free small serverless deployment.
• Extra deployments are metered in LangChain Standard Units at $1.00 each, by compute and memory used; Enterprise adds hybrid and self-hosted options.

Prices come from LangSmith pricing. Managed hosting is LangSmith Deployment, formerly LangGraph Platform.

Pros and cons

Pros

• The most mature checkpointing and resume model among the 12.
• Large ecosystem across Python and TypeScript, with LangSmith tracing ready to use.

Cons

• A low-level graph API means more code than higher-level frameworks for simple agents.
• OpenTelemetry export runs through LangSmith, so the smoothest path keeps you on LangChain’s stack.

2. Microsoft Agent Framework

Verdict: Microsoft Agent Framework is the clear pick for .NET shops and Azure enterprises, and the official successor for AutoGen and Semantic Kernel users.

Microsoft Agent Framework is an MIT-licensed framework for agents and multi-agent workflows in Python and .NET, with a Go SDK in a separate repository. Microsoft announced version 1.0 on April 3, 2026, with stable APIs and a long-term support commitment.

Its graph workflows support checkpoints, streaming, human approval, and time travel, and it ships first-party connectors for Microsoft Foundry, Azure OpenAI, OpenAI, Anthropic Claude, Amazon Bedrock, Google Gemini, and Ollama.

Key features

• Sequential, concurrent, handoff, and group collaboration orchestration patterns.
• Built-in OpenTelemetry observability across Python and .NET.
• MCP and A2A support for tools and cross-framework agents.
• Middleware hooks for content safety, logging, and compliance policies, plus YAML declarative agents.

Pricing and license

• The framework is free under the MIT license.
• Foundry Hosted Agents run on Microsoft Foundry, billed through Azure.
• We found no single public list price for Foundry hosting of framework agents, so model and compute costs follow your Azure agreement.

License and features come from the GitHub repository and the 1.0 announcement. AutoGen users can follow the AutoGen migration guide.

Pros and cons

Pros

• First-class .NET support, which most other frameworks here lack.
• Native OpenTelemetry and checkpointing in the same package.

Cons

• The 1.0 line is six months old, so third-party tutorials and integrations are thinner than LangGraph’s.
• The smoothest hosting path assumes Azure and Microsoft Foundry.

3. Google Agent Development Kit (ADK)

Verdict: Google ADK fits Google Cloud teams and polyglot organizations, since it is the only framework here with official Python, TypeScript, Go, Java, and Kotlin SDKs.

Google Agent Development Kit is an Apache 2.0, code-first framework that is optimized for Gemini but works with other models, including Claude, OpenAI, and local models through Ollama or vLLM. ADK 2.0 added a graph workflow runtime with routing, fan-out, loops, retries, and human input.

Agents deploy to Agent Runtime on Google Agent Platform, Cloud Run, GKE, or any container host. ADK also speaks A2A for calling agents built in other frameworks.

Key features

• Graph workflows plus sequential, parallel, and loop template workflows.
• A Task API for structured agent-to-agent delegation.
• MCP tools, OpenAPI tools, and a tool confirmation flow for human approval.
• OpenTelemetry tracing, documented in the ADK observability guide.

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.",
)

That hello agent comes from the ADK README. The same file can grow into a graph workflow without changing frameworks.

Pricing and license

• ADK is free under the Apache 2.0 license.
• Agent Runtime, Cloud Run, and GKE bill at Google Cloud rates.
• ADK has no separate license fee or paid tier of its own.

License and deployment options come from the ADK repository and deployment docs.

Pros and cons

Pros

• Five official language SDKs.
• A2A and MCP support make it a good hub for mixed-framework estates.

Cons

• The deepest integrations favor Gemini and Google Cloud.
• Google’s hosting product names changed during 2026, so older guides may point to Vertex AI Agent Engine.

Model Vendor SDKs: OpenAI, Anthropic, and AWS Strands

Model vendor SDKs trade graph control for a small API: you define agents, tools, and handoffs, and the SDK runs the loop. The OpenAI Agents SDK, the Claude Agent SDK, and AWS’s Strands Agents are the three most downloaded of this type, and each fits best on its maker’s models or cloud.

4. OpenAI Agents SDK

Verdict: The OpenAI Agents SDK is the lightest path to multi-agent apps with handoffs, guardrails, and tracing, especially for teams already on OpenAI models.

The OpenAI Agents SDK is an MIT-licensed framework in Python and TypeScript. It works with the OpenAI Responses and Chat Completions APIs and, according to its README, more than 100 other models.

Its tracing is on by default and sends runs to OpenAI’s Traces dashboard. Tracing is unavailable for organizations under a Zero Data Retention policy, and the docs list more than 30 external tracing processors, including Langfuse, LangSmith, Braintrust, and Datadog.

Key features

• Handoffs and agents as tools for delegation.
• Input and output guardrails, human approval, and sessions backed by SQLite, Redis, or SQLAlchemy.
• Durable execution integrations with Temporal, Restate, DBOS, and Dapr.
• MCP support for hosted, Streamable HTTP, SSE, and stdio servers, plus sandbox, realtime, and voice agents.

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)

That example comes from the SDK README. Add tools, handoffs, or guardrails as arguments to the same Agent object.

Pricing and license

• The SDK is free under the MIT license.
• You pay for model usage at your provider’s API rates.
• There is no managed runtime for SDK agents, so you host them yourself.

License and features come from the GitHub repository and the SDK documentation.

Pros and cons

Pros

• A small API that a new engineer can learn in a day.
• Tracing works on day one without extra setup.

Cons

• Durability depends on adding Temporal, Restate, DBOS, or Dapr.
• Default tracing goes to OpenAI, so regulated teams need to configure processors or switch it off.

5. Claude Agent SDK

Verdict: The Claude Agent SDK is the fastest way to ship agents that read files, run commands, and edit code, as long as you are committed to Claude models.

The Claude Agent SDK packages the agent loop, built-in tools, and context management behind Claude Code as a Python and TypeScript library. The SDK runs the Claude Code binary, which the Python package bundles.

Use is governed by Anthropic’s Commercial Terms of Service, according to the overview page. The Python repository carries an MIT license, while the TypeScript repository license points to the Commercial Terms.

Key features

• Built-in tools for files, shell commands, and web search, with a permission system for approvals.
• Hooks, subagents, skills, and plugins loaded the same way as in Claude Code.
• Sessions you can resume or fork, plus file checkpointing to rewind changes.
• MCP servers over stdio, HTTP, or SSE, in-process SDK servers, and OpenTelemetry export.

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)

That quick start comes from the Python SDK README. Options such as allowed tools and the working directory go into ClaudeAgentOptions.

Pricing and license

• The SDK has no license fee; you pay for Claude API tokens.
• Anthropic’s hosting guide estimates a minimal container at roughly $0.05 per hour and says token cost usually dominates.
• Claude Managed Agents is a separate, Anthropic-hosted harness for teams that do not want to run containers.

Costs and the subprocess model come from the Agent SDK hosting guide.

Pros and cons

Pros

• A working agent with file and shell tools from the first line of code.
• Strong permission and hook controls for risky tools.

Cons

• Runs Claude models only.
• Each session needs a container or sandbox with the CLI, which is heavier than a library call.

6. Strands Agents

Verdict: Strands Agents is the natural choice for AWS teams that want a model-driven agent loop with OpenTelemetry tracing and a direct path to Amazon Bedrock AgentCore.

Strands Agents is an Apache 2.0 SDK for Python and TypeScript from AWS. It runs in your own process with no hosted control plane and works with Amazon Bedrock, Anthropic, OpenAI, Gemini, and other providers.

The project now lives in the strands-agents/harness-sdk monorepo, which also holds the Strands harness, a preassembled agent. The strands-agents package had 37.1 million PyPI downloads in the last month.

Key features

• Lifecycle controls such as turn limits, token budgets, cancellation, and stop reasons.
• Multi-agent patterns: agents as tools, swarm, graph, and A2A.
• Native OpenTelemetry traces, plus metrics, logs, and an evals SDK.
• MCP tools, session management, guardrails, and structured output.

from strands import Agent
from strands_tools import calculator

agent = Agent(tools=[calculator])
agent("What is the square root of 1764")

That example comes from the Strands README. Its docs cover configuring Amazon Bedrock, Anthropic, OpenAI, Gemini, Ollama, and other providers.

Pricing and license

• Strands is free under the Apache 2.0 license.
• Deployment targets include Amazon Bedrock AgentCore, Lambda, Fargate, App Runner, EKS, and EC2, each billed at AWS rates.
• There is no Strands license tier.

License and features come from the Strands repository.

Pros and cons

Pros

• Native OpenTelemetry and evals in one SDK.
• Many documented AWS deployment targets.

Cons

• Older tutorials point to the previous sdk-python repo path, which now redirects to the monorepo.
• Durable execution beyond sessions needs an external workflow engine.

Multi-Agent and Runtime Frameworks: CrewAI and Agno

CrewAI and Agno package agents together with a runtime and a control plane, so a team gets orchestration, storage, and an admin UI from one vendor. CrewAI organizes work as role-based crews, while Agno positions itself as the runtime for a company’s own agent platform.

7. CrewAI

Verdict: CrewAI is the quickest way to model a business process as a team of role-based agents, with a commercial control plane for enterprises that want one.

CrewAI is an MIT-licensed Python framework with two layers: Crews, which assign roles, goals, and tools to collaborating agents, and Flows, which add event-driven control and state. It has 59,560 GitHub stars, the most of any active framework in this list.

CrewAI collects anonymous usage telemetry by default, according to its README, and teams can switch it off by setting OTEL_SDK_DISABLED to true. Prompts, task content, and tool data are not collected unless the share_crew feature is turned on.

Key features

• Role-based crews plus Flows for deterministic steps.
• Checkpointing, memory, guardrails, and human input.
• MCP servers as tools over stdio, SSE, and Streamable HTTP.
• Tracing and OpenTelemetry in the CrewAI AMP control plane.

Pricing and license

• The framework is free under the MIT license.
• CrewAI AMP Basic is free with 50 workflow executions per month.
• Enterprise is custom priced, with SSO, RBAC, PII redaction, and deployment to CrewAI cloud, your VPC, or your own infrastructure.

Prices come from CrewAI pricing.

Pros and cons

Pros

• The most readable abstraction for business stakeholders.
• Large community and course material.

Cons

• Autonomous crews are harder to make deterministic than explicit graphs.
• Telemetry is on by default and must be disabled for strict environments.

8. Agno

Verdict: Agno suits teams that want to own a full agent platform, with serving, storage, tracing, and access control in their own cloud.

Agno is an Apache 2.0 Python framework paired with AgentOS, a runtime that serves agents over a REST API with more than 50 endpoints and stores sessions, memory, and traces in your own database.

Agents can work alone, in teams, or in workflows. AgentOS also exposes agents over MCP, A2A, AG-UI, Slack, and other interfaces.

Key features

• OpenTelemetry tracing, run history, and audit logs inside AgentOS.
• JWT-based RBAC with multi-user and multi-tenant isolation.
• Human approval steps and cron scheduling without extra infrastructure.
• More than 100 prebuilt toolkits and deploy templates for Docker, AWS, GCP, Azure, and others.

Pricing and license

• The SDK and AgentOS runtime are free and open source.
• The Pro control plane costs $150 per month with one live AgentOS connection and three seats.
• Extra seats cost $30 per month, extra live connections $95 per month, and SAML SSO $300 per month; Enterprise is custom.

Prices come from Agno pricing.

Pros and cons

Pros

• Data stays in your database, with no per-event metering.
• Production API, auth, and tracing included.

Cons

• A larger surface area than a plain library, so the platform is part of the commitment.
• Python only.

Typed and Data-Centric Python: Pydantic AI and LlamaIndex

Pydantic AI and LlamaIndex serve Python teams with specific strengths: Pydantic AI brings type-checked inputs, outputs, and tools to agent code, and LlamaIndex brings document retrieval and parsing. Both are open source under MIT, and both rely on partner tools for some production jobs.

9. Pydantic AI

Verdict: Pydantic AI is the best fit for Python teams that want type-safe agents, any model, and plain OpenTelemetry, with durability supplied by a workflow engine they already trust.

Pydantic AI is an MIT-licensed agent framework from the team behind Pydantic. Structured outputs and tool arguments are validated with Pydantic models, and switching models is a one-string change.

For long-running work, its durable execution integrations cover Temporal, DBOS, Prefect, Restate, and AWS Lambda. Its instrumentation is plain OpenTelemetry, so traces go to Logfire or any OTel backend.

Key features

• Typed outputs, dependencies, and tools checked by static type checkers.
• Subagents, planning, memory, and guardrails through Pydantic AI Harness capabilities.
• MCP client and server support, plus Pydantic Graph for explicit control flow.
• Pydantic Evals for testing agent behavior.

Pricing and license

• Pydantic AI is free under the MIT license.
• Logfire Personal is free up to 10 million telemetry records per month.
• Logfire Team costs $49 per month with 10 million records included and $2 per million after.

Prices come from Pydantic pricing.

Pros and cons

Pros

• The best type safety in Python agent code.
• Vendor-neutral OpenTelemetry and broad durable execution options.

Cons

• No managed agent runtime of its own.
• Durability requires running a separate engine such as Temporal or DBOS.

10. LlamaIndex

Verdict: LlamaIndex is the strongest choice when an agent’s main job is reading, parsing, and extracting from documents.

LlamaIndex is an MIT-licensed Python framework for retrieval and agent applications with more than 300 integration packages. Its Agent Workflows provide event-driven orchestration with branching, parallel steps, human review, durability, and observability.

The company’s README says its primary focus has shifted to LlamaParse, its document platform. The open framework remains available, which makes LlamaIndex strongest for document agents and less obvious as a general orchestration bet.

Key features

• Multi-agent patterns: AgentWorkflow handoffs, orchestrator agents, and custom planners.
• MCP tools, and conversion of workflows and tools into MCP servers.
• The llamactl CLI for local development and deployment to LlamaCloud or self-hosting.
• Deep integrations for parsing, indexing, and vector stores.

Pricing and license

• The framework is free under the MIT license.
• LlamaCloud Free includes 10,000 credits; Starter costs $50 per month and Pro $500 per month.
• LlamaCloud credits cost $1.25 per 1,000, with Enterprise custom.

Prices come from LlamaIndex pricing.

Pros and cons

Pros

• The deepest document parsing and retrieval tooling here.
• Mature ecosystem of integrations.

Cons

• Company focus now centers on LlamaParse.
• Less native production tooling for general agents than LangGraph or Microsoft Agent Framework.

TypeScript Frameworks: Mastra and the Vercel AI SDK

TypeScript teams have two strong options in 2026: Mastra, a full agent framework with workflows, memory, evals, and observability, and the Vercel AI SDK, a provider-neutral toolkit with an agent loop that most Next.js teams already install. Both are Apache 2.0 licensed at the core.

11. Mastra

Verdict: Mastra is the most complete agent framework for TypeScript teams that want workflows, memory, evals, and tracing in one package.

Mastra is a TypeScript framework for agents and workflows that plugs into React, Next.js, and Node or runs as a standalone server. Code outside ee/ folders is Apache 2.0, and enterprise features under ee/ use a separate license, per its license file.

Workflows suspend for human approval and resume from storage, and multi-agent work runs through supervisor agents now that agent networks are deprecated.

Key features

• Model routing across more than 40 providers through one interface.
• Graph workflows with then, branch, and parallel steps, plus suspend and resume.
• Observational memory, RAG, built-in evals, and MCP client and server authoring.
• Built-in tracing with an OpenTelemetry exporter.

Pricing and license

• The framework core is free under Apache 2.0.
• Mastra Platform Starter is free with 100,000 observability events and 24 CPU hours per month.
• Teams costs $250 per month with 1 million events and 250 CPU hours; Enterprise is custom, including licensed self-hosted features.

Prices come from Mastra pricing.

Pros and cons

Pros

• A full stack for TypeScript, from workflows to evals.
• Strong npm adoption, at 8.3 million downloads last month.

Cons

• Enterprise features sit under a non-Apache license.
• API churn: agent networks were deprecated within the 1.x line.

12. Vercel AI SDK

Verdict: The Vercel AI SDK is the right base for web product teams adding agents to an existing Next.js or Node app, with durability added through the Workflow SDK.

The Vercel AI SDK is an Apache 2.0 TypeScript toolkit for model calls, structured output, streaming UI, and agents. Its ToolLoopAgent class runs the tool loop with stopping conditions, runtime context, and tool approvals.

The package named ai had 125.4 million npm downloads last month, the highest in this guide, though that count covers every AI feature built with it. For runs that must survive restarts, Vercel’s Workflow SDK makes TypeScript functions durable.

Key features

• Subagents that take context-heavy tasks off the main agent.
• MCP client through @ai-sdk/mcp, with HTTP transport recommended for production.
• OpenTelemetry spans through the @ai-sdk/otel package.
• UI hooks for React, Svelte, and Vue.

Pricing and license

• The SDK is free under the Apache 2.0 license.
• By default it routes model calls through Vercel AI Gateway, and direct provider packages are also supported.
• Hosting on Vercel follows Vercel’s platform pricing, and self-hosting on any Node runtime is possible.

License and features come from the GitHub repository and AI SDK docs.

Pros and cons

Pros

• Already in many web stacks, so adding an agent adds no new framework.
• Excellent streaming UI support.

Cons

• A toolkit first, so multi-agent orchestration is lighter than in Mastra or LangGraph.
• Durability requires adopting the separate Workflow SDK.

Frameworks we considered but did not profile

AutoGen (61,350 stars) is in maintenance mode, and Semantic Kernel (28,643 stars) now describes itself as Microsoft Agent Framework, its successor. Deep Agents appears inside the LangGraph profile. DSPy, smolagents, Haystack, and AG2 are active open-source projects, but each is narrower or less production-focused for this pillar’s audience.

Production Readiness Compared: Durability, Telemetry, and Hosting

Three questions separate a production framework from a demo framework: can a run resume after a crash, can its traces flow to any OpenTelemetry backend, and is there a supported place to host it. LangGraph, Microsoft Agent Framework, and Google ADK come closest to answering all three with a managed runtime from the same vendor.

Framework	Resume after a crash	Native OpenTelemetry	Managed runtime and entry price
LangGraph	Native checkpoints	Through LangSmith	LangSmith Plus, $39 per seat per month
Microsoft Agent Framework	Native checkpoints	Yes	Foundry Hosted Agents, Azure rates
Google ADK	Resumable runs and workflows	Yes	Agent Runtime, Google Cloud rates
OpenAI Agents SDK	Through Temporal, Restate, DBOS, or Dapr	External processors	Self-host
Claude Agent SDK	Session resume and file checkpoints	Yes	Claude Managed Agents, separate product
Strands Agents	Sessions; external engine for durability	Yes	Amazon Bedrock AgentCore, AWS rates
CrewAI	Checkpointing	On CrewAI AMP	AMP Basic free; Enterprise custom
Agno	Sessions in your database	Yes, in AgentOS	Self-host free; control plane $150 per month
Pydantic AI	Through Temporal, DBOS, Prefect, or Restate	Yes	Self-host; Logfire from free
LlamaIndex	Agent Workflows durability	Through instrumentation integrations	LlamaCloud, from free
Mastra	Suspend and resume from storage	Exporter	Mastra Platform, from free
Vercel AI SDK	Through the Workflow SDK	Yes, @ai-sdk/otel	Vercel platform pricing

Telemetry portability decides your observability options later. Frameworks with native OpenTelemetry can send the same spans to Langfuse, Arize Phoenix, Datadog, or any other backend covered in our guide to AI agent observability tools, without a rewrite.

Which AI Agent Framework Should Your Team Use?

Match the framework to your language, your cloud, and how long your agents run. A team’s existing stack usually narrows 12 options to two or three within an hour, and a one-week prototype of the same agent on the finalists settles the rest.

Startups shipping a first agent

Start with the OpenAI Agents SDK or Pydantic AI for a single product agent, and move to LangGraph once runs need approvals or resume. Pair either with an open-source tracing tool from our AgentOps stack so early traces are not locked to one vendor.

Enterprises on Azure and .NET

Use Microsoft Agent Framework, and plan AutoGen and Semantic Kernel migrations now, since Microsoft names Agent Framework as the successor to both and AutoGen receives no new features. Foundry Hosted Agents keeps identity, networking, and billing inside your Azure agreement.

Teams on Google Cloud or AWS

Google Cloud teams should start with Google ADK and Agent Runtime, and AWS teams with Strands Agents and Amazon Bedrock AgentCore. Both SDKs work with other model providers, so the cloud choice does not lock the model choice.

TypeScript product teams

Choose Mastra when agents are a core product feature with workflows and evals, and the Vercel AI SDK when you are adding an agent to an existing web app. LangGraph.js remains an option when the backend team already runs LangGraph in Python.

Regulated and data-sensitive enterprises

Favor frameworks with native OpenTelemetry and self-hosting, such as Microsoft Agent Framework, Agno, Pydantic AI, and LangGraph with self-hosted LangSmith on Enterprise. Disable default telemetry in the OpenAI Agents SDK and CrewAI unless your policy allows it.

Frequently Asked Questions About AI Agent Frameworks

The Bottom Line: Choose for Durability and Portability

Pick the framework that matches your language and cloud, then confirm it can resume a failed run and emit OpenTelemetry before you commit. LangGraph is the safest general default for stateful agents, Microsoft Agent Framework for Azure and .NET, and Mastra for TypeScript. Recheck status every quarter, since 2026 retired AutoGen and renamed LangGraph Platform within a single year.

We update this guide quarterly, and maintainers can send corrections through our contact page. Once an agent is running, our map of AgentOps tools covers the tracing, evals, gateways, and guardrails that sit around any framework.

Related guides: the AgentOps tools map, the 12 best AI agent observability tools, and Langfuse vs LangSmith vs Braintrust.