AI news
AI model reviews
AI tools
How-to guides
Our staffAboutContact

AI agent frameworks updates 2026: what changed and what to do about it

Microsoft Agent Framework hit 1.0, Google ADK hit 2.0 and OpenAI added sandboxes. Here's what changed in agent frameworks this year and what breaks.

Developer working at three monitors full of code
Photo: Abu Saeid on Unsplash

The big AI agent frameworks updates 2026 brought come down to one shift: the main frameworks finally went stable, and the fight moved from "which library chains my prompts" to "who supplies the runtime the agent lives in". Microsoft Agent Framework hit 1.0, Google's ADK hit 2.0, and OpenAI rebuilt its Agents SDK around sandboxes. If you build agents, this year's releases are worth upgrading to, but a few of them break old code in ways you won't spot straight away.

Underneath the frameworks, the plumbing got more boring in a good way. The protocols they share now sit with a neutral foundation, which I think matters more for most teams than any single release.

AI agent frameworks updates 2026: the releases at a glance

Here's the year in one table. It covers headline releases only (each project also shipped dozens of point releases).

FrameworkHeadline updateWhenWatch out for
Microsoft Agent Framework1.0 for .NET and Python, then a supported runtimeApril 3 (1.0)AutoGen and Semantic Kernel move to maintenance
Google ADK2.0 with a graph-based workflow runtimeMay 19 (Python), June 30 (Go), August 21 (TypeScript)Old execution overrides are silently ignored
OpenAI Agents SDKBuilt-in agent runtime and native sandbox executionApril 15Durable execution still needs outside help
LangChain and LangGraphLangChain 1.4 and 1.5, plus Deep AgentsThrough the yearPython 3.10 dropped; streaming format changed
Claude Agent SDK and Managed AgentsDynamic workflows and self-hosted Managed AgentsSelf-hosting from November 12Self-hosting is by request only
CrewAIStudio, MCP export and enterprise deployment optionsOngoingFree plan caps you at 50 executions a month

The background: from prompt chains to agent runtimes

An agent framework is the code that sits between a language model and the real world. The model decides what to do next; the framework calls the tools, keeps the conversation history, retries when something fails and decides when the job's done. If you're new to the idea, our guide to agentic AI covers the basics.

Early frameworks were mostly about chaining prompts together. That's changed.

The word everyone uses now is "harness". It means the runtime wrapped around the model: file access, a shell, memory, context compaction, approvals for risky actions and tracing. One analogy helps. A strong model without that runtime is a skilled chef in an empty room, and a badly laid-out kitchen ruins good cooking.

An April 2026 paper from MBZUAI's VILA-Lab, "Dive into Claude Code", put a rough number on it: the researchers estimated that about 98.4% of Claude Code's codebase was runtime infrastructure and only about 1.6% was AI decision logic. I'd treat that figure as one team's classification rather than a law, but it explains why vendors spent this year shipping runtimes instead of new chain syntax.

Real examples from this year's releases

Microsoft Agent Framework 1.0

Microsoft merged AutoGen and Semantic Kernel into one SDK, announced it last October, locked features at a release candidate in February and shipped Agent Framework 1.0 for .NET and Python on April 3. It comes with connectors for Microsoft Foundry, Azure OpenAI, OpenAI, Anthropic Claude, Amazon Bedrock, Google Gemini and Ollama, which is a wider list than I expected from Microsoft. By August, its Agent Harness and Foundry Hosted Agents had reached general availability too.

That Agent Harness switches on planning, history persistence, compaction, tool approval and OpenTelemetry by default, while shell access and background sub-agents stay opt-in and print a warning when you turn them on. If you're still on AutoGen, the message is clear: new features go to Agent Framework, and the old projects get fixes and security patches only.

Google ADK 2.0

Google's ADK 2.0 swaps the old hierarchical agent executor for a graph-based Workflow Runtime. Python went GA on May 19, Go on June 30 and TypeScript on August 21. Agents are now nodes in a graph (the BaseAgent class subclasses a new BaseNode), and that's where the trap is. If you overrode methods like _run_async_impl() to inject telemetry or state handling in 1.x, the new engine bypasses those overrides and your calls are silently ignored. No error. Custom session stores with rigid database columns also need schema changes for two new event fields, node_info and output.

OpenAI Agents SDK

On April 15, OpenAI shipped what it called the next evolution of the Agents SDK (version 0.14.0 of the Python package and later). The update adds a model-native runtime with configurable memory, Codex-like filesystem tools and native sandbox execution, so an agent can read files, install dependencies and run code inside a controlled workspace. It also standardises on shared building blocks: MCP for tools, skills, AGENTS.md for instructions, a shell tool and an apply-patch tool for edits.

Oscar Health's Rachael Burns said "The updated Agents SDK made it production-viable for us to automate a critical clinical records workflow that previous approaches couldn't handle reliably enough." That's a vendor-picked quote, of course, so I'd read it as a promising sign rather than proof.

LangChain, LangGraph and Deep Agents

LangChain's year was a steady run of 1.x releases. Version 1.4.0 added FastMCP support through a langchain.mcp namespace. Going through the changelog, 1.5 adds a Decisions API and two beta middlewares: ModelRouterMiddleware picks a model per run, and AutoModeMiddleware blocks tool calls it judges risky. It also drops Python 3.10, and langchain-core 1.7.0 changed how tool-call arguments stream, so you have to upgrade clients before the server or front ends can stop updating. On the hosted side, LangChain used its Interrupt events in New York and London to launch Managed Deep Agents v0.9, built on Deep Agents, its open-source runtime for long-running work.

