Bedrock Agents Classic Sunset: Migration Guide to AgentCore (2026)

On June 30, 2026, AWS quietly renamed Amazon Bedrock Agents to “Amazon Bedrock Agents Classic” and placed it in maintenance mode. Starting July 30, 2026, no new customers can onboard. The model catalog is frozen on that date. No new features will ship. The service that launched in November 2023 as AWS’s flagship AI agent product is being retired after just two years and eight months — part of a broader consolidation that also puts Amazon Kendra and Amazon Q Business into maintenance mode on the same timeline.

If you’re running production agents on Bedrock Agents today, nothing breaks on July 30. Your existing agents, APIs, and Infrastructure-as-Code templates continue to work. But the window is closing: you’re now on a platform that won’t receive new models, new features, or new integrations. The replacement, Amazon Bedrock AgentCore, is a fundamentally different architecture — not an upgrade, but a separate product. This guide walks you through exactly what changed, which migration path fits your workload, and how to execute the move before you’re stuck on a frozen platform.

What AWS Actually Retired — and Why

Bedrock Agents Classic isn’t the only casualty. AWS announced maintenance mode for three first-generation AI services simultaneously:

The pattern is clear: AWS is collapsing point solutions into a smaller set of composable, agent-native platforms. As Forbes reported on July 24, 2026, this retirement signals that AWS’s first-generation AI services were too tightly coupled and too opinionated for the way enterprises actually build agents in production.

The strategic logic: Bedrock Agents Classic was a fully managed, opinionated service. You configured instructions, a model, action groups, knowledge bases, and guardrails — AWS owned the orchestration loop. That worked for bounded, single-purpose agents. But production teams building multi-agent systems, custom orchestration, or framework-specific pipelines (LangGraph, CrewAI, Strands) hit the walls fast. AgentCore gives them the infrastructure without the opinions.

Bedrock Agents Classic vs. AgentCore: Architecture Comparison

These are not two versions of the same product. They’re architecturally different, and understanding the differences is the prerequisite for a clean migration.

The mental model shift: Bedrock Agents Classic was a product — a turnkey service you configured. AgentCore is infrastructure — a set of primitives you compose. If you’ve used Bedrock Agents Classic like a managed database (hand it a schema, it runs queries), AgentCore is more like running your own database engine on managed compute (you control the query planner, AWS manages the servers).

What Happens to Your Existing Agents on July 30

The immediate impact is carefully scoped. Here’s exactly what changes and what doesn’t:

More Read

Agentic AI in Financial Services: Real-World Impact on Fraud Detection and Operational Efficiency

Unlocking CrewAI Memory Types: A Guide for Technical Builders

How to Build an Agentic Workflow with n8n and an LLM (2026 Tutorial)

What Continues Working

All existing APIs remain available to current customers: UpdateAgent, GetAgent, ListAgents, DeleteAgent, PrepareAgent, InvokeAgent, action group APIs, knowledge base APIs, and alias APIs. Your existing Infrastructure-as-Code templates (CloudFormation, Terraform, CDK) that create or manage Bedrock Agents continue to work for allowlisted accounts. Bug fixes and security patches will still be applied.

What Stops

CreateAgent and InvokeInlineAgent are restricted for accounts without prior usage — you can’t create new agents on Agents Classic from a fresh account after July 30. The model catalog is frozen: any new model released to Bedrock after July 30, 2026 will only be available through AgentCore. No new features will be developed. Feature requests are no longer considered.

The Real Risk

The danger isn’t an immediate outage — it’s platform drift. Every month you stay on Agents Classic, you fall further behind: no access to new models (including future Claude, GPT, and Gemini releases on Bedrock), no new tool integrations, no performance improvements, and growing distance from AWS’s primary documentation and support focus. As the Forbes analysis noted, this is a pattern AWS has executed before: maintenance mode is a slow sunset, not a hard stop.

The Two Migration Paths

AgentCore offers two distinct migration strategies. Your choice depends on how much control you need over the agent orchestration loop.

