Agent Frameworks Compared

An agent framework is far more than a router; it bundles the capabilities you would otherwise build yourself. These are the value areas to weigh when choosing — each is a row or a section later in this guide:

• Orchestration & control flow — the core job, in two distinct shapes: horizontal routing (dispatch many diverse requests to the right tool or agent) and vertical, long-horizon execution (drive one complex task through planning, sub-agents, and many sequential tool calls). Most frameworks favor one; the matrix shows which. The field is converging on explicit, graph-based control (see Convergence trends).
• State management & persistence — durable execution, checkpointing, and resume-after-failure, so long-running agents survive crashes and support rollback and human-in-the-loop pauses.
• Memory & context management — short-term/conversational memory, cross-session long-term memory, summarization, and context-window control. This is the difference between an agent that remembers and one that forgets every turn; it's also the area most tied to AWS AgentCore (detailed in Context and memory management below).
• Tool integration — function calling, OpenAPI, and MCP, with automatic schema generation and tool-access governance.
• Multi-agent coordination — supervisor, hierarchical, swarm, and agent-as-tool patterns, plus cross-framework interoperability via the A2A protocol.
• Model abstraction (provider-agnosticism) — a unified interface so you can route per task and swap models without rewriting logic.
• Human-in-the-loop & guardrails — approval gates, steering/interrupts, and policy enforcement before a tool runs.
• Observability & evaluation — step-level tracing, replay debugging, and built-in evaluation harnesses.
• Streaming & multimodality — token streaming and, increasingly, bidirectional audio/image/video.
• Deployment & runtime hosting — where the agent actually runs, increasingly decoupled from the framework via managed runtimes

The decision matrix scores the frameworks on the subset of these that most often drives selection; the capability reference and the memory section give the detail.

Release cadence and recent commit volume are the clearest live signals of how actively a project is being developed. Captured from the GitHub API on 2026-06-09:

How to read it: weight the rows that matter for your situation and compare columns. The AWS/AgentCore rows are the sharpest differentiators:

• AgentCore Runtime support — AgentCore is framework-agnostic and officially documents CrewAI, LangGraph, LlamaIndex, Google ADK, OpenAI Agents SDK, and AWS Strands. Microsoft Agent Framework can run as custom code but isn't AWS-documented, hence ◐.
• AgentCore Memory integration — only Strands ships a native helper, the AgentCoreMemorySessionManager, wiring short- and long-term AgentCore Memory through its hook system (AWS — Strands SDK Memory; Strands docs). Every other framework can use AgentCore Memory, but through the MemoryClient API directly (◐) rather than a built-in integration.
• Integration with AWS services — Strands is AWS-native (Bedrock, AgentCore, Lambda/Fargate/EKS) (AWS Prescriptive Guidance); LangGraph/CrewAI/LlamaIndex integrate well via Bedrock + the AgentCore SDK; ADK and Microsoft Agent Framework are GCP- and Azure-native respectively.
• Model-agnostic capability — LangGraph, CrewAI, Strands, and LlamaIndex route to any provider; ADK and Microsoft Agent Framework support multiple providers but lean toward Gemini and Azure OpenAI.

LangChain is the foundational library beneath much of this — the broad, batteries-included ecosystem (138.8K stars) from which LangGraph emerged; it's the fastest way to prototype and integrate, at the cost of heavier default token and memory overhead. deepagents is LangChain's long-horizon harness — write_todos planning, filesystem context-offload, sub-agent spawning, and auto-summarization layered on the LangGraph runtime — purpose-built for vertical single-task depth rather than horizontal routing. LlamaIndex remains the strongest option when the workload is RAG- and data-connector-heavy.

Memory is where these frameworks differ in kind, not just degree — and it's the area most tied to AWS AgentCore.

• LangGraph — memory is its core competency. Checkpointers save a state snapshot at every super-step into threads (short-term/conversational memory), with get_state/update_state and tunable durability modes; the Store interface adds cross-thread long-term memory with semantic search over embeddings. (persistence & memory docs)
• CrewAI — a unified Memory class (it consolidated short-term, long-term, entity, and external memory into one), backed by LanceDB, with LLM-inferred scope/importance and adaptive recall combining semantic similarity, recency, and importance scores. (memory docs)
• Google ADK — Session/State for short-term context, plus a pluggable MemoryService: InMemoryMemoryService for prototyping or the managed Vertex AI Memory Bank (VertexAiMemoryBankService), which uses Gemini to extract durable memories; retrieval via PreloadMemoryTool/LoadMemoryTool. (sessions & memory docs)
• AWS Strands — built-in conversation managers (SummarizingConversationManager, SlidingWindowConversationManager) for context-window control, and — uniquely — a native Amazon Bedrock AgentCore Memory integration via the AgentCoreMemorySessionManager, wiring short- and long-term AgentCore Memory through the hook system. (Strands AgentCore Memory · AWS docs)
• Microsoft Agent Framework — context providers supply agent memory alongside session-based state management. (overview)
• LlamaIndex — strongest where memory is retrieval: chat memory buffers layered on its indexing/RAG core. (docs)

Best at context/memory generally: LangGraph (first-class state + cross-thread Store) and Google ADK (managed Vertex AI Memory Bank) lead for durable, searchable long-term memory; CrewAI's unified semantic memory is the easiest to adopt.