Claude Agent SDK and Managed Agents

Anthropic's Agent SDK gives you the same tools, agent loop and context management that run Claude Code, in Python and TypeScript. The newer story is Managed Agents, Anthropic's hosted runtime. Its release notes list dynamic workflows in beta, where an agent writes a program that runs many sub-agents in phases (handy for reviewing hundreds of documents), plus OpenTelemetry export. On November 12, Anthropic launched self-hosted Managed Agents, so you can run the whole service and keep session history on your own infrastructure; access goes through your account team.

CrewAI

CrewAI still sells the role-based "crew" model, but its pitch has moved towards governance. On its plans page, the free Basic tier includes a visual editor and 50 workflow executions a month, while Enterprise adds SSO, role-based access control, PII redaction and deployment in your own VPC. You can also export a workflow as an MCP server.

CrewAI claims it's used by 65% of the Fortune 500; I couldn't find an independent check of that number.

The protocols underneath: MCP, A2A and the AAIF

The quieter change may outlast all of the above. In December 2025 the Linux Foundation formed the Agentic AI Foundation (AAIF), seeded with Anthropic's Model Context Protocol, Block's goose and OpenAI's AGENTS.md. At launch there were already more than 10,000 published MCP servers. On October 22 the foundation added four more projects: Agent Skills from Anthropic, Open Responses from OpenAI, OpenEnv from Hugging Face and OpenSandbox from Alibaba. That brings it to 10, including the Agent2Agent (A2A) protocol.

A2A deals with agents talking to other agents, where MCP connects an agent to tools and data. Its 1.0 spec added Signed Agent Cards for cryptographic identity, and by April the project counted more than 150 supporting organizations, with support in Azure AI Foundry, Copilot Studio and Amazon Bedrock AgentCore Runtime. Why should you care? Because a tool you wrap as an MCP server today should work with whichever framework you pick next year.

Benefits and limitations

The upside is real. Stable version numbers mean fewer surprise rewrites, and the shared standards mean your tools are portable. Sandboxes and approval gates are now built in rather than bolted on, which is good news for anyone letting an agent touch a filesystem.

The downsides are just as concrete, though. Several of this year's upgrades break things quietly: ADK's ignored overrides, LangChain's streaming change and the Python 3.10 cutoff. Built-in runtimes also hide a lot. When an agent loops or picks the wrong tool, you'll want tracing, which is why AI agent observability tools became their own category. And the frameworks still lean towards their makers' clouds; ADK is happiest on Google Cloud, Agent Framework on Foundry. Honestly, "model-agnostic" on a vendor's own SDK usually means "works best with ours".

Practical takeaways for builders

  • If you're on AutoGen or Semantic Kernel, plan a move to Microsoft Agent Framework while the old projects still get patches.
  • Before upgrading ADK, search your code for overridden execution methods; they won't run under 2.0.
  • Pin langchain-core below 1.7.0 until every client that reads the stream is upgraded.
  • Build new tool integrations as MCP servers so they're not tied to one framework.
  • Pick a framework that matches where you deploy, not the one with the most GitHub stars.

If you're starting from scratch, our guide on how to build AI agents walks through the first steps, and the piece on how to code AI covers the basics underneath. For small scripts, I'd probably skip a framework entirely and call the model API directly; plenty of useful agents are a loop and three tools.

The next 12 months

I'd guess the next year is about runtimes more than libraries. Microsoft, Anthropic and LangChain all now sell a managed place to run agents, and Anthropic's self-hosted option suggests big customers want that runtime inside their own walls. The AAIF's newer projects point the same way: OpenSandbox is about where agents run safely, and OpenEnv is about training them in shared environments.

What I don't know is whether the frameworks will converge or split. Open Responses could make switching model providers cheap, which would weaken vendor lock-in. Or each lab's runtime could drift towards its own models.

My bet is a bit of both, with MCP and A2A as the parts that stay put.

FAQ

Which AI agent framework should I use?

It depends mostly on where you deploy. Microsoft shops will likely be happiest with Agent Framework 1.0, Google Cloud teams with ADK 2.0, and teams on OpenAI models with the Agents SDK. LangGraph suits complex stateful workflows across providers. For TypeScript-heavy teams, check that the framework's TypeScript version is current before committing.

Is AutoGen still supported?

Yes, but only for maintenance. Microsoft folded AutoGen and Semantic Kernel into Microsoft Agent Framework, which reached 1.0 on April 3, and new features now go there. The older projects keep getting bug fixes and security patches for a limited window, which buys you time to migrate without forcing a rewrite this quarter. If you're starting something new, though, I wouldn't pick AutoGen now; you'd be building on a project whose own maintainers have moved on, and the migration guides only get you so far.

What's the difference between MCP and A2A?

MCP (Model Context Protocol) connects an agent to tools and data, such as a database or GitHub. A2A (Agent2Agent) lets separate agents find each other, delegate tasks and coordinate, even if they're built on different frameworks. Both now sit under the Linux Foundation's Agentic AI Foundation, and most major frameworks support at least MCP.

What is an agent runtime, or "harness"?

It's the code around the model that turns text into action: calling tools, storing history, compacting context and asking before risky steps. That's where most of an agent's engineering effort goes.

Do I need a framework to build an AI agent?

Not always. A basic agent can be a loop that calls a model API and runs a few tools, and that's often easier to debug. Frameworks earn their keep when you need memory, sandboxes, approvals, multi-agent coordination or tracing. If you're comparing options, our guide to evaluating AI agent discovery tools has a useful checklist, and vibe coding explains the lighter-weight route many people start with.

Keep reading