Agent frameworks in 2026: how to choose

In December 2024, Anthropic advised developers to start by calling model APIs directly and to treat agent frameworks with care, because their abstractions hide the prompts and responses you need to debug (Anthropic, 2024). By October 2026 OpenAI, Anthropic, Google, AWS and Microsoft each ship an agent framework of their own, and most pair it with a managed service that runs agents for you. This post maps the options as of 27 October 2026: the three layers a framework can occupy, the AWS and Azure stacks, the independent frameworks, comparison tables, the trade-offs that matter and a way to choose. Every claim links to its source. I will update the page as the field moves; the date above says when I last checked it.

Why the choice matters

An agent framework decides four things: who owns the agent loop, where the agent’s state lives, which models and clouds you can move to later, and how much you rewrite when the vendor changes direction. The last point is not hypothetical.

Several widely used options have recently been closed, archived or replaced. Microsoft’s AutoGen repository now describes the project as archived, says Microsoft provides no bug or security fixes, and advises against production use (AutoGen README). Semantic Kernel’s README states that it “is now Microsoft Agent Framework” (Semantic Kernel README). Amazon Bedrock Agents, renamed Bedrock Agents Classic, no longer accepts new customers; AWS points them to AgentCore (AWS documentation). OpenAI set 26 August 2026 as the shutdown date of its Assistants API, with the Responses and Conversations APIs as replacements (OpenAI). Google’s ADK 2.0 shipped breaking changes to its agent API, event model and session schema; its sessions cannot be read by ADK versions older than 1.28 (PyPI, 2026).

At the same time, the frameworks have converged. Most now speak the Model Context Protocol (MCP) for tools, several speak Agent2Agent (A2A) for calls between agents, and the cloud runtimes accept agents built with competitors’ frameworks. My read: in 2026 the decision that matters most is less which library you import and more which layer of the stack you want to own.

A map of the field

Agent frameworks now sit in three layers. Products increasingly span more than one, which is why comparisons that line them up as equals tend to confuse.

• The loop, or harness. Code that calls the model, runs the tools it asks for, feeds back results, manages context and stops. Examples: Strands Agents, the OpenAI Agents SDK, the Claude Agent SDK, Pydantic AI, smolagents.
• Orchestration. Explicit control flow around one or more loops: graphs, events, branches, retries, human approval and checkpoints. Examples: LangGraph, the workflow engine in Microsoft Agent Framework, ADK 2.0’s Workflow Runtime, CrewAI Flows, Mastra workflows.
• Managed runtime. A hosted service that runs agent code or agent configuration with isolation, identity, memory, tool gateways and tracing. Examples: Amazon Bedrock AgentCore, Microsoft Foundry Agent Service, Claude Managed Agents, Google’s Gemini Enterprise Agent Platform, LangSmith Deployment.

Protocols connect the layers. MCP is now a founding project of the Linux Foundation’s Agentic AI Foundation, alongside Block’s goose and OpenAI’s AGENTS.md (Linux Foundation, 2025). A2A, originally developed by Google and now hosted by the Linux Foundation, reached its first stable specification, version 1.0, and counts more than 150 supporting organisations (Linux Foundation, 2026).

The harness turn

Vendors now ship finished agent loops alongside their toolkits, and they call them harnesses. Four of the following arrived or became stable between April and June 2026.

• Anthropic launched Claude Managed Agents in public beta on 8 April 2026: “an Anthropic-managed harness” with infrastructure for state, memory, permissions and scheduled runs (Anthropic, 2026).
• OpenAI added “a model-native harness” and native sandbox execution to its Agents SDK on 15 April 2026 (OpenAI, 2026).
• Microsoft listed an Agent Harness as a preview feature of Agent Framework 1.0 in April (Microsoft, 2026) and as stable at Build in June (Microsoft, 2026).
• AWS offers a managed AgentCore harness, in preview since April (AWS, 2026) and generally available since June 2026 (AWS, 2026), powered by Strands Agents (AWS documentation), and an open-source strands-harness package (Strands README).
• LangChain describes Deep Agents as “an agent harness” built on LangGraph (LangChain documentation), and Pydantic ships Pydantic AI Harness (Pydantic AI README).

The features overlap closely: planning or to-do lists, sub-agents, a file system, context compaction, skills, tool approval and tracing. My read: the agent loop has become a commodity. What still separates the products is where the loop runs, what it is allowed to touch, and how much of it you can change.

The AWS stack

Strands Agents

