Enterprise Agent Frameworks Compared: LangGraph, CrewAI, AutoGen, Semantic Kernel, and LlamaIndex

Every major open-source agent framework is MIT-licensed and free to run, so the license line on the comparison sheet tells you almost nothing. What separates LangGraph, CrewAI, AutoGen, Semantic Kernel, and LlamaIndex is the architecture model each imposes, how durable their state is, and, increasingly, who is still actively steering the project. That last point moved more in the past year than any feature did.

This comparison works through the dimensions a platform team actually weighs: the orchestration model, state management and checkpointing, human-in-the-loop support, observability, the deployment story, licensing and governance, and Model Context Protocol (MCP) interoperability. Every factual claim about a framework below comes from that project's own repository or first-party documentation, accessed on 2026-08-20. Where a capability could not be verified against a first-party source, the table says so instead of guessing.

By the numbers

The comparison at a glance

The table below is the one-screen version of this article. Read the rows top to bottom as a triage: owner and maintenance status first (because a framework in maintenance mode fails the governance test regardless of features), then architecture model (because it is the hardest thing to migrate off), then the operational rows.

Architecture model: the choice that actually locks you in

MIT licensing means none of these frameworks lock you in legally. The lock-in is architectural: once your team has expressed a hundred workflows as graphs, or crews, or kernel plugins, the rewrite cost is real. So the first decision is which mental model matches your problems and your engineers.

The practical read: graph-style orchestration (LangGraph) suits processes you must be able to audit, replay, and constrain — the shape of most regulated-industry work. Role-based crews (CrewAI) suit open-ended tasks where you want agents to divide labor with less prescriptive wiring. Conversation-driven architectures (AutoGen's pattern, carried forward by Microsoft Agent Framework's handoff and group-collaboration patterns^[9]) suit research-style exploration and dynamic delegation. The kernel/middleware model (Semantic Kernel) suits organizations whose primary asset is a large existing codebase of APIs to expose to models. And a data-framework model (LlamaIndex) suits workloads where retrieval quality, not orchestration topology, decides success.

State, checkpointing, and durable execution

Agents fail mid-run: a model times out, a tool errors, a container is recycled. Whether the workflow resumes or restarts from zero is a framework property, and it is where the five diverge most sharply. LangGraph makes durability a first-class claim — its README leads with "durable execution," agents that "persist through failures" and resume from where they stopped, alongside both short-term working memory and long-term persistent memory across sessions.^[1] The persistence layer is concrete and swappable: the project publishes dedicated checkpoint backends, including Postgres and SQLite packages, on its releases page.^[8]

Microsoft Agent Framework, the successor to both AutoGen and Semantic Kernel, makes the same bet: its workflow feature list includes "checkpointing, streaming, human-in-the-loop, and time-travel."^[9] That convergence is the tell — the two vendors with the most enterprise production exposure both concluded that durable, checkpointed workflow state is table stakes for agents that touch real business processes.

CrewAI approaches the problem from the other end. Crews are deliberately autonomous — "teams of AI agents with true autonomy and agency"^[2] — and Flows exist precisely because production systems need the opposite: event-driven workflows with "precise control over complex automations."^[2] The design question for a CrewAI adopter is how much of each workload belongs in the autonomous layer versus the controlled one. Semantic Kernel and LlamaIndex, by contrast, treat state primarily as memory and data: Semantic Kernel through pluggable vector and memory connectors,^[4] LlamaIndex through its indexes and retrieval layer.^[5] If your definition of state is "what the agent knows," both are strong; if it is "exactly where a nine-step process stopped and how to resume it," LangGraph and Agent Framework are the ones that document that behavior as a core feature.

Human-in-the-loop

For any agent that spends money, touches customer data, or writes to a system of record, the approval gate is not optional. Here the documentation gap between frameworks is itself the finding. LangGraph documents human-in-the-loop as a named capability: the ability to inspect and modify agent state so a person can approve, correct, or redirect a run in flight.^[1] Microsoft Agent Framework likewise lists human-in-the-loop among its workflow features.^[9] Semantic Kernel's oversight story runs through its hooks and filters, which Microsoft positions as the mechanism for delivering "responsible AI solutions at scale."^[6]

CrewAI and LlamaIndex can both implement approval gates, but neither leads with the capability in its repository README, which means your team should prototype the pause-approve-resume path before committing — the pattern is only as good as its persistence. A human approval that takes four hours to arrive requires the durable-state machinery from the previous section; an in-memory pause is a demo, not a control.

Observability and the deployment story

None of the five is only a library anymore; each anchors a commercial gravity well, and observability is usually where the open core ends and the paid product begins. LangGraph integrates with LangSmith for debugging and offers production deployment tooling from the same vendor.^[1] CrewAI bundles "managed deployment, observability, governance, security, and enterprise support" into its AMP suite.^[2] LlamaIndex's commercial layer, LlamaParse, is a managed platform for parsing, extraction, indexing, and deployed document agents.^[5] Microsoft's path is different in kind: Agent Framework ships "built-in OpenTelemetry integration for distributed tracing, monitoring, and debugging"^[9] — an open standard rather than a proprietary tracing product — and Semantic Kernel documents telemetry, hooks, and filters in the SDK itself.^[6]

The decision this forces: decide up front whether agent traces flow into your existing observability stack or into a vendor's. OpenTelemetry-native instrumentation composes with the APM tooling you already run; vendor-specific tracing is often better for agent-specific debugging but adds a data flow (prompts, tool inputs, intermediate reasoning) leaving your boundary — which your security review will treat as a new data-processing relationship, not a dev tool.

