Skip to content

Framework Comparison

How the frameworks covered in these guides differ: languages, multi-agent models, state and human approval, integrations, and which one to pick for which job.

This page compares the frameworks the site covers, so you can choose one before you read its guide. Everything about a package below was checked against the release listed in the first table; where a claim is about a design choice rather than a feature, it is worded as one.

It does not rank frameworks by popularity. Star counts and download numbers change daily, say little about whether a library fits your problem, and cannot be checked from a page that is only rebuilt when the guides are. The two maintenance facts that do matter for choosing are in the table notes: Microsoft AutoGen is archived, and LlamaIndex.TS is deprecated upstream.

FrameworkLanguagesBest forCurrent version
SmolAgentsPythonSmall agents that write code, quick prototypes1.26.0
AgnoPythonAgents, teams and workflows served over HTTP with AgentOS3.2.0
PydanticAIPythonValidated, typed outputs and dependency injection2.68.0
OpenAI Agents SDKPython, TypeScriptHandoffs, guardrails, sessions and tracingPy 0.24.0 · TS 0.22.0
CrewAIPythonRole-based crews and event-driven Flows1.15.41
AG2PythonAsync agents, typed events, a multi-agent Network, MCP and A2A1.3.2
Microsoft AutoGen (archived)Python, .NETExisting AutoGen 0.4 to 0.7 code only0.7.5
LangGraphPython, TypeScriptStateful graphs with loops, checkpoints and interruptsPy 1.2.22 · TS 1.7.4
LlamaIndexPython, TypeScript (deprecated)Retrieval over your own data, event-driven workflowsPy 0.14.26 · TS 0.12.1
HaystackPythonPipelines for retrieval and search, with agents3.5.0
Strands AgentsPython, TypeScriptA model-driven agent loop, from AWS, on any providerPy 1.64.0 · TS 1.24.0
Amazon Bedrock Agents and AgentCorePython, TypeScriptManaged agents and hosting on AWSAgentCore 1.26.0
Microsoft Agent FrameworkPython, .NET, GoAzure and Microsoft stacks; the successor to Semantic Kernel agents and AutoGenPy 1.26.0 · .NET 1.28.0 · Go 0.3.1
Semantic KernelPython, .NETExisting Semantic Kernel applications, plugin-based designPy 1.45.0 · .NET 1.81.0
Google ADKPython, TypeScript, GoGemini and Google CloudPy 2.13.0 · TS 2.4.0 · Go 1.9.0
Claude Agent SDKPython, TypeScriptAgents built on Claude Code’s agent loopPy 0.2.183 · TS 0.3.326
Mistral Agents APIPython, TypeScriptHosted agents on Mistral’s platformPy 3.8.0 · TS 3.5.0

Versions checked against PyPI, npm, NuGet and the Go module proxy on 2026-11-19. The source of truth is src/data/versions.json.

Two notes on the table:

  • AutoGen and AG2 are different projects. See AG2 and Microsoft AutoGen below.
  • LlamaIndex.TS is deprecated upstream. The npm packages @llamaindex/workflow-core and its siblings carry a deprecation notice, and the final releases still install. The Python library is actively released. For new TypeScript projects the LlamaIndex TypeScript guide recommends another framework.

SmolAgents (from Hugging Face) is small enough to read in an afternoon. Its default CodeAgent has the model write Python that calls your tools, rather than emitting JSON tool calls; a ToolCallingAgent is available when you want conventional tool calls. Multi-agent setups use managed_agents: an agent you list there is exposed to the parent as a callable tool.

  • Choose it for: learning how agents work, quick prototypes, tasks that benefit from the model composing several tool calls in one piece of code.
  • Weigh against: it has no checkpoint store, graph engine or approval flow, so long-running or audited workloads need that built around it. Because the model writes code, run it in a sandboxed executor for anything untrusted (see the production guide).

Agno has agents, teams of agents and step-based workflows that share one run interface, and AgentOS, a FastAPI runtime that serves them. Sessions, memory and knowledge are backed by a database you choose, and there are built-in guardrails and an approval decorator for tools.

  • Choose it for: a Python service that needs agents with persistent sessions and memory, a knowledge base and an HTTP API, without assembling those parts from separate libraries.
  • Weigh against: Python only, and a larger surface than the minimal libraries; MCP support and OpenTelemetry export are optional extras.

