How to build or migrate an AI agent with AWS Startup Advisor

AWS Startup Advisor, the AI-powered build assistant designed for founders, now has expanded agent capabilities. Use the solution to turn an idea or local prototype into a recommended architecture and working proof of concept (POC), or map an existing agent stack to AWS without having to rebuild.

Available across developer environments including Kiro, Claude, Cursor, VS Code, and more, AWS Startup Advisor gives you personalized architecture, cost, security, and service-selection guidance, tailored to your tech stack and growth stage.

Here, we explain how it works, walk through the process of migrating an existing agent, and show how its recommendations map across your agent stack.

You can build an agent a dozen ways. The hard part is choosing an architecture that stays consistent, repeatable, and reliable in production.

The architecture you choose can affect the reliability and cost of running the agents. This is where the breadth of AWS becomes an advantage. Startups can choose solutions across the following areas:

1. Runtimes: Amazon Bedrock AgentCore Runtime, AWS Lambda, Amazon Elastic Container Service (ECS), and Amazon Elastic Kubernetes Service (EKS).
2. Models on Amazon Bedrock.
3. Memory and knowledge: AgentCore Memory and Amazon Bedrock Knowledge Bases.
4. Databases: Amazon DynamoDB, Amazon Aurora, and Amazon OpenSearch Service.
5. Guardrails, tool gateway, identity, and observability.

There are options to suit any use case or budget, but how do you decide which combination is the right fit for your startup? AWS Startup Advisor simplifies the decision, analyzing your workload and recommending an architecture across the agent stack.

If you have an existing agent, the challenge is slightly different: how do you move what you already have to AWS without rebuilding it unnecessarily? Memory, guardrails, tools, and other parts of an agent can be tied to the platform they were built on, so migration may require changes across the stack. AWS Startup Advisor maps those components to AWS and identifies where changes are needed.

Here’s how it works:

• Start with your workload: Point AWS Startup Advisor at your idea, your local prototype, or your existing agent code and answer 10 to 15 adaptive questions.
• Get an architecture: AWS Startup Advisor produces a recommended architecture across the agent stack.
• Generate and deploy a POC: It generates a working POC, packaged for the recommended runtime and deployed to AWS, allowing you to validate the approach.
• Plan a migration: For existing agents, the output also includes source-to-target mapping, a total cost of ownership (TCO) comparison, and information about eligibility for AWS Credits.

AWS Startup Advisor takes you through six phases, using information from the code you provide and your answers to build a recommendation for your workload. We’ll discuss each of these phases in more detail further on, but here’s a quick overview:

1. Discover: Scans code and billing to detect models, frameworks, tools, orchestration, isolation, and spend.
2. Clarify: Asks 10 to 15 adaptive questions, skippable when already detected, each with a safe default so the flow never stalls.
3. Design: Selects runtime, deployment model, AgentCore capabilities, and Amazon Bedrock model.
4. Estimate: Estimates monthly AWS cost, and for a migration adds a side-by-side TCO comparison.
5. Generate: Produces Terraform, deployment configs, provider adapters, and migration scripts.
6. Prove: Deploys a working POC to a sandbox so the architecture is validated before production.

The flow produces three sets of artifacts, each with its own report:

• Recommendation: A layered recommendation doc and architecture diagram that picks the AWS runtime (AgentCore, AWS Lambda, Amazon ECS, Amazon EKS), deployment model, AgentCore capabilities, and Amazon Bedrock model, backed by a deterministic scoring engine.
• Migration plan (for existing workloads): A full migration guide with before and after code changes, provider-swap adapters (for example, OpenAI to Bedrock), IAM and setup scripts, an A/B test harness, and cost-monitoring Terraform.
• Deployable POC: Your own app, migrated and packaged for the recommended runtime (migrated source, container Dockerfile, one-command deploy.sh, README), ready to deploy to AWS.

Ask an LLM to suggest an agent architecture and you can get a plausible answer in seconds. However, this is often generic, inconsistent on AWS specifics, and untested against your workload.

