AI agents have moved from novelty to infrastructure, shifting the developer’s challenge from building a proof-of-concept to maintaining a stable runtime. The choice of framework is no longer a function of tool coverage; with the adoption of the Model Context Protocol (MCP), tool integration has been effectively commoditized across the ecosystem, removing the need for framework-specific vetting.

Instead, the decision now hinges on the operational characteristics of the orchestration engine: whether it can handle durable execution, manage complex state, and provide the visibility required to survive contact with production.

This article evaluates the six frameworks worth serious consideration today — LangGraph, Microsoft Agent Framework, CrewAI, the OpenAI Agents SDK, Google ADK, and AWS Strands — by isolating the properties that actually dictate long-term project success.

What is an agent framework?

An agent framework is the orchestration runtime that governs how an agent interacts with its environment. In this architecture, it is critical to distinguish the framework from the model: the LLM is the reasoning engine—the brain that manages the thought process—while the framework is the orchestrator.

Core functions of agent frameworks

Because modern reasoning is now a per-request setting (such as reasoning effort, thinking modes, or adaptive thought budgets), the framework’s primary job is to manage the environment around that "brain." It accomplishes this through three core functions:

1. Managing control flow. While simple LLM calls are linear, agentic work is iterative. The framework provides the primitives—graphs, event loops, or state machines—to define how an agent transitions between tasks, manages cycles, and dictates the sequence of operations.
2. Providing state management. Agents are autonomous, which means they must track state across multiple turns and varying latency. A framework provides the persistence layer that handles state, ensuring that if a process restarts or a network call hangs, the agent maintains its position in the workflow.
3. Acting as a boundary controller. The framework governs the interface between the model’s reasoning and the real world, handling tool invocation, input sanitization, and output normalization. By standardizing these boundaries, it allows you to tune the model’s reasoning parameters or swap providers without rebuilding the logic that drives the agent’s actions.

Ultimately, these frameworks act as operating systems for autonomous software. They provide the infrastructure that enables reproducibility and observability, transforming a proof-of-concept into a stable, production-grade application.

Top agent frameworks to use today

The field has expanded considerably. Alongside the independent frameworks that defined the category, every major model vendor now ships its own — and those vendor frameworks have matured to the point where they belong in the comparison rather than a footnote.

Adoption data is thin. Stack Overflow's April 2026 pulse survey of roughly 1,100 developers put LangChain at 22% adoption, OpenClaw at 17% and LangGraph at 14%. Additional research suggests agent frameworks appear in only 18% of organizations running LLM applications, up from nine percent a year earlier, which means roughly four in five teams are still building without one.

LangGraph

LangGraph is an open-source framework from LangChain for building stateful, multi-actor applications with LLMs. It models a workflow as a graph in which each node is a task or function and each edge is a transition, and importantly, those graphs can contain loops.

That is the whole point of the design: LangGraph exists because the chain-based pipelines that preceded it could not cycle. LangChain now describes it as a low-level orchestration framework and runtime for building, managing and deploying long-running, stateful agents, with durable execution, persistence, streaming and human-in-the-loop as the headline capabilities.

Microsoft Agent Framework

Microsoft Agent Framework is the convergence of AutoGen and Semantic Kernel into a single supported framework. It inherits AutoGen's event-driven, actor-model core along with Semantic Kernel's enterprise plumbing. Workflows are built from executors connected by typed edges and executed in supersteps, with a set of higher-level orchestration patterns layered on top. It ships for .NET, Python and Go, with .NET running slightly ahead.

CrewAI

CrewAI facilitates collaboration between role-based agents: each agent is assigned a role and a goal, and the crew operates as a unit with autonomous delegation between members. CrewAI describes itself as a standalone framework with its own primitives for agents, tasks, crews, flows, tools and orchestration. Crews are only half the model. Flows, added in late 2024, are event-driven workflows with state and branching, and the company's own framing is that the real power comes from combining the two: a Flow for deterministic structure, with a Crew dropped into the steps that need autonomy.

OpenAI Agents SDK

The OpenAI Agents SDK arrived in March 2025 as the production successor to the experimental Swarm project. Its design philosophy is stated in its own documentation: enough features to be worth using, but few enough primitives to make it quick to learn. There are three core concepts — agents, handoffs and guardrails — and a minimal agent is about three lines of code. In April 2026 it gained a native sandbox layer for code-executing agents, which is now its most distinctive feature.

Google ADK

Google's Agent Development Kit launched in April 2025 and reached 2.0 for Python in May 2026, with Go following in June. The 2.0 release was a genuine architectural change: ADK moved from a hierarchical agent executor to a graph-based execution engine, in which agents, tools and functions are all evaluated as nodes in a workflow graph.

ADK is the most polyglot option in this comparison, shipping for Python, Go, Java, Kotlin and TypeScript — though 2.0 itself is not yet available in all five. It also has the deepest native A2A support, which is unsurprising given Google authored the protocol.

AWS Strands

