Scaling cloud migrations with agentic AI on Amazon Bedrock AgentCore

October 2026: This put up was reviewed and up to date for accuracy.

Scaling cloud migrations with agentic AI on Amazon Bedrock AgentCore raises a sensible query. Which components of a big migration program belong to a managed service, and which components want customized automation? One enterprise program answered that query throughout 300+ functions and a hard and fast fiscal yr deadline. The four-agent sample on this put up decreased infrastructure as code (IaC) improvement time from 3 to 4 weeks per utility to minutes, primarily based on inside mission monitoring information.

This sample runs alongside AWS Rework relatively than instead of it, as a hybrid that provides customized brokers the place your program requires them. AWS Rework covers the migration and modernization work, and AWS Database Migration Service (AWS DMS) covers the database tier. The brokers on this put up connect to these providers and carry one additional requirement: sources and locations reached via Mannequin Context Protocol (MCP) instruments that your group builds and maintains.

AWS Skilled Providers builds a collection of purpose-built AI brokers for packages with that requirement. The brokers use the Strands Agents SDK and run on Amazon Bedrock AgentCore, a platform to construct, join, and optimize brokers at scale, with any framework or mannequin. Every agent reaches its sources and locations via MCP instruments uncovered by AgentCore Gateway.

On this put up, you discover the structure of a four-agent sample for MCP-connected environments. You additionally see the code that defines an agent, connects it to its instruments, and applies accountable AI controls. The sample consists of 4 brokers:

• The Consumption Agent, which reads migration inputs from doc and collaboration methods via MCP instruments.
• The IaC Agent, which generates IaC that composes your authorised inside modules.
• The Migration Intelligence and Governance Agent, which reviews and governs inside your individual program instruments.
• The Web site Reliability Engineering (SRE) Agent for operations after cutover.

To comply with alongside, you want an AWS account with entry to Amazon Bedrock AgentCore and to Amazon Bedrock basis fashions. You additionally want familiarity with the Strands Brokers SDK and MCP server patterns, plus the IaC tooling utilized by your group. Affirm first that an AWS managed service doesn’t already cowl your migration path.

When this sample applies

AWS Rework covers migration and modernization for server, community, mainframe, .NET, and utility code workloads as a managed service, and AWS DMS covers databases. This sample provides brokers for the necessities that keep particular to your group.

On this system described right here, three circumstances held collectively.

• MCP-connected sources and locations: The methods holding the migration inputs, and the methods receiving the outputs, had been reached via MCP instruments that the supply staff constructed and maintained. They included an inside wiki holding safety requirements, a ticketing system, a collaboration platform, and an in-house provisioning API.
• Group-specific IaC composition: Generated infrastructure code needed to compose an inside module library that the safety workplace critiques and approves. Writing that composition by hand took 3 to 4 weeks per utility, which throughout a 300+ utility portfolio interprets to years of engineering effort.
• Work persevering with previous cutover: Program scope included operations after handover, which sits exterior the migration providers.

Structure overview

This sample makes use of 4 purpose-built brokers. The structure attaches to a migration program at three factors: the methods holding migration inputs, IaC composition, and operations after cutover. The sample applies safety at every of these factors. The next diagram reveals how the brokers, instruments, and AWS providers join.

The sample organizes brokers into two journeys. The migration journey brokers deal with discovery via deployment. The operations journey agent handles post-migration monitoring.

Migration journey brokers:

• Consumption Agent (Part 1): Reads structure paperwork, questionnaires, and dependency data via MCP instruments, then defines goal state structure.
• IaC Agent (Part 2): Generates IaC that composes your authorised inside modules for every utility.
• Migration Intelligence and Governance Agent: Gives automated portfolio reporting, well-architected assessments, and governance throughout Jira, Confluence, and Webex.

Operations journey brokers:

• SRE Agent (Part 3): Gives monitoring and automatic remediation after cutover.

AWS managed providers carry the migration and complement the customized brokers:

• AWS Database Migration Service (AWS DMS): Generative AI-assisted schema conversion and automatic cutover for database migration.
• AWS Rework: Discovery, wave planning, touchdown zone creation, community conversion, rehost or replatform execution, and modernization for mainframe, virtualized, and .NET workloads.