PydanticAI is built around typed outputs: you give an agent an output_type, and the result is validated against it, with the model asked to retry on validation failure. Tools receive typed dependencies, and graphs (pydantic_graph) are available for explicit control flow. Durable execution wrappers exist for Temporal, DBOS and Prefect.

  • Choose it for: services where the shape of the model’s output matters, and teams that already use Pydantic and type checking.
  • Weigh against: multi-agent work is done by calling one agent from another’s tool; there is no handoff primitive.

A small set of primitives: Agent, Runner, handoffs, guardrails, sessions and tracing. Agents hand a conversation to one another through handoffs, or are called as tools with Agent.as_tool(). Tools can require approval, and an interrupted run can be serialised and resumed. A TypeScript SDK mirrors the primitives.

  • Choose it for: customer-service-style routing between specialists, and for teams who want guardrails and tracing without extra services.
  • Weigh against: it is designed around OpenAI’s API; other providers are supported through adapters (LiteLLM and any-llm extensions) with the usual caveat that features differ by provider. There is no graph engine.

CrewAI offers two models. A Crew is a set of role-defined agents working through tasks, sequentially or under a manager (Process.sequential, Process.hierarchical). Flows are event-driven workflows built from @start, @listen and @router methods, which can contain crews. Tasks can validate output with guardrails, return Pydantic models, ask for human input, and crews can be checkpointed and resumed.

  • Choose it for: pipelines that read naturally as a team (researcher, writer, reviewer) and need a declarative setup.
  • Weigh against: the role-and-backstory abstraction is convenient but adds prompt text you do not fully control; for fine-grained control flow use Flows or a graph library.

These are two separate projects with a shared ancestor.

  • AG2 is a community fork of AutoGen 0.2, started in November 2024 by AutoGen’s original authors. AG2 1.0 (PyPI release 27 July 2026) replaced the AutoGen-era API: pip install ag2 now installs an async framework imported as ag2, with Agent, @tool, typed events and a multi-agent Network. The old import autogen API (ConversableAgent, GroupChat) continues as AG2 Classic, published on PyPI as autogen and in maintenance mode.
  • Microsoft AutoGen is the 0.4 rewrite (autogen-agentchat, autogen-core, autogen-ext; imports autogen_agentchat and so on) that Microsoft develops separately. Its last release is 0.7.5 (30 September 2025), Microsoft moved it to maintenance mode when it launched Microsoft Agent Framework, and the repository is archived. The pyautogen name on PyPI is a proxy for Microsoft’s autogen-agentchat, not for AG2.

Practical consequences: older AutoGen tutorials may describe either project, so check the import line (import autogen is the AG2 Classic or 0.2 API; autogen_agentchat is Microsoft’s). For new work on Microsoft’s stack use Microsoft Agent Framework; for AG2 use the AG2 guide, and see AG2 Classic for existing import autogen code. The AutoGen guide covers Microsoft’s archived project and has a timeline of how the two diverged.

  • Choose AG2 for: multi-agent designs where routing between agents should be explicit and inspectable (a hub with channels and a transition graph), typed events you can test against, and MCP or A2A interoperability.
  • Weigh against: 1.x is not a drop-in upgrade from Classic, and it is Python only.

LangGraph models a program as a graph of nodes over shared state. Edges can be conditional, loops are allowed, Send fans work out in parallel, and Command lets a node update state and choose the next node. With a checkpointer, every step is saved per thread, which enables resuming, time travel and interrupt() for human approval. A TypeScript version has the same model.

  • Choose it for: workflows with loops, branching, long-running state or human review in the middle.
  • Weigh against: it is the most explicit option, so simple agents take more code. MCP client support comes from a separate package (langchain-mcp-adapters), and tracing is through LangSmith or your own callbacks.

LlamaIndex’s core strength is retrieval: loaders, node parsers, indexes, retrievers, query engines and a large set of vector store integrations. Agents are built on event-driven Workflows; AgentWorkflow runs several agents with can_handoff_to rules between them.

  • Choose it for: applications whose main job is answering from your own documents.
  • Weigh against: many integration packages with their own versions, and, in TypeScript, deprecation (see above).

