LangChain · LangGraph · LlamaIndex · CrewAI · AutoGen · Pydantic AI · Mastra · DSPy · Haystack · Semantic Kernel.
One question: which one is right for your stage?

1. LangChain LangChain Inc. · category-defining · most-integrated · most third-party tutorials and hires · Python + JS/TS

The category-defining AI agent framework — the right pick when 'most integrations, most examples, most hires who already know the API' is the bar. LangChain ships the largest connector ecosystem in the category (every LLM provider, every vector DB, every retriever, every tool — typically the first SDK to land an integration). Python + JavaScript/TypeScript first-class. AI-baked-in (LangChain was built specifically for LLM application orchestration from day one). Trade-off: API surface area and abstraction layers can feel heavy for simple single-step prompting; the framework earns its weight at 3+ step pipelines and beyond. The default substrate when 'two trillion-dollar companies wired by SideGuy' includes a framework with the deepest third-party ecosystem.

2. LangGraph LangChain Inc. · LangChain-native stateful graph orchestration · best for complex multi-step agent workflows · Python + JS/TS

The LangChain-native stateful agent orchestration layer — the right pick when 'I need a graph state machine for planner → retrieval → writer → QA → human-handoff loops' is the bar. LangGraph models agent workflows as explicit graphs of nodes (steps) and edges (transitions) with a typed shared state object. Built by LangChain Inc. on top of LangChain primitives — every LangChain tool/retriever/LLM works as a graph node. Strong for stateful multi-step agents where the loop has cycles, conditional branching, parallel fan-out, and human-in-the-loop pauses. AI-baked-in. The procurement-defensible upgrade path from LangChain when single-chain abstractions stop fitting; less compelling for shops not on LangChain primitives.

3. LlamaIndex LlamaIndex Inc. · RAG-first heritage · evolved into agents · best for retrieval-heavy applications · Python + TypeScript

The RAG-first framework that evolved into a full agent framework — the right pick when retrieval is the first-class primitive of your application. LlamaIndex started as the leader for indexing + retrieval over private documents (the index/retriever/query-engine triad still defines the API). Evolved into a full agent framework with workflows, multi-step reasoning, and tool use. Strong for any application where 'AI talks to your private data' is the load-bearing axis. AI-baked-in. Python is first-class; TypeScript SDK exists but is less mature.

4. CrewAI CrewAI Inc. · declarative multi-agent framework · role-based · best for 'team of agents' mental model · Python

The declarative role-based multi-agent framework — the right pick when 'I want to define agents as a team with roles, goals, and tasks' is the bar. CrewAI models agent systems as crews of role-defined agents executing tasks against shared goals. Declarative API: define each agent's role + backstory + goal + tools, define tasks with expected outputs, define crew with process (sequential or hierarchical), call kickoff(). The mental model maps cleanly to how operators describe agent teams to non-technical stakeholders. AI-baked-in. Python-first.

5. AutoGen Microsoft Research · conversational multi-agent · research-heavy · best for experimental multi-agent · Python

The Microsoft-backed conversational multi-agent framework — the right pick when experimental multi-agent research and conversation-driven agent loops are the bar. AutoGen models agent systems as conversations between specialized agents (assistant + user-proxy + custom-defined agents) — agents talk to each other to solve tasks. Strong research roots from Microsoft Research; experimental feature velocity ahead of production-stability velocity. Python-first. AI-baked-in. The pick for teams pushing the multi-agent research edge; less compelling for production teams that want declarative simplicity (CrewAI) or stateful determinism (LangGraph).

6. Pydantic AI Pydantic team · type-safe agent framework · Pydantic-native · best for production teams already on Pydantic · Python

The type-safe agent framework from the Pydantic team — the right pick when 'production teams already use Pydantic for schema enforcement' is the bar. Pydantic AI ships agents with first-class Pydantic models for tool I/O, structured output, and dependency injection — every tool input + LLM output is a typed Pydantic model with validation. Built by the same team behind Pydantic and FastAPI; design tradition is type-safety, explicit dependency injection, and zero-magic abstractions. AI-baked-in. Python-only (Pydantic is Python-native). The pick for production Python teams that want Pydantic-native ergonomics and type-safety as a first-class architectural choice.

7. Mastra Mastra Inc. · TypeScript-native agent framework · best for JS/TS teams shipping in Node ecosystems · TypeScript-first

The TypeScript-native AI agent framework — the right pick when 'JS/TS is the only allowed language and TypeScript ergonomics have to be first-class, not an afterthought' is the bar. Mastra ships agents, workflows, RAG, evals, and integrations with TypeScript-first design — type inference flows through tool definitions, agent state, and workflow steps. Built specifically for Node ecosystems shipping AI features (Next.js apps, Express APIs, edge functions). AI-baked-in (TypeScript-native from day one — never a Python framework with a JS port). The pick for shops shipping AI features inside Node-based products where Python is not an option.

8. DSPy Stanford NLP · prompt-optimization research framework · best for teams treating prompts as programs · Python

The Stanford-rooted prompt-optimization framework — the right pick when 'I want to treat prompts as programs and let the framework optimize them against metrics' is the bar. DSPy models agent systems as composable modules with declarative prompt signatures (inputs → outputs typed) and lets compilers optimize the underlying prompts against your evaluation metric. Different paradigm than LangChain/LlamaIndex/CrewAI — DSPy treats prompt engineering as a compile target, not a hand-written artifact. Strong research roots from Stanford NLP. AI-baked-in. Python-first. The pick for research teams + practitioners who want systematic prompt optimization rather than hand-tuning.

