The agent-framework war already consolidated, and most contenders lost without noticing
The honest definition of agents and automation in 2026 is narrower than the conference talks: it is the engineering discipline of getting a language model to do multi-step work with tools, state, and stop buttons, reliably enough that someone can be paged when it misbehaves. By that definition the field has consolidated hard. The orchestration layer is effectively four projects — LangGraph, CrewAI, the OpenAI Agents SDK, and Microsoft's successor framework — sitting on top of a much older durable-execution layer (Temporal, and the workflow-automation platforms), with a quickly growing harness tier (Deep Agents) that packages opinionated defaults around all of it. Dozens of other "agent frameworks" exist; several have more stars than users.
Three things get miscategorised into this field, and each miscategorisation costs money. First, chatbots with a tool call are not agents: one function invocation inside a conversation is automation in the way a light switch is a control system. Second, fair-code platforms are not open source — n8n, with its 203,000 stars, describes itself as exactly that ("fair-code workflow automation platform"), and its Sustainable Use License permits self-hosting but not offering the platform as a service; teams have chosen it, scaled on it, and then discovered their product boundary collides with the licence. Third, retired frameworks still dominate search results: AutoGen, at 60,734 stars the largest repository in the category, is formally in maintenance mode with Microsoft pointing new users at its Agent Framework successor. Stars measure history; maintenance mode measures the future.
Every agent stack is the same three layers wearing different badges
Read the documentation of every serious option and the same decomposition falls out, which is why architecture arguments in this field are usually branding arguments. There is a model-call layer — the LLM invocations themselves, provider-agnostic in the OpenAI SDK (which claims support for the Responses and Chat Completions APIs plus more than a hundred other models) and pluggable elsewhere. There is a state-and-control layer — LangGraph calls this durable execution with human-in-the-loop interrupts and short- plus long-term memory; Temporal calls it durable workflows with replay; CrewAI splits it into autonomous Crews and event-driven Flows. And there is a harness layer — the batteries-included defaults that LangChain's Deep Agents package (28,800 stars, built on LangGraph) now sells explicitly: planning tools, subagents, and a file-system workspace out of the box.
flowchart TD
T[Trigger: schedule or webhook or human] --> O[Orchestration layer<br/>LangGraph or CrewAI or OpenAI SDK]
O --> M[Model calls<br/>one or more providers]
M --> TO[Tool layer<br/>functions and MCP servers]
TO --> S{control points}
S -->|risky step| H[Human approval<br/>interrupt and inspect state]
S -->|safe step| E[Execute and record]
H -->|approved| E
H -->|rejected| O
E --> D[Durable state<br/>persist every step for replay]
D --> O
The durable-state box is the one this field spent 2024 and 2025 learning to take seriously, mostly by breaking production. An agent that has called six tools and is one step from sending the email is not a prompt; it is a process with state that a crash, a rate limit, or a model timeout can interrupt. The frameworks that survived adoption are the ones that made interruption and resumption a first-class feature rather than an error path. The sequence below is the human-approval loop as LangGraph's interrupt mechanism and the OpenAI SDK's human-in-the-loop support both implement it:
sequenceDiagram
participant W as Workflow
participant S as Durable state
participant H as Human operator
participant T as Tool
W->>S: persist step and pending action
W->>H: interrupt with inspection payload
Note over W,H: state is inspectable and editable before anything runs
H->>W: approve or edit or reject
alt approved
W->>T: execute pending action
T-->>W: result
W->>S: record result and continue
else rejected
W->>S: mark rejected and resume from checkpoint
end
Four orchestration frameworks, four bets, and one of them is a museum
The four-way comparison the market actually forces, on axes that matter:
| Framework | Core bet | Licence | Signature capability | Position |
|---|---|---|---|---|
| LangGraph (40.8k stars) | Low-level graph orchestration, Pregel-inspired | MIT | Durable execution, interrupts, memory; Deep Agents built on top | The safest default for custom stateful agents; you will build more yourself |
| CrewAI (57.9k stars) | Role-based autonomy (Crews) plus event-driven Flows | MIT | Highest-abstraction API; publishes a LangGraph migration guide | Fastest to a demo, but read the generated flows — abstraction hides control points |
| OpenAI Agents SDK (29.1k stars) | Lightweight primitives, provider-agnostic | MIT | Sandbox agents, realtime voice (gpt-realtime-2.1), handoffs, guardrails | Best-engineered primitives; sandbox surface assumes you trust the manifest |
| AutoGen (60.7k stars) | Multi-agent conversation research | CC-BY-4.0 repo plus separate code licence | AgentChat, AutoGen Studio prototyping | In maintenance mode; do not start here — migrate to Microsoft Agent Framework |
AutoGen's own warning banner is the most useful document in the category: no new features, community-managed going forward, migration guide to Microsoft Agent Framework — which is positioned as the enterprise successor with stable APIs, multi-provider model support, and cross-runtime interoperability via A2A and MCP. AutoGen Studio, the no-code GUI, carries an equally explicit disclaimer that it is "not meant to be a production-ready app." Positions stated plainly: start with LangGraph if you need custom control flow and can write Python against a low-level API; start with CrewAI if you want role-based collaboration and accept trading visibility for speed; use the OpenAI Agents SDK when sandboxes, voice, or realtime matter; and treat AutoGen as archaeology — cite it, do not build on it.
The durable-runtime layer predates the agent hype and will outlive it
The unglamorous truth of production agents is that the hardest problems — retries, timeouts, scheduling, exactly-once-ish semantics, audit trails — were solved by workflow engines years before anyone said "agentic." Temporal (22,741 stars, MIT, written in Go) is the canonical durable-execution engine: workflows expressed as code, every step persisted, crashes recovered by replay. Agent teams that bolt LangGraph-style orchestration onto Temporal get the best of both: LLM decisions inside a runtime that treats a killed worker as a rounding error rather than a lost afternoon.
n8n (203,000 stars, 60,500 forks) is the other incumbent, attacking from the visual-automation direction: a browser-based workflow builder with more than 400 integrations and native AI capabilities, self-hosted or cloud. Its licence is the load-bearing fact. "Fair-code" means source-available with a Sustainable Use License — internal business use is fine, embedding it in your own product or offering it to others as a service is not. For a company automating internal operations, that restriction is invisible and the 400 integrations are decisive. For a SaaS company whose product is workflow automation, choosing n8n as the engine means choosing a ceiling on what your product is allowed to be. That is not a defect — it is the business model that funds the engineering — but it belongs in the decision, and it is usually left out of the comparison posts.
Mastra (27,606 stars, TypeScript) rounds out the tier as the modern TypeScript-native framework for AI applications and agents, with its repository listing a custom "Other" licence rather than a standard OSI badge — same instruction as n8n: read it before you architect around it. The TypeScript angle is not cosmetic; teams whose production stack is Node want their agent orchestration in the same language, and Mastra is the credible answer in that world.
Sandboxes are where the SDKs stopped being libraries
The most concrete engineering shift of the last year is execution isolation moving from deployment concern to SDK feature. The OpenAI Agents SDK ships a SandboxAgent concept where the agent works inside a container against a declared manifest — a GitRepo entry pins the repository and ref the agent may inspect — with a local Unix sandbox client on macOS and Linux, a Docker client for Windows, and hosted alternatives. That is an opinionated architecture: the blast radius of an agent action becomes a configured boundary instead of whatever the host process can reach. It also imports new failure modes — the manifest is a trust statement, and a local sandbox client is still executing commands on your machine by design.
The trust question is now documented in the frameworks themselves. AutoGen's MCP workbench example carries an explicit warning that MCP servers "may execute commands in your local environment or expose sensitive information" and to connect only to trusted servers. That sentence is the single most important line in agent security this year, because the MCP ecosystem — the protocol every framework now speaks — is a supply chain. Every tool server you wire in is code running with your credentials, and the frameworks' own docs say so in their install examples.
Deep Agents represents the opposite resolution of the same problem: instead of exposing primitives, it ships the harness — planning tool, subagents, filesystem — so teams inherit opinionated defaults rather than composing their own. The bet is that most agent products are the same product (plan, delegate, use files, persist) with different domains; the counter-bet is that defaults ossify into architectures you cannot exit. Its 28,800-star adoption says the market wants defaults. My position: defaults are correct for v1 of a product and a liability for v3, and Deep Agents is honest enough about being a harness that migrating off it is a refactor rather than a rewrite.
The licence and cost maze decides more architectures than any benchmark
Line up the licences and the field's real structure appears. MIT: LangGraph, CrewAI, OpenAI Agents SDK, Temporal — unrestricted use, including hosted products. CC-BY-4.0 plus a separate code licence: AutoGen — the documentation licence does not govern the code, which is why reading both files matters. Fair-code Sustainable Use License: n8n — free to self-host, forbidden to resell as a service. Custom "Other": Mastra — not a standard OSI licence; the compliance question is open until read.
The commercial layers on top are the real cost shape, because the open cores monetise through them deliberately. LangChain's stack pairs LangGraph with LangSmith for tracing, evaluation, and observability, and LangSmith Deployment for hosting long-running stateful workflows — the durable execution is free, the visibility and hosting are the upsell. CrewAI's AMP Suite adds managed deployment, observability, governance, and enterprise support around the free framework, with a free trial of the Crew Control Plane. OpenAI's SDK is free but its realtime and voice paths pull you toward OpenAI's paid models, and the 100+ provider support exists precisely so that pull is optional. The pattern is the open-core contract everyone in this field actually operates under: orchestration is free, observability and operations are the invoice. Budget the observability line from day one — an agent without tracing is a lottery ticket with a webhook.
Choose by blast radius and replay, not by star count
The choosing logic is constraint-driven, and blast radius comes first. If the agent touches money, sends email, or writes to customer systems, the framework must have interrupts you can wire to a human and durable state you can replay after a crash — that filters immediately to LangGraph (MIT) or an OpenAI SDK plus Temporal pairing, and the human-in-the-loop support stops being a nice-to-have. If the agent is internal tooling over read-only analysis, the abstraction-first options (CrewAI Flows, Deep Agents defaults) buy speed without catastrophe. If the product is a hosted automation platform itself, n8n's licence makes it a dependency on a competitor-adjacent vendor, not an ingredient — build on MIT-licensed parts instead. If your stack is TypeScript end to end, Mastra is the credible native option, with the licence read as a pre-architecture task. And if you are starting a new project on AutoGen today: do not; the migration guide exists because everyone else is already walking that road.
Model cost is the last constraint and the one teams underestimate least. The SDKs are provider-agnostic — that is now table stakes, with the OpenAI SDK advertising 100+ models and every other framework following multi-provider patterns — so the per-token bill is a choice of model per step, not per framework. The expensive agents are the ones that call a frontier model at every node of a deep graph; the cheap ones route trivial steps to small models and reserve the frontier for decisions. Framework choice barely moves that bill; graph design moves it an order of magnitude. Two secondary capabilities move real decisions even though they rarely headline comparisons. Session management — automatic conversation-history handling across agent runs, with Redis-backed persistence as an optional install in the OpenAI SDK — is the difference between an agent that remembers yesterday and one that amnesiacs on every invocation; building it by hand is a week of subtle bugs. And the realtime/voice tier is now inside the SDK rather than a separate product: the OpenAI SDK exposes realtime agents over WebSocket on gpt-realtime-2.1 plus voice pipelines that chain speech-to-text, an agent workflow, and text-to-speech, which collapses what used to be a bespoke integration project into a second install flag. Neither capability changes the orchestration choice — they ride on top of the same Agent primitives — but both are reasons the SDK tier is absorbing work that used to justify bespoke stacks.
The example notebooks are the real documentation, and they form a pattern library
A scoreboard detail the comparison posts miss: the frameworks' example directories are where the field's accumulated workflow patterns actually live. LangGraph's repository alone ships worked notebooks for hierarchical agent teams, plan-and-execute, reflection, Reflexion, self-discover, LLMCompiler, ReWOO, and a whole RAG family spanning adaptive, corrective, and self-reflective variants — each a graph you can read, run, and fork. CrewAI documents checkpointing, knowledge, planning, and testing as first-class concepts, publishes its own migration guide away from LangGraph, and maintains an official skills package that teaches coding agents to scaffold Crews and Flows correctly — agent tooling for building agents, distributed through plugin marketplaces. Microsoft's AutoGen carries design documents for its programming model, topics, and agent-worker protocol that remain the clearest public explanation of distributed multi-agent architecture even with the framework itself in maintenance mode. Free structured courses (LangChain Academy for LangGraph, DeepLearning.AI's pair of CrewAI courses, a self-reported hundred thousand certified CrewAI developers) mean the onboarding path is a curriculum, not a README crawl.
The practical consequence for adoption: before writing any orchestration from scratch, check the example library for your shape of problem — plan-and-execute, reflection loops, and hierarchical teams are all solved, public, and MIT-licensed. The failure mode is the inverse: copying a pattern notebook into production without understanding which control points it silently removed, which is how agents end up with six tools and no approval gates.
Where it breaks
Maintenance-mode archaeology. Trigger: starting a project on a framework whose own README carries a maintenance banner. AutoGen will keep working; it will not keep improving, and its own migration path to Microsoft Agent Framework is the sanctioned exit. Adopting it now is scheduling a migration you already know about.
The MCP supply chain. Trigger: installing a third-party MCP server to give an agent new tools. AutoGen's documentation warns servers may execute local commands or exfiltrate data. Every tool server is arbitrary code adjacent to your credentials; vet them like dependencies, because they are ones that execute.
The Studio trap. Trigger: prototyping in AutoGen Studio and shipping the result. Microsoft states plainly it is not production-ready — no authentication, no security hardening. It is a demo surface for a framework in maintenance mode; treat everything it produces as a sketch.
Fair-code boundary collision. Trigger: building a hosted product on n8n. Self-hosting is fine; offering the platform to others as a service violates the Sustainable Use License. Discovering this after your product's architecture assumes n8n is an expensive refactor with a lawyer attached.
Sandbox manifest drift. Trigger: SandboxAgent runs against a GitRepo manifest whose pinned ref moves. The boundary is only as strong as the manifest is specific — a ref pointing at a mutable branch lets upstream changes redefine what the agent may touch. Pin to a commit, not a branch.
The abstraction wall. Trigger: role-based Crew abstractions hitting a case that needs precise control flow. CrewAI's own answer is its Flows layer and a migration guide from LangGraph — the company documents the exit because enough people need it. If your workflow is fundamentally event-driven, start at the lower abstraction and save the migration.
Observability debt. Trigger: multi-step agents without tracing, debugged by re-running. LangSmith and its equivalents exist because a failed nine-tool agent run is otherwise undebuggable; retrofitting tracing after the first production incident costs more than adopting it on day one.
Open questions
Whether Microsoft Agent Framework consolidates the AutoGen and Semantic Kernel communities fast enough to matter, or becomes a third framework in a market that just demonstrated consolidation. Whether the harness layer (Deep Agents and its equivalents) hardens into the de facto standard stack, or stays a convenience layer that serious products outgrow. Whether fair-code and source-available licences can hold their ground against MIT-licensed competitors as agent infrastructure becomes strategic — n8n's growth says yes so far. And whether MCP's supply-chain problem gets an ecosystem answer — signing, registries, permission surfaces — before an incident answers it for everyone. The field's economics are already decided: orchestration is free, state is cheap, observability and model spend are the bill. The open question is governance, and nobody has shipped a good answer yet.
Resources
Orchestration frameworks:
- LangGraph — low-level orchestration for stateful agents (MIT)
- CrewAI — multi-agent automation with Crews and Flows (MIT)
- OpenAI Agents SDK — lightweight multi-agent framework (MIT)
- AutoGen — maintenance-mode multi-agent framework with Microsoft Agent Framework successor
- Deep Agents — batteries-included agent harness built on LangGraph
Runtimes and workflow platforms: