AI Agent Frameworks 2026: What Actually Converged

Five agent frameworks reached production maturity in the first seven months of 2026 — LangGraph 1.0, Microsoft Agent Framework 1.0, Google ADK 2.0, Pydantic AI V2 and Amazon Bedrock AgentCore — and, independently, all five converged on the same architecture: a graph of steps with a mandatory human-approval pause built into the runtime. That convergence, not any single release, is the real news for anyone scoping an agent project this year.

Most coverage treats these releases as a five-way vendor comparison — pick whichever matches your cloud or language. That misses the pattern. When five competing teams (LangChain, Microsoft, Google, the Pydantic maintainers, AWS) independently converge on the same primitive within nine months, the primitive is telling you something about what production agents actually require. This piece covers what converged, what a live case study from this month reveals about the ceiling, and what a Dutch technical team should take from it.

Five frameworks, one release window

LangGraph 1.0 shipped first, in October 2025, and set the pattern the others followed: durable state that survives a server restart mid-workflow, first-class APIs for pausing a run for human review, and node-level caching so a long graph does not re-run finished work. Microsoft Agent Framework 1.0 reached general availability on 3 April 2026 by merging two frameworks Microsoft had shipped separately — Semantic Kernel and AutoGen — into one .NET and Python SDK, with both Model Context Protocol and Agent-to-Agent support native rather than bolted on; AutoGen and Semantic Kernel are now in maintenance mode only. Google ADK 2.0 followed in May and June, moving from a hierarchical agent executor to a graph-based Workflow Runtime where agents, tools and functions are all nodes in the same graph, with human-in-the-loop as a built-in primitive rather than a workaround. Pydantic AI V2 went stable on 23 June 2026 around a single new concept, capabilities — one composable unit bundling an agent's tools, hooks, instructions and model settings — with memory, guardrails and sandboxed execution shipped as an optional Harness layer on top. And the Amazon Bedrock AgentCore harness reached general availability on 17 June 2026 with a declarative model: you describe the model, tools and instructions, and AWS manages identity, memory, the tool gateway and observability underneath.

What actually converged

Strip away the branding and the five frameworks agree on three things. First, execution is a graph, not a chain or a single loop: steps can run in parallel, fan back in, retry independently and hold state at each node, which is the only structure that scales past a handful of sequential tool calls. Second, human review is a runtime primitive, not application code bolted on afterwards — LangGraph, Microsoft Agent Framework and Google ADK all now let a developer mark a node as "pause here for approval" and have the framework handle the interrupt, the resumable state and the audit trail. Third, tool access increasingly arrives over MCP rather than hand-written functions: Microsoft Agent Framework ships MCP support at 1.0, LangGraph's MCP integration matured through 2026 with streamable HTTP transport, and even Pydantic AI's Harness treats MCP servers as a standard capability source (our deep dive on MCP, RAG and A2A covers the protocol side). None of this was coordinated. It happened because the same failure mode kept showing up in production: agents that ran fine in a demo lost auditability the moment a human needed to intervene mid-task, and teams that hand-rolled their own approval step reinvented the same broken version of it independently. The frameworks did not invent human-in-the-loop; they promoted a pattern practitioners were already building badly into something the runtime handles correctly by default.

What 64 subagents proving a 50-year-old conjecture actually shows

On 10 July, OpenAI reported that GPT-5.6 Sol Ultra had produced a full proof of the Cycle Double Cover Conjecture, a graph-theory problem open since 1973, by deploying up to 64 concurrent subagents that pursued different algebraic and structural approaches in parallel before a coordinating process reconciled them into one proof — in under an hour. The proof has not passed peer review, and conjectures like this one have attracted flawed proofs before, so treat the mathematical claim as provisional. The engineering pattern is not provisional, and it is exactly the graph-plus-orchestration shape described above, pushed to an extreme: many independent workers exploring divergent branches, a supervising process managing them "aggressively and dynamically" rather than running them to a fixed schedule, and a reconciliation step that only a structured runtime — not a single long prompt — can hold together. For a business, the lesson is not "we need 64 subagents." It is that the same primitive — parallel branches, explicit state, a coordinator — that proved a math conjecture is what makes a five-step invoice-matching or contract-review agent reliable at 20 branches instead of one.

The gap the framework choice does not close

Framework maturity has not translated into production deployment at the rate the vendor announcements imply. Independent 2026 surveys put the picture at roughly 79% of enterprises reporting they have adopted AI agents in some form, against only 11–31% (depending on the survey and sector) that run any agent in production — banking and insurance lead, healthcare and government trail. Multiple analyses attribute the gap not to model quality but to governance: pilots stall on identity and access control, the inability to trace what an agent actually did, and insufficient monitoring once an agent touches real data. That is precisely the layer the 2026 framework generation targets — durable state, mandatory approval nodes, built-in observability — which means picking a framework with these primitives natively is now a governance decision, not just a technical one. It also means the opposite failure mode is real: adopting a mature framework and then skipping its human-in-the-loop and audit features to ship faster recreates the exact gap the framework was built to close. The tool solves the problem only if the team actually uses the parts that were added for that reason.

A decision framework for a Dutch technical team

Most comparison posts stop at a feature table. A more useful question for a Dutch SME technical lead, or an in-house dev team working with an implementation partner, is which of four situations you are in.

If your stack is already .NET or you run primarily on Azure, Microsoft Agent Framework is the path of least resistance — it inherits Semantic Kernel's enterprise identity and connector ecosystem, and Microsoft has explicitly put AutoGen and Semantic Kernel into maintenance mode to push migration there, so new projects on either predecessor should move rather than wait.

If your team is Python-first, already invested in LangChain, or needs the most mature human-in-the-loop and durable-execution primitives available today, LangGraph 1.0 is the safest default — it has the longest production track record of the five (GA since October 2025) and the deepest MCP integration.

If you are building on Google Cloud or need mobile or on-device agents (Gemini Nano support shipped with ADK 2.0), Google ADK's graph-based Workflow Runtime is purpose-built for mixing deterministic business logic with model-led steps in the same graph — useful when only part of a workflow should be autonomous.

If you want the least code and are comfortable running entirely inside AWS, Bedrock AgentCore's declarative harness trades control for speed: you describe the agent, AWS runs the infrastructure, and you inherit AWS's identity and observability stack by default rather than building it.

Pydantic AI V2 sits slightly apart — it is the leanest core of the five and suits teams that want to compose their own capabilities rather than adopt a full platform, at the cost of building more of the governance layer yourself.

None of these choices is permanent, and none is free of migration cost later. What is worth fixing now is the requirement, not the vendor: any framework you pick for a 2026 agent project should support durable state, a first-class human-approval step and MCP-based tool access out of the box. A framework missing any of the three is asking your team to rebuild, by hand, the exact primitive the rest of the industry just spent a year converging on.

Our take

Framework maturity is closer to solved than it was a year ago, and that is genuinely useful: less of an agent project's budget now needs to go into orchestration plumbing, and more can go into what actually differentiates a working system — domain logic, data connections, and an approval workflow your compliance team will sign off on. But framework maturity is not implementation maturity. A team can adopt LangGraph 1.0 or Microsoft Agent Framework and still ship an agent with no audit trail, because the human-in-the-loop node is optional, not automatic. If you are scoping an agent development project for the second half of 2026, the more useful question for a build partner is not which framework they use — most credible ones now support the same primitives — but to show you the approval step and audit log on their last production agent. Our AI implementation work starts from that governance layer, not the framework choice, and our note on running an AI pilot covers how to sequence the first one.

Frequently asked questions