9. Haystack deepset · enterprise search heritage · best for European enterprises with on-prem requirements · Python

The deepset-backed enterprise search framework with strong European on-prem heritage — the right pick when 'European enterprise on-prem deployment with mature retrieval pipelines' is the bar. Haystack started as an enterprise search framework (BM25 + neural retrievers + readers) and evolved into a full LLM agent framework. Strong European enterprise customer base. deepset offers managed deployment and enterprise support. AI-bolted-on architecturally for the agent layer (Haystack's heritage is pre-LLM enterprise search; the LLM/agent modules were added later) but the retrieval foundation is mature. Python-first.

10. Semantic Kernel Microsoft · .NET-native (also Python + Java) · best for Microsoft enterprise stack teams · cross-language

Microsoft's .NET-native AI agent framework — the right pick when 'Microsoft enterprise stack standardization (Azure + .NET + Microsoft 365 + Azure OpenAI)' is the bar. Semantic Kernel ships .NET as the first-class SDK with Python and Java SDKs alongside. Built for Microsoft enterprise teams shipping AI features inside .NET applications, Microsoft 365 integrations, and Azure-native deployments. AI-bolted-on architecturally (Microsoft retrofitted Semantic Kernel onto pre-AI .NET application architecture; the framework reflects .NET design conventions more than AI-native abstractions) but for Microsoft enterprise shops the procurement-fit dominates the technical tradeoff. The Microsoft enterprise pick where AutoGen is the Microsoft research-heavy pick.

🚀 If you're a Solo founder building first AI agent feature

Your problem: You're a solo or 2-3 person team shipping your first AI agent feature into production. Single agent that calls a few tools, handles retrieval, returns structured output. You need a framework you can wire in days — not weeks — and won't have to migrate off in 6 months. Pair this decision with the AI Infrastructure megapage for the model substrate decision and the LLM Observability megapage for the monitoring substrate.

1. LangChain — largest ecosystem + most tutorials + most familiar API; the procurement-defensible default when you don't know what you'll need yet
2. LlamaIndex — if your agent is RAG-first (talking to private docs), the deepest retrieval API in the category
3. Pydantic AI — if you're already on Pydantic and want type-safe tool I/O from day one — production-first design tradition
4. Mastra — if you're shipping inside a Next.js or Node app — TypeScript-native means no Python service to deploy alongside
5. CrewAI — if your problem maps cleanly to 2-3 role-defined agents — declarative API onboards fast

📈 If you're a Series A startup with 5-20 production agents

Your problem: You have product-market fit and 5-20 AI agents in production. Real customer impact when an agent fails. Multi-step workflows are emerging — planner → retrieval → executor → QA loops. You need stateful orchestration, observability, and the ability to add new agents without rewriting the framework layer every quarter. Pair with the LLM Observability megapage for trace + eval discipline and the Vector Databases megapage for the memory substrate at this scale.

1. LangGraph — stateful graph orchestration is the right shape for planner→retrieval→executor→QA loops; first-class LangSmith tracing
2. LangChain — if your agents are simpler chains and the third-party ecosystem matters more than graph orchestration
3. LlamaIndex — if the agents are predominantly RAG-shaped — the retrieval foundation is mature for production
4. Pydantic AI — type-safe tool I/O cuts schema-bug surface area meaningfully at this scale where reliability matters
5. CrewAI — if the agents map to role-based teams and you have 3-5 crew per workflow

🏢 If you're a Mid-market team standardizing agent infrastructure across multiple products

Your problem: You're 50-500 employees with 3-10 product teams each shipping AI features on different frameworks today. Cost discipline matters (engineer time on framework migrations is real budget), reliability matters (customer-facing agents can't break), and you need a substrate the next 5 years of AI products will run on. Coordinate with the Compliance Authority Graph for SOC 2 / DPA posture and the LLM Observability megapage for the cross-team observability substrate.

1. LangChain + LangGraph — largest ecosystem + stateful orchestration + first-party LangSmith observability — the procurement-defensible standardization bet
2. LlamaIndex — if retrieval-heavy products dominate the product portfolio — RAG depth wins at scale
3. Pydantic AI — if Python is org-standard and type-safety is a load-bearing architectural choice for production reliability
4. Mastra — if TypeScript / Node is org-standard for the application layer — TypeScript-native cuts service boundary complexity
5. Haystack — if European data residency + on-prem deployment + deepset commercial support are load-bearing

🏛 If you're a Enterprise CTO standardizing agent framework org-wide (security · compliance · multi-team)

Your problem: You're 1000+ employees standardizing AI agent infrastructure across the org. Multiple AI teams, multiple frameworks today (some on LangChain, some on raw SDKs, some on internal frameworks), multi-cloud reality, .NET + Python + TypeScript all in production. Strict procurement, central FinOps, audit + compliance + DPA + BAA. AI-baked-in vs AI-bolted-on matters at this 5-year horizon (see /operator cockpit for the operator-layer view).

1. LangChain + LangGraph — AI-baked-in + largest ecosystem + first-party LangSmith observability + procurement-defensibility — the AI-native enterprise default
2. Semantic Kernel — if Microsoft Azure + .NET + Microsoft 365 are org-standard, the procurement-defensible Microsoft enterprise pick
3. LlamaIndex — for retrieval-heavy products where RAG depth dominates the framework decision
4. Haystack — if European on-prem deployment + deepset commercial support + EU data residency are load-bearing
5. Pydantic AI — for Python production services where type-safety is a load-bearing architectural choice