Agent frameworks: LangGraph vs Microsoft Agent Framework vs Strands vs OpenAI Agents SDK vs CrewAI

1. Executive summary

The question that separates these five is not "which is most powerful" — it is "what happens when the process dies four minutes into a nine-minute task." Every framework here can call a model and a tool in a loop. What they disagree about is whether that loop is a durable, inspectable, interruptible thing you can operate, or a Python function that runs until it doesn't.

LangGraph is the target of this assessment because durability is the axis I have seen decide the most real selections, and it is the only one of the five where durability is the product rather than a feature. Its checkpointer and interrupt model let a run pause for a human decision and resume exactly where it stopped, across a restart, which is the difference between a real approval gate and a time.sleep with hope in it. It went 1.0 GA in October 2025 with a commitment to no breaking changes before 2.0 — a meaningful signal in a field where two major frameworks changed status that same month.

The cloud-aligned pair are strong for different reasons. Microsoft Agent Framework reached 1.0 with stable APIs and a long-term-support commitment in early April 2026, after converging AutoGen and Semantic Kernel; it leads this page on enterprise governance and observability, and it is the only serious option if your line-of-business code is .NET. Strands Agents is AWS's Apache-2.0 SDK, and its architectural bet — emit OpenTelemetry, let the platform do the rest — pays off directly: AgentCore Evaluations reads its traces natively, and CloudWatch and X-Ray get instrumentation without configuration.

The other two are honest about being something else. The OpenAI Agents SDK is the fastest path from nothing to a working multi-agent system — agents, tools, handoffs, guardrails, sessions and tracing, in well under a hundred lines — and its control model is correspondingly thin. CrewAI has the most ergonomic multi-agent metaphor on this page and the weakest durability story, which makes it excellent for the prototype that convinces a stakeholder and risky for the system that survives them.

2. Positioning

These five get lined up as interchangeable "agent frameworks," which hides the distinction that decides most selections: who owns the control flow, and who owns the state.

Read the "resume after crash" row against the "who decides the route" row and the shape of the field appears. Frameworks that let the model drive freely are pleasant to write and hard to resume, because there is no explicit position to resume to. LangGraph's graph is more work up front and gives you a place to stand: a node, a state object, a checkpoint. Microsoft's typed workflows are the same idea with a different vocabulary. Strands splits the difference by leaning on the platform — the managed runtime holds what a checkpointer would.

What these scores are not: a popularity ranking. GitHub stars and search volume favour LangGraph and CrewAI by a wide margin, and neither number tells you what happens at 2 a.m. when a nine-step agent dies on step seven holding a half-finished refund.

3. Radar criteria — the reasoning

Orchestration expressiveness

LangGraph 4.7 — an explicit graph of nodes and edges with a typed state object expresses conditional routing, cycles, parallel branches and sub-graphs without fighting the abstraction. Microsoft Agent Framework 4.4, whose workflow model gives typed edges and checkpointing over the same idea. Strands 3.8 — a model-driven loop plus Graph, Swarm and Workflow multi-agent primitives added in its 1.0; expressive, but the loop is the default and the graph is the opt-in. OpenAI Agents SDK 3.6, where the expressive unit is a handoff rather than a control-flow graph. CrewAI 3.4 — crews plus the newer flows construct, ergonomic for the pattern it models and awkward outside it.

Durability & resumability

The axis I weight most heavily for production, and the widest spread on this page. LangGraph 4.8 — checkpointers (SQLite for development, Postgres for production) persist state at every step, so a killed process resumes from its last checkpoint on the same thread id. MAF 4.2, checkpointable workflows, newer and less battle-tested in the wild. Strands 3.6 — session persistence, with the AgentCore runtime carrying much of the burden, which is durability you inherit rather than durability you control. OpenAI Agents SDK 3.0, sessions remember conversation state but there is no first-class resume-mid-graph. CrewAI 2.8 — largely in-process; a crash means a re-run, which is unacceptable for anything with side effects.

Human-in-the-loop

LangGraph 4.7 — interrupts are the mechanism that makes an approval gate real: the run stops inside the graph, the state is persisted, a human decides hours later, the run continues from that node. Every other option here asks you to build some part of that. MAF 4.0, approval patterns over workflow checkpoints. OpenAI Agents SDK 3.4 and Strands 3.4, both able to gate a tool call, neither able to pause a long-running run durably without help. CrewAI 3.0 — human input steps exist and are shaped for interactive use rather than for an approval that arrives tomorrow morning.

Observability & tracing

MAF 4.6 — OpenTelemetry with the emerging GenAI semantic conventions, wired to Foundry tracing and Application Insights, which is the most complete out-of-box story here. Strands 4.4 — OTel instrumentation ships built-in and routes to CloudWatch and X-Ray without configuration; being trace-first is its defining design choice. LangGraph 4.2 — excellent visibility through LangSmith, and good OTel coverage, but the best experience is on a vendor surface. OpenAI Agents SDK 4.0, built-in tracing with a hosted viewer and exporters. CrewAI 3.4, third-party integrations rather than a native story.

