Three weeks from now, Amazon will quietly stop letting new customers spin up Bedrock Agents — the framework tens of thousands of teams used to ship their first agentic prototypes back in 2024. Existing customers keep it, for now. Everyone else gets redirected to Bedrock AgentCore, a different architecture with a different mental model. AWS calls it a rename. It isn't. Renames don't come with new APIs, new state management, and a migration guide.
If you spent 2024 and 2025 building on Bedrock Agents Classic, you now have a decision to make before your team's next roadmap review: rebuild on AgentCore, or start shopping elsewhere. That decision is annoying. But it isn't the interesting part of this story.
The interesting part is that this is the third time in eighteen months a major vendor has done this to its own agent framework. Microsoft folded Semantic Kernel and AutoGen into a single Microsoft Agent Framework in April, telling two developer communities their production code was now legacy. Anthropic has revised the Claude Agent SDK's subagent model twice since release. LangGraph shipped a typed v2 streaming API that isn't a drop-in replacement for v1. Nearly every framework a practitioner reasonably chose in 2024 has since been deprecated, forked, or fundamentally rearchitected.
This isn't vendors being careless. It's what happens when an entire industry is still discovering what an "agent" architecturally is. Frameworks are opinions about orchestration, state, and tool-calling frozen into an API — and right now nobody, including the companies with the most engineers on the problem, has settled opinions. AWS didn't sunset Bedrock Agents because it was bad software. It sunset it because AgentCore reflects a year of hard lessons about session persistence, memory, and identity that the original design never anticipated.
Here's the part that should actually change how you build. The layer that has stayed stable through all this churn isn't any framework — it's the protocol layer underneath it. Model Context Protocol has been adopted, largely unmodified in its core contract, by Anthropic, Microsoft's new Agent Framework, LangGraph, and now AWS's own tooling. The Agent-to-Agent protocol locks its 1.0 spec on July 28 — the same week Bedrock Agents Classic closes to new signups — with every major vendor already implementing against the draft. Protocols are boring by design: they specify how a tool gets called and how one agent hands work to another, and they don't care whether the orchestrator sitting on top is AgentCore, LangGraph, or something that doesn't exist yet.
That gives you a genuinely useful architectural rule for anything you're building or rebuilding right now: put your real investment — your tool definitions, your data connectors, your business logic — behind an MCP server, not inside a framework's proprietary tool-calling syntax. Let the orchestration framework be the disposable, swappable layer, because empirically, it is. A tool you wrote as an MCP server survives a framework migration as a config change. A tool you wrote as a Bedrock Agents Classic action group is now a rewrite.
This also reframes the migration decision itself. Teams currently debating "AgentCore vs. staying put vs. switching to LangGraph" are asking the wrong question. The right question is whether your agent's capabilities are portable at all, independent of which orchestrator ends up hosting them twelve months from now. If they're not — if your tools, memory, and guardrails are all bespoke to Bedrock Agents Classic's SDK — the AgentCore migration is your forcing function to fix that, not just a lift-and-shift.
Concretely, that means auditing three things before you touch a line of migration code. First, where do your tool schemas live — in a framework-specific action group or config, or in something that speaks MCP and could be pointed at a different orchestrator tomorrow? Second, where does conversation and task state persist — in the framework's own session store, or in a database you control that any orchestrator could read from? Third, how are your guardrails and approval flows implemented — as framework middleware you'd have to reimplement from scratch, or as a policy layer that sits in front of any tool call regardless of who's making it? Teams that can answer "we own that, independent of the framework" to all three will treat this sunset as a config change. Teams that can't will spend Q3 relearning why they shouldn't have coupled so tightly to a single vendor's abstractions in the first place.
There's a benchmark worth sitting with here too. Gemini 2.5 Pro with Deep Think just posted 82.4% on GPQA Diamond using a two-million-token context window and parallel reasoning — a capability jump that will itself reshape what orchestration even needs to do, since a model that can hold that much context and reason over it natively needs less scaffolding, not more elaborate scaffolding. Some of the frameworks being deprecated today aren't just losing to better competitors. They're losing to model capability that made their original scaffolding unnecessary in the first place. That should worry anyone who's built a career's worth of expertise around a specific orchestration framework rather than around the underlying problem of getting reliable, auditable tool use out of a model.
Pick your orchestrator like you'd pick a text editor: use whichever one is most productive this quarter, and don't be precious about it. Pick your protocols like you'd pick a database: expect to live with the consequences for years. AWS just proved, again, which of those two choices actually needed the plan.
