Pick up any framework comparison and you'll find a table. Columns for features, rows for frameworks, checkmarks and X's. It tells you what's available. Whether the thing holds together at 3 a.m. when a container restarts mid-workflow requires a different kind of knowledge.

Start upstream of the table. Every agent orchestration framework embeds an argument about what the hard problem in orchestration actually is. LangGraph's bet is that it's control flow. CrewAI's bet is task decomposition across specialists. The Claude Agent SDK is built around permission boundaries on an autonomous loop. Microsoft Agent Framework 1.0, which reached GA last month and has the shortest production track record of the four, is organized around enterprise interoperability. These are architectural commitments that shape every production decision downstream.

Constraints shape architectures

A workflow that branches based on intermediate results, loops back on itself, and might need to pause for human approval before continuing. The dominant constraint here is state: who holds it, how it's structured, and whether it survives interruptions.

LangGraph's graph structure exists to answer this. State is a typed object. Each node reads and mutates it. Checkpoints capture state at every step boundary. The origin post makes the logic explicit: an agent written as a single function with a while-loop can't be checkpointed in a portable format, can't be streamed at intermediate points, can't be paused for human review. Once you accept that agents need to be inspectable, resumable, and interruptable, the graph structure follows. A simple ReAct agent takes roughly three times more code than in lighter frameworks. The verbosity is the point. You're paying for the ability to survive failure, and that cost is visible in every file you write.

A different constraint entirely. Your problem decomposes naturally into specialist roles: a researcher gathers information, an analyst evaluates it, a writer produces output. The hard part is coordinating those specialists without turning coordination itself into a bottleneck.

CrewAI's role-based model addresses this directly. The crew metaphor does real structural work. It enforces hub-and-spoke communication, hierarchical delegation, and task-level isolation. A manager agent coordinates; if an executor fails, the manager can reassign that task without restarting the entire crew. Teams that need to move fast on problems with clean task boundaries find this abstraction maps well to how they already think about the work.

Then there's the case where you're building around a single powerful model and need precise control over what it can do at specific moments in its reasoning. The Claude Agent SDK's hook architecture intercepts the tool execution lifecycle with deterministic logic. Claude decides; hooks enforce. The design analysis identifies the core values as "human decision authority, safety and security, reliable execution." The tradeoff is real: the SDK is Claude-model-locked, and there's no built-in state persistence. You get tight control over a powerful loop, and you build everything else yourself.

The fourth bet looks different again. You're in an enterprise environment where model portability, compliance middleware, and protocol interoperability are table stakes. Microsoft Agent Framework 1.0 ships with data-flow workflows, a middleware pipeline for intercepting agent behavior without modifying prompts, and native MCP and A2A support at 1.0. One detail worth noting: graph drift detection. Save a checkpoint, change the workflow graph, try to resume, and the runtime detects the mismatch via a signature hash and refuses to continue rather than silently doing the wrong thing. That's an enterprise concern baked into the architecture. It assumes your workflows are long-lived, your codebase evolves, and silent corruption is worse than a loud failure.

Four frameworks, four bets about what's hard. The heuristic works because it forces you to name your constraint before you start evaluating tools.

What a crash tells you

There's a concept that becomes sharp in production and barely registers in evaluation: durable execution. What happens when your agent process dies mid-task?

Long-running agent workflows hit LLM provider outages, container restarts, and timeout limits routinely. How a framework handles that failure tells you more about its design philosophy than any feature list.

LangGraph gives you checkpoints at node boundaries. CrewAI's Flows layer adds step-level state persistence, but at workflow boundaries, not inside the agent's reasoning loop. The Claude Agent SDK provides no built-in persistence. If a process crashes mid-task, the work is gone. Microsoft's Durable Task extension automatically checkpoints every state transition, though it remains in preview at 1.0 GA.

Each of these reflects the framework's argument about what counts. The Claude Agent SDK omits durability deliberately. It optimizes for permission boundaries, and teams that need fault tolerance build their own persistence layer on top. CrewAI optimizes for role-based coordination, and teams that need state granularity within a task often migrate to LangGraph when they hit that ceiling.

A sharp analysis from Diagrid draws a distinction worth sitting with: saving state and guaranteeing completion are different things. Even LangGraph, which has the most developed durability story, gives you snapshots and recovery mechanisms. If your agent is halfway through a long operation within a single node, that intermediate work is gone on crash. You get a save point. What you do with it is your problem.

Shared protocols, different structures

One reasonable objection: aren't these frameworks converging? All four now support MCP in some form. A2A adoption is spreading. Protocol-level interoperability is reducing switching costs.

Protocol convergence and architectural convergence are different things, though. You can swap the model provider in Microsoft Agent Framework with one line of code. You cannot swap the orchestration model. LangGraph's explicit graph, CrewAI's role-based crews, the Claude Agent SDK's reactive loop with hooks, and Microsoft's data-flow workflows with middleware pipelines are fundamentally different structures. Shared protocols let your agents talk to each other across frameworks. The frameworks still think about orchestration in fundamentally different ways.

The commitment underneath

The framework you pick will quietly shape how you handle branching, error recovery, human-in-the-loop patterns, and state management for the life of the system. Teams that migrate between frameworks 6–12 months in usually chose based on prototyping speed or feature checklists instead of asking which constraint would dominate in production.

A control philosophy shapes how you encounter anticipated problems and unanticipated ones alike. A team that chose LangGraph for its checkpointing will, months later, find themselves structuring new features as graph nodes because that's what the system rewards. A team that chose CrewAI will decompose novel problems into roles because that's the abstraction they have. The framework's argument about what's hard becomes your team's default way of thinking about complexity. That's the nature of architectural commitment. The framework's argument needs to match the reality your system will face.

Better to choose that shape deliberately than to discover it when something crashes at 3 a.m. and you learn what your framework thinks is important by what it saved and what it didn't.