On runtime shape: Semantic Kernel and LlamaIndex are SDKs you embed in your own services, with Semantic Kernel explicitly documenting local model options such as Ollama, LMStudio, and ONNX for constrained environments.^[4] AutoGen's Core supports local and distributed runtimes you operate yourself.^[3] LangGraph and CrewAI give you both paths — self-host the open framework, or buy the vendor's managed runtime.^[1][2] Teams with strict data-residency requirements should verify precisely which telemetry and state leaves their environment in the managed options; that detail is in each vendor's terms, not in this comparison's scope.

Licensing and governance: who owns your orchestration layer

Since all five licenses are MIT (AutoGen's repository additionally shows CC-BY-4.0 for documentation content),^{[1][2][3][4][5]} governance risk is concentrated in stewardship, not legal terms. The 2025-2026 period rearranged that landscape more than any feature release did.

Microsoft consolidated its two agent efforts into one. AutoGen's README carries the maintenance-mode notice above and tells new users to start with Microsoft Agent Framework, with a published migration guide for existing users.^[3] Semantic Kernel's README now opens with "Semantic Kernel is now Microsoft Agent Framework!" and describes Agent Framework as its "enterprise-ready successor," available at version 1.0 as a production-ready release with "stable APIs, and a commitment to long-term support."^[4] Agent Framework itself is an MIT-licensed, Microsoft-owned framework for Python and .NET, with sequential, concurrent, handoff, and group collaboration patterns, and migration guides from both predecessors.^[9] Semantic Kernel remains supported with a documented non-breaking-change commitment across C#, Python, and Java,^[6] but net-new Microsoft-stack builds now have an official answer, and it is not either of the two frameworks that spent 2024 in every comparison article.

The independents carry a different risk profile. LangChain and CrewAI Inc. are venture-backed companies whose frameworks feed commercial platforms; their incentive is continued open-source investment, but a platform team should track where the open/paid boundary moves over time. LlamaIndex shows what repositioning looks like in practice: the project now describes itself as a document agent and OCR platform, its commercial energy is in LlamaParse, and the TypeScript implementation was archived in April 2026.^[5][7] None of that is a criticism — it is a reminder that with MIT-licensed frameworks, the thing you are actually betting on is the maintainer's roadmap, and roadmaps are readable in public if you look.

MCP interoperability: the escape hatch that changes the calculus

The Model Context Protocol, which Anthropic open-sourced in November 2024 as "an open standard that enables developers to build secure, two-way connections between their data sources and AI-powered tools,"^[12] has become the neutral tool-integration layer across this entire field. The specification is itself MIT-licensed and maintained in a public repository with a published governance model.^[13] Its significance for framework selection: your tool and data integrations no longer have to be written in any one framework's plugin dialect.

All five frameworks now meet the protocol somewhere first-party. LangChain publishes langchain-mcp-adapters, a wrapper that makes MCP tools "compatible with LangChain and LangGraph."^[10] CrewAI's README states MCP and A2A support for production agents.^[2] Semantic Kernel lists MCP in its plugin ecosystem alongside native code, prompts, and OpenAPI specs.^[4] AutoGen's README demonstrates connecting agents to MCP servers.^[3] LlamaIndex ships llama-index-tools-mcp, which "connects to MCP Servers and allows an Agent to call the tools provided by MCP Servers."^[11]

Honest objections

"The framework choice matters less than this article implies." Partly true. The models do the reasoning; the framework is scaffolding, and a strong team can build a durable agent runtime on any of the five, or on none of them. If your agent surface is one or two workflows, a framework evaluation is over-engineering — call the model API directly and revisit when you have ten workflows and an on-call rotation. The framework decision becomes material at portfolio scale, where consistency of state handling, tracing, and approval gates across dozens of agents is the thing you are actually buying.

"Maintenance mode is not death." Also fair. AutoGen is MIT-licensed; nothing stops a team from running it for years, and "community managed"^[3] projects sometimes thrive. But an enterprise adopting a framework today is signing up for years of security patches, model-API churn, and protocol evolution — and choosing a project whose own steward has named a successor means betting against that steward's stated direction. The migration guide exists;^[3] the honest move is to read it now, not after the divergence has compounded.

"These frameworks churn too fast to standardize on at all." The strongest objection, and the record supports it: within roughly two years this field saw Microsoft consolidate two frameworks into a third and LlamaIndex reposition around document agents while archiving its TypeScript port.^[3][4][7] The mitigation is not to freeze the decision but to shrink its blast radius: keep business logic and tool integrations outside the framework (MCP helps precisely here), treat the orchestration layer as replaceable, and standardize on the concepts — durable state, checkpoints, approval gates, traces — rather than on any vendor's API for them.

The decision framework

Match the shape of your problem and your stack to the framework whose model fits it natively, rather than ranking them on a single axis.

One more synthesis worth stating plainly: the five projects are converging on the same enterprise feature set — durable state, human approval gates, standard telemetry, MCP tools. LangGraph documents durable execution and human-in-the-loop;^[1] Agent Framework documents checkpointing, human-in-the-loop, and OpenTelemetry;^[9] CrewAI added controlled Flows beside autonomous Crews.^[2] That convergence means the differentiators that persist are the ones this article ordered first: the architecture model your team will think in, and the governance trajectory of the organization maintaining it.

How to apply this