AWS released Strands Agents as open source in May 2025 and took it to 1.0 that July. Its premise is "model-driven": rather than encoding orchestration in an explicit graph, Strands leans on the model's own reasoning to decide what to do next, and gives you a very small surface to work with. Getting a working agent takes three lines, which is the shortest path in this group.

Note that the default model provider is Amazon Bedrock, so an AWS account is required unless you change it. Python and TypeScript only.

Other frameworks worth knowing

A few more frameworks are close to the cut and may be the right answer depending on your constraints:

• Pydantic AI reached 1.0 in September 2025 and is the strongest option if end-to-end type safety and OpenTelemetry-native observability are your priorities.
• LlamaIndex Workflows, unbundled from LlamaIndex core in June 2025, is a lean event-driven step graph.
• Mastra is the TypeScript-native default for teams that do not want to run Python at all.
• Hugging Face's smolagents remains the minimalist choice for code-writing agents.

Operational criteria comparison table: Agent frameworks

Rather than exhaustively listing every capability for every framework, we focus here on the architectural philosophies that define the top performers. For a bird’s-eye view of where each tool stands, refer to the comparison matrix below; for the technical nuances that actually influence production, see the analysis following.

When to choose which framework

And a shorter answer to the question most people actually arrive with:

Comparing the six frameworks

Ease of usage

Developer experience is currently defined by the trade-off between speed-to-first-agent and the ceiling of the framework’s capability. Frameworks like AWS Strands and the OpenAI Agents SDK prioritize a "minimalist surface"—you can often instantiate a working agent in three lines of code. This is optimal for rapid prototyping where the logic is straightforward.

Conversely, frameworks like LangGraph, Google ADK, and Microsoft Agent Framework provide "opinionated power." They demand a deeper understanding of their primitives—graphs, supersteps, or executors—and often require a more rigid project structure. While this presents a steeper learning curve, it also prevents the architectural "spaghetti" that typically forces teams to rewrite their agent code once the project scales beyond a simple demo.

Multi-agent interaction patterns: Hierarchical vs. peer-to-peer

The way agents communicate is the primary determinant of system complexity. Frameworks generally fall into one of two camps: structured hierarchies or decentralized swarms. CrewAI and Microsoft Agent Framework lean into structured, role-based orchestration where agents are assigned specific tasks, creating a deterministic "crew" or "superstep" pattern. This is highly effective for predictable, complex workflows where you need to manage delegation and handoffs.

Conversely, LangGraph and AWS Strands favor peer-to-peer or graph-based interactions. By utilizing nodes and edges (or swarm hooks), they allow for more fluid, iterative, and cyclic interactions. This approach is more powerful for open-ended problem solving, but it shifts the burden of preventing infinite loops or deadlocks entirely onto the developer.

Memory support: Transient vs. persistent state

The practical challenge of memory is defining the scope of context. We see two distinct models here: the "unified system" and the "checkpoint-first" architecture. CrewAI and Google ADK have converged on unified memory systems that use hierarchical scopes and LLM-driven importance scoring to manage long-term data. This is ideal for agents that need to "learn" from interaction history.

In contrast, LangGraph treats memory as a state-management problem, separating thread-scoped checkpoints from long-term stores. This gives developers granular control over what data is persisted, making it the superior choice for high-compliance or highly specific state-tracking environments.

Structured output: Optional vs. load-bearing

Structured output is no longer a convenience—it is the mechanism that drives agentic flow. While most frameworks offer structured output as an optional utility, LangGraph treats it as load-bearing; nodes return structured state, which is the literal input for the next transition in the graph. This makes structure a requirement for the workflow to function.

Conversely, frameworks like the OpenAI Agents SDK and AWS Strands treat structured output as a call-time configuration. While this makes for a faster implementation in simple agents, it places the burden of schema validation and error handling on the developer at the time of the invocation, rather than baking it into the runtime’s execution logic.

Caching: Prompt-level vs. workflow-level

Caching strategy determines whether you are optimizing for model cost or execution speed. We see two distinct levels of caching here. Some frameworks, like AWS Strands and OpenAI Agents SDK, focus on "prompt-level" caching—reusing model inputs and tool definitions to trim latency and token spend at the model provider level. This is a passive, set-and-forget performance gain.

Others, like LangGraph, focus on "workflow-level" caching. By caching the results of specific nodes in a graph, LangGraph allows you to skip entire computational blocks if the input state hasn't changed. This is a much more aggressive strategy that directly affects your ability to resume and optimize complex, multi-step agentic tasks.

Replay and time travel

Replay lets you revisit and analyze previous executions, which is how you actually debug an agent. Replayability depends on how a framework handles state at the execution level. LangGraph provides true time-travel capabilities by checkpointing state at every super-step, which allows for branch-and-fork debugging. You can explore alternative paths from any saved checkpoint without re-running the entire workflow.

In contrast, frameworks like the OpenAI Agents SDK prioritize observability and tracing. They provide visibility into execution, but they lack first-party state-forking, requiring developers to manage their own re-execution logic if a step fails or needs to be rerun.