AWS released Strands Agents as an open-source SDK in May 2025. It takes what AWS calls a “model-driven approach”: the agent uses the model to direct its own steps and choose its tools, and a working agent takes a few lines of code. At launch, AWS named Amazon Q Developer, AWS Glue and VPC Reachability Analyzer as internal production users (AWS, 2025). Version 1.0 followed on 15 July 2025 with four multi-agent primitives (agents as tools, handoffs, swarms and graphs), A2A support and a session manager that restores agent state from a remote store (AWS, 2025).

Today the repository is called harness-sdk. It holds Python and TypeScript SDKs under Apache-2.0, and its README lists first-class support for Amazon Bedrock, Anthropic, OpenAI and Gemini models, with Bedrock as the TypeScript default. The same README adds a batteries-included harness, created with one create_harness() call (Strands README). The SDK is at 1.62.0 (PyPI); the harness package is at 0.3.2 (PyPI).

Amazon Bedrock AgentCore

AgentCore became generally available on 13 October 2025 (AWS, 2025). It is a set of modular services that can be used together or alone: Harness, Runtime, Memory, Gateway, Identity, Code Interpreter, Browser, Observability, Payments, Evaluations, Optimization, Policy and Registry. AWS states that the services work with any framework, naming CrewAI, LangGraph, LlamaIndex and Strands Agents, and with any foundation model (AWS documentation).

Runtime is the hosting layer. Each user session runs in a dedicated microVM with its own CPU, memory and file system, which is destroyed when the session ends. Sessions last up to 8 hours on microVMs or up to 14 days on EC2-backed Instances. Runtime speaks MCP and A2A, accepts 100 MB payloads, and bills for resources consumed, which AWS says typically removes CPU charges while the agent waits for a model response (AWS documentation). Gateway turns APIs and Lambda functions into MCP tools; Policy checks every tool call through Gateway against rules written in natural language or in Dogwood, a Cedar-compatible policy language (AWS documentation).

Harness or Runtime

AWS’s own comparison makes the split explicit. With Runtime, “the orchestration loop is yours”: you package your agent, in any framework or none, as a container and call the other AgentCore services from your code. With the harness, the loop is provided and the agent is configuration: model, system prompt, tools, memory and limits (AWS documentation). The harness can switch model providers mid-session, attach skills, mount S3 Files or EFS, and export itself to Strands code when configuration is not enough. It has no separate charge; you pay for the AgentCore services it uses (AWS documentation). It does not support a choice of framework, bidirectional streaming or graph-style workflows (AWS documentation).

My read: on AWS the real decision is harness or Runtime, not Strands or something else. Strands powers the harness, but Runtime is framework-neutral.

The Azure stack

Microsoft Agent Framework

Microsoft Agent Framework is the declared successor to both Semantic Kernel and AutoGen (Microsoft, 2026). It reached release candidate on 19 February 2026 and version 1.0 for .NET and Python on 3 April 2026, with “stable APIs, and a commitment to long-term support”. The 1.0 release made the graph-based workflow engine stable, with checkpointing so long-running processes survive interruptions. It ships connectors for Microsoft Foundry, Azure OpenAI, OpenAI, Anthropic Claude, Amazon Bedrock, Google Gemini and Ollama, and supports MCP and A2A (Microsoft, 2026). Workflows cover sequential, concurrent, handoff and group-collaboration patterns with streaming, human-in-the-loop and time travel; a Go SDK lives in a separate repository; the licence is MIT (Agent Framework README).

The Agent Harness composes existing building blocks rather than adding a second runtime. Function invocation, history persistence, to-do tracking, plan and execute modes, file memory, tool approval and OpenTelemetry are on by default. In Python, create_harness_agent is released, while background agents, file access and looping remain experimental, and Go has no packaged harness yet (Microsoft Learn). The Python package is at 1.23.0 (PyPI).

Microsoft Foundry Agent Service

Foundry Agent Service is the managed side. It offers three agent types. Prompt agents are configuration only: instructions, model and tools, run by Foundry. Voice-based prompt agents do the same for real-time speech. Hosted agents are your own code in a container or a .zip file, built with Agent Framework, LangGraph, the OpenAI Agents SDK, the Anthropic Agent SDK, the GitHub Copilot SDK or no framework. A fourth path skips the agent resource and calls the Responses API from code you run elsewhere (Microsoft Learn).

