LangChain vs CrewAI vs 12 More Agent Frameworks

Fourteen agent frameworks make up the entire "Frameworks" category in our index: LangChain, LangGraph, CrewAI, LlamaIndex, Microsoft AutoGen, Microsoft Agent Framework, the OpenAI Agents SDK, Pydantic AI, Mastra, Letta, Google Agent Development Kit (ADK), Claude Agent SDK and Agno. All thirteen are free at the core: our own pricing census already found that every framework in the index is free or freemium, the only category where that's unanimous. Twelve of the thirteen are open-source; Claude Agent SDK's two wrapper packages carry an MIT license, but Anthropic's own docs place overall SDK use under its Commercial Terms of Service and the CLI binary the wrapper bundles and spawns isn't published as source, so it doesn't clear the same bar. So the choice between them is rarely about budget. It's about which job you're actually doing: retrieval over your own documents, standing up a multi-agent crew fast, wiring a bespoke production system with deep control, getting LangGraph's own explicit, checkpointed graph control and human-in-the-loop replay once LangChain's own quick-start abstractions aren't enough, shipping a straightforward agent this week, getting validated, type-safe output out of the model, building natively in the JS/TypeScript stack instead of Python, migrating off a now-frozen Microsoft framework onto its supported successor, building an agent that has to genuinely remember across sessions instead of starting fresh every call, standardizing on Google's own official SDK across four languages with native cross-vendor agent interoperability, building the tightest possible integration with Claude Code's own harness at the cost of being single-vendor on Anthropic, or wanting built-in memory, knowledge and multi-agent Teams without assembling them from separate libraries, plus a genuine BYOC production path. Each of the thirteen was built to be the best answer to one of those jobs, and the honest verdict on each, pulled from its own researched listing, names which job it is not built for just as clearly as the one it is.

The fourteen, at a glance

GitHub star counts below were pulled live from each project's public repository between 20 and 29 July 2026, except LangGraph's, pulled 16 August 2026 when it joined this table. They are a rough proxy for community size and momentum, not a quality score.

Star count tracks age and marketing surface area as much as fit for your project. LangChain and AutoGen are both multi-year-old projects that came out of the earliest wave of the space, while Pydantic AI, the OpenAI Agents SDK, Mastra, Letta, Microsoft Agent Framework, Google ADK and Claude Agent SDK are newer entrants building on lessons the older projects already learned in public; Microsoft Agent Framework is the youngest of all as a unified product (1.0 GA on 2026-04-03), which is why its star count trails despite inheriting AutoGen and Semantic Kernel's combined lineage. Google ADK, by contrast, launched April 2025 and already out-stars every framework here except LangChain, AutoGen, CrewAI and LlamaIndex, reflecting Google's own distribution reach more than any single feature. Claude Agent SDK's star count (7.8k on the Python package; its TypeScript sibling trails at 1.7k) is the smallest here, but it's also the newest entrant in this table and the only one distributed as a thin wrapper around an existing, already-adopted product (Claude Code) rather than a standalone project building its own audience from scratch. A smaller star count is not a red flag by itself; check the "watch out for" column below instead.

The decision: what are you actually building?

Every one of these frameworks has a listing on this site with a full researched verdict, a named persona it's not for, and genuine sourced cons, not marketing copy. Reading all twelve side by side, the honest decision tree looks like this:

• Your app lives or dies on getting the right context into the model (document Q&A, enterprise search, RAG over messy PDFs) → LlamaIndex. It's the reference RAG implementation, with 300-plus data connectors and hybrid/recursive retrieval built in. Watch out for: it's retrieval-first, not agent-first, so a real-time conversational or heavily agentic app is a worse fit, and the strongest document parsing (LlamaParse) is the paid LlamaCloud, not the free core.
• You're building something bespoke and need the largest integration surface plus real stateful, multi-step control → LangChain (with LangGraph). Nothing else matches its ecosystem of model, vector-store and tool integrations, and LangGraph gives genuine graph-based control: branching, loops, human-in-the-loop, multi-agent coordination. Watch out for: the abstractions have churned across major versions, so older tutorials can actively mislead, and it's overkill for a single prompt-and-response wrapper.
• You want to stand up a working multi-agent system (a team of specialists handing off tasks) as fast as possible → CrewAI. Its role-based "crew" abstraction is unusually readable for how much coordination it buys, and the community momentum is real. Watch out for: the crew model alone is hard to constrain tightly: deterministic control needs its newer Flows layer, and it's younger and less battle-tested than lower-level frameworks for complex, long-running production control.
• You want the shortest path from a spec to a working production agent (support triage, a tool-using assistant) with tracing and guardrails included → OpenAI Agents SDK. Four primitives (agents, handoffs, guardrails, sessions) instead of a graph engine, with built-in tracing that would otherwise take weeks to build; a beta "sandbox agents" mode also gives an agent its own persistent file/shell workspace. Watch out for: durable state is limited to manual, approval-scoped snapshots (no automatic step-by-step checkpointing), handoffs are linear chains rather than a graph, and it's young (v0.x) so APIs can still shift.
• You're building in the JS/TypeScript stack (a Next.js app, a Node service) and don't want to stand up a separate Python service just for the agent layer → Mastra. It's the only framework in this category built TypeScript-first from the ground up, unifying agents, durable typed workflows, memory and observability in one Apache-2.0 package, with 90+ model providers behind one interface and built-in Vercel/Netlify/Cloudflare deployers. Watch out for: no Python path at all, a much younger ecosystem than LangChain's (26.5K GitHub stars vs. 142K+), and its deepest enterprise controls (RBAC, SSO, IAM) sit behind a separate source-available Enterprise license rather than the open core.
• Malformed model output breaking your app in production is the problem you're actually trying to solve → Pydantic AI. Every response is validated against your own Pydantic models at the boundary, with a type-safe dependency-injection system and unusually pleasant, low-boilerplate ergonomics. Watch out for: fewer pre-built integrations than LangChain (you build more of the glue yourself), and while its 2.0 release added real checkpointed durability via Temporal/DBOS/Prefect/Restate integrations, you still have to operate that orchestrator yourself, and LangGraph's native graph-branching still goes deeper.
• Your agent has to genuinely remember and improve across long-running sessions, not reset to a blank slate on every call → Letta. It's the only framework here built stateful-first: memory, tools and configuration persist as a durable server-side object, versioned with git-based Context Repositories, and a "sleep-time compute" feature lets an agent keep reorganizing its own memory between requests. Watch out for: a much smaller community than the incumbents (23.9K GitHub stars vs. LangChain's 142K+), a single smaller seed round backing it versus rivals' later-stage raises, and a product surface split across two separately-adopted repos (the core framework and the newer Letta Code CLI harness).
• You're learning the "agents talking to agents" pattern, or maintaining an existing AutoGen codebase → Microsoft AutoGen, with eyes open. It pioneered conversational multi-agent orchestration and is still a clean, well-documented, genuinely free way to learn the pattern. But Microsoft has put it into maintenance mode: bug and security fixes only (no tagged release since September 2025), with the README itself pointing new users to the Microsoft Agent Framework, while the original authors maintain a separate, genuinely active community fork (AG2) that controls the old PyPI packages. For a new, long-lived production build, evaluate the Microsoft Agent Framework or AG2 before starting fresh on AutoGen itself. A three-way split in an ecosystem you'll have to maintain for years is a real, structural risk, not a style preference.
• You're migrating an existing AutoGen or Semantic Kernel project, or starting fresh with real Azure/Microsoft Foundry investment → Microsoft Agent Framework. It's Microsoft's own live successor, unifying AutoGen's orchestration with Semantic Kernel's enterprise plumbing into one framework across .NET, Python and Go, with a genuine production-ops layer (the Agent Harness for shell/filesystem access and human-in-the-loop approval, plus an optional Foundry Hosted Agents managed layer) most frameworks here leave entirely to you, and first-party migration guides from both predecessors. It's also more open than the Microsoft branding suggests: Anthropic's Claude and local Ollama models are first-class, not afterthoughts. Watch out for: it's young as a unified product (1.0 GA only since 2026-04-03), its GitHub community (12.4k stars) is a fraction of LangChain's or legacy AutoGen's, and Microsoft's own terms put the risk on you for any non-Microsoft model or MCP server you connect through it.
• You want Google's own official agent SDK, need genuine cross-vendor multi-agent interoperability, or you're standardizing on a language beyond Python → Google Agent Development Kit. It's the only framework here shipping production-grade SDKs in four languages (Python, Go, Java, TypeScript, plus an experimental Kotlin/Android runtime), and the only one built natively around the Agent2Agent (A2A) protocol, now Linux Foundation-governed, for agents built on different frameworks or by different vendors to talk to each other, alongside native MCP tool support. It's genuinely model-agnostic via LiteLLM despite the Gemini-first branding. Watch out for: documentation and third-party examples still skew heavily toward Python even though the other three SDKs reached 1.0 GA, a real learning curve for a comprehensive framework with several new concepts to internalize, and its optional managed Agent Runtime layer prices across several independent usage-based meters with no flat fee.
• You want memory, knowledge/RAG and multi-agent Teams built into the framework itself, and a production runtime you deploy into your own cloud rather than a vendor's → Agno. A fast, model-agnostic Python framework (formerly Phidata) that ships long-term memory, session storage, domain knowledge and native two-way MCP support as first-class primitives, plus a free local AgentOS Control Plane for development. Watch out for: its widely-repeated "10,000x faster than LangGraph" claim has no independent benchmark behind it, the January 2025 Phidata-to-Agno rename leaves a trail of outdated tutorials, and the paid AgentOS production tier is BYOC-only: there's no fully managed, zero-infrastructure hosted option the way Mastra Cloud or Letta Cloud offer.
• You're already building on Claude (or Claude Code) and want its exact agent loop, tools and context management as a callable library, not a reimplementation → Claude Agent SDK. It's Anthropic's own library, built on the same agent harness that powers Claude Code, with the full built-in Claude Code toolset (files, bash, web search/fetch) and native MCP support out of the box, plus a genuine choice between self-hosting the subprocess yourself or handing it to Claude Managed Agents, Anthropic's own hosted REST API. Watch out for: it's the only framework here with no supported path to a non-Anthropic model (a GitHub issue asking for one was closed "not planned"), the MIT license on its wrapper packages doesn't extend to the closed-source CLI binary they bundle, and Anthropic changed programmatic-usage billing twice in six weeks in mid-2026.