How the elements join

This part describes how the framework elements work together at runtime.

Every agent is a Strands agent, outlined by a basis mannequin, a system immediate, and a set of instruments. Amazon Bedrock AgentCore runtime hosts them in a serverless atmosphere with session isolation and multi-agent orchestration. Amazon Bedrock basis fashions energy the reasoning that interprets paperwork, generates code, and drives multi-step workflows. For mannequin availability by AWS Area, confer with Supported basis fashions in Amazon Bedrock.

Every agent calls MCP instruments scoped to its perform via AgentCore Gateway, a functionality of Amazon Bedrock AgentCore, which converts your APIs, AWS Lambda capabilities, and current providers into MCP-compatible instruments. AgentCore Id, a functionality of Amazon Bedrock AgentCore, authenticates every name via scoped AWS Id and Entry Administration (IAM) roles and your identification supplier.

Amazon Bedrock AgentCore reminiscence shops agent session state and shared context. Brokers use this shared context to persist outputs and observe migration progress throughout over 300 functions. When the Consumption Agent completes discovery, it writes the goal structure and dependency mappings to AgentCore reminiscence. The IaC Agent reads this shared context to start code era with out guide handoff.

Defining an agent in code

The next Python instance defines the IaC Agent and prepares it for Amazon Bedrock AgentCore runtime. The agent reaches your MCP instruments via AgentCore Gateway, and it calls a basis mannequin via Amazon Bedrock with an Amazon Bedrock Guardrails coverage hooked up.

 import json
 import logging
 import os
 import uuid
 from bedrock_agentcore.runtime import BedrockAgentCoreApp
 from strands import Agent
 from strands.fashions import BedrockModel
 from strands.instruments.mcp import MCPClient
 from strands.instruments.mcp.mcp_types import MCPClientCredentials

 logger = logging.getLogger(__name__)
 app = BedrockAgentCoreApp()

 REGION = os.environ["AWS_REGION"]

 # url+auth lets the SDK run the client_credentials grant and re-mint the
 # token on expiry. A statically captured bearer token would go stale.
 gateway = MCPClient(
     url=os.environ["GATEWAY_MCP_URL"],
     auth=MCPClientCredentials(
         client_id=os.environ["GATEWAY_CLIENT_ID"],
         client_secret=get_secret("gateway/client_secret"),
         scopes=[os.environ["GATEWAY_SCOPE"]],
     ),
 )

 mannequin = BedrockModel(
     model_id=os.environ["MODEL_ID"],
     region_name=REGION,
     guardrail_id=os.environ["GUARDRAIL_ID"],
     guardrail_version=os.environ.get("GUARDRAIL_VERSION", "1"),
     guardrail_trace="enabled",
 )



 @app.entrypoint
 def invoke(payload, context):
     immediate = (payload.get("immediate") or "").strip()
     if not immediate:
         return {"standing": "error", "error": "lacking required discipline: immediate"}

     attempt:
          with gateway:
              # Fetch the authorised insurance policies for this wave first, so the principles
              # journey within the system immediate as an alternative of relying on the mannequin
              # to ask for them.
              lookup = gateway.call_tool_sync(
                  tool_use_id=str(uuid.uuid4()),
                  title="get_policies",
                  arguments={
                      "resource_types": payload.get("resource_types", []),
                      "wave": payload.get("wave"),
                  },
              )
              if lookup["status"] != "success":
                  return {"standing": "error", "error": "coverage lookup failed"}
              insurance policies = lookup.get("structuredContent", {})
 
              # instruments=[gateway]: SDK owns the connection lifecycle and paginates
              # device discovery, which list_tools_sync() alone doesn't.
              agent = Agent(
                  mannequin=mannequin,
                  system_prompt=(
                      f"{IAC_AGENT_PROMPT}nn"
                      f"Generated IaC satisfies these authorised insurance policies:n"
                      f"{json.dumps(insurance policies.get('insurance policies', []), indent=2)}"
                  ),
                  instruments=[gateway],
              )
              end result = agent(immediate)
 
          if end result.stop_reason == "guardrail_intervened":
              logger.warning("guardrail blocked request, session_id=%s",
                             getattr(context, "session_id", None))
              return {"standing": "blocked_by_guardrail"}
 
          return {
              "standing": "okay",
              "iac": str(end result),
              "policy_set_version": insurance policies.get("model"),
              "waived_policies": insurance policies.get("waived", []),
          }
 
      besides Exception as e:
          logger.exception("invocation failed, session_id=%s",
                           getattr(context, "session_id", None))
          return {"standing": "error", "error": str(e)}
 
 
  if __name__ == "__main__":
      app.run()