Code execution: Security vs. capability

Code execution is the most volatile operational criterion because it introduces significant security and isolation requirements. The divide here is between "hosted utility" and "flexible sandbox."

The OpenAI Agents SDK offers the most integrated experience by providing a native, multi-backend sandbox layer that abstracts away the complexity of snapshotting and filesystem isolation. This is a "set-and-forget" capability.

In contrast, frameworks like LangGraph and CrewAI treat code execution as a modular capability, allowing you to plug in your own sandboxes (Docker, micro-VMs, or remote executors). This flexibility is vital for teams with rigid security postures or specialized hardware requirements, but it requires more upfront work to wire the execution environment correctly.

Human in the loop

The implementation of human-in-the-loop interactions creates a sharp divide regarding process durability. Microsoft Agent Framework and LangGraph treat interrupts as persistent events; because the state is checkpointed, an approval request survives process restarts or service redeploys. This is a requirement for long-running workflows where an approval may need to persist over days.

Conversely, frameworks like CrewAI take a task-based approach, surfacing prompts to the user during specific task execution. This is efficient for linear, short-lived agents but does not provide the same structural durability for complex, multi-stage approval chains.

Customization & middleware: Event-driven vs. hook-based

Every framework provides some form of customization, but the "hook" mechanism changes how you manage an agent’s lifecycle. AWS Strands and Microsoft Agent Framework prioritize middleware-heavy designs, where you can intercept calls at almost any point—around the model, the tool, or the client—to rewrite arguments or force retries. This is a "pluggable" architecture perfect for complex enterprise requirements.

LangGraph takes a different path, embedding its customization hooks directly into the graph execution. Because those hooks run inside the compiled graph, they have visibility into the state of the entire workflow. This is more powerful for complex decision-making, but it creates a steeper learning curve compared to the modular middleware approach found in Strands.

Durable execution: Native vs. delegation

Durable execution—the ability of an agent to survive a process crash and resume its work—reveals the most significant architectural differences.

Microsoft Agent Framework pursues an ambitious, native "durable extension" design that attempts to make workflow threads inherently resilient, though it is currently in preview. Most other frameworks, such as the OpenAI Agents SDK and Google ADK, treat durability as a responsibility to be delegated, documenting integrations with external platforms like Temporal.

LangGraph occupies the middle ground, providing a suite of durability modes that are integrated into its own platform layer. This creates a "tiered" decision: if you require durability today, you are either opting into a specific platform-native solution or architecting for external infrastructure.

Interoperability: The MCP and A2A standard

The industry is moving toward two protocols that are effectively rewriting the rules of framework choice. The Model Context Protocol (MCP) has largely commoditized tool integration, turning what was once a framework’s primary moat into a shared utility. Every framework here now supports it, meaning your choice is no longer dictated by which libraries have the most pre-built tool integrations.

Agent2Agent (A2A), however, tells a different story. While MCP handles how agents talk to tools, A2A standardizes how agents talk to each other across different runtimes. Google ADK and AWS Strands have moved fast here, providing first-party, stable support that allows you to expose agents as remote services.

In contrast, for frameworks like LangGraph, A2A is currently an "add-on" handled at the platform layer, while for Microsoft Agent Framework, it remains in a state of registry uncertainty. If your roadmap involves a multi-framework or cross-org agent ecosystem, A2A support is the new, non-negotiable threshold for evaluation.

What the production data says

One more thing is worth knowing before you choose, because it complicates the case for multi-agent architecture that comparisons like this one tend to assume.

Stack Overflow's survey put 69% of respondents on single-agent designs, with 68% saying they actively prefer predictable single-agent setups. Gartner predicted in mid-2025 that over 40% of agentic AI projects would be canceled by the end of 2027, citing escalating costs, unclear business value and inadequate risk controls.

The gap between the multi-agent systems teams design and the mostly-single-call systems they actually run in production is not an argument against these frameworks. It is an argument for instrumenting what you build. The most useful finding comes from Databricks: organizations with AI governance in place ship roughly twelve times more projects to production, and those using evaluation frameworks around six times more. Framework choice matters much less than whether you can see what your agents are doing and tell whether their output is any good.

Conclusion

Framework choice has become less consequential than it was, and more consequential in a different way:

• Less consequential because MCP has commoditized tool access and A2A is doing the same for agent-to-agent communication, so the thing you can build is decreasingly determined by the library you pick.
• More so because the frameworks now differ sharply on the properties that decide whether an agent survives contact with production: whether state is durable, whether a failed run can resume, whether a paused approval outlives a redeploy, and whether you can reconstruct what happened after the fact.

Whichever you choose, the framework is only half the problem. Splunk Agent Observability evaluates, observes and protects AI agents across the development lifecycle, with documented instrumentation for CrewAI, LangGraph, the OpenAI Agents SDK, Google ADK, Microsoft Agent Framework, Pydantic AI, Strands and A2A. See how it works.

FAQs about agent frameworks