Mastra: TypeScript-native, not a Python port with JS bindings

Every other framework on this list started life as a Python library and later added a JavaScript/TypeScript SDK as a secondary target. Mastra reverses that: founded in San Francisco in 2024 by Sam Bhagwat (co-founder of Gatsby) as a Y Combinator company, it was built TypeScript-first from the ground up, designed to drop straight into an existing Next.js or Node app instead of standing up a separate Python service. It unifies five things developers otherwise assemble from separate packages: typed agents, durable typed workflows (retries, branching), memory, observability (evals, metrics, traces) and a server layer, all in one Apache 2.0-licensed core that's free to self-host anywhere, with model routing across 90+ providers behind one standard interface. It backs that up with real commercial traction: a $22M Series A led by Spark Capital (mid-2026, $35M total raised, with Y Combinator and Gradient Ventures among the seed backers) and named production customers including Replit, Sanity, MongoDB, Brex and Marsh. The honest tradeoff is scope and age, not capability: it's TypeScript-only with no Python path at all, its GitHub community (26.5K stars) is a fraction of LangChain's multi-year head start (142K+), and its deepest enterprise controls (RBAC, SSO, IAM, audit logs) sit behind a separate source-available Enterprise license rather than the free Apache-2.0 core.

Letta: stateful, memory-first agents, not a stateless call graph