The entrypoint returns the generated IaC along with the coverage set model that formed it, so a reviewer traces the output again to a signed-off customary. AgentCore Runtime handles session isolation and scaling. For deployable examples, see the Amazon Bedrock AgentCore samples repository and the Strands Agents samples repository on GitHub. For the deployment steps, confer with Getting began with AgentCore runtime.

Part 1: Consumption Agent for automated discovery

The Consumption Agent reads the migration inputs that reside in your doc and collaboration methods. On this program, these methods had been reachable via MCP instruments the supply staff constructed and maintained.

The agent ingests structure documentation, utility stock lists, consumption questionnaires, and dependency data via these instruments. It then produces a goal AWS structure with a advisable migration sample, useful resource sizing specs, and a compliance validation report.

The output feeds instantly into the IaC Agent, creating an automatic handoff from consumption to infrastructure provisioning.

Part 2: IaC Agent for automated infrastructure code era

AWS Skilled Providers deployed the IaC Agent first within the portfolio, and it delivers probably the most instantly measurable affect. It generates IaC code adhering to your safety finest practices and requirements.

The way it works

The agent workflow proceeds via 5 steps:

Step 1: Ingest the steering doc. The agent reads the steering doc from the wave staff. It extracts deployment scope, compliance constraints, and Safety Workplace-approved wave-specific overrides.

Step 2: Interpret the goal state structure diagram. Utilizing the Consumption Agent’s output, the IaC Agent identifies infrastructure elements, their relationships, and dependencies.

Step 3: Generate IaC. Based mostly on this interpretation, the agent generates IaC utilizing your outlined and established patterns. It populates configurations with wave-specific parameters and configures distant state administration. It then applies obligatory tagging and provides monitoring configurations required by organizational requirements.

Step 4: Validate via Coverage in Amazon Bedrock AgentCore. Earlier than execution, Coverage in AgentCore evaluates every device name towards Cedar guidelines. It calculates the scope of potential change, checks dependency conflicts with concurrent waves, and confirms compliance window validity.

Step 5: Execute and report. The centralized execution airplane triggers the IaC, screens deployment, and reviews outcomes via AgentCore Observability, a functionality of Amazon Bedrock AgentCore. Publish-deployment validation runs mechanically and compliance metrics replace in actual time.

Customized MCP instruments: The safety basis

Every motion passes via customized MCP instruments uncovered by Amazon Bedrock AgentCore Gateway and ruled by AgentCore Id and Coverage in AgentCore. AgentCore Id authenticates every agent motion via scoped IAM roles with least-privilege entry. The framework validates inputs towards outlined schemas and rejects malformed inputs on the boundary.

No credentials or delicate values cross via agent context, as a result of AgentCore Id resolves secrets and techniques at runtime from a centralized credential supplier. AgentCore Observability and AWS CloudTrail write every agent motion to an immutable, centralized audit path. Coverage in AgentCore enforces Cedar guidelines that assist forestall a single operation from affecting greater than an outlined threshold.

Curated organizational insurance policies as MCP instruments

The safety workplace curates the coverage set, not the agent. A versioned doc holds every rule, the useful resource varieties it covers, a machine-checkable assertion, and the approval file. The next instance reveals three insurance policies and one wave exception.

