---
title: "AI agent frameworks compared: LangGraph, CrewAI, ADK, and more"
description: "An AI agent frameworks comparison of LangGraph, LangChain, CrewAI, the OpenAI, Claude, and Google SDKs, Pydantic AI, Mastra, and more, by language and license."
summary: "AI agent frameworks are libraries that run the model and tool loop for you and add state, orchestration, and tracing on top. This comparison sorts 13 current options by language, orchestration model, and license, notes each project's status, and ends with a guide to choosing one."
type: "comparison"
canonical_url: "https://theaiengineering.com/articles/ai-agent-frameworks"
markdown_url: "https://theaiengineering.com/articles/ai-agent-frameworks.md"
topic: "AI agents"
author: "The AI Engineering Editors"
publisher: "The AI Engineering"
published: "2026-11-02"
updated: "2026-11-02"
keywords: ["ai agent frameworks","ai agent frameworks comparison","ai agent frameworks open source","langchain vs langgraph","ai agent frameworks python","ai agent frameworks typescript","best ai agent frameworks"]
citation: "The AI Engineering Editors. \"AI agent frameworks compared: LangGraph, CrewAI, ADK, and more.\" The AI Engineering, updated Nov 02, 2026. https://theaiengineering.com/articles/ai-agent-frameworks"
---

# AI agent frameworks compared: LangGraph, CrewAI, ADK, and more

## TL;DR

- AI agent frameworks differ most in orchestration model: plain tool loops, graph workflows, handoffs between agents, and role-based crews.
- LangChain 1.0 and LangGraph 1.0 shipped in October 2025, and LangChain agents run on the LangGraph runtime, so LangGraph is the lower layer rather than a competitor.
- Microsoft Agent Framework reached version 1.0 in April 2026 as the successor to AutoGen and Semantic Kernel, and the AutoGen repository is now archived.
- Most frameworks covered here use the MIT or Apache 2.0 license; the Claude Agent SDK is governed by Anthropic's Commercial Terms of Service, and Mastra licenses its enterprise directories separately.
- Choose by language, by how much control you need over execution order, and by target model and cloud; for simple tasks, a hand-written loop is a valid choice.