Every other framework on this list (LangChain, CrewAI, LlamaIndex, AutoGen, the OpenAI Agents SDK, Pydantic AI and Mastra) is fundamentally a stateless call graph: an agent's context is rebuilt from a prompt on every request, and any memory beyond that is something you bolt on yourself with a vector store or a database. Letta inverts that premise. It grew directly out of MemGPT, the UC Berkeley Sky Computing Lab research project that pioneered virtual context management for LLMs, and is built by Sarah Wooders and Charles Packer, the same researchers behind that original paper. An agent's memory, tools and configuration persist as a durable server-side object across sessions, versioned with git-based "Context Repositories" that can be branched, diffed and rolled back like code, and a "sleep-time compute" feature lets an agent keep reasoning and reorganizing its own memory during idle periods. The Apache 2.0-licensed core (letta-ai/letta) is free and self-hostable; a newer CLI/agent-harness layer, "Letta Code," adds a managed Letta Cloud option with a genuine free tier and $20/month Pro/API/Teams plans. It's backed by a $10M seed led by Felicis (with angels including Google DeepMind's Jeff Dean and Hugging Face's Clem Delangue) and runs in production at Bilt, 11x, Kognitos and Hunt Club. The honest tradeoff is scale, not capability: a single, smaller seed round versus the later-stage rounds backing several rivals here, a GitHub community (23.9K+ stars) a fraction of LangChain's 142K+, and a product surface split across two separately-adopted repos (the core framework and the newer Letta Code harness).

Google ADK: the only one built for cross-vendor interoperability from day one

Every framework on this list treats "how do I connect to an agent built on a DIFFERENT framework" as an afterthought, if it's addressed at all. Google Agent Development Kit (ADK), first announced at Google Cloud NEXT in April 2025, is built around the opposite premise: it ships native support for the Agent2Agent (A2A) protocol (an open standard, now governed by the Linux Foundation with 150+ organizations reported in production) specifically so agents built on ADK can delegate work to and receive work from agents built on entirely different stacks, alongside native Model Context Protocol (MCP) tool support. It's also the only framework here shipping production-grade SDKs in four languages: Python (the flagship, now at 2.0 GA), Go, Java and TypeScript all reached 1.0 GA, with an additional experimental Kotlin/Android runtime on top, versus every other framework in this list's one to three languages. Despite the obvious Gemini-first branding, it's genuinely model-agnostic through a LiteLLM integration reaching OpenAI, Anthropic Claude, Cohere, local Ollama models and 100+ other providers. The Apache 2.0-licensed core (google/adk-python, 20,900+ stars) is free and fully self-hostable anywhere (Cloud Run, GKE, Docker, or your own infrastructure), with an optional managed Agent Runtime layer (part of the Gemini Enterprise Agent Platform, formerly Vertex AI Agent Engine) for teams that want autoscaling without operating the infrastructure themselves. The honest tradeoff is maturity of the non-Python surface, not capability: an independent hands-on review found documentation and third-party examples still skew heavily toward Python even though the other three SDKs are GA, calls it "an extensive framework" with a real learning curve, and the managed Agent Runtime prices across several independent usage-based meters (compute, memory, session storage) with no flat fee or hard spending cap.

Claude Agent SDK: the only one built around one vendor's harness, not a general-purpose framework

Every other framework on this list is a general-purpose orchestration layer that happens to support (or optimizes for) one model provider while remaining reachable by others. Claude Agent SDK inverts that premise: it isn't a framework that added Claude support, it's the literal agent harness behind Claude Code: the same tool loop, context management and built-in tools (file read/write/edit, bash execution, web search and fetch), exposed as a Python or TypeScript library you call directly. Two APIs cover the two shapes of use: a one-shot query() function, and a stateful ClaudeSDKClient for multi-turn sessions that holds the same subprocess open across exchanges. Custom tools mount as in-process MCP servers via a @tool decorator (no subprocess management), hooks intercept and can block specific tool calls before they run, and subagents let a session delegate focused subtasks. For production, you either self-host the subprocess yourself (Anthropic publishes a hosting cookbook for Docker, Kubernetes and sandbox providers like Modal and E2B) or route the same agent code to Claude Managed Agents, a separate Anthropic-hosted REST API where Anthropic runs the agent and the sandbox instead. The honest tradeoff is the one this section's headline names: Claude models only, by explicit design (a GitHub issue asking Anthropic to support other providers was closed "not planned"), unlike every other major-lab SDK in this table (OpenAI Agents SDK, Google ADK, Microsoft Agent Framework), all of which reach other vendors' models through a LiteLLM-style integration. The MIT license on its two wrapper packages (claude-agent-sdk-python, 7.8k+ stars; claude-agent-sdk-typescript, 1.7k+ stars) doesn't extend to the compiled Claude Code CLI binary they bundle and spawn as a subprocess, which isn't published as source. Anthropic's own docs place overall SDK use under its Commercial Terms of Service. And unlike a framework with a stable, settled pricing story, Anthropic changed how programmatic usage is billed twice within about six weeks in mid-2026, reversing a planned split onto a separate "Agent SDK credit" pool on the day it was due to take effect after user backlash.

