Anthropic Now Controls 40% of Enterprise LLM Spend. Here's How It Beat OpenAI on the Metric That Actually Matters.
On July 30, 2026, Amazon closed Bedrock Agents to new customers and put it in maintenance mode. The replacement, AgentCore, is a complete re-architecture — not a rename. Enterprise teams that built production agent workflows on Bedrock Agents now face a 4-8 week migration. Here's what the decision tells you about building on managed cloud AI platforms.
On November 28, 2023, Amazon announced the general availability of Amazon Bedrock Agents — a managed platform for building AI agents with tool calling, knowledge base retrieval, and task orchestration on AWS infrastructure. It was one of the first production-ready managed agent platforms from a major cloud provider, and it attracted significant enterprise adoption in the window when enterprise AI teams were moving from proof-of-concept to production agent deployments.
On July 30, 2026, AWS closed Bedrock Agents to new customers. The product — now renamed Amazon Bedrock Agents Classic — is in maintenance mode. Existing customers keep access. No new organizations can onboard. The model catalog is frozen. The replacement product, Amazon Bedrock AgentCore, is a fundamentally different architecture that requires a 4-8 week migration for production deployments.
Two years and eight months from GA to maintenance mode. That is the shelf life of the first generation of managed enterprise AI agent platforms.
Forbes noted in July 2026 that AWS had effectively killed AI services it launched just two years prior — and the Bedrock Agents retirement is the most prominent example. For enterprise teams that built production workflows on Bedrock Agents, the retirement is a forced migration decision. For enterprise teams choosing cloud AI infrastructure in 2026, it is a case study in the managed platform lifecycle risk that every vendor selection decision should account for.
A Timeline of What Happened
Understanding the sequence of events provides useful context for the migration decision enterprise teams now face.
| Date | Event |
|---|---|
| November 28, 2023 | Amazon Bedrock Agents reaches general availability |
| October 13, 2025 | Amazon Bedrock AgentCore reaches general availability |
| March 3, 2026 | AgentCore Policy reaches GA |
| March 31, 2026 | AgentCore Evaluations reaches GA |
| June 30, 2026 | Bedrock Agents renamed to Bedrock Agents Classic, enters maintenance mode |
| July 30, 2026 | Bedrock Agents Classic closed to new customers; model catalog frozen |
The timeline reveals an overlap period: AgentCore launched in October 2025 and Bedrock Agents Classic wasn't retired until July 2026 — giving enterprise teams approximately nine months to evaluate and begin migrating. That overlap was intentional. AWS designed it to give existing customers runway for evaluation. But for teams that built significant production workloads on Bedrock Agents Classic in 2024 or early 2025, nine months is tight for a production migration when the engineering resources were already committed to building on top of the existing platform.
The migration is not optional indefinitely. Bedrock Agents Classic's model catalog is frozen as of July 30. Teams running on the classic platform will not receive new model releases — which means the performance ceiling of their production agent deployments is locked to the model capabilities that existed at the end of July 2026, while the AgentCore-based deployments of competitors will continue to improve as AWS releases newer models.
What Was Bedrock Agents Classic? The Original Architecture's Limits
Bedrock Agents Classic was a single-agent orchestration framework. The core abstractions were:
- An agent definition: a system prompt, a set of tool definitions, and a knowledge base connection
- Tool calling: the agent could call a defined list of external APIs or Lambda functions, with structured input/output schemas
- Knowledge base retrieval: the agent could query a Bedrock Knowledge Base using vector search over enterprise documents
- Session context: conversation history within a single session, managed by the platform
This architecture was well-matched to the enterprise AI use cases that dominated 2023 and early 2024: customer service chatbots with FAQ retrieval, internal Q&A tools over enterprise knowledge bases, simple task automation that triggered a defined sequence of API calls based on user intent.
By 2025 and 2026, enterprise AI use cases had outgrown this architecture. Teams were building:
- Multi-agent workflows where one orchestrator agent delegated subtasks to specialized sub-agents running in parallel
- Long-running background processes that operated over hours or days rather than single sessions
- Persistent memory across sessions — where an agent needed to remember context from a user's previous interactions weeks earlier
- Complex tool routing that needed to handle authentication, rate limiting, retry logic, and protocol translation across dozens of external APIs
- Real-time policy enforcement — access controls and content policies checked at the tool call layer before external APIs were reached
Bedrock Agents Classic could not support these patterns natively. Enterprise teams building them were writing significant custom code around the platform rather than on top of it — a signal that the managed platform abstraction was no longer capturing the use case complexity.
What AgentCore Is: A Different Architecture for a Different Agent Pattern
Amazon Bedrock AgentCore is not Bedrock Agents with more features. It is a rebuilt infrastructure layer designed for multi-agent systems with shared state, persistent memory, and unified tool routing.
AWS introduced AgentCore in October 2025 with three core capabilities that address the architectural gaps in Bedrock Agents Classic:
AgentCore Memory provides centralized, persistent state management across agent sessions and across agents in a multi-agent system. When an agent completes a task, it can write important facts, user preferences, and workflow outcomes back to AgentCore Memory. In a subsequent session — hours, days, or weeks later — any agent in the fleet can retrieve that stored context without rebuilding it from scratch. This solves the session isolation problem that made Bedrock Agents Classic unsuitable for use cases requiring continuity across interactions.
An agent managing enterprise IT support tickets, for example, can remember that a specific user has a known network configuration issue, has tried specific troubleshooting steps, and prefers email notifications over Slack. With Bedrock Agents Classic, that context had to be rebuilt from ticket history in every session. With AgentCore Memory, it persists and is retrievable in milliseconds.
AgentCore Gateway is the unified routing, authentication, and protocol translation layer for agent tool calls. When an agent needs to call an external API — a CRM, an ERP system, a third-party data provider — AgentCore Gateway handles the authentication, enforces access control policies, translates protocols between REST, GraphQL, or gRPC, and executes at thousands of requests per second with millisecond policy checks. This replaces the custom middleware that most enterprise teams building on Bedrock Agents Classic had to build themselves to handle tool call routing at production scale.
Enterprise infrastructure controls in AgentCore — VPC support, AWS PrivateLink, CloudFormation integration, resource tagging — are native rather than retrofitted. Bedrock Agents Classic required significant custom configuration to meet enterprise security requirements. AgentCore ships with these controls enabled by default, which reduces the compliance setup time and reduces the risk of misconfiguration that creates security exposure.
Why AWS Rebuilt Rather Than Extended
The question enterprise teams ask when evaluating a platform migration is always whether the new platform is an evolution of the old one or a replacement of it. In the case of AgentCore, the answer is unambiguous: replacement.
The session-based, single-agent model in Bedrock Agents Classic and the persistent-memory, multi-agent model in AgentCore are not compatible abstractions. You cannot extend Bedrock Agents Classic to be AgentCore by adding features; the statefulness model is different enough that the execution model, the API contracts, and the agent definition language are all different. This is why the migration is a rewrite rather than a configuration change.
AWS made the architectural break clean rather than attempting a compatibility layer for two reasons. First, a compatibility shim that preserved Bedrock Agents Classic's abstractions while running on AgentCore's infrastructure would have created a performance and architectural ceiling that would have limited AgentCore's design space. The memory model and gateway routing in AgentCore are optimized for the AgentCore execution model; forcing them to emulate Bedrock Agents Classic's stateless model would have defeated the architectural purpose. Second, a clean break forces migration — and migration is how AWS ensures that enterprise customers are running on the infrastructure that AWS is actively investing in, maintaining, and extending. A long-lived compatibility shim creates a large base of customers on a path AWS has no incentive to improve, which generates support debt and capability divergence over time.
The clean architectural break is the correct engineering decision for AWS. It is also a significant migration burden for enterprise customers who built production workloads on the previous architecture. Both things are true simultaneously.
The Infrastructure Risk Lesson: Every Managed AI Platform Has a Retirement Timeline
The Bedrock Agents retirement is the first major case study in managed cloud AI platform obsolescence, but it will not be the last. The pace at which AI agent patterns have evolved since 2023 — from simple tool calling to multi-agent orchestration, from stateless to persistent memory, from single-model to multi-model routing — is faster than any previous category of enterprise software.
Managed cloud AI platforms are built against the agent pattern state of the art at launch. When the state of the art advances — which in AI is happening on 12-18 month cycles — managed platforms face a choice between incremental extension and architectural replacement. Bedrock Agents Classic's retirement demonstrates that AWS chose replacement when extension proved insufficient.
Enterprise teams should assume this pattern will repeat. Platforms launched in 2024 that are showing architectural limitations relative to 2026 agent patterns are on the same lifecycle trajectory that brought Bedrock Agents Classic to maintenance mode. The SpaceXAI Grok 4.6 enterprise agent architecture, with its 500K context window and multi-level reasoning, illustrates the capability target that 2024-era managed platforms were not built to support — which means 2024 platforms will face the same architectural pressure that retired Bedrock Agents Classic.
For enterprise teams evaluating any managed cloud AI platform investment in 2026, the relevant planning horizon is not "what use cases does this platform support today?" but "what use cases will we need in 24 months, and is this platform's architecture capable of supporting them without a forced migration?"
Evaluating Cloud AI Infrastructure: A Framework for Reducing Platform Retirement Risk
Enterprise teams have five levers for reducing the migration risk that platform retirements create.
1. Separate agent logic from infrastructure logic. The most migration-resistant architecture keeps agent task definitions — what the agent does, how it reasons, what goals it pursues — cleanly separated from infrastructure definitions — how it accesses tools, how it stores state, how it routes between models. When infrastructure changes (as it did from Bedrock Agents to AgentCore), cleanly separated logic means re-plumbing the infrastructure layer without rewriting the agent behavior. Teams that tightly coupled task logic to Bedrock Agents Classic's specific API contracts are facing the most difficult migrations.
2. Build against open-source abstractions where production stability allows. Agent orchestration frameworks like LangChain, LlamaIndex, and AutoGen are open-source and evolve on community timelines rather than vendor roadmap timelines. Teams that built on these frameworks with Bedrock as the backend compute layer can swap compute backends without rewriting orchestration logic. The tradeoff is operational overhead: managed platforms like AgentCore reduce infrastructure management burden that self-managed open-source deployments require. But the tradeoff is real, and the Bedrock Agents retirement illustrates the cost of the alternative.
3. Evaluate platform investment signals before committing production workloads. AgentCore launched in October 2025; Bedrock Agents Classic entered maintenance mode in June 2026. The nine-month overlap was the signal that AWS was moving its infrastructure investment to AgentCore. Enterprise teams that read the launch announcement and recognized it as an architectural successor could have begun planning their migration rather than being forced into it. For each managed AI platform decision, evaluate what the vendor has launched recently: platforms receiving recent major architectural investment are more likely to receive continued investment; platforms that have not had architectural changes in 12 months are on the retirement trajectory.
4. Negotiate migration support into enterprise agreements. Enterprise agreements with managed cloud AI platform vendors should include migration support commitments: if the vendor retires a platform, what migration tooling will they provide? What documentation? What engineering support hours? The Bedrock Agents retirement comes without migration tooling that automates the code translation — teams are rewriting manually. Future enterprise agreements with AWS, Google Cloud, and Azure should specify the vendor's commitments when platforms are retired or architecturally changed.
5. Maintain parallel infrastructure for critical workloads. High-value production agent workloads should run against at least two infrastructure options: the managed platform that provides operational simplicity and the self-managed option that provides architectural control. Running a parallel self-managed environment creates the migration path when the managed platform is retired — not as a replacement in normal operation, but as a validated alternative that has been tested against the production workload.
The Competitive Dynamics: What AgentCore Changes for Enterprise AI Infrastructure
Beyond the migration mechanics, the Bedrock Agents→AgentCore transition shifts the competitive positioning of AWS's enterprise AI infrastructure offering.
IBM's partnership with OpenAI for enterprise consulting illustrates how enterprise AI infrastructure distribution works in practice: system integrators control the last mile of enterprise AI deployment, and platform capability directly determines which system integrators can productively build on a given cloud AI platform. AgentCore's multi-agent memory and gateway capabilities make it possible for enterprise consulting teams to build more sophisticated agent workflows on AWS than Bedrock Agents Classic supported — which expands the addressable market for AWS-based enterprise AI projects at system integrators.
The practical effect for enterprise buyers: the managed agent infrastructure that AWS offers through AgentCore in 2026 is materially more capable than what Bedrock Agents Classic offered in 2024 — but it requires migration to access. Enterprise teams that have been frustrated with Bedrock Agents Classic's architectural limits have reason to evaluate AgentCore; teams that built production workflows optimized for Bedrock Agents Classic's constraints need to evaluate whether the migration cost is justified by the capability gain.
For most production deployments that hit the architectural limits of Bedrock Agents Classic — especially those with persistent user context requirements, multi-agent orchestration needs, or complex tool routing at scale — AgentCore's capabilities justify the migration investment. For simple, stateless agent deployments that fit within Bedrock Agents Classic's original design parameters, the migration cost may exceed the benefit over the remaining lifetime of the deployment.
Takeaway: AWS retiring Bedrock Agents after two and a half years of production availability is the first major managed cloud AI platform obsolescence event — and it will not be the last. The lesson for enterprise teams is not to avoid managed cloud AI platforms; it is to build against them with architectural discipline that reduces migration cost when platforms are replaced. Separate agent logic from infrastructure logic. Build against open-source abstractions where the operational overhead is acceptable. Read vendor platform investment signals before they become forced migrations. Negotiate migration support into enterprise agreements. The Bedrock Agents→AgentCore transition is the infrastructure risk scenario that every enterprise cloud AI roadmap needs to account for, because the AI platform evolution cycle is running at 18-24 months — faster than most enterprise technology refresh cycles were designed to handle.
Frequently Asked Questions
What happened to Amazon Bedrock Agents and why did AWS retire it?
Amazon Bedrock Agents, launched in November 2023, was renamed Amazon Bedrock Agents Classic on June 30, 2026, and closed to new customers on July 30, 2026. The product is now in maintenance mode — existing customers keep full access with no announced end-of-life date, but no new accounts can onboard, and the model catalog is frozen as of July 30 with new models available only through the replacement product, AgentCore. AWS retired Bedrock Agents because the original product's architecture — a single-agent framework with basic tool calling — proved insufficient for the multi-agent, long-running workflow use cases that enterprise AI teams are building in 2026. The original Bedrock Agents product was designed for relatively simple agent patterns: one agent, a defined set of tools, short-horizon task completion. Enterprise deployments pushed well beyond those constraints, requiring multiple agents collaborating on shared state, persistent memory across sessions, and complex tool routing across external APIs and internal systems. Rather than attempting to extend Bedrock Agents' architecture to support these patterns, AWS rebuilt from the ground up and called the result AgentCore.
What is Amazon Bedrock AgentCore and how is it different from Bedrock Agents Classic?
Amazon Bedrock AgentCore, which reached general availability in October 2025, is a managed infrastructure layer for building, deploying, and operating AI agents at enterprise scale. Unlike Bedrock Agents Classic (a single-agent framework with static tool definitions), AgentCore is designed for multi-agent systems where agents share memory, delegate tasks to other agents, and route through a unified gateway. Three capabilities define AgentCore that Bedrock Agents Classic did not have. First, AgentCore Memory: a centralized, persistent memory layer where agent state and learned facts are stored across sessions — so an agent can remember a user's previous interactions, troubleshooting history, or accumulated context from prior workflow executions without rebuilding context in every session. Second, AgentCore Gateway: a unified routing layer that handles authentication, protocol translation, and authorization policy enforcement when agents call external APIs or internal tools — handling thousands of requests per second with millisecond-level policy checks. Third, built-in enterprise controls: VPC support, AWS PrivateLink, CloudFormation integration, and resource tagging — the infrastructure governance features that Bedrock Agents Classic was retrofitting at deployment time are native in AgentCore from day one.
How long does it take to migrate from Bedrock Agents Classic to AgentCore?
The migration from Bedrock Agents Classic to AgentCore requires rewriting agent logic rather than reconfiguring it — because the underlying architecture is different enough that the old agent definitions don't translate to AgentCore constructs. Enterprise teams running production Bedrock Agents workloads should plan for 4 to 8 weeks of migration effort, depending on deployment complexity. The critical rewrite targets are: tool routing (which in Bedrock Agents Classic was defined as a static list of tool definitions now needs to be wired through AgentCore Gateway with explicit authentication and authorization configuration), memory management (context that Bedrock Agents Classic managed within the agent's prompt window now needs to be stored in and retrieved from AgentCore Memory), and multi-agent orchestration (any workflow that chained multiple Bedrock Agents calls needs to be re-architected as a multi-agent system within AgentCore's agent fleet model). Teams running simple Bedrock Agents deployments — single-agent, stateless, limited tool set — can likely complete migration in 2 to 3 weeks. Teams with complex production deployments involving persistent state, multi-agent coordination, or extensive tool integrations should budget 6 to 8 weeks minimum.
What are the enterprise risks of building production workloads on managed cloud AI platforms?
The Bedrock Agents retirement illustrates four risk categories that apply to any managed cloud AI platform. First, architectural obsolescence risk: cloud AI platforms are built against the state of AI agent patterns at launch. When agent patterns evolve — as they have from single-agent to multi-agent in 18 months — the platform that was optimal at launch may require rebuilding rather than extending. Managed platforms abstract away infrastructure complexity but also abstract away the ability to make incremental architectural improvements; you get the upgrade when the provider ships it, not when your use case needs it. Second, migration cost risk: retiring a managed platform and replacing it with a fundamentally different architecture generates real engineering cost. The Bedrock Agents to AgentCore migration is 4 to 8 weeks of engineering effort for production deployments. That is not a small cost for teams that built on Bedrock Agents expecting platform continuity. Third, feature freeze risk: Bedrock Agents Classic's model catalog is frozen as of July 30, 2026. Teams running production workloads on the classic platform cannot access newer model releases without migrating. Over time, capability gaps between the frozen platform and the current platform widen in ways that can affect the performance of production workloads. Fourth, governance risk: when a managed platform enters maintenance mode, the vendor's investment in security patches, compliance updates, and incident response for that platform typically declines. Enterprise teams with compliance requirements should assess whether a maintenance-mode platform maintains the security posture their compliance framework requires.
Which other cloud AI platform decisions carry similar retirement risk in 2026?
The Bedrock Agents retirement is not an isolated event. Several other managed cloud AI platforms launched in 2023 and 2024 are at similar architectural transition points as agent patterns have evolved. AWS's Bedrock Knowledge Bases (launched alongside Bedrock Agents) has been significantly restructured for AgentCore compatibility. Microsoft's Copilot Studio (launched in late 2023) has undergone two major architecture changes. Google's Vertex AI Conversation (also launched in 2023) was migrated to Vertex AI Agent Builder with a different data model. The pattern is consistent: AI platform products launched in 2023 were designed for the agent patterns that existed then — retrieval-augmented generation, simple function calling, chatbot-style interaction. The enterprise AI workloads that organizations are building in 2026 — long-running agentic workflows, multi-agent orchestration, stateful reasoning across sessions — require architectural capabilities that 2023 platforms were not designed to provide. Teams evaluating any managed cloud AI platform in 2026 should assess the platform's architecture against the full 3-year workflow requirements they expect to have, not just current requirements. Platform obsolescence in AI is running on an 18-24 month cycle, which is faster than most enterprise technology refresh cycles.
How should enterprise teams evaluate cloud AI infrastructure decisions to reduce platform retirement risk?
Enterprise teams building on managed cloud AI platforms should apply five evaluation criteria that reduce platform retirement risk. First, evaluate the platform's abstraction layer: how much custom code is being written against platform-specific APIs and constructs versus standard interfaces that could be re-implemented against a different backend? The more platform-specific the integration, the higher the migration cost when the platform changes. Second, understand the vendor's architectural investment signals: AWS's AgentCore launch signals the architectural direction AWS is investing in for the next 2-3 years. Teams choosing cloud AI platforms should evaluate which products have recent major architectural investment and which products look like they are in a holding pattern. Third, negotiate data portability and migration support clauses into enterprise agreements: if you are building production workloads on a managed AI platform, your enterprise agreement should specify the vendor's data export obligations and migration support commitments in the event of platform retirement or architectural change. Fourth, run parallel architecture evaluations: for high-value production workloads, test the target architecture against at least two platform options — one managed (e.g., AgentCore or Vertex AI Agent Builder) and one self-managed (e.g., open-source agent frameworks like LangChain, LlamaIndex, or AutoGen running on your own compute). The parallel evaluation surfaces both the managed platform's value and its constraints. Fifth, modularize the agent logic: if your agent's task logic is cleanly separated from the infrastructure layer (memory, routing, orchestration), migrating the infrastructure layer is a week-long re-plumbing exercise rather than a codebase rewrite.