Five Agent Frameworks, one Decision Matrix

This post anchors to the open-source agent framework landscape as of May 20, 2026 — five canonical frameworks that have already shifted under teams' feet: Swarm archived, AutoGen in maintenance mode, LangGraph 1.0 GA, CrewAI 1.0 GA, Smolagents holding the sub-1,000-LOC code-first lane. Choosing among them by star count is the wrong axis. The right axis is mental model.

Two of the five are already in managed transition: OpenAI archived the Swarm repo in March 2025 and redirected users to the production Agents SDK; Microsoft moved AutoGen to maintenance mode in early 2026 and shipped the Microsoft Agent Framework (MAF) 1.0 as the greenfield successor in April 2026. Teams that evaluate frameworks from 2024 blog posts are still being sent to both deprecated paths. That mis-routing has real consequences — maintenance-mode frameworks receive bug fixes only, and archived repos receive nothing.

This guide covers each framework's mental model, core API, and production posture; the 18-row × 5-column comparison matrix that consolidates every decision dimension in one place; a 6-question decision tree; and the case for ignoring star counts entirely in favor of verified production case studies. If you want to understand the patterns these frameworks run — fan-out, pipeline, supervisor, debate, swarm — the companion post on 5 multi-agent orchestration patterns covers that orthogonal axis.

Before diving into each framework, it helps to have the five mental models laid out side by side. Every ergonomic difference — scaffolding time, learning curve, production fit — follows predictably from the mental model. The section after this one covers each framework in depth; the matrix in Section 07 tabulates every dimension.

LangGraph 1.0 reached general availability on October 22, 2025, with zero breaking changes from v0.x — the existing API carries forward. The same day, LangChain 1.0 (Python and TypeScript) also went GA. The canonical 2026 entry point is create_agent (Python) or createAgent (TypeScript) with a middleware array exposing hooks before_agent, before_model, wrap_model_call, wrap_tool_call, after_model, and after_agent. For fully custom orchestration, StateGraph remains the lower-level primitive — define nodes, edges, and a typed state schema, then compile and run.

The defining production capability is checkpointing. LangGraph ships built-in checkpointers for Postgres and Redis. Any state can be replayed forward from any prior checkpoint — time-travel debugging in practice. When an agent crashes mid-workflow, resume from the last good checkpoint. When a workflow reaches a human-approval gate, suspend there and resume only after an asynchronous approval signal arrives. No other open-source framework in this comparison offers this depth of state management out of the box.

The production track record is the strongest of the five. According to LangChain's own case study post, Klarna's AI Assistant — powered by LangGraph and LangSmith — serves 85 million active users and reportedly reduced customer resolution time by 80%. LinkedIn runs a hierarchical recruiter agent and a SQL Bot. Uber's Developer Platform uses LangGraph for automated unit-test generation, reportedly saving ~21,000 developer hours. Replit built a human-in-the-loop multi-agent system on it. These are vendor-confirmed; treat them as directional, not audited.

The trade-off is the graph mental tax. Building a 3-step prototype in LangGraph feels like overkill — the StateGraph definition, conditional edges, and checkpointer setup add ceremony that CrewAI or the Agents SDK don't require at that scale. For workflows that need explicit state and production-grade recovery, LangGraph pays for itself within the first production incident. For throwaway prototypes, reach for something else. See the LangChain vs LangGraph comparison for the detailed API difference between the two.

AutoGen v0.4 was a major architectural rewrite that reorganized the codebase into three layered packages: autogen-core (the asynchronous actor runtime), autogen-agentchat (the multi-agent conversation primitives), and autogen-ext (integrations). The actor model means agents are addressable entities that exchange typed messages; the runtime handles routing, lifecycle, and OpenTelemetry span emission. GroupChat is the canonical multi-agent primitive — manager-routed or fixed-turn-order message passing across specialized agents.

The critical fact for 2026 builds: AutoGen is in maintenance mode as of early 2026. It will receive bug fixes and security patches; it will not receive new features. The successor for new builds is the Microsoft Agent Framework (MAF) 1.0, which reached GA in April 2026 and merges AutoGen with Semantic Kernel under a single production-grade umbrella. For .NET shops, MAF is the only current path with active feature development. For teams already running AutoGen v0.4, a migration guide is live on Microsoft Learn; our Microsoft Agent Framework 1.0 guide walks the successor architecture in detail.

AutoGen's star count (~50–55k, verify at publish day) leads the field — an artifact of the large V0.2 era community rather than a signal of current momentum. That gap between star count and maintenance posture is the clearest example of why star-based framework selection fails.