Where they overlap, and where they don't compete at all

These twelve aren't twelve competitors for the same job: most pairs solve different problems and get combined in production rather than chosen between. The clearest example in our own index: LlamaIndex's own FAQ states plainly that "many production stacks use both together," pairing LlamaIndex-for-retrieval with LangGraph-for-orchestration, a pattern independently corroborated across the 2026 comparison articles we found when researching our LangChain vs LlamaIndex page. The two frameworks compete head-on only at the edges (LangChain's own retrieval features vs. LlamaIndex's growing agent Workflows); the dominant real-world pattern is complementary, not rival.

Agno's closest comparison in this list is CrewAI (both are free, open-source Python multi-agent frameworks with a paid production layer bolted on top), but the shape of that paid layer is the real difference: CrewAI's is a fully managed cloud runtime with genuine production volume (2B+ trailing-12-month workflow runs), while Agno's AgentOS is BYOC-only, deployed into the customer's own cloud rather than run by Agno. Against Pydantic AI, the split is scope rather than deployment model: Pydantic AI centers narrowly on type-safe, validated structured output, while Agno bundles memory, knowledge and multi-agent Teams as built-in primitives from the start.

CrewAI and LangGraph are a closer head-to-head: both are genuine multi-agent orchestration choices, and our CrewAI vs LangChain page covers that pairing directly: CrewAI trades some of LangGraph's fine-grained control for a faster, more readable path to a working crew. Pydantic AI and the OpenAI Agents SDK are the two newest, most minimal Python entrants, and they don't really compete with each other either. Pydantic AI's centre of gravity is validated structured output from Python type hints, while the Agents SDK's is OpenAI's own primitives (handoffs, guardrails, sessions) for triage-style multi-agent routing. AutoGen and Microsoft Agent Framework are the clearest non-competition of all: they aren't rivals, they're predecessor and successor: Microsoft's own guidance is to evaluate the Agent Framework first for any new build, so AutoGen isn't really competing for new adoption at all right now. Mastra doesn't compete head-on with any of the other rivals either: the language choice (TypeScript vs. Python/.NET/Go) usually settles the shortlist before a feature comparison starts, so a Python team weighing LangChain against Pydantic AI was never going to consider Mastra anyway, and vice versa. Letta stands apart on a different axis entirely: it's the only one that's stateful by design, so the real choice isn't Letta-vs-LangChain on features, it's whether persistent memory is the actual requirement. Google ADK is another axis-of-one: its A2A protocol support means the real question isn't "ADK instead of LangChain," it's whether an agent needs to talk to agents built on OTHER frameworks at all. Microsoft Agent Framework is the only other listing here with any A2A support, so a genuinely multi-framework, cross-vendor deployment is the specific scenario where ADK's design goal matters most, and none of the other nine's internal-only orchestration solves that problem no matter how it's configured. Claude Agent SDK sits outside this whole comparison in a different way still: it isn't really competing to be YOUR framework of choice among ten vendor-neutral options, it's the tool you reach for once you've already decided to build specifically on Claude and want its exact production harness rather than reimplementing a tool loop against the Claude API yourself: the real choice there is Claude Agent SDK vs. hand-rolling it, not Claude Agent SDK vs. LangChain.

One thing all twelve get right