Path 1: AgentCore Managed Harness (Config-Based)

The managed harness is the closest analog to Bedrock Agents Classic. You define an agent by specifying a model, system prompt, and tools. AgentCore handles the full agent loop: reasoning, tool selection, action execution, and response streaming. Each session runs in its own isolated microVM with filesystem and shell access.

Best for: Teams migrating simple, single-purpose agents that don’t require custom orchestration logic. If your Bedrock Agents Classic setup was standard — model + instructions + action groups + knowledge bases — the harness path minimizes code changes.

What you get: Managed compute, memory, identity controls, observability, and tool integration — all configurable through three API calls. Supports any model provider (Bedrock, Anthropic, OpenAI, Gemini).

Limitation: You’re still delegating the orchestration loop. If you need custom routing, multi-agent coordination, or framework-specific patterns, you’ll hit the same walls you hit on Agents Classic — just in a newer product.

Path 2: Code-Defined Agents on AgentCore Runtime

Deploy your own agent code — built with Strands, LangGraph, CrewAI, OpenAI Agents SDK, Claude Agent SDK, or fully custom logic — on AgentCore’s managed infrastructure. You own the orchestration loop; AWS provides the Runtime (serverless microVMs), Gateway (MCP/A2A tool connections), Memory, Policy enforcement, Identity, and Observability.

Best for: Teams already using or planning to adopt an open-source agent framework. If you’re building multi-agent systems, need custom tool-calling patterns, or want framework portability, this is the path.

What you get: Full control over agent logic with production-grade infrastructure underneath. Sessions can run up to 8 hours with asynchronous tool execution. Native MCP and A2A protocol support means your agents can interoperate with tools and other agents across the ecosystem.

The Strands connection: Strands Agents is AWS’s open-source SDK (Python and TypeScript) for building agents. Version 1.0 shipped May 21, 2026 with multi-agent orchestration, A2A protocol support, and a remote session manager. It’s model-agnostic but has native AgentCore integration. If you don’t already have a framework preference, Strands is the path of least resistance for AWS-native teams.

Component-by-Component Migration Map

Here’s how each Bedrock Agents Classic concept maps to AgentCore:

Critical note on Knowledge Bases: Your existing Amazon Bedrock Knowledge Bases and Guardrails are not affected by the Agents Classic retirement. They’re separate services that continue to evolve independently. AgentCore agents consume them the same way Classic agents did. This is the one piece of the migration that doesn’t require rearchitecting.

Step-by-Step Migration Checklist

Use this checklist whether you’re taking the harness path or the code-defined path. Steps marked with [H] are harness-specific; [C] are code-defined-specific.

Phase 1: Inventory and Assessment (Week 1)

1. Audit your existing agents. Run ListAgents across all regions. For each agent, document: the model ID, system prompt, action groups (with Lambda ARNs), knowledge base associations, guardrail configurations, and alias mappings. Export these configurations — they’re your migration blueprint.

2. Classify each agent. Categorize by complexity:

• Simple (single model + prompt + 1-2 action groups): Harness path candidate
• Moderate (multiple action groups + knowledge bases + guardrails): Harness path, but verify all features are supported
• Complex (custom prompt overrides, multi-turn orchestration, chained agents): Code-defined path with Strands or your framework of choice

3. Check your account’s AgentCore access. Verify you can create resources in AgentCore. Run a simple test deployment to confirm IAM permissions and service quotas.

Phase 2: Build the AgentCore Equivalent (Weeks 2-3)

4. [H] Use the AgentCore CLI import. The AgentCore CLI can import existing Bedrock Agents Classic configurations as a starting point. Run the import, then review and adjust the generated harness configuration. This handles model, prompt, and basic tool mappings automatically.

5. [C] Set up your agent framework. If taking the code-defined path, initialize your Strands/LangGraph/CrewAI project. Configure AgentCore Runtime as your deployment target. Map each Classic action group to an MCP tool definition or Gateway endpoint.

