Do not start a new project on AutoGen. Microsoft put it in maintenance mode and the repository now carries a banner saying it "will not receive new features or enhancements and is community managed going forward." The Python package tells the same story more bluntly: autogen-agentchat last shipped version 0.7.5 on 30 September 2025 — ten months of silence in the fastest-moving category in enterprise software.
That leaves a real three-way decision, not the one the search box suggests. For a durable, auditable, long-running agent, use LangGraph. If your identity, network and compliance boundary is already Azure, use Microsoft Agent Framework — the actual successor to AutoGen, 1.0 since 3 April 2026. Use CrewAI to get a convincing prototype in front of a steering committee this week, and plan to rewrite it before it touches a customer's money.
Everything below is normalised to one workload, because vendors each quote the metric that flatters them: a 12-step back-office agent, 50,000 runs a month, ~90 seconds of wall clock per run, one human approval gate, and a hard requirement to resume a paused run up to 72 hours later. That last clause is what separates these products.
| LangGraph | Microsoft Agent Framework | CrewAI | AutoGen | |
|---|---|---|---|---|
| Status (1 Aug 2026) | 1.2.10, 28 Jul 2026 | 1.13.0, 30 Jul 2026 | 1.15.10, 31 Jul 2026 | 0.7.5, Sep 2025 — maintenance |
| State model | Explicit graph state, checkpointed at super-step boundaries | Session state + graph workflows with checkpointing | Flow state, @persist to SQLite by default |
Conversation history |
| Durability control | Three modes: exit / async / sync |
Workflow checkpointing, time-travel | Snapshot per persisted method | Manual save_state/load_state; no automatic checkpointing |
| Human-in-the-loop | First-class interrupt, resume by thread ID |
Built into workflow orchestration | @human_feedback decorator (1.8.0+) |
Conversational only |
| Retry semantics | RetryPolicy, default 3 attempts, writes cleared per attempt |
Middleware hooks | Agent + guardrail retries, no tool idempotency guard | Not production-grade |
| Observability | LangSmith (proprietary); OTel export available | Native OpenTelemetry | Platform traces; OTel via third parties | Minimal |
| Licence | MIT | MIT | MIT | MIT |
| Where the money goes | LangSmith seats + LCU/LSU compute | Azure model tokens + container compute | Free tier, then "contact sales" | n/a |
| Languages | Python, JS | Python, .NET, Go (preview) | Python | Python, .NET |
AutoGen Is Not a Choice Anymore, It Is a Migration
AutoGen is a dead end with a very good funeral. Microsoft did not abandon the ideas — it merged them. Microsoft's own documentation states that Agent Framework "combines AutoGen's simple abstractions for single- and multi-agent patterns with Semantic Kernel's enterprise-grade features such as session-based state management, type safety, filters, telemetry," and calls it "the next generation of both Semantic Kernel and AutoGen."
The steel-man for staying: AutoGen is MIT-licensed, 60,000 people starred it, and code that works today will keep working. Maintenance mode means bug fixes and security patches continue. If you have a working AutoGen system serving real traffic, there is no fire drill.
There is also a second exit, and Microsoft's migration guide will not point you to it. AutoGen's original creators forked the project in November 2024 and now maintain AG2 under open governance: ag2 reached 1.0.0 on 27 July 2026, and the classic ConversableAgent codebase still ships as the autogen PyPI package, 0.14.1 on 30 June 2026 — maintenance-only, but not silent. If what you have invested in is the classic conversational patterns rather than the v0.4 architecture, AG2 is the shorter migration. The trade is obvious and worth saying plainly: you are choosing a volunteer-governed project over a Microsoft-resourced one.
The problem is asymmetric risk. Every model provider integration, every protocol (MCP, A2A), every safety control shipped from here lands in Agent Framework and not in AutoGen. You are volunteering to maintain the adapters yourself, forever, for a system whose whole value was that someone else maintained them. Budget the migration now; it is cheaper as a planned quarter than as an incident.
What "Durable" Actually Means When the Process Dies
Durable execution means an agent run survives the death of the process running it and resumes from its last saved point rather than from the beginning. Every vendor on this list uses the word. Only two of them let you tune what it costs.
LangGraph is the only one that makes the tradeoff a parameter. Its checkpointer documentation defines three durability modes: exit, where "LangGraph persists changes only when graph execution exits"; async, which "persists changes asynchronously while the next step executes"; and sync, which "persists changes synchronously before the next step starts." Checkpoints land at super-step boundaries — each tick of the graph — which is the detail that matters: state inside a long node is not saved. If step 7 of your 12 makes three API calls and dies on the third, you replay all three.
That is not a LangGraph defect. It is the honest boundary of graph checkpointing, and every framework here shares it. It is also why teams running side-effecting agents for hours pair a graph framework with a genuine durable-execution engine underneath, rather than expecting the agent library to be one.
CrewAI's answer is the @persist decorator, which its Flows documentation describes as maintaining "flow state across restarts or different workflow executions," saved by default to a local SQLite file. Local SQLite is a fine default for a laptop and a liability at 50,000 runs a month across replicas — you will be swapping the backend before you ship. Microsoft Agent Framework puts checkpointing, streaming, human-in-the-loop and time-travel in its graph workflows, and reached 1.0 stability for orchestration patterns in July 2026.
LangGraph Wins on State and Charges You for the View
LangGraph is the default recommendation, and the reason is boring: explicit state you can inspect, checkpoint, replay and diff. LangChain shipped 1.0 on 22 October 2025 and cites Uber, JP Morgan, Blackrock and Cisco as production users. Its flagship reference is Klarna: LangChain's own case study claims an assistant serving "over 85 million active users," doing work "equivalent of 700 full-time staff," with query resolution time down 80%. Treat those as vendor-published figures — they are — but the architecture is real and public.
Failure handling is the most mature of the three. The fault-tolerance docs specify a RetryPolicy with a default of three attempts, an explicit non-retryable exception list (ValueError, TypeError, RuntimeError and friends — bugs, not blips), retries only on 5xx for HTTP libraries, and error handlers that run after retries are exhausted so you can route to a compensating path. One sharp edge: node timeouts "only apply to async nodes. Sync nodes with a timeout are rejected at compile time." Find that in staging, not at 2am.
The catch is commercial, and it is the thing buyers miss. The framework is MIT. The place you actually operate it is not. As of 1 August 2026, LangSmith's published pricing is $0 per seat per month on Developer with 5,000 base traces, $39 per seat per month on Plus with 10,000, and custom on Enterprise, plus usage metered at "$1.50 / LCU" of compute and "$1.00 / LSU" of storage, with deployment runtime billed at 0.045 LCU per vCPU-hour and database compute at 0.177 LSU per vCPU-hour. And self-hosting is gated: "Self-hosted is available on the Enterprise plan."
Who should not pick LangGraph: a team of three shipping an internal summariser; anyone whose security posture forbids a SaaS trace store and whose budget will not clear an enterprise contract to self-host it; and anyone allergic to the LangChain ecosystem's release velocity. You can run LangGraph OSS with no LangSmith at all — export to an OTel backend and keep the bill at zero — but you give up the debugging experience that is most of the argument for choosing it.
CrewAI Is the Fastest Demo and the Slowest Audit
CrewAI is genuinely the quickest path from blank file to a plausible multi-agent workflow, and its adoption is not fake. Its homepage claims "65% of the Fortune 500" and "450M+ agentic workflows ran per month." Role-and-backstory agents map onto how business stakeholders already describe work, which is why it wins the demo.
Then production arrives. Three specific problems, in order of severity.
Security. In March 2026, CERT/CC published VU#221883, covering CVE-2026-2275, CVE-2026-2285, CVE-2026-2286 and CVE-2026-2287 — an insecure sandbox fallback in the Code Interpreter, an SSRF in the RAG search tools, and an arbitrary local file read in the JSON loader. SecurityWeek reported on 31 March 2026 that researcher Yarden Porat of Cyata found them, and that chained via prompt injection they allowed sandbox escape onto the host. Credit where due: the CERT note was revised on 20 May 2026 to record that "The CodeInterpreterTool (including its Docker sandbox and insecure SandboxPython fallback) has been completely removed," centralised path and URL validation was added, and "All issues are fixed in current releases." That is a good outcome. It is also a reminder that an agent framework is an execution engine, and you should red-team it before production like one.
Retry safety. Issue #5802, open since 14 May 2026, is titled "Tool re-execution on task retry has no idempotency guard — duplicate payments, emails, trades possible." The body is exact: "When a CrewAI task fails and is retried — via max_retry_limit, exception handling, or external re-trigger — any @tool decorated function that already executed runs again." If your agent touches a payment rail or an outbound email queue, you must build the idempotency layer yourself.
Cost visibility. CrewAI's pricing page, checked 1 August 2026, lists exactly two tiers: Basic, free, with 50 workflow executions a month; and Enterprise, "Custom," behind a request form. Fifty executions is a tutorial allowance. At our 50,000-run workload you are in a sales conversation with no published anchor — no per-execution rate, no overage table, nothing to model in a budget.
Who should not pick CrewAI: anyone whose agent moves money, sends external communications, or produces a record a regulator can subpoena; anyone who needs a defensible cost forecast before signing; anyone whose failure mode is "the agent did the right thing twice."
Microsoft Agent Framework Is the Azure Answer, and That Is the Whole Point
If your enterprise runs on Entra, Azure networking and Microsoft's compliance paperwork, this is the least-effort defensible choice. It is MIT, it ships Python and .NET with Go in public preview, and its repository advertises "Built-in OpenTelemetry integration for distributed tracing, monitoring, and debugging" — no proprietary trace store required. The 1.0 announcement commits to "stable APIs, and a commitment to long-term support," with connectors for Azure OpenAI, OpenAI, Anthropic Claude, Amazon Bedrock, Google Gemini and Ollama — so model portability is real, even if the gravity is not.
The economics are the cleanest here, mostly by being someone else's line item. Azure's Foundry Agent Service pricing states "There is no additional charge for creating or running Foundry-native agents using prompts and workflows"; you pay for model tokens, container compute per hour for hosted agents, and per-tool charges for things like file search and web search. No seat licence, no compute-unit abstraction to decode.
Read the 1.0 note carefully before you commit, though. A long list of the parts you will actually reach for — the DevUI debugger, Foundry hosted agents, Foundry observability and evaluations, Skills, the agent harness — was still marked preview at GA, and has been shipping in pieces through July 2026. "1.0" here means the core SDK is stable, not that the surrounding platform is finished.
Who should not pick Microsoft Agent Framework: anyone deliberately building multi-cloud who does not want their agent runtime's best path to run through Foundry; anyone whose team is a Python-and-Postgres shop with no .NET or Azure muscle; and anyone who needs the mature third-party ecosystem, where LangGraph is years ahead.
The Criteria That Actually Predict Regret
Feature matrices do not predict which team is unhappy in eighteen months. In practice, four questions do.
- Can you replay a single run, end to end, from stored state? If the answer is no, your first production incident becomes an archaeology project. This is the single strongest argument for LangGraph.
- What happens to a side effect on retry? Not "does it retry" — every framework retries. Does the payment fire twice? Assume the framework will not save you; build the idempotency key yourself. CrewAI's open issue is the honest version of a problem all of them have.
- Where does the trace live, and who owns it? LangSmith is excellent and proprietary, with self-hosting behind an Enterprise contract. OpenTelemetry-native pipelines keep the data in your estate. This is a procurement decision disguised as a debugging preference, and it is worth treating agent observability as its own engineering discipline.
- Do you need multiple agents at all? Cognition's Walden Yan made the sharpest version of the counter-argument in June 2025: "Actions carry implicit decisions, and conflicting decisions carry bad results." Be careful quoting that as settled, though — Anthropic published the opposite result the same month: a multi-agent research system that "outperformed single-agent Claude Opus 4 by 90.2%" on its internal eval, at roughly 15x the token cost, while conceding that domains "that require all agents to share the same context or involve many dependencies between agents are not a good fit." The two findings reconcile on workload shape rather than on a winner: fan out for breadth-first reading, keep writing single-threaded. A 12-step back-office agent is the second kind, which is why most such projects are one agent with a routing problem.
What Would Change This Answer
Three things, and you should watch them.
Microsoft finishing the platform. If Foundry observability, evaluations and the harness all reach GA and the Go SDK stabilises, Agent Framework becomes the default for a much wider set of buyers than Azure shops.
LangChain's pricing. The LCU/LSU model is fine at pilot scale and unmodellable at fleet scale. If self-hosting ever lands below the Enterprise tier, the "run OSS, skip the platform" hedge stops being a hedge.
CrewAI publishing a real price. A free tier and a phone number is not a pricing page. A published per-execution rate would put it back in serious procurement conversations, because the developer experience genuinely is the best of the three.
The market signal is already visible in release cadence. LangGraph shipped 28 July 2026. AG2 shipped 29 July. Agent Framework shipped 30 July. CrewAI shipped 31 July. Microsoft's AutoGen last shipped in September 2025. Cadence is the most honest benchmark in open source, and it is free to check — provided you check the forks too.
The Bottom Line
Framework choice matters less than most architecture reviews assume, and matters enormously in exactly one dimension: what your system can prove about a run that already happened. LangChain's own survey of 1,340 practitioners, fielded in late 2025, found 57.3% with agents in production and quality — accuracy, consistency, adherence to guidelines — as the leading blocker. Quality is not a model problem. It is a state, replay and evaluation problem, and it is the one your framework either helps with or hides.
Pick LangGraph and pay for the state model. Pick Microsoft Agent Framework if the compliance boundary is already drawn around Azure. Pick CrewAI for the demo and be honest with yourself about the rewrite. And migrate off AutoGen on a schedule you choose.
The framework you can debug at 3am is the framework you should buy.
Continue Reading
- LangGraph vs Google ADK: Which Enterprise AI Framework Should You Choose?
- MCP vs LangChain vs OpenAI Functions: Which for Enterprise?
- How to Red-Team Your AI Agents Before Production
- AI Observability Engineering: Why Traditional Monitoring Misses 90% of Agent Risks
- 10,000 AI Failures Exposed. Hallucination Isn't #1.
- No One's Responsible When AI Agents Fail. That Ends Now.
- MCP Goes Stateless: Enterprise AI Governance Just Got Real
- Why 88% of AI Agent Pilots Never Reach Production