Each hosted-agent session gets its own VM-isolated sandbox. Files, disk state and session identity persist when the agent scales to zero, and idle agents cost nothing (Microsoft, 2026). Microsoft announced general availability of hosted agents on 9 July 2026. Its July and August update lists Toolboxes as generally available too: they give agents one MCP-compatible endpoint and keep tool credentials outside agent code (Microsoft, 2026). Every agent can have its own Microsoft Entra identity, published agents can be shared through Microsoft Copilot and Teams, and the service supports A2A, with version 1.0 generally available (Microsoft Learn).

AWS and Azure side by side

The two clouds have arrived at nearly the same shape.

Sources: AgentCore overview, AgentCore Runtime, Bedrock Agents, Foundry Agent Service overview, Foundry hosted agents, AutoGen README, Semantic Kernel README.

Both clouds host agents built with outside frameworks: AgentCore Runtime lists LangGraph, Google ADK and the OpenAI Agents SDK among supported frameworks (AWS documentation), and Foundry hosted agents name LangGraph, the OpenAI Agents SDK and the Anthropic Agent SDK (Microsoft Learn). Agent Framework also ships a connector for Amazon Bedrock models (Microsoft, 2026). My read: if your organisation has already chosen a cloud, its managed runtime is a sensible default, and the framework inside it can be chosen on its own merits.

Google, briefly

Google’s Agent Development Kit (ADK) 2.0 was published on 19 May 2026 (PyPI, 2026). It adds a graph-based Workflow Runtime with routing, fan-out and fan-in, loops, retries, human-in-the-loop and nested workflows, and a Task API for structured delegation between agents. ADK is optimised for Gemini but model-agnostic, and exists in Python, Java, Kotlin, Go and TypeScript (ADK README). The managed home is the Agent Runtime in Gemini Enterprise Agent Platform, which lists ADK, Agent2Agent, LangChain, LangGraph, AG2 and LlamaIndex as supported, alongside Sessions, Memory Bank and sandboxed code execution (Google Cloud documentation).

The independent frameworks

LangGraph

LangGraph calls itself “a low-level orchestration framework and runtime for building, managing, and deploying long-running, stateful agents”. You model the agent as a graph, and choose exactly where fixed logic ends and model-driven steps begin. Its core features are durable execution, streaming, human-in-the-loop and memory (LangChain documentation). Version 1.0 arrived on 22 October 2025 with a promise of “no breaking changes until 2.0”. LangChain 1.0’s create_agent runs on LangGraph, so a team can start with the high-level API and drop down later. Both libraries are documented for Python and JavaScript (LangChain, 2025). Deep Agents adds planning, sub-agents and a pluggable virtual file system on top (LangChain documentation). LangSmith Deployment, LangChain’s managed runtime for agent workloads, runs in LangChain’s cloud, as a hybrid with the data plane in your infrastructure, or self-hosted on Kubernetes (LangChain documentation). The Python package is at 1.2.18 (PyPI).

OpenAI Agents SDK

The OpenAI Agents SDK is a light framework built on agents, tools, handoffs, guardrails, sessions and tracing. It is provider-agnostic: besides OpenAI’s Responses and Chat Completions APIs, it supports more than 100 other models (OpenAI Agents SDK README). The April 2026 release added the harness, sandbox execution with built-in support for Blaxel, Cloudflare, Daytona, E2B, Modal, Runloop and Vercel, and snapshotting so a run can resume in a fresh container after the original fails. OpenAI argues for keeping harness and compute apart so that credentials stay out of the environment where model-written code runs. The new features shipped in Python first, with TypeScript to follow (OpenAI, 2026). The package is still pre-1.0, at 0.24.0 (PyPI). For durability beyond a single run, Temporal’s integration, in which each model call runs as a retried Temporal Activity, became generally available for Python on 23 March 2026 (Temporal).

Claude Agent SDK and Claude Managed Agents

Anthropic renamed the Claude Code SDK to the Claude Agent SDK on 29 September 2025. The harness behind Claude Code had begun to power almost all of Anthropic’s major agent loops, and the new name reflects that it can serve many kinds of agent beyond coding (Anthropic, 2025). The SDK runs the Claude Code binary as a library in Python or TypeScript, with built-in tools, hooks, sub-agents, MCP, permissions and sessions that can be resumed or forked. Anthropic’s Commercial Terms of Service govern its use, except for components that carry their own licence; the Python package’s licence file is MIT (Anthropic documentation, PyPI). The Python package is at 0.2.174 (PyPI). Claude Managed Agents is the hosted version: Anthropic runs the harness and the sandbox, or you run the sandbox yourself. It costs standard token rates plus $0.08 per session-hour of active runtime (Anthropic, 2026).

Pydantic AI

Pydantic AI is a typed agent loop for Python. Every model is “a string swap away”, outputs are validated against Pydantic types, and instrumentation uses plain OpenTelemetry. Pydantic AI Harness adds memory, guardrails, sub-agents, planning and context management as composable capabilities, and Pydantic Graph covers explicit control flow (Pydantic AI README). Its durable-execution support is unusually broad: eight engines, including Temporal, DBOS, Prefect, Restate and Apache Airflow (Pydantic documentation). The package is at 2.62.0 (PyPI).

CrewAI

CrewAI offers two models in one Python framework: Crews, teams of role-based agents that collaborate with some autonomy, and Flows, event-driven workflows for precise control. A commercial suite, CrewAI AMP, adds managed deployment, observability and governance (CrewAI README). The open-source package is at 1.15.30 (PyPI).

Mastra

Mastra is a TypeScript-first framework. It combines agents, a graph-based workflow engine with suspend and resume, memory, evals, observability and authoring of MCP servers, and plugs into React, Next.js or Node.js (Mastra README). The core package is at 1.79.0 and mostly Apache-2.0, with code in ee/ directories under a separate enterprise licence (npm).

smolagents and code actions

Hugging Face’s smolagents keeps its agent logic to about 1,000 lines and treats code agents as first-class: the model writes its actions as Python, run in a sandbox such as E2B, Modal or Docker (smolagents README). The approach rests on research such as CodeAct, which reported up to 20% higher success rates for code actions than for JSON or text actions in tests of 17 models (Wang et al., 2024). The latest release, 1.26.0, dates from May 2026 (PyPI).

Comparison tables

Frameworks

Versions are the latest Python release on PyPI on 27 October 2026 unless marked otherwise. A version below 1.0 means the vendor has not yet promised a stable API.

Managed runtimes

Methods and their trade-offs

Configuration or code

Configured agents remove the most work. AWS’s comparison lists 16 capabilities, from memory to model switching, that need no code in the harness and custom code in Runtime (AWS documentation). The cost is control: no framework choice, no graph workflows, and lifecycle hooks only in part. Foundry draws the same line between prompt agents and hosted agents (Microsoft Learn). AWS offers a way out: a harness can be exported to Strands code (AWS documentation). Check the exit path of any configured agent before you rely on it.

A loop or a graph

Anthropic’s distinction still holds. Workflows orchestrate models and tools “through predefined code paths”; agents “dynamically direct their own processes and tool usage” (Anthropic, 2024). Graph frameworks such as LangGraph, Agent Framework workflows and ADK’s Workflow Runtime suit processes you can draw in advance, where you want determinism, audit and approval steps. Loop-first SDKs such as Strands, the OpenAI Agents SDK and the Claude Agent SDK suit open-ended tasks where the model should decide the next step. Most mature options now offer both, so the question is which one your system is mostly made of.

One agent or several

Multi-agent systems can help and can hurt. Anthropic’s research system, a lead agent with parallel sub-agents, outperformed a single agent by 90.2% on its internal research evaluation. It also used about 15 times the tokens of a chat, and Anthropic notes that tasks with many dependencies between agents are a poor fit, as are most coding tasks, which offer less parallel work than research (Anthropic, 2025). Cognition argues that agents must share full context and traces, because “actions carry implicit decisions”, and recommends a single-threaded agent as the simplest way to follow that rule (Cognition, 2025). A study that built a taxonomy of multi-agent failures and applied it to more than 1,600 traces from seven frameworks identified 14 failure modes in three groups: system design, misalignment between agents and task verification (Cemri et al., 2025). A framework that makes multi-agent patterns easy does not make them reliable.

Durable execution

Long-running agents fail mid-task: a container dies, a model API times out, a human takes a day to approve a step. Frameworks handle this in three ways. Some persist state themselves: LangGraph resumes a restarted server where it stopped (LangChain, 2025), and Agent Framework workflows checkpoint so processes survive interruptions (Microsoft, 2026). Some snapshot the environment: the OpenAI Agents SDK restores agent state in a fresh sandbox from the last checkpoint (OpenAI, 2026). Others hand the job to a workflow engine: Pydantic AI supports eight (Pydantic documentation), and Temporal wraps the OpenAI Agents SDK (Temporal). My read: if your organisation already runs Temporal or a similar engine, use it, and pick a framework that integrates with it.

Tool calls as JSON or as code

Most frameworks have the model emit structured tool calls. Code agents let it write a short program instead, which can combine several tools in one step. CodeAct reported up to 20% higher success rates with code actions (Wang et al., 2024). The price is a sandbox you must trust. smolagents (smolagents README), the sandbox agents in the OpenAI Agents SDK (OpenAI, 2026) and the shell and code-interpreter tools in AgentCore and Foundry all move in this direction.

Observability

Tracing is now standard, and much of it uses OpenTelemetry: AgentCore Observability accepts OTEL-compatible telemetry (AWS documentation), Agent Framework has built-in OpenTelemetry (Agent Framework README), and Pydantic AI’s instrumentation is plain OpenTelemetry (Pydantic AI README). The shared vocabulary for agent spans, the OpenTelemetry GenAI semantic conventions, still carries the status “Development” (OpenTelemetry). Expect attribute names to change, and keep dashboards loosely coupled to them.

Interoperability and exit cost

Standards lower the cost of switching. Tools exposed over MCP can be reused across most frameworks in this post and through both clouds’ tool gateways. A2A lets an agent built with one framework call another, and is supported on AgentCore Runtime and in Foundry (Linux Foundation, 2026). What does not move easily is state: checkpoints, session stores and memory formats are framework-specific, as ADK 2.0’s session schema change showed (PyPI, 2026).

Open problems

Churn

The ground keeps moving. AutoGen’s README declares the project archived, Bedrock Agents Classic is closed to new customers, the Assistants API reached its shutdown date and ADK 2.0 changed its session schema (sources above). Speculation: more consolidation is likely, because two clouds and three model providers now ship overlapping stacks.

Pre-1.0 foundations

Three SDKs in this post are below 1.0: the OpenAI Agents SDK at 0.24.0, the Claude Agent SDK at 0.2.174 and the Strands harness at 0.3.2 (PyPI, PyPI, PyPI). Under semantic versioning, major version zero means “anything MAY change at any time” (Semantic Versioning 2.0.0). Pin versions and read changelogs.

No neutral comparison

My read: there is no widely used independent benchmark that runs the same tasks, with the same model, across these frameworks and reports success, cost and latency. I could not find one while researching this post. Vendor claims compare a product with its own previous release or with building from scratch. Until such a benchmark exists, the most reliable comparison is your own: a small set of real tasks, run on two candidates.

Multi-agent reliability

The failure taxonomy above places multi-agent failures in system design, coordination between agents and verification (Cemri et al., 2025), all areas that a framework shapes. My read: frameworks make the patterns easy to assemble, but testing whether agents misunderstood each other is still left to you.

Isolation and credentials

Agents that run code need sandboxes, and sandboxes need to be kept away from secrets. The managed runtimes now isolate each session in a microVM or VM (AWS documentation, Microsoft, 2026), and OpenAI recommends designing on the assumption of prompt injection and exfiltration attempts (OpenAI, 2026). Self-hosted setups must build the same separation themselves.

How to choose

Work through these questions in order. Each one narrows the field.

1. Do you need an agent? If the steps are known, a workflow or a few direct model calls is cheaper and easier to debug (Anthropic, 2024).
2. Where must it run? If your organisation is committed to AWS or Azure, start from AgentCore or Foundry Agent Service. Both host agents built with outside frameworks, so this choice does not fix the framework.
3. Configuration or code? If a model, a prompt and a set of tools describe the agent, try the AgentCore harness or a Foundry prompt agent first. Move to Runtime or hosted agents when you need custom control flow.
4. Loop or graph? For processes you can draw, with approvals and audit, use a graph framework: LangGraph, Agent Framework workflows or ADK 2.0. For open-ended tasks, use a loop-first SDK.
5. Which language? .NET points to Agent Framework. TypeScript points to Mastra, LangGraph’s JavaScript version, or the TypeScript SDKs from OpenAI, AWS and Google. Java, Kotlin and Go point to ADK, or to Agent Framework for Go.
6. How tied to one model provider are you? Provider SDKs track their own models closely; OpenAI argues that model-agnostic frameworks “do not fully utilize frontier models capabilities” (OpenAI, 2026). If you expect to switch providers, choose a model-agnostic framework.
7. How long do tasks run? For hours-long runs or human approval that may take days, check durability first: built-in checkpoints, sandbox snapshots or an external engine.
8. What will it cost to leave? Expose tools over MCP, keep business logic in plain functions outside the framework, and emit OpenTelemetry. Then the framework is replaceable.

The short version

My read: run your three most important tasks on two candidates before you commit. A week of comparison costs less than a migration.