{
    "policy_set": "security-office/baseline",
    "model": "2026.09.1",
    "insurance policies": [
      {
        "id": "SEC-ENC-001",
        "applies_to": ["aws_s3_bucket", "aws_ebs_volume", "aws_rds_cluster"],
        "requirement": "Encrypt information at relaxation with a buyer managed KMS key",
        "assertion": "kms_key_id != null and sse_algorithm == 'aws:kms'",
        "severity": "blocking",
        "supply": "SecOffice/Encryption-Commonplace-v4"
      },
      {
        "id": "SEC-NET-014",
        "applies_to": ["aws_security_group_rule"],
        "requirement": "No ingress from 0.0.0.0/0 on administrative ports",
        "assertion": "not (cidr_blocks accommodates '0.0.0.0/0' and to_port in [22, 3389])",
        "severity": "blocking",
        "supply": "SecOffice/Community-Commonplace-v7"
      },
      {
        "id": "OPS-TAG-003",
        "applies_to": ["*"],
        "requirement": "Carry proprietor, cost-center, data-classification, and wave tags",
        "assertion": "tags has_keys ['owner', 'cost-center', 'data-classification', 'wave']",
        "severity": "blocking",
        "supply": "SecOffice/Tagging-Commonplace-v2"
      }
    ],
    "wave_overrides": [
      {
        "wave": "wave-14",
        "policy_id": "SEC-NET-014",
        "decision": "exception",
        "expires_on": "2026-10-31",
        "approved_by": "security-office"
      }
    ]
  }

An AWS Lambda perform serves that doc, and AgentCore Gateway exposes the perform as an MCP device named get_policies. The IaC Agent requests solely the insurance policies in scope for the useful resource varieties within the wave it generates.

  import json
  from datetime import date
  from pathlib import Path
 
  POLICY_SET = Path("insurance policies/security-office-baseline.json")
 
  def get_policies(occasion, context):
      """Return the authorised insurance policies for the requested useful resource varieties and wave.
 
      AgentCore Gateway exposes this perform because the get_policies MCP device.
      """
      doc = json.hundreds(POLICY_SET.read_text())
      requested = set(occasion.get("resource_types") or [])
      at this time = date.at this time()
      waived = {
          o["policy_id"]
          for o in doc["wave_overrides"]
          if o["wave"] == occasion.get("wave")
          and date.fromisoformat(o["expires_on"]) >= at this time
      }
      insurance policies = [
          p for p in doc["policies"]
          if (p["applies_to"] == ["*"] or requested & set(p["applies_to"]))
          and p["id"] not in waived
      ]
      return {
          "model": doc["version"],
          "insurance policies": insurance policies,
          "waived": sorted(waived),
      }

The response carries the coverage set model, so generated code data which guidelines produced it and a reviewer traces a useful resource again to a signed-off customary. Waived insurance policies journey in their very own discipline relatively than disappearing, and the compliance report lists them for the wave. Every exception carries an expiry date, so a lapsed waiver stops making use of with out guide cleanup.

Two coverage layers function right here, they usually reply completely different questions. AgentCore Coverage evaluates Cedar guidelines to determine whether or not an agent calls a device in any respect. The curated coverage set decides what the generated infrastructure satisfies.

IaC era primarily based in your patterns

The IaC Agent generates infrastructure code primarily based in your outlined and established patterns. These patterns encode organizational requirements into reusable constructs. They embrace community configurations, safety group guidelines, IAM roles, Amazon CloudWatch alarms, Amazon Elastic Compute Cloud (Amazon EC2) configurations, Amazon Digital Non-public Cloud (Amazon VPC) layouts, and obligatory tagging.

This strategy offers consistency throughout waves, velocity for wave groups who don’t write infrastructure code from scratch, and governance the place safety updates propagate to customers on their subsequent deployment cycle.

Output artifacts

The agent produces IaC code, automated take a look at circumstances, compliance reviews, and deployment runbooks for every utility.

The IaC Agent pushes generated code on to your code repository (comparable to AWS CodeCommit, GitLab, or Bitbucket). From there, it enters your current evaluate and deployment pipeline with out requiring modifications to your current toolchain.

Migration Intelligence and Governance Agent: Portfolio-wide visibility

A 300+ utility portfolio wants standing reporting, progress monitoring, follow-up actions, and well-architected validation. On this program, that work ran contained in the buyer’s personal Jira, Confluence, and Webex. Performing it by hand creates vital overhead for mission managers and supply leads.

The Migration Intelligence and Governance Agent addresses this with automated, on-demand intelligence and governance throughout the portfolio. It aggregates information from three sources via AgentCore Gateway. Jira offers dash progress and impediments. Confluence offers structure documentation and runbooks. Webex offers assembly notes and motion gadgets.

