The 2026 Agent Frameworks Landscape

This content was generated with the assistance of AI and should be verified against the official documentation of each tool and framework before being relied on in production.

This section’s bibliography lists the reference material consulted while preparing these pages.

Every version below was read from the framework’s own package registry (PyPI, Maven Central, npm, crates.io, NuGet) on 2026-09-28, and every capability cell was checked against the installed package’s public API or its official repository documentation on that date. Frameworks in this space release weekly; treat the table as a dated snapshot and re-check a framework’s own documentation before choosing it. The deeper, framework-specific material lives elsewhere in this AI section: the LangChain sub-section and the Spring AI sub-section cover those two frameworks in full.

Comparison

Framework Language Paradigm State / persistence Multi-agent MCP / A2A support Status (2026-09-28)

LangGraph

Python, TypeScript

Low-level graph of nodes and edges over typed state; you build the loop

Checkpointers per thread (in-memory, SQLite, Postgres); cross-thread stores with semantic search

Supervisor via tools, handoffs/swarm (langgraph-swarm), subgraphs

MCP via langchain-mcp-adapters; A2A via the A2A SDKs

Stable 1.x (langgraph 1.2.12; JS 1.4.18)

LangChain create_agent

Python, TypeScript

Prebuilt tool-calling agent on LangGraph, customised with middleware

LangGraph checkpointer and store

Sub-agents as tools; langgraph-supervisor for existing code

MCP via langchain-mcp-adapters; A2A via the A2A SDKs

Stable 1.x (langchain 1.4.2)

OpenAI Agents SDK

Python, TypeScript

Lightweight agents with handoffs, guardrails and tracing

Sessions (SQLite, Conversations API, custom)

Handoffs; agents as tools

MCP built in (local and hosted MCP tools); no built-in A2A

0.x, actively developed (openai-agents 0.22.3; JS 0.18.0)

Claude Agent SDK

Python, TypeScript

The Claude Code agent harness as a library: built-in tools, permissions, hooks

Resumable and forkable sessions, pluggable session store

Subagents (AgentDefinition) with isolated contexts

MCP built in (including in-process SDK servers); no built-in A2A

0.x, actively developed (claude-agent-sdk 0.2.161; npm 0.3.284)

Microsoft Agent Framework

Python, .NET

Agents plus graph-based workflows; successor to AutoGen and Semantic Kernel agents

Agent sessions with history providers; workflow checkpointing

Sequential, concurrent, handoff, group-chat and Magentic orchestrations

MCP and A2A both built in

GA since 1.0 (2026-04-03); agent-framework 1.19.0, Microsoft.Agents.AI 1.22.0

CrewAI

Python

Role-based Crews of agents plus event-driven Flows

Built-in crew memory; Flow state with @persist

Sequential and hierarchical crews, delegation

MCP and A2A (A2AConfig) built in

Stable 1.x (crewai 1.15.22)

smolagents

Python

Minimal agents; CodeAgent writes actions as Python code, ToolCallingAgent uses JSON tool calls

In-run step memory; persistence is the application’s

Managed agents

MCP via MCPClient / ToolCollection; no A2A

Stable 1.x (smolagents 1.26.0, Hugging Face)

Google ADK

Python, Java, Go, TypeScript

Code-first LlmAgent plus workflow agents (sequential, parallel, loop)

Session and memory services

Sub-agents, agents as tools

MCP (MCPToolset) and A2A (RemoteA2aAgent, to_a2a) built in

Stable (google-adk 2.10.0; Java 1.10.1, Go 1.7.0, npm 2.1.0)

LangChain4j

Java

AI Services plus an agentic module (workflows, supervisor, planners)

ChatMemory / ChatMemoryStore; AgenticScope persistence

Supervisor agent, workflow composition, custom planners

MCP client (langchain4j-mcp); A2A client (langchain4j-agentic-a2a)

Core stable 1.x (1.20.2); agentic modules still beta (1.20.2-beta30)

Spring AI

Java (Spring Boot)

ChatClient with advisors and tools; patterns written as ordinary Spring code

ChatMemory / ChatMemoryRepository (JDBC, Cassandra, Neo4j, MongoDB, Cosmos DB, Redis)

Tools calling other clients; community subagents (spring-ai-agent-utils)

MCP client and server built in; A2A only via community projects

Stable 2.0 (2.0.1; 2.1 in milestones)

Mastra

TypeScript

Agents plus workflows, with a built-in dev server

Memory (threads, working memory, semantic recall) over pluggable storage

Agent networks, agents as tools

MCP (@mastra/mcp) and A2A built in

Stable 1.x (@mastra/core 1.71.0)

Rig

Rust (see the Rust Reference)

Composable LLM building blocks: agents, tools, RAG, pipelines

Application-managed

Composition (agents as tools)

MCP through the rmcp Rust MCP SDK, not built into rig-core; no A2A

0.x (rig-core 0.42.0)

The Java rows reflect the version baseline used throughout this sub-section; see Spring AI and A2A for why "community only" matters for A2A v1.0.

2026 deprecations and migrations

Several frameworks that older books and tutorials build on were retired or superseded in 2025-2026. This matters when following a book’s code: an example can be conceptually sound and still not run.

The OpenAI Assistants API was sunset on 2026-08-26; its replacement is the Responses API with the Conversations API for state, plus the OpenAI Agents SDK for agent orchestration, and OpenAI’s migration guide maps threads, runs and assistants onto the new primitives (Assistants API migration guide). Code written against Assistants — including examples in books published before the sunset — no longer runs.

AutoGen and the agent features of Semantic Kernel have been superseded by the Microsoft Agent Framework, which reached general availability with version 1.0 on 2026-04-03; AutoGen is in maintenance mode, and Microsoft publishes migration guides from both (Microsoft Agent Framework blog).

Prompt flow is scheduled for retirement on 2027-04-20; new flows should be built elsewhere, and existing ones migrated before that date.

Two API changes inside living frameworks are worth knowing as well: LangChain 1.x replaced the 0.x create_react_agent with langchain.agents.create_agent plus middleware (see LangGraph v1 release notes), and CrewAI’s current model is Crews plus Flows.

Choosing a framework

There is no single best framework; there is a best fit for a team and a problem. Weigh:

  • Language and platform. Use what the team and the rest of the system already run: LangChain4j or Spring AI in a Java estate, Microsoft Agent Framework in .NET, Mastra in TypeScript, Rig in Rust, and any of the Python frameworks otherwise.

  • Control vs. convenience. Low-level graphs (LangGraph, Microsoft Agent Framework workflows) give full control of the loop and state; prebuilt agents (create_agent, OpenAI Agents SDK, CrewAI crews, Claude Agent SDK) are faster to start with and harder to bend.

  • Model coupling. Vendor SDKs (OpenAI Agents SDK, Claude Agent SDK) are tuned for their own models and platform; the others are model-agnostic. Check whether the provider-neutral ones support the features you need (prompt caching, reasoning controls) on your model.

  • State and durability. Long-running or human-in-the-loop agents need durable checkpoints and resumable runs (see Human-in-the-Loop).

  • Interoperability. MCP support is now table stakes; A2A support matters if your agents must work with other teams' agents (see Agent-to-Agent Protocol (A2A)).

  • Observability and evaluation. Prefer frameworks that emit OpenTelemetry GenAI spans or integrate with your tracing backend (see Observability for Agents).

  • Maturity and stability. A 0.x version number means breaking changes are expected; beta modules (LangChain4j’s agentic module) likewise. Budget for upgrades.

  • Lock-in. Keep business logic in plain functions and tools, and let the framework own only orchestration, so a later switch is a rewrite of the thin layer, not of everything.

One plain function, three frameworks' tool wrappers
# docsassistant/core.py -- business logic with no framework imports
from docsassistant.search import search_docs


def search_docs_core(query: str, k: int = 5) -> list[dict]:
    """Search this site's documentation; returns page paths, sections and snippets."""
    return search_docs(query, k=k)


# LangChain / LangGraph
from langchain_core.tools import StructuredTool

lc_tool = StructuredTool.from_function(search_docs_core, name="docs_search")

# OpenAI Agents SDK
from agents import function_tool

oa_tool = function_tool(search_docs_core, name_override="docs_search")

# Claude Agent SDK: in-process MCP server
from claude_agent_sdk import create_sdk_mcp_server, tool


@tool("docs_search", "Search this site's documentation.", {"query": str, "k": int})
async def claude_docs_search(args: dict) -> dict:
    hits = search_docs_core(args["query"], args.get("k", 5))
    return {"content": [{"type": "text", "text": str(hits)}]}


docs_server = create_sdk_mcp_server(name="docs", tools=[claude_docs_search])

The function is the asset; each wrapper is a few lines. StructuredTool.from_function and the OpenAI Agents SDK’s function_tool infer the schema from the signature and docstring; the Claude Agent SDK’s @tool takes an explicit input schema and exposes the tool through an in-process MCP server (create_sdk_mcp_server), which is then passed to ClaudeAgentOptions(mcp_servers=…​). See LangChain — Tools, OpenAI Agents SDK and Claude Agent SDK — Overview.

A framework’s overhead shows up directly in cost. For a run of model calls with input and output tokens at prices and per token,

so a framework that adds a planning call, a large default system prompt or verbose tool schemas to every step raises or every . Measure it with a trace of a representative task before committing (see Cost, Latency & Throughput).

References