By May 2026, the orchestration-framework conversation has converged on four serious choices: LangGraph (stateful production with durable execution), CrewAI (fast role-based prototypes), AutoGen (conversational depth at 5-6x the cost overhead of LangGraph), and Microsoft Agent Framework (enterprise-conversational, the heir to Semantic Kernel and the AutoGen production runtime merged). The other names you hear — LlamaIndex Workflows, Swarm/Swarm-2 from OpenAI, Haystack Agents, Pydantic AI — are real options for specific niches but not architect-default choices. This lesson is the defensible recommendation. The 2026 trade-offs, the named numbers, the migration paths, and the single answer to "what should we pick this quarter?" for each of the five most common architect situations. If you only read one section, read the decision table at the end — it is the deliverable.

The 2026 Framework Landscape

Four serious choices, ranked by 2026 production adoption among architect-led teams shipping at scale:

1. LangGraph — the production default. Stateful graph orchestration with durable execution via Postgres/Redis/SQLite checkpointing, time-travel debugging, native LangSmith observability. The framework most teams converge on at production scale.
2. CrewAI — the fast-prototype default. Role-based crews with manager agents, 90-minute time-to-first-working-multi-agent, opinionated API. The framework most teams use for the first eight weeks before migrating.
3. AutoGen — the conversational-depth choice. Multi-agent group chats, sophisticated dialogue patterns, the AutoGen Studio visual builder. Higher cost overhead (5-6x vs LangGraph on equivalent workloads) but the right answer when conversational depth between agents is the requirement.
4. Microsoft Agent Framework — the enterprise-conversational choice. Released GA in February 2026, merging Semantic Kernel's enterprise plumbing with AutoGen's conversational runtime. The answer when you are already on Microsoft Graph + Entra ID + Copilot Studio and want the agent stack to align.

Each of these is a serious framework with named production deployments. The recommendation conversation is not "which is best" — it is "which fits your situation." This lesson gives you the situation-specific answer.

LangGraph: The Production Default

What it is

LangGraph (from the LangChain team) is a stateful graph orchestration framework for agents. Agents are modeled as graphs over typed state. Nodes are agent steps (LLM calls, tool calls, conditional routers). Edges are transitions. The state schema is explicit and durable — every state transition can be persisted to Postgres, Redis, or SQLite.

What it does well

• Durable execution. The killer feature. Every step checkpoints to persistent storage. If the agent crashes mid-tool-call, it resumes from the last checkpoint. Long-running workflows (hours-long approval flows, multi-day research tasks) become reliable rather than brittle.
• Time-travel debugging. You can replay the graph from any checkpoint. The 2:47 AM Tuesday incident? Open the trace, replay the graph from the state just before the bad decision, see exactly what the agent thought. Under-5-minute incident triage.
• Native observability. LangSmith integration is one config line. Multi-agent traces, tool-call traces, latency breakdowns, cost attribution all in one console.
• Graph-shaped multi-agent. The orchestrator-worker pattern, agent-network patterns, hierarchical patterns, and human-in-the-loop interrupts all express cleanly as graphs.
• LangGraph Studio. Visual graph editor and runtime that lets non-engineers inspect, edit, and deploy graphs. Closed the "platform vs code" gap that LangChain alone could not.

What it does poorly

• Learning curve. The graph + state model is unfamiliar to teams used to chains or crews. First production deployment takes 4-8 weeks of team learning.
• Verbose for trivial cases. A two-step agent in LangGraph requires more code than the equivalent in CrewAI. The verbosity pays off at scale; it stings at prototype.
• Python-first. The JavaScript/TypeScript port (LangGraph.js) exists and is production-viable as of 2026 but the ecosystem maturity is still behind Python by ~6 months.

The numbers