The agent offers well-architected assessments throughout migrated workloads, compliance and governance validation, and structure sample adherence monitoring.

Automated actions embrace updating Confluence pages with newest migration standing, creating Jira duties for recognized motion gadgets, and producing ServiceNow tickets for escalations. These actions require specific human approval earlier than execution. This approval-gated structure is a core design precept throughout the 4 brokers. Brokers assist human decision-making relatively than changing it.

On-demand reporting throughout the 300+ utility portfolio replaces guide aggregation, primarily based on inside mission monitoring information. Your outcomes would possibly differ primarily based on portfolio dimension and power integrations.

Part 3: SRE Agent for proactive post-migration operations

The SRE Agent covers the part after handover. The migration providers full at cutover. After functions run on AWS, the SRE Agent shifts the staff from reactive response to proactive enchancment.

The agent screens Amazon CloudWatch metrics, utility efficiency information, and historic patterns. It raises alerts earlier than points have an effect on manufacturing. The agent additionally publishes automated remediation playbooks for widespread failure patterns and recommends effectivity enhancements.

Goal areas (with human-in-the-loop approval) embrace database cluster right-sizing, efficiency tuning, storage tiering, and compute scaling and effectivity enhancements.

The SRE Agent extends the sample previous migration. Functions don’t land on AWS and cease there. They constantly enhance over time.

Knowledge migration with AWS DMS

Alongside the customized AI brokers, two AWS managed providers deal with the information and utility modernization, server and community migration layer.

DMS Schema Conversion with generative AI reduces guide schema mapping effort. It converts code objects that rules-based conversion leaves unfinished, comparable to saved procedures, capabilities, and triggers. This functionality is usually obtainable in a subset of AWS Areas, so affirm Area assist throughout wave planning. AWS DMS then shortens the cutover window with automated migration duties. The service integrates instantly into the agent pipeline. The IaC Agent provisions goal infrastructure, then AWS DMS migrates the information.

AWS Rework covers the server, community, and code layers of the identical program. The AWS Rework Consumer Information lists the present capabilities by workload sort.

Safety and compliance: Embedded, not bolted on

This structure embeds safety from the beginning, not as an afterthought, making use of it at every part of the migration lifecycle. Key controls throughout the agent suite:

• Safety requirements enforcement: The IaC Agent pulls your safety workplace requirements instantly from Confluence and applies them throughout generated IaC utilizing customized MCP instruments.
• Touchdown zone validation: The framework validates generated infrastructure towards the enterprise’s touchdown zone compliance necessities earlier than deployment.
• Human-in-the-loop approval gates: Automated actions throughout all brokers within the suite require specific human approval earlier than execution. No agent acts autonomously on manufacturing methods.
• AgentCore Gateway coordination: Amazon Bedrock AgentCore Gateway coordinates context and safety controls throughout brokers, sustaining constant coverage utility all through the migration lifecycle.
• Steady integration and steady supply (CI/CD) integration: The framework integrates safety controls into the CI/CD pipeline, with automated take a look at circumstances generated alongside IaC to catch compliance points earlier than they attain manufacturing.
• Accountable AI controls on the inference layer: Amazon Bedrock Guardrails applies content material filters, denied matters, delicate info filters, and contextual grounding checks to every immediate and every mannequin response. An agent acts solely on output that clears the guardrail. Guardrail traces circulation into AgentCore Observability alongside the tool-call audit path.

This strategy aligns with the AWS shared accountability mannequin. AWS offers safety of the underlying infrastructure, whilst you’re chargeable for safety within the cloud. The brokers automate your configuration tasks whereas sustaining human oversight for approval selections.

On this implementation, the sample maintained enterprise safety requirements throughout the over 300 utility portfolio at speeds guide processes couldn’t match. Your outcomes would possibly differ primarily based in your safety necessities and organizational requirements.

Measurable affect

Throughout the migration program, this framework delivered the next outcomes. These metrics mirror this particular implementation. Your outcomes would possibly differ primarily based on utility complexity, staff dimension, and organizational necessities.