CrewAI 1.0 OSS went GA on October 26, 2025. The mental model is role-based: each Agent has a role, goal, backstory, and tool list. Each Task has a description, expected output, and an assigned agent. A Crew collects agents and tasks, then runs a Process. Two processes are available in production: Sequential (tasks run in order) and Hierarchical (a manager LLM routes tasks to specialist agents). A Consensual process is planned but not yet implemented as of May 2026.

For more complex orchestration, CrewAI Flows adds a Python class-based primitive with @start, @listen, and @router decorators that orchestrate arbitrary mixtures of crews, agent calls, and regular Python code. Flows is the recommended primitive when the workflow outgrows Sequential or Hierarchical.

The fastest scaffold time of the five — approximately 10 minutes from pip install crewai to a working multi-agent flow via the CLI scaffolder. That speed makes CrewAI the natural choice for teams running parallel proof-of-concepts or for workflows that map cleanly to a researcher → writer → editor → reviewer role chain. For the detailed comparison between CrewAI and LangGraph architecture, see the deep-dive on LangGraph vs CrewAI.

As of v1.10.x, CrewAI supports MCP servers as first-class tools and A2A (Agent-to-Agent) task execution. CrewAI Inc. claims their framework powers approximately 1.4 billion agentic automations per month and is used by 60% of the Fortune 500. These figures are vendor-stated and have not been independently audited — treat them as directional marketing.

OpenAI Swarm is archived. It was always an educational framework — described in its own README as "exploring ergonomic, lightweight multi-agent orchestration" — and OpenAI stopped updating it when the production Agents SDK launched in March 2025. Bug reports and PRs against the openai/swarm repo are not triaged. The Swarm README explicitly redirects users to the Agents SDK.

The OpenAI Agents SDK is the production successor. The Python package (openai-agents) released v0.17.3 on May 19, 2026 — the day before this post's publish date. The TypeScript counterpart (@openai/agents) released v0.8.3 on April 6, 2026. The SDK is provider-agnostic — it supports OpenAI Responses and Chat Completions APIs alongside 100+ other LLMs.

The mental model is handoff-centric. The multi-agent primitive is a handoff: one agent delegates to another. Around that core sit guardrails (input and output validation), sessions (automatic conversation history), and tracing (debug and observability). In April 2026, OpenAI added two major capabilities: the Model-Native Harness (a control plane owning the agent loop, model calls, tool routing, handoffs, approvals, tracing, and run state) and Sandbox Execution (a controlled environment for file I/O, command execution, package install, port exposure, and state snapshotting). Sandbox providers include Blaxel, Cloudflare, Daytona, E2B, Modal, Runloop, and Vercel — making the Agents SDK the strongest fit for TypeScript-first Next.js deployments of the five. Source: OpenAI, "The next evolution of the Agents SDK".

HuggingFace launched Smolagents on December 31, 2024 with an unusual pitch: "a barebones library for agents that think in code." The core logic is approximately 1,000 lines — deliberately kept small so any engineer can read and audit it in a single sitting. That constraint is the differentiator, not an oversight.

The mental model is code-first. The primary agent type, CodeAgent, writes Python code snippets as its actions rather than calling JSON tool schemas. This makes tool composition natural — agents can nest function calls, use loops, and apply conditionals in the same way a developer would. The alternative, ToolCallingAgent, uses the classic JSON tool-call format for teams that prefer the more constrained interface. Both extend MultiStepAgent, the ReAct-loop base class.

Code-first execution means arbitrary Python runs — which requires a sandbox in any production or multi-tenant context. Supported sandbox providers: Modal, E2B, Blaxel, and Docker. Without a sandbox, CodeAgent executes in the host process, which is acceptable for local development and fully trusted environments only.