Evaluation hooks

Scored on how little glue you write to get an agent's behaviour in front of an evaluator — the plumbing I went through in detail in the eval tooling comparison. MAF 4.5, because Foundry's agent converters turn a run into evaluator input directly and continuous evaluation scores sampled production traffic. Strands 4.4 — AgentCore Evaluations (GA March 31, 2026) consumes its OTel traces natively, including tool-level scoring, with no adapter at all. LangGraph 4.4, the LangSmith trace-to-dataset-to-experiment loop, plus first-class support in the OSS eval libraries. OpenAI Agents SDK 3.8. CrewAI 3.2 — you assemble it.

Tool & MCP interop

Close to a tie, and rightly so: MCP has become the thing that makes tools portable across every framework here. MAF 4.4 (MCP and agent-to-agent interop treated as first-class rather than adapters) and Strands 4.4 (native MCP, plus A2A in 1.0). OpenAI Agents SDK 4.3, MCP support and hosted tools. LangGraph 4.2, MCP through adapters plus the largest integration library in the field. CrewAI 3.8, first-class MCP with a smaller tool surface. Nobody should lose a selection here — which is exactly why exposing your own tools over MCP is the cheapest portability hedge available.

Multi-agent patterns

CrewAI 4.2 — role-based crews are its whole thesis and the most natural way to express "a researcher, a writer and a critic," which is why it wins an axis it otherwise trails on. MAF 4.3, inheriting AutoGen's group-chat and orchestration patterns deliberately. LangGraph 4.2, supervisor and swarm patterns built on the graph. OpenAI Agents SDK 4.0 — handoffs are a clean, explicit delegation model. Strands 3.9, Graph / Swarm / Workflow primitives plus agents-as-tools.

Language reach

MAF 4.4 — Python and .NET as first-class peers is unique here and decisive for a lot of enterprises. OpenAI Agents SDK 3.8 (Python and JS/TS), LangGraph 3.6 (Python and JS/TS, with Python clearly primary), Strands 3.4 (Python and TypeScript, Python primary), CrewAI 3.0 — Python only. Java shops are unserved by all five, which is worth knowing before you promise otherwise.

Enterprise governance

MAF 4.7 — Entra identity, Foundry hosting with bring-your-own storage, policy and residency controls, and a vendor support relationship you can escalate through. Strands 4.4, IAM plus AgentCore identity, gateway and policy controls. LangGraph 3.6 — capable, but governance is yours to assemble, and the best-integrated control plane is a vendor SaaS you may need to self-host. OpenAI Agents SDK 3.4, provider-centric. CrewAI 3.0 — the least enterprise scaffolding of the five. If you have to produce audit evidence, this axis and the observability axis are where that evidence comes from, per the register-and-evidence approach in AI governance.

Portability (higher = less lock-in)

Nobody scores well, which is the honest finding. MAF 3.4 and Strands 3.4 — both open-source and multi-provider, but their value is concentrated in one cloud's platform. LangGraph 3.2 — model-agnostic and self-hostable, yet the graph and state schema are your application, so leaving is a rewrite. CrewAI 3.0. OpenAI Agents SDK 2.8, the strongest provider gravity of the five despite supporting other models. The mitigation is the same for all of them and it works: domain tools as plain functions with no framework imports, tools exposed over MCP, and the state you would need to reconstruct a session persisted in a schema you own.

4. Radar scorecard

How these scores are arrived at — the rings, the 0–5 scale, and the evidence rules — is written up in the radar methodology. This table and the chart below are generated from one file, scorecards.json: the source of truth, machine-readable, and kept separate so two copies of the same numbers cannot drift apart between editions. LangGraph is the primary column because "do we need durable orchestration?" is the decision this assessment exists to answer. Last reviewed 2026-Q3.

Comparator scores (same axis order — Orchestration, Durability, HITL, Observability, Evals, Tools/MCP, Multi-agent, Languages, Governance, Portability). Microsoft Agent Framework: 4.4 / 4.2 / 4 / 4.6 / 4.5 / 4.4 / 4.3 / 4.4 / 4.7 / 3.4. Strands Agents: 3.8 / 3.6 / 3.4 / 4.4 / 4.4 / 4.4 / 3.9 / 3.4 / 4.4 / 3.4. OpenAI Agents SDK: 3.6 / 3 / 3.4 / 4 / 3.8 / 4.3 / 4 / 3.8 / 3.4 / 2.8. CrewAI: 3.4 / 2.8 / 3 / 3.4 / 3.2 / 3.8 / 4.2 / 3 / 3 / 3.