AI agent frameworks are libraries that run the model and tool loop of an [AI agent](https://theaiengineering.com/glossary/ai-agent) for you, and add state management, orchestration, and tracing on top. This comparison covers 13 frameworks that are active in November 2026, checked against each project's official documentation and repository: LangGraph, LangChain, LlamaIndex, CrewAI, Microsoft Agent Framework, the OpenAI Agents SDK, the Claude Agent SDK, Google's Agent Development Kit (ADK), Pydantic AI, Mastra, the Vercel AI SDK, DSPy, and Strands Agents. The comparison also notes the status of AutoGen, which is now archived. For background on the loop these tools implement, start with our explainer on [AI agents](https://theaiengineering.com/articles/what-are-ai-agents) or the [AI agents topic hub](https://theaiengineering.com/topics/ai-agents).

## What is an AI agent framework?

An AI agent framework is a library that implements the agent loop (call a model, execute requested tools, feed results back) and adds the infrastructure production agents need around it.

A model provider's SDK gives you a single model call with [tool calling](https://theaiengineering.com/glossary/tool-calling). A framework adds the parts you would otherwise write yourself:

- **The loop itself**, with stopping conditions such as step limits and token budgets.
- **Tool plumbing**: turning functions into schemas, validating arguments, and connecting to tool servers over the [Model Context Protocol](https://theaiengineering.com/glossary/model-context-protocol).
- **State and memory**: conversation sessions, checkpoints, and [agent memory](https://theaiengineering.com/glossary/agent-memory) that persists between runs.
- **Orchestration**: multi-step workflows, branching, and coordination in a [multi-agent system](https://theaiengineering.com/glossary/multi-agent-system).
- **Human-in-the-loop**: pausing for approval and resuming later.
- **Observability and evals**: traces of every model and tool call, often through OpenTelemetry, plus evaluation tooling.

The tradeoff is abstraction. Every framework encodes opinions about how agents should be structured, and those opinions help when they match your problem and slow you down when they do not.

## AI agent frameworks at a glance

The 13 active frameworks split into three groups: general orchestration frameworks (LangGraph, LangChain, CrewAI, Microsoft Agent Framework), vendor SDKs (OpenAI, Anthropic, Google, and the AWS-originated Strands Agents), and focused libraries (LlamaIndex, Pydantic AI, Mastra, Vercel AI SDK, DSPy). The table lists maintainer, languages, license, and status as of November 2026.

| Framework | Maintainer | Languages | License | Status |
|---|---|---|---|---|
| LangGraph | LangChain | Python, TypeScript | MIT | Stable; 1.0 in October 2025 |
| LangChain | LangChain | Python, TypeScript | MIT | Stable; 1.0 in October 2025 |
| LlamaIndex | LlamaIndex | Python | MIT | Maintained; company focus moved to document parsing |
| CrewAI | CrewAI | Python | MIT | Active; commercial platform alongside |
| Microsoft Agent Framework | Microsoft | Python, .NET (Go in preview) | MIT | 1.0 in April 2026; replaces AutoGen and Semantic Kernel |
| OpenAI Agents SDK | OpenAI | Python, TypeScript | MIT | Active; launched March 2025 |
| Claude Agent SDK | Anthropic | Python, TypeScript | Anthropic Commercial Terms | Active; formerly the Claude Code SDK |
| Google ADK | Google | Python, TypeScript, Go, Java, Kotlin | Apache 2.0 | Active; version 2.0 adds graph workflows |
| Pydantic AI | Pydantic | Python | MIT | Active |
| Mastra | Mastra | TypeScript | Apache 2.0, enterprise directories separate | Active |
| Vercel AI SDK | Vercel | TypeScript | Apache 2.0 | Active |
| DSPy | Stanford NLP | Python | MIT | Active |
| Strands Agents | Open source project started by AWS | Python, TypeScript | Apache 2.0 | Active; SDKs now in one monorepo |
| AutoGen | Microsoft | Python | MIT (code) | Archived; no fixes or support |

License notes matter for some teams. The Python package of the Claude Agent SDK carries an MIT license file, but the [Claude Agent SDK documentation](https://code.claude.com/docs/en/agent-sdk/overview) states that use of the SDK is governed by Anthropic's Commercial Terms of Service. Mastra's code is Apache 2.0 except for directories named `ee/`, which use a separate enterprise license. Our [agent frameworks directory](https://theaiengineering.com/platforms/agent-frameworks) tracks these projects over time.

## AI agent frameworks comparison: orchestration and strengths

The biggest practical difference between AI agent frameworks is the [orchestration model](https://theaiengineering.com/glossary/agent-orchestration): how the framework decides which step runs next. Four shapes cover the field: a tool loop driven by model output, an explicit graph of steps, [handoffs](https://theaiengineering.com/glossary/agent-handoff) that transfer control between specialized agents, and role-based crews that collaborate on tasks.

**Figure 1: The four orchestration shapes. Most frameworks support more than one, but each is built around a primary shape.**

Four panels: a model and tools in a loop, a branching graph of steps A to D, triage handing off to billing or support, and a researcher, writer, reviewer crew.

Components:

- **Model**
- **Tools**
- **A**
- **B**
- **C**
- **D**
- **Triage**
- **Billing**
- **Support**
- **Researcher**
- **Writer**
- **Reviewer**

Groups:

- Tool loop: Model, Tools
- Graph workflow: A, B, C, D
- Handoffs: Triage, Billing, Support
- Role-based crew: Researcher, Writer, Reviewer

Connections:

- Model → Tools: call
- Tools → Model: result
- A → B
- B → C
- B → D
- C → D
- Triage → Billing
- Triage → Support
- Researcher → Writer
- Writer → Reviewer

| Framework | Primary orchestration model | Strengths | Watch for |
|---|---|---|---|
| LangGraph | Graph of nodes over shared state | Durable execution, interrupts for human approval, fine control | More concepts and code than a simple loop |
| LangChain | Prebuilt agent loop (`create_agent`) with middleware | Fast start, large integration catalog | Abstraction layers to learn before customizing |
| LlamaIndex | Event-driven workflows; agents over data | Data connectors, indexing, retrieval | Framework is no longer the company's main product |
| CrewAI | Role-based crews plus event-driven Flows | Quick multi-agent prototypes with roles and tasks | Crews trade step-level control for autonomy |
| Microsoft Agent Framework | Agents plus graph workflows (sequential, concurrent, handoff, group) | .NET support, checkpointing, OpenTelemetry, Azure integration | Migration work for AutoGen and Semantic Kernel users |
| OpenAI Agents SDK | Tool loop with handoffs and agents as tools | Small API, guardrails, sessions, built-in tracing | Hosted tools are specific to OpenAI's platform |
| Claude Agent SDK | The Claude Code loop as a library | Built-in file, shell, and web tools; subagents; hooks; permissions | Claude models only; runs a bundled Claude Code binary |
| Google ADK | LLM agents, workflow agents (sequential, parallel, loop), graph workflows | Five languages, evaluation tooling, model-agnostic design | Deepest integrations target Google Cloud and Gemini |
| Pydantic AI | Typed tool loop; Pydantic Graph for explicit flow | Type safety, structured outputs, model fallback, durable execution | Python only |
| Mastra | Agents plus graph workflows (`.then()`, `.branch()`, `.parallel()`) | TypeScript-native, suspend and resume, memory, evals | Enterprise features under a separate license |
| Vercel AI SDK | Tool loop (`ToolLoopAgent`) with `stopWhen` and `prepareStep` | Unified provider API, UI hooks for React, Svelte, Vue, Angular | A toolkit more than a workflow engine |
| DSPy | Declarative modules (`Predict`, `ChainOfThought`, `ReAct`) tuned by optimizers | Optimizes prompts and weights against a metric | Needs a metric and examples to deliver its main benefit |
| Strands Agents | Model-driven loop with lifecycle controls | Turn limits, token budgets, hooks, tracing; many model providers | Repositories were recently restructured |

## LangChain vs LangGraph

LangChain and LangGraph are layers of the same stack, not alternatives. LangGraph is the low-level runtime for stateful, graph-based agents. LangChain sits on top, providing a prebuilt agent loop, middleware, and model and tool integrations. LangChain's documentation states that LangChain agents are built on top of LangGraph and inherit its persistence, durable execution, and [human-in-the-loop](https://theaiengineering.com/glossary/human-in-the-loop) support.

Both libraries reached 1.0 in October 2025. The LangChain 1.0 release introduced `create_agent` as the standard way to build an agent, replacing LangGraph's `create_react_agent`, and added middleware hooks for customizing the loop. LangGraph 1.0 kept backward compatibility and moved its prebuilt agents into LangChain. LangChain also publishes Deep Agents, a higher-level package for agents that plan, spawn [subagents](https://theaiengineering.com/glossary/subagent), and use a virtual file system.

A practical split:

- **Use LangChain** when a single agent with tools and some customization covers the task.
- **Use LangGraph directly** when you need to combine deterministic steps with agentic ones, run branches in parallel, or resume long workflows after failure.
- **Use Deep Agents** when you want planning, subagents, and context management assembled for you.

LangSmith, the company's commercial tracing and deployment product, is optional; both open-source libraries run without it, and our [LLM observability guide](https://theaiengineering.com/articles/llm-observability) covers alternatives.

## OpenAI Agents SDK vs Claude Agent SDK vs Google ADK

The three model-vendor SDKs take different positions. The OpenAI Agents SDK is a small, provider-agnostic loop built around agents, handoffs, and guardrails. The Claude Agent SDK packages the full Claude Code agent, with built-in tools, for Claude models only. Google ADK is a broad, multi-language framework optimized for Gemini but designed to work with other models.

**OpenAI Agents SDK.** OpenAI released the SDK in March 2025 and describes the library as a production-ready upgrade of its earlier experimental Swarm project. The core primitives are agents (a model with instructions and tools), handoffs and agents-as-tools for delegation, and guardrails for validating inputs and outputs. Sessions, tracing, human-in-the-loop, voice and realtime agents, and sandbox agents for long tasks sit on top. The SDK supports OpenAI's Responses and Chat Completions APIs and, per its README, more than 100 other LLMs.

**Claude Agent SDK.** Anthropic's SDK, renamed from the Claude Code SDK, gives Python and TypeScript programs the same agent loop, tools, and context management that power Claude Code. Built-in tools read, write, and edit files, run shell commands, and search the web, and the SDK adds hooks, subagents, MCP connections, permission modes, and resumable sessions. The SDK runs a bundled Claude Code binary and works with Claude models through the Claude API or supported cloud platforms, including Amazon Bedrock, Google Cloud, and Microsoft Foundry.

**Google ADK.** The Agent Development Kit is available in Python, TypeScript, Go, Java, and Kotlin under Apache 2.0. ADK combines model-driven LLM agents with deterministic workflow agents (sequential, parallel, and loop), and ADK 2.0 adds graph-based workflows with routing, fan-out and fan-in, retries, and human-in-the-loop steps. ADK includes evaluation tooling and is model-agnostic, though optimized for Gemini.

## CrewAI vs AutoGen and Microsoft Agent Framework

CrewAI and Microsoft Agent Framework both put multi-agent collaboration at the center of their design. CrewAI is a Python framework built around crews of role-based agents and event-driven Flows. Microsoft Agent Framework is the unified successor to AutoGen and Semantic Kernel. AutoGen itself is archived, so new projects that would have used it should evaluate Agent Framework instead.

**CrewAI.** CrewAI defines agents by role and goal, groups them into crews that work through tasks, and adds Flows: structured, event-driven workflows that manage state, persist execution, and hand complex steps to crews. Crews favor autonomy; Flows restore precise control. CrewAI Inc. sells a commercial control plane, but the framework itself is MIT-licensed.

**Microsoft Agent Framework.** Microsoft [announced Agent Framework 1.0](https://devblogs.microsoft.com/agent-framework/microsoft-agent-framework-version-1-0/) for .NET and Python on April 3, 2026, and a Go SDK is now in public preview. The framework combines AutoGen's agent abstractions with Semantic Kernel's enterprise features, such as session state, type safety, middleware, and telemetry, and adds graph-based workflows that support sequential, concurrent, handoff, and group-collaboration patterns with checkpointing and time travel.

**AutoGen status.** The [AutoGen repository](https://github.com/microsoft/autogen) states that the project is archived and no longer maintained, with no bug fixes, security fixes, or support from Microsoft, and advises against production use. Microsoft publishes migration guides from both AutoGen and Semantic Kernel to Agent Framework.

## TypeScript AI agent frameworks: Mastra vs Vercel AI SDK

For TypeScript teams, the main choices are Mastra, the Vercel AI SDK, LangGraph.js, the OpenAI Agents SDK for JavaScript, Google ADK for TypeScript, and the TypeScript versions of the Claude Agent SDK and Strands Agents. Mastra and the Vercel AI SDK are TypeScript-first rather than ports, and they sit at different levels of abstraction.

**Vercel AI SDK.** The AI SDK is a provider-agnostic TypeScript toolkit for building AI features and agents in frameworks such as Next.js, React, Svelte, Vue, and Angular. The SDK defines agents as models that use tools in a loop, and its `ToolLoopAgent` class manages the loop, context, and stopping conditions, with `stopWhen` and `prepareStep` for loop control. When given a plain model string, the SDK routes through Vercel's AI Gateway by default; provider packages connect to model APIs directly.

**Mastra.** Mastra is a TypeScript framework for agents and applications. Mastra provides agents with configurable stopping conditions, a graph-based workflow engine with `.then()`, `.branch()`, and `.parallel()`, suspend and resume for human approval, memory, retrieval, evals, and MCP server authoring. Mastra integrates with the Vercel AI SDK's UI libraries, so the two can be used together.

## Pydantic AI, LlamaIndex, DSPy, and Strands Agents

These four frameworks each solve a narrower problem well: Pydantic AI brings type safety to the agent loop, LlamaIndex specializes in agents over data, DSPy optimizes prompts against a metric instead of hand-tuning them, and Strands Agents offers a model-driven loop with built-in lifecycle controls and broad provider support.

**Pydantic AI.** From the team behind the Pydantic validation library, Pydantic AI is a typed agent loop in which tools, dependencies, and outputs are validated Python types, which fits teams that rely on [structured outputs](https://theaiengineering.com/glossary/structured-outputs). Pydantic AI supports model fallback when a provider fails, durable execution on engines such as Temporal, DBOS, Prefect, and Restate, and Pydantic Graph for typed control flow when one loop is not enough. Instrumentation uses OpenTelemetry.

**LlamaIndex.** The LlamaIndex framework is a Python toolkit for building LLM-powered agents over your data, with data connectors, indexes, and event-driven workflows. The project's README notes that the company's primary focus has shifted to LlamaParse, its document parsing platform, while the open-source framework remains available. The retrieval components remain relevant for agents that mostly answer questions over document collections; our explainer on [retrieval-augmented generation](https://theaiengineering.com/articles/what-is-rag) covers the underlying pattern.

**DSPy.** DSPy, from Stanford NLP, replaces hand-written prompts with declarative signatures (typed inputs and outputs) and modules such as `Predict`, `ChainOfThought`, and `ReAct`. Optimizers then tune the prompts, or the weights, of a DSPy program against a metric you define. DSPy pays off when you have examples and a scoring function, which makes it a natural partner to a mature [LLM evaluation](https://theaiengineering.com/articles/llm-evaluation) setup.

**Strands Agents.** AWS open-sourced Strands Agents in May 2025 under Apache 2.0. The project now ships Python and TypeScript SDKs and a preassembled agent from one monorepo. Strands takes a model-driven approach: model output drives planning and tool selection, while the SDK provides turn limits, token budgets, hooks, MCP, multi-agent patterns, and tracing. Strands supports Amazon Bedrock, Anthropic, OpenAI, Gemini, and other providers.

## How to choose an AI agent framework

Choose an AI agent framework by answering four questions in order: which language your team ships in, how much control you need over step order, which models and cloud you are committed to, and whether you need multi-agent coordination. Those answers usually narrow the field to two or three candidates; then prototype the same task in each.

| If you need | Evaluate first |
|---|---|
| Explicit control over long-running, stateful workflows with human approval | LangGraph, Microsoft Agent Framework, Mastra workflows, ADK graph workflows |
| A working tool-using agent in Python with little code | LangChain `create_agent`, OpenAI Agents SDK, Pydantic AI, Strands Agents |
| An agent that works in files, shells, and terminals | Claude Agent SDK, OpenAI Agents SDK sandbox agents |
| TypeScript with a web front end | Vercel AI SDK, Mastra, LangGraph.js |
| .NET, Java, Go, or Kotlin | Microsoft Agent Framework (.NET, Go preview), Google ADK (Java, Go, Kotlin) |
| Role-based multi-agent prototypes | CrewAI |
| Agents over large document collections | LlamaIndex |
| Type-checked outputs throughout | Pydantic AI |
| Prompt optimization against a metric | DSPy |
| Deep alignment with one model vendor | That vendor's SDK: OpenAI, Claude, ADK, or Strands for AWS |

Check three further points before committing. First, tool connectivity: whether the framework can consume tools from MCP servers and, if you need agent-to-agent calls, whether it supports the A2A protocol; our [A2A vs MCP comparison](https://theaiengineering.com/articles/a2a-vs-mcp) explains the difference. Second, observability: whether traces export through OpenTelemetry to the tools you already run. Third, exit cost: how much of your code would change if you moved to another framework or model.

### Do you need an agent framework at all?

Not always. Anthropic's engineering post [Building effective agents](https://www.anthropic.com/engineering/building-effective-agents) recommends starting with direct LLM API calls, because many agent patterns take only a few lines of code, and advises understanding the code underneath any framework you adopt. A hand-written loop with a step limit, a few tools, and tracing is often enough for a single-purpose agent. Frameworks earn their place when you need durable state, resumable human approval, multi-agent orchestration, or several model providers behind one interface.

## Where to go next

If the agent loop itself is still unfamiliar, read [what AI agents are and how they work](https://theaiengineering.com/articles/what-are-ai-agents) before choosing a framework. To connect any of these frameworks to tools and data, continue with [what the Model Context Protocol is](https://theaiengineering.com/articles/what-is-model-context-protocol). For tracing agents once they are in production, see our guide to [LLM observability](https://theaiengineering.com/articles/llm-observability).

## Frequently asked questions

### Which AI agent framework is best?

No single AI agent framework is best for every project. LangGraph and Microsoft Agent Framework suit long-running, stateful workflows that need explicit control. The OpenAI Agents SDK, Pydantic AI, and Strands Agents suit quick, code-first agents. Mastra and the Vercel AI SDK suit TypeScript teams. The right choice depends on language, control needs, target models, and existing cloud infrastructure.

### Are AI agent frameworks open source?

Most major AI agent frameworks are open source. LangGraph, LangChain, LlamaIndex, CrewAI, Microsoft Agent Framework, the OpenAI Agents SDK, Pydantic AI, and DSPy use the MIT license, while Google ADK, the Vercel AI SDK, and Strands Agents use Apache 2.0. Mastra is Apache 2.0 outside its enterprise directories. The Claude Agent SDK is governed by Anthropic's Commercial Terms of Service.

### What is LangGraph used for?

LangGraph is used to build long-running, stateful agents and workflows as graphs of nodes that share state. Teams choose LangGraph when they need durable execution that resumes after failures, human-in-the-loop interrupts that pause for approval, and explicit control over which step runs next. LangChain's prebuilt agents run on LangGraph, and LangGraph is available for both Python and TypeScript.

### What is Microsoft Agent Framework?

Microsoft Agent Framework is Microsoft's open-source framework for building AI agents and multi-agent workflows in Python and .NET, with a Go SDK in public preview. Microsoft announced version 1.0 in April 2026. The framework combines AutoGen's agent abstractions with Semantic Kernel's enterprise features and adds graph-based workflows with checkpointing, human-in-the-loop support, and OpenTelemetry tracing.

### What is the difference between CrewAI and LangGraph?

CrewAI organizes work around roles: you define agents with roles and goals, group them into crews, and use event-driven Flows for precise control. LangGraph organizes work around a graph: you define nodes, edges, and shared state, and the runtime executes the graph with persistence and interrupts. CrewAI is quicker for role-based prototypes; LangGraph gives finer control over execution.

## Terms in this guide

- [AI agent](https://theaiengineering.com/glossary/ai-agent): An AI agent is a software system in which a large language model runs in a loop, calling tools, reading their results, and repeating until the task is complete or a stop condition is reached.
- [Multi-agent system](https://theaiengineering.com/glossary/multi-agent-system): A multi-agent system is an AI architecture in which several language-model agents, each with its own prompt, tools, and context, work on parts of a task and pass results to one another.
- [Tool calling](https://theaiengineering.com/glossary/tool-calling): Tool calling is an LLM capability in which the model, given a list of tool definitions, outputs a structured request naming a tool and its arguments, which the application executes and returns.
- [Agent memory](https://theaiengineering.com/glossary/agent-memory): Agent memory is the set of mechanisms that let an AI agent keep and retrieve information beyond a single model call, from the current context window to external stores that persist across sessions.
- [Structured outputs](https://theaiengineering.com/glossary/structured-outputs): Structured outputs is an LLM API feature that constrains generation so the model's response always conforms to a developer-supplied JSON Schema, producing output that code can parse without retries.
- [Model Context Protocol (MCP)](https://theaiengineering.com/glossary/model-context-protocol): Model Context Protocol (MCP) is an open protocol, introduced by Anthropic in November 2024, that standardizes how AI applications connect to external tools, data sources, and prompts through MCP servers.
- [LLM observability](https://theaiengineering.com/glossary/llm-observability): LLM observability is the practice of instrumenting LLM applications to record each request's prompts, responses, tool calls, token usage, latency, cost, and quality scores as traces that teams can search and analyze.
- [LLM-as-a-judge](https://theaiengineering.com/glossary/llm-as-a-judge): LLM-as-a-judge is an evaluation method in which a language model scores or compares the outputs of an LLM application against a rubric, a reference answer, or another response, replacing or supplementing human graders.
- [Human-in-the-loop](https://theaiengineering.com/glossary/human-in-the-loop): Human-in-the-loop (HITL) is an agent design in which the run pauses at defined checkpoints, such as before a sensitive tool call, so a person can approve, edit, or reject the action.
- [OpenTelemetry](https://theaiengineering.com/glossary/opentelemetry): OpenTelemetry is an open source, vendor-neutral observability framework of APIs, SDKs, a wire protocol, and naming conventions for traces, metrics, and logs, including conventions for LLM calls and agent runs.
- [Agent orchestration](https://theaiengineering.com/glossary/agent-orchestration): Agent orchestration is the control logic that decides which agent, model call, or tool runs next in an AI system and what each receives, whether written in code or chosen by a model.
- [Agent handoff](https://theaiengineering.com/glossary/agent-handoff): An agent handoff is a transfer of control in which one AI agent passes the conversation, and responsibility for the task, to another agent better suited to the next part of the work.
- [Subagent](https://theaiengineering.com/glossary/subagent): A subagent is an AI agent that another agent starts for one subtask, running in a separate context window with its own instructions and tools, and returning only a condensed result.
- [Model failover](https://theaiengineering.com/glossary/model-failover): Model failover is the automatic rerouting of an LLM request to a backup model, deployment, or provider when the primary target returns an error, times out, or hits a rate limit.
- [ReAct agent](https://theaiengineering.com/glossary/react-agent): A ReAct agent is an AI agent that alternates a written reasoning step, an action such as a tool call, and an observation of the result, repeating the cycle until it can answer.
- [Chain-of-thought prompting](https://theaiengineering.com/glossary/chain-of-thought): Chain-of-thought prompting is a technique that has a language model write intermediate reasoning steps before its final answer, which improves large models' accuracy on arithmetic, commonsense, and symbolic reasoning tasks.
- [Agent sandbox](https://theaiengineering.com/glossary/agent-sandbox): An agent sandbox is an isolated execution environment in which an AI agent runs code, shell commands, or a browser, with enforced limits on the files, network hosts, and credentials it can reach.
- [A2A protocol](https://theaiengineering.com/glossary/a2a-protocol): The A2A (Agent2Agent) protocol is an open standard, introduced by Google in April 2025, that lets AI agents built on different frameworks discover each other, exchange messages, and delegate tasks.

## Related guides

- [What are AI agents? How agents work and when to use one](https://theaiengineering.com/articles/what-are-ai-agents): AI agents are LLM systems that call tools in a loop until a task is done. Learn how the loop works, agents vs agentic AI, examples, failure modes, and limits.
- [How to build an AI agent: a step-by-step guide in Python](https://theaiengineering.com/articles/how-to-build-an-ai-agent): Learn how to build an AI agent from scratch in Python: when you need one, tool schemas, the agent loop, stop conditions, guardrails, evals, and tracing.
- [What is the Model Context Protocol (MCP)? How it works](https://theaiengineering.com/articles/what-is-model-context-protocol): The Model Context Protocol (MCP) is an open standard for connecting AI apps to tools and data. Learn its architecture, transports, tool calls, and security.
- [A2A protocol vs MCP: differences and when to use each](https://theaiengineering.com/articles/a2a-vs-mcp): A2A protocol vs MCP: A2A connects AI agents to other agents, and MCP connects an agent to tools and data. Compare agent cards, tasks, transports, and security.

Part of the [AI agents](https://theaiengineering.com/topics/ai-agents) topic hub.

## Cite this guide

The AI Engineering Editors. "AI agent frameworks compared: LangGraph, CrewAI, ADK, and more." The AI Engineering, updated Nov 02, 2026. https://theaiengineering.com/articles/ai-agent-frameworks

- Title: AI agent frameworks compared: LangGraph, CrewAI, ADK, and more
- Author: The AI Engineering Editors
- Publisher: The AI Engineering
- Published: 2026-11-02
- Updated: 2026-11-02
- URL: https://theaiengineering.com/articles/ai-agent-frameworks
- Markdown: https://theaiengineering.com/articles/ai-agent-frameworks.md

To cite one section, link to its anchor:

- [What is an AI agent framework?](https://theaiengineering.com/articles/ai-agent-frameworks#what-is-an-ai-agent-framework)
- [AI agent frameworks at a glance](https://theaiengineering.com/articles/ai-agent-frameworks#ai-agent-frameworks-at-a-glance)
- [AI agent frameworks comparison: orchestration and strengths](https://theaiengineering.com/articles/ai-agent-frameworks#ai-agent-frameworks-comparison-orchestration-and-strengths)
- [LangChain vs LangGraph](https://theaiengineering.com/articles/ai-agent-frameworks#langchain-vs-langgraph)
- [OpenAI Agents SDK vs Claude Agent SDK vs Google ADK](https://theaiengineering.com/articles/ai-agent-frameworks#openai-agents-sdk-vs-claude-agent-sdk-vs-google-adk)
- [CrewAI vs AutoGen and Microsoft Agent Framework](https://theaiengineering.com/articles/ai-agent-frameworks#crewai-vs-autogen-and-microsoft-agent-framework)
- [TypeScript AI agent frameworks: Mastra vs Vercel AI SDK](https://theaiengineering.com/articles/ai-agent-frameworks#typescript-ai-agent-frameworks-mastra-vs-vercel-ai-sdk)
- [Pydantic AI, LlamaIndex, DSPy, and Strands Agents](https://theaiengineering.com/articles/ai-agent-frameworks#pydantic-ai-llamaindex-dspy-and-strands-agents)
- [How to choose an AI agent framework](https://theaiengineering.com/articles/ai-agent-frameworks#how-to-choose-an-ai-agent-framework)
- [Where to go next](https://theaiengineering.com/articles/ai-agent-frameworks#where-to-go-next)
- [Frequently asked questions](https://theaiengineering.com/articles/ai-agent-frameworks#faq)