• IaC improvement time decreased from weeks to minutes: from 3–4 weeks per utility to minutes of automated era (primarily based on inside mission monitoring information).
• Sample consistency utilized throughout waves: no wave can deviate from the authorised IaC patterns baseline.
• Safety compliance: verified mechanically at every deployment, with an entire audit path requiring zero guide effort.
• Structure-to-deployment constancy improved: the agent interprets the diagram, and the IaC realizes it as designed.
• On-demand portfolio reporting throughout over 300 functions with exact metrics and 0 guide aggregation.
• Wave staff onboarding improved: groups add paperwork and the brokers produce the IaC and the reviews.

Price issues

Working this sample provides value in just a few predictable locations. Basis mannequin tokens often dominate, as a result of consumption and IaC era push paperwork, insurance policies, and structure context via a mannequin and return generated code. Amazon Bedrock AgentCore payments on consumption. Runtime expenses per second for the CPU and reminiscence a session makes use of, and CPU scales to zero whereas an agent waits on a mannequin response or a human approval. Gateway, Reminiscence, Coverage, and Guardrails every invoice per unit of use, and Observability telemetry payments at Amazon CloudWatch charges.

Throughout a 300+ utility portfolio the brokers run for the size of the migration program relatively than as a single job, so deal with this as a operating value that tracks wave exercise. Token quantity follows doc dimension and tool-call depend greater than utility depend, so a pilot wave offers you a per-application baseline. On the AWS Rework facet, the evaluation and the migration brokers for virtualized, Home windows, and mainframe workloads can be found for free of charge. The sources a migration creates invoice usually, and customized transformations are priced per agent minute. For present charges, confer with Amazon Bedrock pricing, Amazon Bedrock AgentCore pricing, AWS Rework pricing, Amazon CloudWatch pricing, and the AWS Pricing Calculator.

Clear up sources

To keep away from ongoing expenses after you end testing the framework, take away the sources that you simply created:

• Delete the brokers from AgentCore runtime, then take away the Gateway targets and the Gateway.
• Delete the AgentCore reminiscence sources that maintain session state and shared context.
• Delete the guardrail, the Coverage in AgentCore definitions, and the IAM roles created for the brokers.
• Delete the CloudWatch log teams that AgentCore Observability wrote to, should you now not want the historical past.
• Delete any AWS DMS replication situations and endpoints provisioned for take a look at migrations.

Affirm within the Amazon Bedrock AgentCore console that no agent classes stay lively.

Conclusion

Migrating 300+ functions to AWS on an aggressive timeline wants greater than added engineers. Managed providers carry most of that work. The place a requirement falls exterior them, an agent sample can shut the hole whereas people preserve selections, approvals, and technique.

This sample delivered measurable outcomes on one program whose sources and locations sat behind MCP instruments. Goal-built Strands brokers addressed these particular necessities, Amazon Bedrock AgentCore utilized safety structurally, and human-in-the-loop design stored automation supporting decision-making relatively than changing it. Use AWS Rework and AWS DMS for the migration, and run these brokers with them the place MCP-connected sources and locations name for it.

Subsequent steps

Based mostly in your use case, contemplate these paths:

• Planning a migration? Join AWS Rework to your favourite AI code companion and get began with server, community, and code migration and modernizations, and AWS DMS for database.
• Sources and locations behind MCP instruments? Consider this sample. See Amazon Bedrock AgentCore to learn to construct and deploy brokers.
• Inside module library to honor? Consider the IaC Agent. IaC improvement time dropped from weeks to minutes towards a guide baseline on this program.
• Governance inside your individual program instruments? Think about the Migration Intelligence and Governance Agent for standing reporting and well-architected assessments. Be taught extra about Amazon Bedrock AgentCore Reminiscence for agent state administration.
• Publish-migration? Discover the SRE Agent sample to shift from reactive operations to proactive enchancment. Use Amazon CloudWatch for monitoring and automatic alerting.
• Constructing your individual brokers? Begin with the Strands Agents SDK and Amazon Bedrock AgentCore, utilizing MCP servers tailor-made to your migration bottlenecks. Open the Amazon Bedrock AgentCore console to get began, learn Deploying Strands Agents to Amazon Bedrock AgentCore runtime.

To discover the providers used on this put up:

For background on the providers and SDKs used right here, learn these AWS posts:

In regards to the authors