Haystack builds applications from components wired into pipelines, which are graphs that may contain loops and can be paused at a breakpoint and resumed from a snapshot. Retrieval components, document stores and rankers are in the core package. An Agent component handles tool-calling loops, and AgentTool lets one agent be used as a tool by another.

  • Choose it for: search and question-answering systems where the pipeline structure should be explicit and serialisable.
  • Weigh against: many components (including OpenTelemetry and Datadog tracing, web search and Hugging Face models) live in separate integration packages, so check what you need is installed.

Strands, from AWS, runs a model-driven loop: you give the model a prompt and tools, and it decides the steps. It is not tied to AWS: model providers include Bedrock, Anthropic, OpenAI, Gemini, Mistral, Ollama, LiteLLM and others. Multi-agent patterns are agents-as-tools, a Swarm and a Graph; there are session managers (file and S3), interrupts for human input, structured output, MCP and OpenTelemetry in the core package, and A2A support. Python and TypeScript SDKs exist.

  • Choose it for: a small, readable agent loop that fits AWS deployment (see the Bedrock and AgentCore guide) but is not locked to it.
  • Weigh against: the default model provider is Bedrock, so you need AWS credentials unless you configure another provider; retrieval tools come from the separate strands-agents-tools package.
  • Amazon Bedrock Agents and AgentCore: managed agent hosting, memory, gateway and identity on AWS. Pair it with Strands or another framework for the agent code.
  • Microsoft Agent Framework: Microsoft’s agent SDK for Python, .NET and Go, combining Semantic Kernel’s enterprise foundations with AutoGen’s multi-agent patterns, with graph workflows, checkpointing, A2A and OpenTelemetry. The core is stable in Python and .NET; Go is in preview.
  • Semantic Kernel: Microsoft’s plugin-oriented SDK for Python and .NET. New agent work on Microsoft’s stack should look at Agent Framework first; Semantic Kernel remains relevant for existing applications.
  • Google ADK: Gemini-first agents with Python, TypeScript and Go SDKs.
  • Claude Agent SDK: the Claude Code agent loop as a library: built-in tools, subagents, hooks, permissions and file checkpointing. It runs agents that use a computer (files, shell, web) more than it orchestrates workflows.
  • Mistral Agents API: agents and conversations stored on Mistral’s platform, with built-in tools, MCP connectors and handoffs. State lives on the server.

The tables cover the ten general-purpose Python frameworks. Cells describe what is in the package at the version listed above, using the names you will find in the code. “Extra” means an optional install extra of the same package; “separate package” means a different distribution you must also install. A dash means the package does not provide it, not that it cannot be built.

All ten stream model output and tool results as the run progresses.

FrameworkMulti-agent modelExplicit workflow or graph
SmolAgentsmanaged_agents (sub-agents called as tools)None; planning_interval adds periodic plans
OpenAI Agents SDKhandoffs; Agent.as_tool()None
CrewAICrew with sequential or hierarchical processFlows (@start, @listen, @router)
LangGraphSubgraphs; Command and Send routingCore feature (state graph, loops, fan-out)
AG2Network hub with channels, Handoff and Finish; sub-agents as toolsTransition graphs inside the Network
LlamaIndexAgentWorkflow with can_handoff_toEvent-driven Workflow
HaystackAgentTool (an agent used as a tool)Pipeline (graph of components, may loop)
PydanticAIAn agent called from another agent’s toolpydantic_graph
AgnoTeamWorkflow (step-based)
Strands AgentsAgents as tools; Swarm; GraphGraph
FrameworkPersisted stateHuman approvalTyped output
SmolAgentsIn-run step memory; no storeNone built inNone (final_answer_checks can validate)
OpenAI Agents SDKSessions (SQLite and others); serialisable RunStateneeds_approval on toolsoutput_type
CrewAICrew checkpoints and Flow persistenceTask human_input; Flow human feedbackTask output_pydantic, output_json
LangGraphCheckpointers (in-memory in the core; SQLite and Postgres are separate packages)interrupt()State schemas; response_format on the prebuilt agent
AG2Storage for history (in-memory built in)hitl_hook, context.inputresponse_schema
LlamaIndexSerialisable workflow Context; memory classesInputRequiredEvent and HumanResponseEventoutput_cls on agents
HaystackPipeline breakpoints and snapshotshaystack.hooks.human_in_the_loopresponse_format on OpenAI chat generators
PydanticAIMessage history; Temporal, DBOS and Prefect wrappers for durable runsrequires_approval, DeferredToolRequestsoutput_type (central to the API)
AgnoDatabase-backed sessions and memory (SQLite, Postgres, MongoDB and others)@approval, tool requires_confirmationoutput_schema
Strands AgentsSession managers (file, S3)Interruptsstructured_output_model
FrameworkMCP clientTracingRetrieval and vector stores
SmolAgentsMCPClient (extra mcp)OpenTelemetry through an extra (telemetry)None
OpenAI Agents SDKagents.mcpBuilt-in tracing (sent to OpenAI by default; can be disabled or redirected)Hosted FileSearchTool only
CrewAIcrewai.mcpEvent bus; optional tracingKnowledge sources
LangGraphSeparate package (langchain-mcp-adapters)LangSmith or custom callbacksNone (provided by LangChain)
AG2ag2.mcp (extra mcp)Telemetry middleware (extra tracing)None
LlamaIndexSeparate package (llama-index-tools-mcp)Instrumentation module; integration packagesCore feature
HaystackSeparate package (mcp-haystack)Tracer interface (haystack.tracing) and logging tracer; OpenTelemetry in integration packagesCore feature
PydanticAIIncluded in the default pydantic-ai installOpenTelemetry and Logfire (Agent.instrument_all)Embeddings API; no vector stores
AgnoExtra mcpagno.tracing; OpenTelemetry extraKnowledge and vectordb
Strands AgentsIn core (strands.tools.mcp)OpenTelemetry in coreSeparate package (strands-agents-tools)