• Adoption: by Q2 2026, ~62% of architect-led production multi-agent deployments at companies >500 employees, per the LangChain State of AI Agents 2026 report (caveat: vendor-published).
• Cost overhead vs raw LLM API calls: ~3-7% (checkpoint storage + LangSmith ingestion).
• Production references: LinkedIn (Recruiter agent), Klarna (customer agent), Elastic (security agent), Replit (code agent).
• Pricing: open-source core. LangGraph Platform (managed runtime + observability) starts ~$39/seat/month for teams, $1,500/month base for production deployments.

When to pick LangGraph

Production matters more than prototype speed. You have at least one engineer who can absorb the graph/state mental model. You have long-running workflows (hours+) or human-in-the-loop interrupts. Incident response time matters (regulated industry, customer-facing). You expect to scale beyond 50,000 queries per day.

CrewAI: The Fast-Prototype Default

What it is

CrewAI is a role-based multi-agent framework. You define agents (each with role, goal, backstory, tools). You define tasks (each with description, expected output, agent assignment). You define a crew (the team of agents). Run the crew. The framework handles agent communication, task sequencing, and optional manager-agent orchestration.

What it does well

• Fast time-to-prototype. 90 minutes from blank file to working multi-agent crew. The role-based API is intuitive and reads like English.
• Hierarchical mode. CrewAI's manager agent pattern maps directly to the orchestrator-worker pattern. Useful for the "I want a router and three specialists" case.
• CrewAI Studio. The visual builder launched in late 2025 lets non-engineers compose crews. Salesforce-meets-LangGraph-Studio.
• Strong defaults. Good prompt scaffolding out of the box. Beginners produce reasonable agents on the first try.
• Tools ecosystem. ~120 pre-built tools in the official CrewAI tools package by Q2 2026.

What it does poorly

• Production durability. CrewAI's hierarchical mode is less battle-tested than LangGraph for long-running stateful workflows. The checkpoint story is improving in 2026 (Memory module added in Q1 2026) but still trailing.
• Debugging at scale. The high-level abstractions make it harder to debug when things go wrong. You often need to drop into the underlying chain code anyway.
• Lock-in to the role/goal/backstory pattern. Works well for most cases. Awkward when your agent does not fit a "role" metaphor (data-processing agents, structured-output agents).
• Observability still developing. Native CrewAI tracing is functional but less mature than LangSmith. Most production teams pipe CrewAI through Langfuse or Arize Phoenix.

The numbers

• Adoption: ~24% of architect-led production multi-agent deployments. Higher (~40%) for prototype-phase deployments.
• Cost overhead: ~5-10% over raw LLM calls (prompt scaffolding tax).
• Production references: Cloudflare (internal agents), Adobe (creative-workflow agents), Booking.com (research agents).
• Pricing: open-source. CrewAI Enterprise (managed runtime + studio) ~$200/month base, scales with usage.

When to pick CrewAI