Smolagents is model-agnostic — any LLM accessible via litellm works, as do local models via transformers or ollama. MCP tool support is available via MCPClient; MCP resources support is an open feature request (issue #1460) and not yet shipped as of May 2026. The framework holds approximately 26.5k GitHub stars (verify at publish day) under an Apache 2.0 license (verify in the LICENSE file). Latest stable: v1.24.0, released January 16, 2026.

Worst fit: production multi-tenant systems at scale without adding your own checkpointing layer. Smolagents deliberately keeps state management out of scope — the 1,000-LOC ethos means the framework does not try to solve every problem. For HuggingFace-ecosystem teams that need auditability above all else, it remains the only framework in this comparison that makes auditing feasible at all.

The table below is the canonical single-page reference for choosing among the five frameworks. Star counts and version numbers are dated May 20, 2026 and flagged for re-verification at your publish or evaluation date — both move daily. All other rows draw from primary sources cited throughout this post.

The matrix above is the asset that doesn't exist elsewhere in consolidated form. Most published comparisons either cover two or three frameworks, drop half the dimensions, or miss the Swarm → Agents SDK and AutoGen → MAF transition rows entirely. The 18-row format is designed to be the single-tab reference a team can share during a framework-selection decision. Verify star counts and version numbers at your evaluation date — both change daily.

For the broader architectural patterns that run on top of any of these frameworks — fan-out, pipeline, supervisor, debate, swarm — the agent architecture patterns taxonomy covers that layer. For known failure modes when implementing any of these, see orchestration anti-patterns.

Most teams don't need to evaluate all five frameworks. They need to answer six questions in order and arrive at one. The tree below follows real 2026 production constraints — TypeScript-first stacks, auditability requirements, workflow shape, checkpointing needs, cloud-stack alignment, and sandbox requirements. Work through each question; stop at the first "Yes."

GitHub star counts are the most-cited and least-useful signal in framework selection. The chart below shows approximate star counts as of May 2026 (verify at publish day — all move daily). Note the inversion: AutoGen leads on stars by a wide margin yet is in maintenance mode. LangGraph trails significantly yet has the most independently-confirmable production deployments of any open-source agent framework.

The star-count inversion is worth interpreting directly. AutoGen accumulated its star count during the 2023–2024 period when it was the most-discussed multi-agent framework in AI research circles. That popularity predates its maintenance-mode transition by two years. Stars from that era persist; feature development doesn't. A framework selected by star count in May 2026 will be built on a framework that has already entered end-of-life for features.

The more meaningful signal is production case study quality. LangGraph has four vendor-confirmed deployments with named companies and quantified outcomes (Klarna 85M users / 80% resolution reduction, Uber ~21K dev-hours). Those are testable claims backed by specific engineering teams. CrewAI's "1.4B automations / 60% F500" is vendor-stated marketing without third-party corroboration — informative for momentum, not for technical confidence. Smolagents has one independent cloud-vendor-published case study (AWS). Agents SDK and AutoGen have internal OpenAI and Microsoft footprints that are real but harder to evaluate externally.

The forward projection is clearer than the current snapshot: teams adopting LangGraph 1.0 or the Agents SDK today are on active development paths with growing ecosystems. Teams adopting AutoGen for new builds face a migration to MAF within the next 12–18 months anyway. The star-count shortcut actively leads teams into that migration debt.

Every ergonomic friction point in agent framework adoption traces back to a mismatch between the team's mental model of the workflow and the framework's native mental model. A team that thinks of their agents as a cast of specialized roles will find CrewAI frictionless and LangGraph foreign — even though LangGraph is technically capable of the same workflow. A team that thinks in directed graphs will find LangGraph natural and CrewAI's role-based abstractions limiting when they need a conditional edge.

The five mental models in this comparison are not arbitrary style choices. Each reflects a different philosophy about what the core agent primitive should be:

• Graph (LangGraph): The workflow IS the graph. State is explicit. Every transition is an edge. Complexity is managed by making structure visible.
• Actor (AutoGen → MAF): Agents ARE actors. They communicate by message-passing. The runtime handles the rest. Complexity is managed by isolating agents behind typed message boundaries.
• Role (CrewAI): Agents ARE people on a team. Give them a job description and they collaborate. Complexity is managed by organizational analogy.
• Handoff (Agents SDK): The multi-agent primitive IS the handoff. One agent passes control to another. Complexity is managed by composing simple delegation chains.
• Code-first script (Smolagents): The agent IS a Python programmer. Actions are code. Complexity is managed by the full power of the language — loops, conditionals, function composition — with the constraint of a 1,000-line core that never hides what it does.

The practical implication: before running a framework benchmark or reviewing a star-count table, ask which mental model your workflow already follows. If the answer is clear — role-based pipelines with defined specialists — the framework selection is nearly determined. If the answer is ambiguous — a mix of stateful graph steps and role-based delegation — that ambiguity is the signal that a hybrid architecture is worth evaluating, and the Claude Agent SDK production patterns guide covers cross-framework production discipline that applies regardless of which orchestration layer you choose.

For TypeScript teams evaluating this landscape, the Vercel AI SDK 6 deep dive covers the stop-condition and tool-call API that bridges any of these frameworks into a Next.js deployment. The MCP vs LangChain vs CrewAI comparison covers the protocol-versus-framework distinction, which becomes relevant once MCP tool support is a requirement.