5. The radar

Ten agent-framework axes; higher is better on all of them. The shapes carry the argument. LangGraph spikes on the three axes that decide production risk — durability, human-in-the-loop, orchestration — and dips on languages, governance and portability. Microsoft Agent Framework is the roundest shape here, which is what "enterprise convergence" looks like when it works. Strands mirrors MAF at a lower amplitude except on observability and evals, where being OTel-native puts it level. OpenAI Agents SDK and CrewAI are visibly smaller shapes with one tall axis each — interop and multi-agent ergonomics respectively. Click any name in the legend to toggle it; two shapes at a time is far more legible than five.

6. Workload-specific analysis

7. Reference architecture

The shape I would build keeps the framework at the edge, so a change of framework is an adapter change rather than a rewrite — and keeps the evidence a governance review will ask for as a by-product of running.

graph TB
  subgraph Yours["Your code — no framework imports"]
    TOOLS["Domain tools
plain functions + docstrings"]
    POL["Policy + guardrails"]
    STATE[("Session state
your schema")]
  end
  subgraph Edge["Adapter layer (~10 lines per framework)"]
    ADP["register tools · build agent"]
  end
  subgraph FW["Agent framework"]
    LOOP["Orchestration
graph / loop / crew"]
    CKPT[("Checkpointer")]
  end
  MCP["MCP server
tools, portable"] --> ADP
  TOOLS --> MCP
  TOOLS --> ADP
  POL --> ADP
  ADP --> LOOP
  LOOP --> CKPT
  LOOP -->|"interrupt"| HUMAN["Human approval"]
  HUMAN -->|"resume from node"| LOOP
  LOOP -->|"OTel spans"| OBS[("Traces
CloudWatch / App Insights / OTel backend")]
  OBS --> EVAL["Eval: online sampling
+ CI gate on a dataset"]
  LOOP --> STATE
  EVAL -.->|"failures become test cases"| EVAL

8. POC plan (4 weeks)

• Week 1 — try to disqualify "no framework" first. Write the agent as a plain loop with your tools and a step cap. If the task needs no branching, no resume and no approval, you are done and you have saved yourself a dependency. A surprising share of candidates stop here.
• Week 2 — test the axis that actually decides it: kill the process. Start a long task, terminate it mid-flight, and try to resume. Then pause for a human approval and resume an hour later, after a restart. This is where LangGraph's checkpointer and MAF's workflows separate from sessions-and-hope, and where a happy-path demo tells you nothing.
• Week 3 — wire observability and evaluation before you like the framework. Get OTel traces into your backend, then run one real evaluator over them — tool-call accuracy is the fastest useful signal. If this takes more than a day, that cost recurs forever, and it is exactly what separates Strands on AWS and MAF on Azure from the rest.
• Week 4 — price the exit, then write the ADR. Estimate honestly what it would cost to move to the runner-up: which code moves free, which is a rewrite, and what happens to in-flight persisted state. Record the framework, the version, the state-ownership decision, and the conditions under which you would revisit.

9. Final recommendation

Default to LangGraph when durability and human approval shape the design; take Microsoft Agent Framework in Azure and .NET estates; take Strands on AWS with AgentCore; use the OpenAI Agents SDK to start fast and CrewAI to prototype — and hold AutoGen and Semantic Kernel for new builds.

The decision rule I would give a team is one question: what has to survive? If the answer is a process restart, a human decision that arrives tomorrow, or an auditor's question next quarter, you need durable orchestration with an explicit position to resume to, and LangGraph is the most mature expression of that on this page — with MAF close behind and better governed if you are already on Azure. If the answer is "nothing much yet, we're learning what the agent should even do," then the fast, ergonomic options are the right call and the graph runtime is premature.

Whichever you pick, spend the first week on the three seams rather than on the framework: tools as plain functions exposed over MCP, state persisted in a schema you own, and OpenTelemetry out to your own backend. Those three make the framework a replaceable component, which matters in a field where the two most-recommended frameworks of early 2025 were both in maintenance mode by October and one of them had been replaced by its own vendor.

I would re-assess when MAF has a full year of production mileage behind its 1.0 (its governance and observability lead is already the strongest here, and durability maturity is the gap), when LangGraph's OTel story matches its LangSmith story closely enough that the vendor surface stops being a consideration, and if a durable-execution engine such as a workflow platform becomes the standard substrate underneath these frameworks — which would move the deciding axis off the framework entirely.

References

Agent frameworks move faster than any other category on this radar, and vendor comparison pages are worthless here. I have leaned on release announcements, official docs and status changes with dates attached.

Scores are my own architect-level judgment for the stated use case, calibrated to mid-2026 — not a vendor ranking, and not a benchmark result. Agent-framework axes, higher is better. NOT comparable with any other assessment here. Re-score against your own POC numbers before you commit.