6. Migrate action groups to MCP tools. For each Lambda-based action group:

• Keep the Lambda function — the business logic doesn’t change
• Create an MCP server wrapper or register the Lambda as a Gateway tool
• Test tool invocation independently before connecting to the agent

7. Connect Knowledge Bases. Your existing Bedrock Knowledge Bases work directly with AgentCore agents. Update the agent configuration to reference them via the AgentCore API surface rather than the Classic agent association.

8. Configure Policy and Guardrails. Port your existing Guardrails configuration (it’s the same service). Then add AgentCore Policy rules for any agent-specific action controls you need — spending limits, tool access restrictions, or approval workflows.

Phase 3: Test and Validate (Week 3-4)

9. Run parallel invocations. Send identical prompts to both your Classic agent and the new AgentCore agent. Compare responses for accuracy, tool-calling behavior, and latency. Document any behavioral differences.

10. Load test the AgentCore agent. AgentCore’s default quota supports up to 5,000 active concurrent sessions in US East (N. Virginia) and US West (Oregon), and 2,500 in other regions, with 200 agent interactions per second. Verify your workload fits within these limits or request increases.

11. Validate observability. Confirm that traces, metrics, and logs appear correctly in the new AWS/Bedrock-AgentCore CloudWatch namespace. Update any dashboards, alarms, or monitoring integrations that reference the old metric namespace.

Phase 4: Cut Over (Week 4-5)

12. Update client integrations. Switch your application code from the Bedrock Agents InvokeAgent API to the AgentCore Runtime API. This is a breaking API change — the request/response format differs. Update SDKs and test end-to-end.

13. Update IaC templates. Replace Bedrock Agents CloudFormation/Terraform resources with AgentCore equivalents. The resource types and property schemas are different.

14. Decommission Classic agents. Once the AgentCore agents are handling production traffic, delete the Classic agents to avoid confusion and stop any residual costs. Keep your audit documentation for compliance records.

AgentCore’s New Capabilities You Didn’t Have Before

Migration isn’t just about preserving existing functionality. AgentCore introduces capabilities that Bedrock Agents Classic never offered, and several of them can materially improve your agent deployments.

AgentCore Browser

Agents can now automate browser workflows with OS-level interaction capabilities beyond Chrome DevTools Protocol. This opens up web scraping, form filling, and UI testing workflows that previously required separate browser automation infrastructure. As of April 2026, the Browser tool supports both CDP-based and OS-level actions within the same session.

AgentCore Payments (Preview)

Built in partnership with Coinbase and Stripe, AgentCore Payments is the first managed payment capability purpose-built for autonomous agents. Agents can autonomously access and pay for APIs, MCP servers, web content, and other agents. Stablecoin support enables sub-cent microtransactions with configurable spending guardrails. This is genuinely new territory — agent governance frameworks will need to evolve to account for agents that hold and spend budgets.

AgentCore Evaluations and Optimization

The evaluations service lets you run batch evaluations and A/B tests against production agent workloads. The recommendations capability analyzes production traces to generate optimized system prompts and tool descriptions automatically. This closed-loop optimization didn’t exist in Classic — you had to build it yourself.

Framework Portability

AgentCore is framework-agnostic. You can deploy agents built with LangGraph, CrewAI, Microsoft Agent Framework, Strands, or fully custom code. This eliminates vendor lock-in at the orchestration layer — if you decide to switch from LangGraph to Strands (or vice versa), the infrastructure doesn’t change.

Long-Running Sessions

Classic agents were limited to synchronous invocations lasting minutes. AgentCore supports sessions up to 8 hours with asynchronous tool execution. For complex research tasks, multi-step data processing, or workflows that require human-in-the-loop approvals, this is a significant upgrade.

Pricing: What Changes

Bedrock Agents Classic used per-invocation pricing. AgentCore uses consumption-based pricing across 12 independent components. Here are the key rates:

The net cost impact depends heavily on your workload profile. High-throughput, short-lived agents may see costs increase due to the per-component billing model. Long-running, complex agents that previously required multiple invocations and external orchestration infrastructure may see costs decrease. Run the AgentCore pricing calculator with your actual invocation volumes before committing to a migration timeline.

The Broader Context: Why This Matters Beyond AWS

AWS’s move isn’t happening in isolation. Every major cloud vendor is converging on the same pattern: decomposed, framework-agnostic agent infrastructure that separates orchestration from platform services.

• Google launched Vertex AI Agent Builder with ADK (Agent Development Kit) support, recently releasing Gemini 3.6 Flash with built-in Computer Use for agent automation.
• Microsoft now requires a dedicated Agent 365 license (effective July 1, 2026) for AI agent security capabilities in Copilot Studio and Microsoft Foundry — separating agent governance from general cloud security licensing.
• Salesforce just landed a $1.6 billion VA Agentforce deal, with Agentforce ARR reaching $1.2 billion (205% YoY growth). Enterprise agentic platforms are becoming their own product category.
• Open-source frameworks like LangGraph and Strands are becoming the agent-building layer, with cloud platforms providing the deployment and governance layer underneath.

The strategic implication: the “agent platform” is splitting into two tiers. The orchestration tier (how agents think, plan, and act) is moving to open-source frameworks. The infrastructure tier (how agents deploy, scale, pay, authenticate, and get monitored) is where cloud vendors compete. AgentCore is AWS placing its bet on the infrastructure tier. If you’re building agents on AWS, understanding this split — and designing your architecture accordingly — is more important than the migration mechanics.

Common Migration Mistakes to Avoid

Based on patterns from early adopters and AWS’s own guidance, here are the pitfalls that catch teams during this transition:

1. Treating it as a version upgrade. AgentCore is not Bedrock Agents v2. It’s a different product with different APIs, different resource types, and a different architectural model. Teams that approach migration as a configuration update will stall when they discover the API surfaces don’t align. Plan for a rebuild, not a reconfiguration.

2. Migrating everything at once. Start with your simplest agent. Get one agent running on AgentCore, validate the full lifecycle (deploy, invoke, monitor, update), then migrate the rest. The first agent teaches you the operational differences; the rest are pattern repetition.

3. Ignoring the pricing model shift. Per-invocation pricing and per-component consumption pricing optimize differently. An agent that was cheap on Classic (few invocations, each doing a lot internally) might be expensive on AgentCore (each tool call, memory write, and policy check is metered separately). Model your costs before migrating production workloads.

4. Not updating observability. Your existing CloudWatch dashboards, alarms, and runbooks reference Bedrock Agents metrics and log groups. AgentCore publishes to a different namespace (AWS/Bedrock-AgentCore) with different metric names. A migration that skips the monitoring update leaves your ops team blind during the most critical period.

5. Over-engineering the framework choice. If your agents are simple and you’re happy with AWS-native tooling, use the managed harness. Don’t adopt LangGraph or Strands just because AgentCore supports them. Framework migration and platform migration at the same time doubles the risk. Pick one battle per quarter.

What to Do This Week

With the July 30 cutoff five days away, here’s a prioritized action plan:

Immediate (before July 30):

• Run ListAgents across all regions and export every agent configuration. This is your insurance policy.
• Verify your AWS account has AgentCore access and test a basic deployment.
• If you were planning to create new agents on Classic, do it now — after July 30, CreateAgent is blocked for accounts without prior usage.

Next 30 days:

• Classify your agents by complexity and assign migration paths (harness vs. code-defined).
• Migrate your simplest agent as a proof of concept.
• Run the AgentCore pricing calculator with your actual production volumes.

Next 90 days:

• Complete migration of all production agents.
• Update IaC templates, monitoring, and runbooks.
• Evaluate AgentCore-only features (Browser, Payments, Evaluations) for new use cases.

FAQs

Will my existing Bedrock Agents stop working on July 30, 2026?

No. Existing agents continue to function normally. All management and invocation APIs remain available to current customers. What stops is the ability to create new agents from accounts that haven’t used the service before, and the model catalog freezes — no new models will be added after that date.