A few of these cells reflect packaging rather than capability. LangGraph and Haystack both work with MCP and OpenTelemetry through other packages, and every framework that lacks built-in retrieval can use any vector store library from inside a tool.

You are buildingLook at firstAlso consider
A first agent, to learn how they workSmolAgentsPydanticAI, Agno
Structured extraction or an API with validated outputPydanticAIOpenAI Agents SDK (output_type)
Customer service with routing to specialistsOpenAI Agents SDKCrewAI, LangGraph
A team of role-based agentsCrewAIAgno teams, AG2
Loops, branching and human review in a long-running processLangGraphMicrosoft Agent Framework workflows, CrewAI Flows
Question answering over documentsLlamaIndexHaystack
Search or retrieval pipelines you want to serialiseHaystackLlamaIndex
Agents served as an HTTP service with sessions and memoryAgnoOpenAI Agents SDK with FastAPI
Experiments with explicit multi-agent routing, MCP or A2AAG2Strands Agents, LangGraph
AWS deploymentStrands Agents with AgentCoreLangGraph on AgentCore
Azure or .NETMicrosoft Agent FrameworkSemantic Kernel for existing code
Google Cloud or GeminiGoogle ADK
An agent that works with files, a shell and the webClaude Agent SDK
TypeScriptLangGraph, OpenAI Agents SDKClaude Agent SDK, Strands Agents, Google ADK
Start
├─ New to agents? → SmolAgents, or Agno / PydanticAI if you want typed or served
│
├─ Need validated, typed output? → PydanticAI
│
├─ Multi-agent?
│ ├─ Role-based crew → CrewAI
│ ├─ Handoffs between specialists → OpenAI Agents SDK
│ ├─ Teams served over HTTP → Agno
│ └─ Explicit routing, MCP and A2A → AG2 or Strands Agents
│
├─ Loops, branching, resumable state? → LangGraph
│
├─ Data and search?
│ ├─ Retrieval over your documents → LlamaIndex
│ └─ Serialisable pipelines → Haystack
│
├─ Cloud platform?
│ ├─ AWS → Strands Agents + AgentCore
│ ├─ Azure / .NET → Microsoft Agent Framework
│ └─ Google Cloud → Google ADK
│
└─ Tied to one model vendor?
├─ Claude → Claude Agent SDK
├─ Mistral → Mistral Agents API
└─ OpenAI → OpenAI Agents SDK

Where an upstream or in-guide migration path exists:

Moves between other frameworks are rewrites. The parts that carry over are your tool functions, prompts and evaluation data, which is a good reason to keep them in plain functions and files rather than inside one framework’s classes.


Back to Home | All Guides | Quick Start