Agent Frameworks Compared: A Technical Feature-by-Feature Guide

An agent framework is the harness that orchestrates a model's reasoning, tool calls, state, and multi-agent coordination. This is Part 3 of The Token Scarcity Playbook — a technical comparison of the major frameworks built so you can score them against your own needs. It centers on a decision matrix rated on the criteria that actually drive selection — ease of use, multi-agent orchestration, model-agnostic capability, AWS-service and Amazon Bedrock AgentCore integration (including AgentCore Memory), latency, and observability so you can weight the rows that matter to you.

The frameworks covered: LangGraph, LangChain, CrewAI, AWS Strands, Google ADK, LangChain deepagents, and Microsoft Agent Framework (the successor to AutoGen and Semantic Kernel).

Table of Contents

• What an agent framework does — the jobs to evaluate

• Adoption and usage data

• Development activity

• Decision matrix — score against your needs

• Capability reference

• Context and memory management

• Use-case fit

• Per-framework assessment

• Convergence trends — where the field is heading

• Decision summary

• References

What an agent framework does — the jobs to evaluate

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 (the subject of Part 2).

• 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.

Adoption and usage data (primary sources, 2026-06-08)

Development activity (how actively maintained)

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:

Decision matrix — score against your needs

Legend: ● strong · ◐ moderate · ○ basic/weak · — none. Ratings are a qualitative read of each project's official documentation and documented integrations (2026-06-08). For every row, ● is better — including "low framework overhead," where ● means less overhead. Latency is directional: in practice the model and task dominate end-to-end latency far more than framework overhead does.

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.

Capability reference (from official docs)

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.

Context and memory management

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.

Use-case fit

Per-framework assessment

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)

Convergence trends — where the field is heading

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.

Decision summary

• 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 — which is what Part 4 assembles into a production system.

Next → Part 4: Building a Multi-Agent Orchestration System.

References

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

9. Amazon Bedrock AgentCore — Use any agent framework

10. Amazon Bedrock AgentCore — Strands SDK Memory integration

11. Strands — AgentCore Memory Session Manager

12. AWS Prescriptive Guidance — Strands Agents

Context & memory documentation

13. LangGraph — persistence & memory

14. CrewAI — memory

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

Usage & development-activity data (primary)

16. GitHub — langchain-ai/langgraph · langchain · crewAIInc/crewAI · microsoft/autogen · microsoft/agent-framework · google/adk-python · strands-agents · run-llama/llama_index 17. PyPI download statistics — pypistats.org