Can I use LangGraph or CrewAI agents on AgentCore?

Yes. AgentCore is framework-agnostic. You can deploy agents built with LangGraph, CrewAI, Strands, OpenAI Agents SDK, Claude Agent SDK, AutoGen, or fully custom code on AgentCore’s managed Runtime. The infrastructure services (Memory, Gateway, Policy, Identity, Observability) work identically regardless of framework.

Are Bedrock Knowledge Bases and Guardrails also being retired?

No. Knowledge Bases and Guardrails are separate services that continue to evolve independently. AgentCore agents consume them directly. This is the one part of the migration that doesn’t require rearchitecting.

What’s the difference between the AgentCore managed harness and code-defined agents?

The managed harness is config-based: you declare model, tools, and instructions, and AgentCore handles the orchestration loop. Code-defined agents give you full control: you write the agent logic in your framework of choice and deploy it on AgentCore’s Runtime. The harness is faster to set up; code-defined gives you more flexibility. Both use the same underlying infrastructure services.

How does AgentCore pricing compare to Bedrock Agents Classic?

Classic used per-invocation pricing. AgentCore uses consumption-based pricing across 12 components (Runtime, Gateway, Memory, Policy, etc.). The net impact depends on your workload: simple agents with few tool calls may cost more due to per-component metering; complex agents that previously required external orchestration infrastructure may cost less. Use the AgentCore pricing calculator to model your specific workload before migrating.

Key Takeaways

• July 30, 2026 is the hard cutoff for new customer access to Bedrock Agents Classic. Existing agents keep running, but the model catalog freezes and no new features ship.
• AgentCore is not an upgrade — it’s a separate product with a different architecture. Plan for a rebuild, not a reconfiguration.
• Two migration paths exist: the managed harness (config-based, closest to Classic) and code-defined agents (framework-agnostic, full control). Pick based on orchestration complexity.
• Knowledge Bases and Guardrails are safe — they’re separate services that AgentCore agents consume directly.
• New capabilities unlock on migration: 8-hour sessions, browser automation, autonomous payments, framework portability, and closed-loop optimization via evaluations.
• The broader industry is converging on the same pattern: open-source orchestration + cloud-native infrastructure. This migration is a chance to align your architecture with that direction.
• Start this week: export all agent configurations before July 30, verify AgentCore access, and migrate your simplest agent first as a proof of concept.

References

1. AWS, Amazon Bedrock Agents Classic Maintenance Mode, AWS Documentation, 2026.
2. Janakiram MSV, AWS Kills The AI Services It Launched Just Two Years Ago, Forbes, July 24, 2026.
3. Faisal Haque, AWS Just Retired Its Flagship AI Agent Product. It Launched in 2023, AWS in Plain English, July 2026.
4. AWS, Amazon Bedrock AgentCore, AWS Product Page, 2026.
5. AWS, Amazon Bedrock AgentCore Increases Default Runtime Quota Limits, AWS What’s New, July 2026.
6. AWS, Release Notes for Amazon Bedrock AgentCore, AWS Documentation, 2026.
7. AWS, Technical Deep Dive: AgentCore Payments and Innovation in Agentic Commerce, AWS ML Blog, 2026.
8. Cipher Projects, Amazon Bedrock Agents vs AgentCore + Strands (2026): Managed Agent or Production Runtime?, 2026.
9. Cloud Burn, Amazon Bedrock AgentCore Pricing: 12 Components Breakdown, 2026.
10. AWS, Amazon Bedrock AgentCore Browser Adds OS-Level Interaction Capabilities, April 2026.

What to read next on rpabotsworld.com:

• Guardrails in Amazon Bedrock: Building Safer and Governed Generative AI Applications in LangGraph
• LangGraph vs. CrewAI vs. Microsoft Agent Framework vs. Google ADK
• AI Agent Control Planes: The 2026 Enterprise Governance Guide
• 16 Reasons Why Agentic Automation Programs Fail