Native AgentCore Memory: AWS Strands is the only framework with a first-class AgentCore Memory integration (AgentCoreMemorySessionManager). Every other framework can use AgentCore Memory — it's a managed AWS service callable through the MemoryClient API, but without a built-in helper, so you wire it up yourself. If AgentCore Memory is central to your design, Strands is the path of least resistance.

LangGraph — the control-first choice and the adoption leader on production pull (56.1M downloads/month). Its low-level StateGraph, durable execution, and checkpointing make routing logic explicit, testable, and auditable; you pay for that in boilerplate and a steeper curve. Best where correctness, rollback, and human-in-the-loop matter more than speed of authoring. (docs)

CrewAI — the velocity choice (53.1K stars). Crews model teams of role-playing agents; Flows add event-driven state and control. It's standalone and token-conscious, and gets a working multi-agent system up quickly. The trade-off is less explicit low-level control than a graph gives you. (docs)

Google ADK — the most feature-complete on multimodality and interoperability (20.0K stars, 26.0M downloads/month, Apache-2.0). ADK 2.0's graph runtime closed much of the deterministic-control gap with LangGraph; Gemini Live and the A2A protocol are genuine differentiators. Strongest for GCP shops and cross-framework estates; leans toward Gemini/GCP. (docs)

AWS Strands — the AWS-native choice (6.1K stars but 14.8M downloads/month, reflecting AWS-backed production use). A model-driven loop with native MCP, rich multi-agent primitives (swarm, graph, agent-as-tool), OpenTelemetry, and deployment straight to AgentCore/Lambda/Fargate. The trade-off is less explicit routing transparency than a graph framework. (docs)

Microsoft Agent Framework — the Azure/.NET choice and the direct successor to AutoGen + Semantic Kernel (GA, Feb 2026). It pairs simple agent abstractions with graph-based workflows (type-safe routing, checkpointing, HITL), MCP, and first-class .NET + Python. Best where the estate is Azure-centric. (docs)

The frameworks are converging faster than their branding suggests. Five trends stand out:

1. Explicit, deterministic graph control is becoming universal. Early frameworks were model-driven — the LLM decided the loop. For production reliability and auditability, everyone is now wrapping that autonomy in deterministic, graph-based orchestration. The clearest example is Google ADK: it began hierarchical and model-driven, then shipped Graph Workflows in 2.0 (2026-05-19) — a graph execution engine with routing, fan-out/fan-in, loops, retries, and explicit state, pitched as "weave deterministic code with adaptive AI reasoning" (ADK docs · ADK 2.0 release). That is a direct convergence on the StateGraph + conditional-edges model LangGraph pioneered. Microsoft Agent Framework did the same with graph Workflows (type-safe routing, checkpointing), and CrewAI added event-driven Flows beside its autonomous Crews. The field has effectively agreed that production agents need explicit control around autonomous reasoning — LangGraph's original thesis.
2. MCP is the universal tool protocol. Every framework here speaks Model Context Protocol, so tools are increasingly portable across frameworks (ADK MCP tools · Strands MCP · Microsoft Agent Framework MCP).
3. A2A is standardizing cross-framework interop — 150+ organizations, letting agents built in different frameworks call one another.
4. Hosting is decoupling from the framework. Managed runtimes — AWS AgentCore, Vertex AI Agent Engine, and Azure — run any framework, so framework choice and deployment target are now independent decisions.
5. Model-agnostic is the default. LiteLLM (or equivalent) is table stakes; single-provider lock-in is now the exception.

The practical consequence: frameworks are differentiating less on core orchestration capability — which is converging on the LangGraph-style explicit graph — and more on ecosystem, cloud-nativeness, and ergonomics. Increasingly you pick for your cloud and your team's style, not for a capability only one framework has.

• Compliance / explicit control / AWS-agnostic → LangGraph (+ deepagents for long single tasks).
• Rapid multi-agent prototyping → CrewAI.
• AWS / Bedrock → AWS Strands.
• GCP / Gemini multimodal / A2A interop → Google ADK.
• Azure / .NET → Microsoft Agent Framework.
• RAG / broad integrations → LangChain or LlamaIndex.

One framework-independent point: all of these run on managed agent runtimes such as AWS AgentCore, so the framework and the hosting are separate decisions.

Official documentation

1. LangGraph — overview & concepts
2. LangChain — documentation
3. CrewAI — introduction (Crews & Flows)
4. Google ADK — documentation
5. AWS Strands Agents — documentation
6. LangChain deepagents — overview
7. Microsoft Agent Framework — overview
8. A2A protocol surpasses 150 organizations — Linux Foundation

AWS AgentCore integration

1. Amazon Bedrock AgentCore — Use any agent framework

2. Amazon Bedrock AgentCore — Strands SDK Memory integration

3. Strands — AgentCore Memory Session Manager

4. AWS Prescriptive Guidance — Strands Agents

Context & memory documentation

1. LangGraph — persistence & memory

2. CrewAI — memory

3. Google ADK — sessions & memory (Vertex AI Memory Bank)

Usage & development-activity data (primary)

1. GitHub — langchain-ai/langgraph · langchain · crewAIInc/crewAI · microsoft/autogen · microsoft/agent-framework · google/adk-python · strands-agents · run-llama/llama_index

2. PyPI download statistics — pypistats.org