There is a comparison everyone writes about these two frameworks, and it is the wrong one. You line up LangGraph and Microsoft Agent Framework, you make a table — sequential, concurrent, handoff, group chat — and you discover they both have all of it. Then you reach for tie-breakers: stars, languages, which one a conference keynote blessed. None of that tells you which to run, because on the axis everyone measures, the two have already converged.
So measure the other axis. Not what patterns can it orchestrate but who owns the loop while it runs in production. That question splits them cleanly, and it is the one you actually live with.
The patterns converged; the ownership did not#
Start with what's true. Microsoft Agent Framework hit 1.0 GA on April 2, 2026, the consolidated successor to AutoGen and Semantic Kernel, with migration guides from both. It ships sequential, concurrent, handoff, group chat, and Magentic orchestration as first-class primitives, plus graph-based workflows with checkpointing, streaming, human-in-the-loop, and time-travel. LangGraph models the same space as a directed graph of nodes and edges over typed state, with checkpointers — MemorySaver for development, SQLite or Postgres for production — and the same human-in-the-loop interrupts.
Read those two paragraphs again. The orchestration vocabularies are nearly identical. If you choose on orchestration, you are flipping a coin.
The open core is the bait. The hook is the platform the open core points back to.
The divergence is structural, and it shows up the moment your agent leaves your laptop. LangGraph gives you a graph object. It is provider-agnostic and it runs wherever Python or TypeScript runs. That is the whole pitch and also the whole bill: you assemble the production surface around it. Persistence backend, retries, the tracing pipeline, the guardrails, the place it actually runs — all yours to wire. The lock-in, such as it is, lives inside your own codebase.
Microsoft Agent Framework inverts that. The orchestration is open source and genuinely good — but the parts that make an agent safe in production are not in the package. Task-adherence guardrails that keep an agent on task, PII protection that flags sensitive data access, prompt-injection defenses, hosted-agent management, traces you can actually read — those light up when you deploy through Azure AI Foundry. The framework even tells on itself: DevUI, the local inspector, is documented as a sample "not intended for production use." The open core is real. It is also a wedge. Follow it to production and you arrive at Foundry.
CodeAct is the one genuinely new idea#
Most of this comparison is two roads to the same town. One piece of MAF is not, and it's worth slowing down for. CodeAct lets the model write a single short Python program that calls your tools via call_tool(...), runs it once in a sandbox, and returns one consolidated result — instead of the usual chatter of one tool call per turn, each round-tripping through the model. It ships in the alpha agent-framework-hyperlight package, and the sandbox is a fresh, locally isolated Hyperlight micro-VM spun up per call.
That is a real bet about where agent execution is heading: the model as a programmer that emits a plan-as-code, not a switchboard operator placing one call at a time. LangGraph has no first-class answer here. You can build it — you can always build it — but you own the sandbox, the isolation boundary, and the blast radius. MAF is shipping an opinion about code-writing agents with the micro-VM included. Whether you want Microsoft's opinion or your own is, again, the same question in a new costume.
So choose the question, not the feature#
Here is the decision, stated as the thing it actually is.
- You want to own the run loop. Your agent must run across clouds, or on-prem, or somewhere no hyperscaler reaches. You already have observability and a secrets story and an opinion about sandboxes. You are willing to pay in assembly for the right to move. That is LangGraph. The graph is yours; so is everything around it.
- You want to rent the run loop. You are on Azure, or happy to be. You would rather inherit task-adherence, PII filtering, injection defense, and readable traces than build them, and you accept that "production" and "Foundry" become synonyms. That is Microsoft Agent Framework. The orchestration is free; the safety net is the subscription.
Both are defensible. What is not defensible is choosing them by feature parity, because feature parity is exactly what they achieved and exactly what hides the decision. The frameworks converged so that the platforms underneath them could diverge. Pick the lock-in you can live with — in your code, or in your cloud — and the rest of the table answers itself.
