Migration & Modernization

Migrate Your AI Workloads to Amazon Bedrock with AWS Transform

Today, we’re announcing the model-to-model migration assessment custom transformation for AWS Transform, an AI agent that assesses your generative AI applications and produces a comprehensive migration plan for moving from other GenAI providers to Amazon Bedrock.

Enterprises that built generative AI on OpenAI, Google Gemini, or direct Anthropic APIs find that scaling to production demands more than a model endpoint. They’re migrating to Amazon Bedrock to gain AWS Identity and Access Management (IAM)-based security, VPC endpoint isolation, prompt caching, Bedrock Guardrails, and unified operational tooling through Amazon CloudWatch. But migrating AI workloads isn’t like switching a dependency version. Real codebases use multiple models for different tasks, wrap calls in frameworks like LangChain or CrewAI, and wire streaming and function calling deep into application logic. Manual migration can take weeks per service and risks breaking production systems.

With this new transformation capability, you point the agent at your codebase, answer a few questions about your priorities, and get a detailed migration assessment, including model mappings, cost estimates, an SDK migration guide, and a step-by-step runbook to move your workloads to Bedrock.

What is AWS Transform custom?

AWS Transform custom uses agentic AI to perform large-scale code modernization against your repositories. AWS provides AWS-managed transformations for common use cases like Java version upgrades, AWS SDK migrations, and codebase analysis — pre-built and AWS-vetted, ready to use without additional setup. The model-to-model migration assessment joins this catalog as a new AWS-managed transformation focused on evaluating AI workload migration paths to Amazon Bedrock. It assesses workloads using:

  • OpenAI (direct SDK, ChatGPT API).
  • Google Gemini (@google/genai).
  • Anthropic (direct SDK usage).
  • Open-source models (via LiteLLM, Ollama, or direct inference).

And produces migration guidance for integration patterns, including direct SDK calls, framework-wrapped patterns (LangChain, LlamaIndex), agentic architectures (CrewAI, LangGraph, custom agent loops), and multi-provider routing layers (LiteLLM).

From startup migration to enterprise transformation

This transformation builds on migration technology originally developed by the AWS Startups team. Startups moving from OpenAI or Google Gemini to AWS frequently need to migrate their AI workloads as part of their cloud journey — but often lack the engineering capacity for manual rewrites. The AI powered migration capability on Startups web experience and Claude Plugin has been helping startups make this transition, providing guided, interactive migration paths from competitive AI providers to Amazon Bedrock.

Based on patterns learned from real startup migrations—across frameworks like LangChain, LiteLLM, and CrewAI, and providers including OpenAI, Gemini, and Anthropic—we’ve now brought this capability to AWS Transform as a managed custom transformation available to all AWS customers. Enterprise teams get the same intelligent migration agent, now integrated into the Transform workflow with support for larger codebases, multi-service architectures, and enterprise governance requirements.

If you’re a startup, you can continue using the Startup Migration web experience for a guided, interactive migration path with credits and hands-on support. If you’re working at enterprise scale or want to integrate migration into your development workflow, the AWS Transform custom transformation gives you the same underlying intelligence with full infrastructure integration.

How model-to-model migration assessment works

The transformation follows a five-phase workflow designed to be safe, interactive, and transparent about trade-offs: (1) Discover, which scans and inventories your existing services; (2) Clarify, which asks about your priorities and constraints; (3) Map, which identifies equivalent models on AWS Bedrock; (4) Estimate, which assesses cost and risk implications; and (5) Recommend, which delivers a full assessment with actionable next steps.

What makes this different from find-and-replace migration tools:

  • It asks before it acts. The Clarify phase gathers your priorities: full vs. partial migration, target region, cost vs. quality trade-offs, and how to handle agentic workloads. No assumptions.
  • It understands architecture. A LangGraph StateGraph with conditional edges? It only swaps the LLM binding. A CrewAI crew with hierarchical delegation? It updates the LLM parameter, nothing else. Your graph topology, routing logic, and orchestration patterns remain unchanged.
  • It’s honest about gaps. If a capability has no Bedrock equivalent, the agent flags it and recommends partial migration rather than silently breaking functionality.
  • It checks the model’s lifecycle. It excludes models within 90 days of end-of-life from all recommendations. You won’t migrate to a model that’s about to be deprecated.