Turning a suggestion into a deployable solution requires decisions about AWS services, configuration, costs, and how different components work together. AWS Startup Advisor is designed to take those workload-specific requirements into account when making recommendations.

The solution is grounded in AWS expertise, encoding how AWS startup experts design agent architectures across the verticals where startups actually build. This knowledge is drawn from years of watching which architectures hold up in production and which break under real traffic. The solution provides a workload-specific recommendation in under 15 minutes, a process that would usually take weeks.

To demonstrate what this looks like in practice, we used AWS Startup Advisor to migrate a research agent to AWS. The agent was built on a single LangGraph StateGraph with four in-process nodes (generate query, web research, reflection, finalize answer), backed by Google Gemini and Google Search, with a React frontend and a FastAPI backend.

The goal was to move it to AWS without rewriting the underlying agent framework. We invoked AWS Startup Advisor conversationally from the command line in Claude Code and followed the migration workflow from discovery through deployment.

Here’s what we got:

> can you help migrate my agent to AWS?

AWS Startup Advisor loads the migration skill and walks the six phases in order.

AWS Startup Advisor scans the workspace and produces a structured signal inventory in under a minute, so the recommendation is grounded in what the code actually does rather than what you remember it doing:

Detected signals:
- Framework: LangGraph + LangChain (single StateGraph 'pro-search-agent', 4 nodes)
- Multi-agent: Yes (generate_query -> web_research -> reflection -> loop -> finalize_answer)
- Model provider: Google Gemini (langchain-google-genai + google-genai)
- External tool: Google Search API (native grounding)
- Data stores: Redis 6 + Postgres 16 (LangGraph checkpointer/store)
- Frontend: React + Vite
- Trigger: request (React UI -> FastAPI/LangGraph backend)

AWS Startup Advisor pre-fills what it already detected (framework, multi-agent, model provider) and asks only what it cannot infer. Each question carries a safe default (the pre-filled answer it applies if you do not respond), so the flow never stalls. The questions are adaptive and multiple-choice:

Q1 - What matters most for the LLM model choice?
     (Gemini today; on AWS the natural target is Amazon Bedrock.)
     > A) Best quality / reasoning   B) Fastest speed   C) Lowest cost
     > D) Specialized capability     E) Balanced   [selected]

Q2 - How do you want to run the agent on AWS?
     > A) Fully managed (rebuild on the platform)
     > B) Bring my framework (run my existing code)   [selected, recommended]

Q3 - How long does a typical research task run end-to-end?
     > A) < 15 min   B) 15 min to 8 hr [selected]   C) > 8 hr

Q4 - How much of the ops do you want to own?
     > A) Minimal   B) Moderate [selected]   C) Full control

Q5 - What traffic shape do you expect?
     > A) Steady / continuous [selected]   B) Bursty / spiky   C) Rare

The remaining questions covered state model (stateful), cross-conversation memory (session-only), tenant isolation (nice to have), compliance (none), and region (single). Anything the code already answered was shown pre-filled, so this run took a handful of clicks, not a lengthy questionnaire.

AWS Startup Advisor does not hand back a menu of options; it makes one recommendation and explains why. A deterministic scoring engine first rules out runtimes that will not fit the workload, then ranks what remains on how the agent actually runs (session length, orchestration, traffic shape, ops preference, and existing infrastructure), and records why each was chosen or eliminated:

Runtime scores: AgentCore 44 | Lambda MicroVMs 41 | ECS 33 | EKS 28
Eliminated: Lambda Standard (15-min timeout cannot cover 15min-8hr sessions)

Recommendation: Amazon Bedrock AgentCore Runtime, framework on runtime
(bring the existing LangGraph code, adopt POST /invocations + GET /ping)
Model: Claude Sonnet 4.6 (balanced), with a tiered cascade after the migration
plan (Claude Haiku 4.5 for query generation and reflection, Claude Sonnet 4.6
for final synthesis)
Web search: AgentCore native Web Search replaces Google Search grounding