You are building a prototype to validate the pattern. You have fewer than five specialists. Your sessions are under five minutes. You do not yet need time-travel debugging. Your team is new to multi-agent and you want fast iteration. You expect to migrate to LangGraph or Microsoft Agent Framework at production scale (and that is fine — it's a 4-6 week migration when the time comes).

AutoGen: The Conversational-Depth Choice

What it is

AutoGen (originally Microsoft Research, now jointly maintained with the AutoGen community) is a multi-agent framework optimized for conversational depth between agents. Its core pattern is the "group chat" — multiple agents talk to each other, with a conversation manager choosing who speaks next, until a termination condition is met.

The original AutoGen runtime is now folded into Microsoft Agent Framework (covered in the next section), but the AutoGen 0.4+ research line continues as the experimental playground. For 2026, when this lesson says "AutoGen," it means the AutoGen Studio and AutoGen 0.4+ research line — not the production runtime, which lives in Agent Framework.

What it does well

• Deep multi-agent conversations. The group-chat pattern produces conversational depth between agents that other frameworks struggle to match. Useful for research, brainstorming, debate-style problem solving.
• Sophisticated turn-taking. The conversation manager can be a rule-based selector, an LLM-based selector, or a custom function. You can express patterns like "always alternate between researcher and critic" or "let the agent who has the most information speak next."
• Code-execution patterns. AutoGen's strength in agent-writes-code-then-executes patterns made it the default for early agent-in-Jupyter and agent-in-CLI use cases. Still strong here.
• AutoGen Studio. Visual workflow builder for the conversational patterns. Used heavily for academic research and prototyping.

What it does poorly

• Cost. The killer issue. Group-chat patterns produce many LLM calls per turn (each agent's turn, the conversation manager's selection, the termination check). Production benchmarks consistently show 5-6x the cost overhead of an equivalent LangGraph implementation on the same workload.
• Latency. Same reason as cost. More LLM calls per turn = more wall-clock latency. Voice-agent use cases are generally infeasible.
• Production durability. The pure-AutoGen runtime has weaker checkpoint support than LangGraph. Teams running production AutoGen often migrate to Microsoft Agent Framework for the durable runtime.
• Debugging. Group-chat traces are hard to read. The conversation manager's selection logic is often LLM-based and therefore opaque.

The numbers

• Adoption: ~6% of architect-led production multi-agent deployments. Much higher (~28%) in research and academic settings.
• Cost overhead vs LangGraph: ~5-6x on equivalent workloads, per Microsoft Research's own published benchmarks and independent reproductions.
• Production references: research-heavy use cases, GitHub Copilot's agent-mode early prototypes (since migrated to Microsoft Agent Framework), academic agent-research labs.
• Pricing: open-source. AutoGen Studio is free. The production deployments mostly go through Azure OpenAI for billing.

When to pick AutoGen

Conversational depth between agents is the actual requirement (research workflows, multi-perspective brainstorming, agent debate). Latency budget is loose (over 30 seconds per turn is acceptable). Cost budget is loose. You are in a research or experimental context. Otherwise: pick Microsoft Agent Framework if you want the conversational runtime in a production-grade wrapper, or LangGraph if conversational depth is not actually the requirement.

Microsoft Agent Framework: The Enterprise-Conversational Choice

What it is

Microsoft Agent Framework (GA in February 2026) is the merger of Semantic Kernel (Microsoft's enterprise LLM orchestration library, .NET-first with strong Python support) and the AutoGen runtime (multi-agent conversation patterns). It is positioned as the production-grade agent framework for the Microsoft stack — Entra ID identity, Microsoft Graph for data, Microsoft Fabric for warehouse access, Copilot Studio for the no-code entry point, and Agent Framework for the code-first deployments.

What it does well

• Enterprise authentication. Entra ID, conditional access, managed identity all wire up cleanly. The Azure-first organization gets identity for free.
• Microsoft Graph integration. Calendar, email, Teams, SharePoint, OneDrive — the Microsoft 365 data graph is a single SDK call away. For internal-productivity agents, this is a 6-12 week head start over building the same integrations from scratch.
• AutoGen-pattern conversation runtime. Group-chat, multi-agent conversation, sophisticated turn-taking — all the AutoGen patterns, in a production-grade runtime with durable execution and Azure-native observability.
• .NET and Python support. Unusual among 2026 frameworks. .NET-first organizations get a first-class citizen, not an afterthought.
• Copilot Studio interop. Agents built in Agent Framework can be exposed to Copilot Studio's no-code surface, letting business users build flows that call Agent Framework agents.

What it does poorly

• Azure lock-in. Designed for Azure-deployed organizations. AWS-native or GCP-native orgs find it awkward (you can run it elsewhere, but the integrations are weaker).
• Newer. GA February 2026 means production references are still building. Six months in, ecosystem is real but smaller than LangGraph's.
• Conceptual surface area. Inherits complexity from both Semantic Kernel and AutoGen. The learning curve is similar to or steeper than LangGraph's.
• Cost. Better than pure AutoGen (the production runtime is more efficient) but still higher than LangGraph (~2-3x on equivalent multi-agent workloads).

The numbers

• Adoption: ~8% of architect-led production multi-agent deployments in Q2 2026 — heavily concentrated in Microsoft-stack organizations. Trajectory steep upward.
• Cost overhead vs LangGraph: ~2-3x for multi-agent conversational workloads.
• Production references: Microsoft's own internal agents (M365 Copilot extensions, GitHub Copilot agent mode), large financial services firms standardizing on Azure (named: a top-3 US bank, a top-5 UK bank).
• Pricing: open-source. Production deployments via Azure AI Foundry, priced by Azure OpenAI consumption + Foundry runtime fees.

When to pick Microsoft Agent Framework

You are an Azure-deployed org with Entra ID identity, Microsoft Graph data, and Copilot Studio already in use. Your agents need conversational depth (research, multi-step analysis, debate-style). Your .NET teams need to participate in agent development. You want Microsoft to own the support contract.

The Honorable Mentions

These are real frameworks with real use cases, but they are not architect-default choices for general multi-agent production work.

LlamaIndex Workflows

The event-driven multi-agent framework from LlamaIndex. Excellent for RAG-heavy multi-agent designs where retrieval is the dominant operation. Choose when LlamaIndex is already your retrieval layer. ~3% adoption.

OpenAI Swarm and Swarm-2

OpenAI's lightweight multi-agent reference implementation. Swarm-2 (March 2026) added durable execution. Easy to learn, less feature-rich than LangGraph. Best fit: OpenAI-API-only stacks at small scale. ~4% adoption, trending up after Swarm-2.

Haystack Agents (deepset)

Strong for European deployments (German company, GDPR-first design), production-mature pipeline model. Less multi-agent-native than LangGraph. ~2% adoption.

Pydantic AI

The type-safe agent framework. Best fit for Python teams who want Pydantic-style strictness. Lighter weight than LangGraph. Excellent for single-agent and small-multi-agent cases. ~3% adoption.

Vercel AI SDK

Strong for Next.js/TypeScript front-end deployments where the agent lives close to the UI. Not a primary multi-agent framework. Better positioned as a streaming + tool-calling layer.

Platform-native: Lindy, Relevance AI, Flowise

No-code platforms covered in Lesson 1. The "platform-native" choice when you do not want to manage a framework at all. Right for citizen-developer and small-team prototypes.

The Architect's Decision Table

The deliverable. Five common architect situations, the recommended framework, and the reason.

1. "We need to ship a multi-agent prototype in two weeks to validate the pattern with stakeholders." → CrewAI. 90-minute time-to-first-crew. Migrate later if the pattern validates.
2. "We are at production scale. We need durable execution. Incident response time matters." → LangGraph. The 2026 production default. Time-travel debugging earns its complexity.
3. "We are an Azure-deployed org with Entra ID and Microsoft Graph. Our use case has conversational depth." → Microsoft Agent Framework. The integration head start is 6-12 weeks of work you do not have to do.
4. "We need genuine multi-agent conversation depth for research/brainstorming/debate. Cost and latency are loose." → AutoGen (with a planned migration to Microsoft Agent Framework when you move to production).
5. "We have no engineers. Citizen developers and PMs are building the agents." → Platform-native (Lindy + Relevance + Vellum, or n8n with the AI Agent node). Frameworks come later if at all.

The Migration Paths That Actually Work

Most teams pick one framework and stay. Some teams pick wrong and migrate. The migration paths that actually work in 2026:

CrewAI → LangGraph

The most common migration. Pattern: 4-6 weeks of work. Rewrite agents as LangGraph nodes (one node per CrewAI agent). Rewrite the manager as the LangGraph orchestrator with conditional edges. Pull the prompts directly (CrewAI's role/goal/backstory pattern translates to LangGraph system prompts cleanly). Keep the eval set. Validate against the eval set before cutting over. The reason this works: the role-based CrewAI structure maps directly to graph nodes.

AutoGen → Microsoft Agent Framework

Increasingly common as Agent Framework matures. 4-8 weeks. AutoGen agents become Agent Framework agents directly (Agent Framework is a superset of AutoGen). The migration is more about adopting the production runtime than rewriting agent logic.

Custom-built → LangGraph

The pattern when an engineering team built their own orchestration layer in 2023-2024 and wants to stop maintaining it. 6-12 weeks. The hard part is unwinding the custom state management; the LangGraph state schema usually subsumes whatever was custom-built.

Platform-native → CrewAI/LangGraph

The pattern when a Lindy/Relevance prototype validated and the team needs production-grade code. 2-4 weeks for CrewAI, 6-8 weeks for LangGraph. The agents migrate prompt-first; the tool integrations are the time sink.

The Defensible Recommendation

Two-sentence defensible recommendation for the 2026 architect:

Default to a single smart agent (see the previous lesson). If multi-agent is justified, prototype in CrewAI for 4-8 weeks. Then make a deliberate production-framework choice — LangGraph if you need durable execution and time-travel debugging, Microsoft Agent Framework if you are Azure-native and need conversational depth, AutoGen only if conversational depth is the literal requirement and cost is not a constraint.

For 80% of architect situations in 2026, the answer is LangGraph. For ~10%, Microsoft Agent Framework. For ~5%, CrewAI as the long-term answer (not migrating). For ~5%, something else.

What This Lesson Deliberately Did Not Cover

This lesson did not cover the LangChain-vs-LangGraph confusion ("LangChain is the chains library; LangGraph is the graph library; they share a team and a Python package but are different products"). It did not cover the durable-execution comparison with Temporal/Inngest (that is a separate question covered in chapter 4.3). It did not cover the Build-vs-Buy decision against Salesforce Agentforce or Microsoft Copilot Studio (covered in chapter 4.1). It did not cover the A2A protocol or interoperability between framework choices (chapter 4.3). The scope here is intentionally narrow: pick the framework, defensibly.

Key Takeaways

• Four serious frameworks in 2026: LangGraph (62% adoption), CrewAI (24%), Microsoft Agent Framework (8%, trajectory steep), AutoGen (6%, mostly research). The other names (LlamaIndex Workflows, OpenAI Swarm-2, Haystack, Pydantic AI, Vercel AI SDK) are niche choices, not architect defaults.
• LangGraph is the production default — durable execution via Postgres/Redis/SQLite checkpoints, time-travel debugging, native LangSmith. Cost overhead 3-7% over raw LLM calls. Pick when production matters.
• CrewAI is the fast-prototype default — 90-minute time-to-first-crew, role-based API, manager-agent hierarchical mode. Cost overhead 5-10%. Pick for validation, migrate at production scale.
• AutoGen is the conversational-depth choice — group-chat patterns, sophisticated turn-taking. Cost overhead 5-6x LangGraph. Pick only when conversational depth is the literal requirement and cost/latency budgets are loose.
• Microsoft Agent Framework (GA February 2026) is the enterprise-conversational choice — Semantic Kernel + AutoGen merger, Entra ID/Graph/Fabric integration. Cost overhead 2-3x LangGraph. Pick for Azure-native organizations with conversational depth requirements.
• Decision table: CrewAI for 2-week prototypes, LangGraph for production at scale, Agent Framework for Azure + conversational, AutoGen for research/depth-only, platform-native for citizen-developer teams.
• Migration paths: CrewAI → LangGraph is 4-6 weeks and the most common; AutoGen → Agent Framework is 4-8 weeks; platform-native → framework is 2-8 weeks depending on framework.
• The defensible recommendation: for 80% of architect situations, LangGraph. For ~10%, Microsoft Agent Framework. For ~5%, CrewAI long-term. For ~5%, something else. Make the choice deliberately, not by fashion.