Let us show you how this works

We’ll walk through a migration assessment using a chatbot built using Gemini Flash (via Gemini API). You can run this transformation directly from the command line using the AWS Transform Custom:

# Install the AWS Transform Custom CLI
curl -fsSL https://transform-cli.awsstatic.com/install.sh | bash

# Verify the installation
atx --version

# Configure your AWS region
export AWS_REGION=us-east-1

# Run the migration assessment against your codebase
atx custom def exec \
  --code-repository-path ./my-gemini-app \
  --transformation-name GenAI-to-Bedrock-Migration-Assessment \
  --trust-all-tools

You can also run interactively by starting atx and asking the agent directly:

> Execute the GenAI-to-Bedrock-Migration-Assessment transformation on the codebase at ./my-gemini-app

Phase 1: Discovery

The agent scans the codebase and produces a structured inventory in under a minute:

Now I have a complete picture of the codebase. Let me create the migration state and generate the discovery profile.

Now let me generate the `ai-workload-profile.json` based on my analysis:
- **AI source:** Gemini
- **Models detected:** 
- **Capabilities in use:** text_generation
- **Integration pattern:** direct_sdk via @google/genai
- **Gateway/router:** None (direct SDK)

Phase 2: Interactive requirements

The agent then asks you questions to understand your priorities; not making assumptions about what “best” means for your use case:

**--- AI Strategy & Setup ---**
  
Q1 — AI framework or orchestration layer** (select all that apply)
> A) No framework — direct API calls
> B) LLM router/gateway
> C) LangChain / LangGraph
> D) Multi-agent framework
> E) OpenAI Agents SDK
> F) MCP/A2A
> G) Voice platform

Q2 — What matters most for your AI application?

> A) Best quality/reasoning
> B) Fastest speed
> C) Lowest cost
> D) Specialized capability
> E) Balanced
> F) I don't know

Phase 3: Map

Based on your answers, the agent produces a model mapping with transparent cost comparisons at your actual token volumes:

Design Summary:

| Source Model | Bedrock Model | Input/1M | Output/1M | Savings | Assessment |
|---|---|---|---|---|---|
| Gemini 2.5 Flash Lite | Nova Lite| $0.06 | $0.24 | **40% cheaper** | Strong migrate |

- **Overall assessment:** Strong migrate — Bedrock is cheaper with comparable speed for simple text generation tasks.
- **Integration:** Direct SDK swap (`@google/genai` → `@aws-sdk/client-bedrock-runtime` Converse API)
- **Files to modify:** `src/components/Model.jsx`, 
- **Capability gaps:** None (text generation fully supported)

The agent also identifies additional cost levers available on Bedrock:

  • Prompt caching — up to 90% savings on repeated system prompts (Claude models).
  • Tiered model routing — route simple tasks to Nova Micro/Lite, complex tasks to Claude Sonnet.
  • Mantle OpenAI-compatible endpoints — for some workloads, change three environment variables instead of rewriting SDK calls.

Phase 4: Estimate

The agent calculates projected Bedrock costs at your actual token volumes, including additional cost levers:

# Cost Estimation Summary
> Bedrock/Gemini list pricing, ±15–25% accuracy; with ~$1K/month Gemini spend

## Model Comparison
| Model | Monthly Cost | vs Gemini 2.5 Flash-Lite | Fit |
|-------|-------------|--------------------------|-----|
| **Nova Lite** (recommended) | ~$600 | -40% | Closest Bedrock alternative |
| Nova Micro | ~$350 | -65% | Speed + simple tasks; validate quality |
| Gemma 3 4B IT on Bedrock | ~$250* | -75% | Budget alternative, if available/approved |
| Gemini 2.5 Flash-Lite (current) | ~$1,000 | — | Baseline |