Every framework's core library is free to use: you pay your model provider, not the framework vendor, for the actual agent runs (eleven of the twelve are also open-source; Claude Agent SDK's wrapper is MIT but its bundled CLI binary isn't published as source, so it's free without being fully open). Where they differ is the optional paid layer bolted on top: LangChain's LangSmith (observability, $39/seat/month past a 5,000-trace free tier), LlamaIndex's LlamaCloud (managed document parsing, from $50/month), Pydantic AI's Logfire (observability, free tier plus usage-based paid plans), Mastra Cloud (hosted Studio, observability and deployment, free Starter tier then $250/month Teams), Letta Cloud (a managed layer for the newer Letta Code product, with a genuine free tier then $20/month Pro/API/Teams plans), Microsoft Agent Framework's Foundry Hosted Agents (managed, scale-to-zero deployment, billed as Azure/Foundry consumption rather than a flat price), Google ADK's Agent Runtime (managed, autoscaling deployment, billed as Google Cloud consumption across several usage-based meters), Agno's AgentOS (a BYOC production control plane, $150/month Pro for 4 seats and 1 live connection, custom Enterprise), and Claude Agent SDK's Claude Managed Agents (a separate hosted REST API, billed as standard Claude API token rates plus $0.08/session-hour). CrewAI's only paid offering is a custom-priced Enterprise deployment platform; AutoGen and the OpenAI Agents SDK currently have no first-party paid tier at all. None of the twelve requires paying anything to use the framework itself: the paid layers are all optional production tooling, never a gate on trying the framework.

FAQ

Which AI agent framework should I learn first?

If you don't yet know what you're building, start with LangChain: it has the largest ecosystem, the most tutorials and documentation, and its LangGraph layer covers the widest range of use cases, so skills transfer well even if you switch frameworks later. If you already know your job is retrieval/RAG specifically, start with LlamaIndex instead. If you're building specifically in TypeScript or Next.js and don't want to touch Python at all, start with Mastra instead of any of the Python-first options. If your agent needs to genuinely remember across sessions rather than reset each call, start with Letta instead of any of the stateless options.

Can I use more than one of these frameworks together?

Yes, and it's common: LlamaIndex-for-retrieval paired with LangGraph-for-orchestration is a well-documented production pattern (see LlamaIndex's own FAQ). They're libraries you import, not platforms that lock you in, so combining the retrieval strength of one with the orchestration strength of another is a normal architecture, not a hack.

Is Microsoft AutoGen safe to build on today?

For learning the multi-agent conversation pattern or maintaining existing AutoGen code, yes. For a brand-new, long-lived production system, Microsoft's own README steers new users to the Microsoft Agent Framework instead, which reached a production-ready 1.0 GA release on 2026-04-03. AutoGen itself receives bug and security fixes only (no tagged release since September 2025), and the ecosystem has split three ways (AutoGen, the genuinely active community AG2 fork, and the now-GA Microsoft Agent Framework). Evaluate the successor first.

What is Microsoft Agent Framework, and how is it different from AutoGen?

It's the framework AutoGen and Semantic Kernel became once Microsoft decided to support one unified stack instead of two. It merges AutoGen's multi-agent orchestration with Semantic Kernel's enterprise plumbing into one SDK for .NET, Python and Go, adds a production-ops layer (the Agent Harness, plus an optional Foundry Hosted Agents managed deployment) neither predecessor shipped, and reached a production-ready 1.0 GA on 2026-04-03. Both AutoGen and Semantic Kernel are now in Microsoft-declared maintenance mode, with official migration guides pointing existing projects toward the Agent Framework.

Do any of these frameworks lock me into one LLM provider?

Eleven of the twelve are model-agnostic in practice. LangChain, CrewAI (via LiteLLM), LlamaIndex, AutoGen, Pydantic AI, Mastra (90+ providers behind one routing interface), Letta (bring your own API keys), Microsoft Agent Framework (Azure OpenAI, OpenAI, Anthropic Claude and local Ollama models as first-class providers, plus Google Gemini via its Go SDK), Google ADK (native Gemini, plus OpenAI, Anthropic Claude, Cohere, Ollama and 100+ others via LiteLLM) and Agno (20+ providers, including OpenAI, Anthropic and local Ollama models) all support essentially any major provider. The OpenAI Agents SDK is OpenAI-branded and optimised for OpenAI's own models, but is genuinely provider-agnostic too, supporting 100-plus other LLMs through LiteLLM and the Chat Completions API. Claude Agent SDK is the one genuine exception: it runs Claude models only, by Anthropic's explicit design, and a GitHub issue asking Anthropic to support other providers was closed "not planned."

Which framework has the most integrations?