AWS Startup Advisor estimates monthly run cost at the workload's actual token volumes. For a migration it puts that cost side by side with current spend and a cost-optimized alternative, so the trade-off is explicit rather than buried.

AWS Startup Advisor writes the deployable artifacts: a layered recommendation doc and architecture diagram, a full migration guide with before-and-after code, provider-swap adapters, IAM and setup scripts, and cost-monitoring Terraform, each with its own HTML report. For the LangGraph model binding, the guide includes the exact change, which keeps the graph topology intact and swaps only the model client:

# Before: Gemini via langchain-google-genai
from langchain_google_genai import ChatGoogleGenerativeAI
llm = ChatGoogleGenerativeAI(model="gemini-2.5-pro", api_key=GEMINI_API_KEY)

# After: Claude on Amazon Bedrock via langchain-aws
from langchain_aws import ChatBedrockConverse
llm = ChatBedrockConverse(model="us.anthropic.claude-sonnet-4-6")

It also flagged the one change that is not a drop-in swap: Gemini did grounded search inside a single model call, so the web-research node has to be rewired as a tool-use step that calls AgentCore Web Search and feeds the results back into the graph, rather than a model-string change. The Advisor marks that node explicitly, so the larger change is visible rather than hidden.

Rather than stop at a plan, AWS Startup Advisor packaged the migrated app for AgentCore Runtime, built an ARM64 container from the pinned Python 3.11 image, pushed it to Amazon ECR, and stood up a live AgentCore Runtime endpoint. A smoke test then exercised the full loop end to end: endpoint -> LangGraph graph -> Bedrock Claude calls -> a cited answer.

Agent endpoint: READY
agentcore invoke '{"prompt": "..."}'
-> LangGraph pro-search-agent graph -> Bedrock Claude (Haiku) -> answer

The example above illustrates how AWS Startup Advisor can migrate an existing agent, but an agent is more than its model and framework. A migration covers the whole agent stack and can include runtime, memory, tools, identity, guardrails, observability, and data stores that support the application.

The solution takes each layer of the source stack and maps it to the AWS equivalent that best fits the workload, spanning:

• Runtime and orchestration: Maps supported source runtimes (Cloud Run, GKE, Heroku, Fly.io) and agent frameworks (LangGraph, CrewAI, AutoGen, OpenAI Agents SDK, Vertex AI) to AgentCore Runtime, Amazon ECS, Amazon EKS, or AWS Lambda.
• Models: Maps models such as GPT, Gemini, and Claude to models available on Amazon Bedrock, such as Claude, Nova, Llama, and DeepSeek.
• Memory and knowledge: Maps memory and checkpoints (OpenAI Threads, LangGraph), and vector stores (Pinecone, Chroma, Weaviate) to AgentCore Memory, Amazon Bedrock Knowledge Bases, and Amazon OpenSearch Service.
• Tools, guardrails, and identity: Maps function calling, moderation, and authentication to Amazon Bedrock AgentCore Gateway, Guardrails, and Identity, with Cognito for full user management and per-tenant isolation for multi-tenant apps.
• Observability and data stores: Maps LangSmith and custom logging to Amazon Bedrock AgentCore Observability, powered by Amazon CloudWatch; source datastores to DynamoDB, S3, and Aurora/RDS.

AWS Startup Advisor generates this complete per-layer mapping for your specific stack. It can also account for components you want to keep. For example, if you already use Temporal for durable execution, the solution recommends running AWS runtimes alongside it rather than requiring you replace it.

AWS Startup Advisor agent capabilities are available in your development environment at launch. Choose the entry point that best fits where you and your startup are today:

• Web: https://aws.amazon.com/aws-startups/advisor
• Kiro, VS Code, and Cursor: https://marketplace.visualstudio.com/items?itemName=AmazonWebServices.aws-startup-advisor
• Claude Code: https://claude.com/plugins/aws-startup-advisor

Once installed, open a conversation with AWS Startup Advisor and ask it to build or migrate your agent. It scans your code, asks a few questions, and returns a deployable architecture with the artifacts to match. Begin with your existing repository or describe the agent you want to build to get started.