## Cost Summary
```
Current GCP:        ~$1,000/month
Projected Bedrock:  ~$600/month (Nova Lite)
Savings:            ~$400/month (~40%)

Phase 5: Recommend

The agent delivers the full migration assessment: model mapping reference, cost analysis, SDK migration guide with sample code changes, and a prioritized migration runbook. For direct SDK usage, the migration guide includes sample code changes such as:

// Before: Gemini SDK
<p><code class="lang-js">import { GoogleGenAI } from "@google/genai";</code></p><div class="hide-language"><div class="hide-language"><pre><code class="lang-js">const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });

const response = await ai.models.generateContent({
  model: "gemini-2.5-flash-lite",
  contents: prompt,
});

return response.text;
```
// After: Bedrock SDK

import { BedrockRuntimeClient, ConverseCommand } from "@aws-sdk/client-bedrock-runtime";
const bedrock = new BedrockRuntimeClient({ region: "us-east-1" });

const response = await bedrock.send(new ConverseCommand({
  modelId: "amazon.nova-lite-v1:0",
  messages: [{ role: "user", content: [{ text: prompt }] }],
}));
return response.output.message.content[0].text;</code></pre></div></div>

For LangChain applications, the guide maps Gemini integrations such as ChatGoogleGenerativeAI to Bedrock integrations such as ChatBedrockConverse. For direct SDK usage, it covers Converse API patterns, system message extraction, streaming, and function-calling conversion to Bedrock’s toolConfig format.

Architecture preservation in practice

The agent understands that migration means changing the model provider, not redesigning your application:

Framework/Pattern What Changes What Stays the Same
1 LangGraph StateGraph LLM binding (ChatOpenAI → ChatBedrockConverse) Graph topology, conditional edges, state management, tool nodes
2 CrewAI Crew llm parameter in agent definitions Crew structure, tasks, delegation patterns, hierarchical process
3 LiteLLM Router Model identifiers (add bedrock/ prefix) Routing weights, fallback ordering, health check logic, retry config
4 Custom agent loop Tool definitions (→ Converse toolConfig), response parsing While-loop structure, termination conditions, memory management

Things to know

  • Supported languages: Python and TypeScript (JavaScript) are fully supported. Java support is coming soon.
  • Repository size: Works best with repositories under 500 files. For larger monorepos, point the agent at the relevant service directory.
  • What you can’t migrate today: OpenAI’s Realtime API, Assistants API with persistent threads, and DALL·E image generation don’t have direct Bedrock equivalents. The agent will flag these and recommend partial migration.
  • Region matters: Not all Bedrock models are available in all regions. The agent checks availability for your target region and will recommend alternatives if your preferred model isn’t available.
  • This is interactive: Unlike batch transformations, the agent will pause and ask you questions. Use --trust-all-tools for a more autonomous experience, or omit it to approve each step.
  • Model recommendations update: The cost comparisons and model mappings reflect current Bedrock pricing and availability. Running the transformation again in the future will use updated pricing data.

Now available

The model-to-model migration assessment is available today in AWS Transform custom in the following AWS regions: us-east-1 (US East – N. Virginia), eu-central-1 (Europe – Frankfurt), eu-west-2 (Europe – London), ca-central-1 (Canada – Central), ap-northeast-1 (Asia Pacific – Tokyo), ap-northeast-2 (Asia Pacific – Seoul), ap-southeast-2 (Asia Pacific – Sydney), and ap-south-1 (Asia Pacific – Mumbai). It works with any codebase that uses supported providers (OpenAI, Google Gemini, Anthropic, or open-source models via LiteLLM/Ollama).

Pricing: You pay standard AWS Transform pricing for the transformation execution. There is no additional charge for the model-to-model migration transformation itself.

Get started:

Give it a try with one of your repositories and let us know what you think! Share feedback on AWS re:Post for AWS Transform or through your usual AWS Support contacts.