LangChain, by a wide margin: its own listing describes it as having "unmatched integrations" across models, vector stores and tools, and that breadth is the single biggest reason teams reach for it over a narrower framework even when they don't need LangGraph's control layer specifically.

How is Mastra different from the other eleven frameworks here?

It's the only one built TypeScript-first rather than as a Python library with a JS/TS SDK bolted on. That makes it a natural fit for a team already building in Next.js or Node that wants agents, durable workflows and memory without standing up a separate Python service, but it also means no Python path at all, unlike LangChain, LlamaIndex, AutoGen, Microsoft Agent Framework, Google ADK, the OpenAI Agents SDK, Pydantic AI, Letta, Agno and Claude Agent SDK, which all ship first-party Python support.

How is Letta different from the other eleven frameworks here?

It's the only one built stateful-first. LangChain, CrewAI, LlamaIndex, AutoGen, Microsoft Agent Framework, Google ADK, the OpenAI Agents SDK, Pydantic AI, Mastra, Agno and Claude Agent SDK all rebuild an agent's context from a prompt on every call (or, in Claude Agent SDK's case, persist state only as local session-transcript files unless you wire up your own SessionStore); Letta agents persist as a durable server-side object with git-versioned memory across sessions. That makes it the right pick when an agent genuinely needs to remember and improve over time, not when the task is a bounded, stateless workflow.

What is Google ADK, and how does it compare to Microsoft Agent Framework?

Both are a major AI lab's official, first-party agent SDK with an optional managed hosting layer and native MCP + A2A protocol support, the closest analogues to each other in this category. The practical difference is ecosystem: Google ADK spans four languages (Python, Go, Java, TypeScript) versus Microsoft Agent Framework's three (.NET, Python, Go), and is built for Google Cloud/Gemini rather than Azure/Microsoft Foundry. Neither locks you to its parent company's models: both reach OpenAI and Anthropic Claude alongside their own first-party models.

Does Google ADK lock me into Gemini or Google Cloud?

No to both. The model layer is genuinely open via a LiteLLM integration (OpenAI, Anthropic Claude, Cohere, Ollama and 100+ other providers), and the framework itself is free, Apache 2.0-licensed and fully self-hostable on any infrastructure: Cloud Run, GKE, Docker, or elsewhere entirely. The optional managed Agent Runtime is a Google Cloud convenience, not a requirement.

What is Claude Agent SDK, and how is it different from the other major-lab SDKs here?

It's Anthropic's own official library, built on the same agent harness, tool loop and context management that power Claude Code, not a general-purpose framework that added Claude support. Unlike OpenAI Agents SDK, Google ADK and Microsoft Agent Framework, which all reach other vendors' models through a LiteLLM-style integration, Claude Agent SDK runs Claude models only, by explicit design (a GitHub issue asking Anthropic to support other providers was closed "not planned"). In exchange, it ships the full built-in Claude Code toolset (files, bash, web search/fetch) and native MCP support by default, with a choice between self-hosting the subprocess yourself or handing it to Claude Managed Agents, Anthropic's own hosted REST API.

Is Claude Agent SDK open source?

Partly. The Python and TypeScript wrapper packages both carry an MIT license on GitHub, but Anthropic's own docs state that use of the SDK as a whole is governed by its Commercial Terms of Service, and the compiled Claude Code CLI binary the wrapper bundles and spawns as a subprocess isn't published as source. So, unlike the other eleven frameworks in this comparison, it isn't self-hostable-forever the way a fully open-source framework is.

Is Agno the same as Phidata?

Yes. Agno is the rebrand of Phidata, announced in January 2025: the GitHub organization moved from phidatahq/phidata to agno-agi/agno, and a 2.0 release in September 2025 introduced AgentOS, the production runtime layer. It's free and Apache 2.0-licensed at the core (41,596 GitHub stars, 5,739 forks), with a separately priced AgentOS platform ($150/month Pro, custom Enterprise) that deploys into your own cloud rather than Agno's.

Every framework above carries its own full researched listing: pricing tiers, sourced pros and cons, and a committed verdict on who it's for and who it isn't. Start with the frameworks category, or go deeper on a specific pairing with our CrewAI vs LangChain and LangChain vs LlamaIndex comparisons.