GCP To AWS

Category F — AI/Bedrock (If ai-workload-profile.json Exists)

Fire when: ai-workload-profile.json exists in $MIGRATION_DIR/.

AI Context Summary

Before presenting questions, show:

AI Context Summary: AI source: [from summary.ai_source: "Gemini", "OpenAI", "Both", or "Other"] Profile origin: [from metadata.profile_source: if iac_vertex or summary.inferred_from_iac is true, state that Terraform was the primary signal and application code did not fully characterize the workload] Models detected: [from models[].model_id; if empty, say None inferred from code or IaC — the following questions will pin down models and frameworks] Capabilities in use: [from integration.capabilities_summary where true; if all false or pattern is unknown, say Not inferred — confirm below] Integration pattern: [from integration.pattern; if unknown, say Unknown (IaC-only)] via [from integration.primary_sdk, or not determined] Gateway/router: [from integration.gateway_type, or "None (direct SDK)"] Frameworks: [from integration.frameworks, or "None"]

Q14 — Framework auto-detection signals

Auto-detect signals — scan IaC and application code before asking:

Multi-Workload Confirmation Table (if workloads[] has ≥ 2 entries)

Fire when: ai-workload-profile.json contains a non-empty workloads[] array with 2 or more entries. This replaces the per-workload Q16–Q22 loop with a single confirmation table.

Before presenting Q16–Q22, show the detected workloads and proposed Bedrock targets:

Detected AI Workloads:

#	Model	SDK Method	Capability	Confidence	Proposed Bedrock Target
1	gemini-2.5-flash	generateContent	text_generation	medium	[text-class per Q16 priority]
2	gemini-2.5-flash	generateContent (structured)	structured_output	high	[same text-class as row 1]
3	imagen-3.0-generate-001	generateImages	image_generation	high	[image-class model]

For each row, you can:

• Accept — keep the proposed mapping

• Edit — change the capability or Bedrock target

• Drop — this isn't an AI workload (false positive)

(v1: merge and split actions are planned for v2)

Do you accept all mappings? Or type the row number to edit.

Timing: This table fires AFTER existing global/infra questions complete (Q1–Q15 and Q14–Q15 AI globals). It does not replace or conflict with the master Clarify orchestrator or PR #57 auto-extraction — those run first, and their answers feed into the capability confirmation.

Behavior:

1. High-confidence rows (confidence = high): Pre-fill Bedrock target from capability → Bedrock model mapping. Do NOT ask Q16–Q22 for these rows unless the user edits.

2. Medium/low-confidence rows: Ask at most 2 questions per row:

   • "Is the detected capability correct?" (confirm or select from: text_generation, structured_output, image_generation, embedding, speech_to_text, text_to_speech, unknown)

   • "What matters most for this workload?" (Q16 priority: quality/speed/cost/balanced)

3. Target mapping (default, overridden by user edits — look up actual model IDs from design-refs tables, not hardcoded names):

   Capability	Target Class	Notes
   text_generation	Text/reasoning class	Apply Q16–Q19 override hierarchy
   structured_output	Text/reasoning class (same as text_generation)	Uses same Bedrock target as text_generation for that workload's priority tier — structured output is a mode, not a different model
   image_generation	Image generation class	e.g., Nova Canvas
   embedding	Embedding class	e.g., Titan Embed Text v2
   speech_to_text	Speech-to-text class	e.g., Transcribe
   text_to_speech	Text-to-speech class	e.g., Polly
   unknown	Ask Q16–Q22 for this workload	Falls back to full questionnaire

4. After confirmation — persist workloads[] to preferences.json (REQUIRED):

   Immediately after the user confirms (accepts all, or finishes editing individual rows), write the final workloads[] array to preferences.json. This is the single source of truth for all downstream phases (Design, Estimate, Generate). Do NOT rely on ai-workload-profile.json downstream — it contains the raw Discover output before user edits/drops.

   Write rules:

   • Read existing preferences.json (preserving all non-AI fields written by earlier Clarify categories)

   • Add or overwrite the top-level workloads key with the confirmed array

   • Each entry MUST include: workload_id, model_id, sdk_method, capability, capability_confidence, structured_output, call_sites, target_bedrock_model, and the user's priority/latency_tier selections (use defaults "balanced"/"standard" for high-confidence rows that were auto-accepted)

   • Dropped rows are excluded from workloads[] — they do not appear

   • Write the file atomically (write to .tmp, then rename) to prevent partial writes on failure

   • If write fails: STOP. Output: "Failed to persist workloads to preferences.json — do not proceed to Design."

   Single-workload case: If only 1 workload exists (confirmation table skipped), persist it to workloads[] after Q16–Q22 completes, using the same schema. Design always reads workloads[] regardless of count.

   Zero-workload case: If no AI workloads detected and user doesn't report any, write "workloads": [] to preferences.json. Design emits empty design_blocks[] for this case.

5. Question budget: 4 global questions (Q14, Q15, framework, spend) + at most 2 per medium/low workload. For an app with 3 high-confidence workloads: 4 questions total, 0 per-workload. For an app with 2 high + 1 medium: 4 + 2 = 6 questions max.

Single-workload fallback: If workloads[] has exactly 1 entry or is empty, skip the confirmation table and proceed with the existing Q16–Q22 flow below.

Known limitations (v1):

• Gateway calls (LiteLLM, OpenRouter) and custom HTTP calls to AI endpoints are not yet detected as separate workloads — they may be miscategorized or missed. Planned for v2.

• Merge and split actions are not supported in v1. Users who need to combine or split workloads should edit individual rows.

Q14 — What AI framework or orchestration layer are you using? (select all that apply)

Auto-detect signals — scan IaC and application code before asking:

• No AI framework imports, raw HTTP calls to OpenAI/Gemini endpoints → A

• LiteLLM imports or config files → B

• OpenRouter base URL in code/config → B

• PortKey, Helicone, Martian SDK imports → B

• Kong AI Gateway, Apigee AI config files → B

• Custom proxy class wrapping the AI client → B

• LangChain/LangGraph imports → C

• LangChain/LlamaIndex with provider-agnostic model config → C

• CrewAI imports, Crew and Agent class definitions → D

• AutoGen imports, ConversableAgent patterns → D

• Custom multi-agent loop with dispatcher logic → D

• OpenAI Agents SDK / Swarm imports → E

• Custom while-loop agent with tool-call parsing → E

• mcp.server / mcp.client imports, MCP config JSON files → F

• A2A protocol config or SDK imports → F

• Vapi, Bland.ai, Retell SDK imports → G

• Nova Sonic / Nova 2 Sonic or Whisper integration in code → G

Skip when: Auto-detection fully resolves the framework(s). Use detected value(s) with chosen_by: "extracted".

How your AI calls reach the model determines migration effort. Gateway users can often migrate by changing a single config line.

A) No framework — direct API calls to OpenAI/Gemini B) LLM router/gateway (LiteLLM, OpenRouter, PortKey, Kong, Apigee) C) LangChain / LangGraph D) Multi-agent framework (CrewAI, AutoGen, custom) E) OpenAI Agents SDK / custom agent loop F) MCP servers or A2A protocol G) Voice/conversational agent platform (Vapi, Retell, Bland.ai)

(Multiple selections allowed)

Combination Logic

If answer includes B and no other selections, skip or abbreviate SDK migration steps. If answer is A only, proceed with standard model migration flow.

Interpret → ai_framework array (multiple selections → array of all selected values). Default: auto-detect from code, fallback ["direct"].

Q15 — Approximately how much are you spending on OpenAI or Gemini per month?

A) < $500/month B) $500–$2,000/month C) $2,000–$10,000/month D) > $10,000/month E) I don't know

Activate eligibility (Founders & Portfolio): Pre-Series B, founded in the last 10 years, AWS Account on Paid Tier Plan, and either new to Activate Credits or requesting more credits than previously received.

Interpret → ai_monthly_spend. Default: B → "$500-$2K".

Q16 — What matters most for your AI workloads?

Present with concrete anchors: Quality = legal analysis/code gen; Speed = autocomplete/live chat; Cost = classification/tagging at scale; Specialized = specific feature (→ Q17); Balanced = all-rounder.

A) Best quality/reasoning — accuracy matters most, willing to pay more B) Fastest speed — response time is the primary constraint C) Lowest cost — high volume, budget tight, good-enough quality at scale D) Specialized capability — rely on a specific feature (covered in Q17) E) Balanced — no single dimension dominates F) I don't know

Interpret → ai_priority. Default: E → "balanced".

Q17 — What is your MOST CRITICAL specialized AI feature?

A) Function calling / Tool use B) Ultra-long context (> 300K tokens) C) Extended thinking / Chain-of-thought D) Prompt caching E) RAG optimization F) Agentic workflows G) Real-time speed (< 500ms) H) Multimodal with image generation I) Real-time conversational speech J) None — standard features are sufficient

Interpret → ai_critical_feature. Default: J → no override.

Q18 — What's your AI usage volume and cost tolerance?

A) Low volume + quality priority — small-scale, quality matters most B) Medium volume + balanced — moderate production use, balanced approach C) High volume + cost critical — high scale, budget is tight, need cost control

Interpret → ai_token_volume: A → "low", B → "medium", C → "high". Default: A → "low".

Q19 — Which Gemini or OpenAI model are you currently using?

Auto-detect signal: If ai-workload-profile.json exists and models[0].model_id is set with detection confidence ≥ 0.8, map to the matching Q19 answer and skip Q19. Set ai_model_baseline with chosen_by: "extracted". If multiple models detected with similar confidence, ask Q19.

Skip when: Primary model fully resolved from discovery. Use detected value with chosen_by: "extracted".

Establishes baseline Bedrock recommendation. Override hierarchy: Q17 special features (hard override) > Q16 priority > Q18/Q21 volume and latency > Q19 source model (baseline only).

A) Gemini 3.5 Flash (GA — current flagship Flash model) B) Gemini 3.5 Flash Thinking (thinking budget enabled) C) Gemini 3.1 Pro D) Gemini 3.1 Flash-Lite (high-volume, low-cost) E) Gemini 2.5 Flash (standard, no thinking budget) F) Gemini 2.5 Flash Thinking (thinking budget enabled — variable output pricing) G) Gemini 2.5 Pro H) Gemini 3 Pro / 3.1 Pro Preview I) Gemini Flash (2.0 Flash) or Gemini Flash 1.5 (EOL Sep 2025 — flag for source model upgrade) J) Gemini Pro 1.5 (EOL Sep 2025 — flag for source model upgrade) K) GPT-3.5 Turbo L) GPT-4 / GPT-4 Turbo M) GPT-4o N) GPT-5.4 / GPT-5.4 Mini / GPT-5.4 Nano O) GPT-5 / GPT-5.x (older) P) GPT-5.5 / GPT-5.5 Pro Q) o-series (o1, o3) R) Other / Multiple models S) I don't know

Override examples: GPT-4 + Q16=cost → Haiku; Flash + Q17=extended thinking → Sonnet; GPT-4o + Q17=speech → Nova 2 Sonic; GPT-3.5 + Q22=complex → Sonnet; GPT-5 + Q16=balanced → Sonnet; GPT-5.5 + Q16=cost → Sonnet 4.6; Gemini 2.5 Flash Thinking + Q16=cost → Nova Lite (if thinking budget is low) or Sonnet 4.6 (if full thinking mode).

Interpret → ai_model_baseline. Default: auto-detect from code, fallback Q16 priority-based.

Q20 — What input types must the model accept: text only, images (vision), or audio/video?

Auto-detect signal: Read integration.capabilities_summary:

Skip when: Modalities fully resolved from capabilities_summary. Use detected value with chosen_by: "extracted".

A) Text only B) Vision required — model must process images C) Audio/Video inputs needed

Interpret → ai_vision. Default: A → no constraint.

Q21 — How important is AI response speed?

Present with concrete anchors: Critical = autocomplete/live chat/real-time transcription; Important = chat assistant/search augmentation; Flexible = report generation/batch analysis.

A) Critical (< 500ms) — users staring at a loading spinner B) Important (< 2s) — quick response expected, brief pause acceptable C) Flexible (2–10s) — users can wait, background/async acceptable

Interpret → ai_latency. Default: B → "important".

Q22 — How complex are your AI tasks?

Present with concrete examples: Simple = classify/extract/summarize; Moderate = analyze+JSON/few-shot; Complex = multi-turn reasoning/tool use/agentic.

A) Simple (classification, short summaries, extraction) B) Moderate (analysis, structured content, few-shot) C) Complex (multi-step reasoning, tool use, agentic workflows)

Interpret → ai_complexity. Default: B → "moderate".

Category G — Agentic Workflows (If agentic_profile exists in ai-workload-profile.json)

Fire when: ai-workload-profile.json contains agentic_profile with is_agentic: true.

Skip entirely when: agentic_profile is absent from ai-workload-profile.json.

Agentic Context Summary

Before presenting Category G questions, show:

Agentic Context Summary: Framework: [from agentic_profile.framework] Agents detected: [from agentic_profile.agent_count] ([list agents[].agent_id]) Orchestration pattern: [from agentic_profile.orchestration_pattern] Tools: [from agentic_profile.tool_count] tools detected Memory: [from agentic_profile.has_memory; if true, backend: agentic_profile.memory_backend] Human-in-the-loop: [from agentic_profile.has_human_in_loop]

Q23 — How do you want to migrate your agent system?

Auto-detect signals — recommend default based on agentic_profile.framework:

• gateway_type is "llm_router" (LiteLLM or OpenRouter detected) → Default to A (retarget). These users are already abstracted from the model provider — migration is a config change (swap model IDs), not a code rewrite. Set migration_approach: "retarget" automatically and skip Q23 unless the user explicitly asks to evaluate Harness or Strands.

• langgraph, crewai, autogen → Default to A (retarget). These frameworks support Bedrock as a model provider with minimal code changes.

• openai_agents → Surface all options. OpenAI Agents SDK is tightly coupled to OpenAI API; retarget is harder. Note partial retarget (HTTP-compatible routing to Bedrock) as a bridge.

• strands → Already AWS-native. Recommend B (Harness) for managed deployment or note "already on target framework."

• custom → Surface all options. Custom loops vary widely in complexity.

Skip when: Auto-detection fully resolves AND user has no preference signal. Use detected default with chosen_by: "extracted".

Your agent system can migrate to AWS in different ways, each with different effort and risk:

A) Retarget — Keep your current framework ([framework name]), swap the model layer to Bedrock. Fastest path, lowest risk. Your orchestration code stays the same. B) AgentCore Harness — Declare your agent as configuration (model + tools + prompt). Get managed runtime, memory, identity, and observability. Good for simpler agents or incremental migration. (Preview — 4 regions: us-east-1, us-west-2, eu-central-1, ap-southeast-2) C) Strands native — Rewrite orchestration using AWS Strands SDK on AgentCore. Most AWS-integrated, highest effort. Best for teams wanting full AWS-native multi-agent capabilities. D) I'm not sure — Help me decide based on my workload.

For OpenAI Agents SDK users: Note that a partial retarget (HTTP-compatible routing to Bedrock while keeping OpenAI SDK orchestration) is a valid short-lived bridge before committing to B or C. This is not a fourth path — it's a Phase 0 step within B or C.

If answer is D: Recommend A (retarget) as default for LangGraph/CrewAI/AutoGen users. Recommend B (Harness) for OpenAI Assistants or simple single-agent patterns. Recommend C (Strands) only if user explicitly wants AWS-native multi-agent and accepts refactor cost.

Interpret → ai_constraints.agentic.migration_approach: A → "retarget", B → "harness", C → "strands", D → "undecided" (treated as "retarget" in Design unless overridden). Default: auto-detect based on framework.

Q24 — Do your agents need to remember context across sessions?

A) No — each request is independent, no memory needed B) Within a session — conversation history during a single interaction, but fresh start each time C) Across sessions — remember user preferences, past interactions, accumulated knowledge between separate conversations

Interpret → ai_constraints.agentic.memory_requirement: A → "none", B → "session", C → "cross_session". Default: B → "session".

Q25 — How long do your agent tasks typically run?

A) Quick (< 30 seconds) — simple tool calls, single-turn responses B) Medium (30 seconds – 5 minutes) — multi-step reasoning, several tool calls C) Long (5 minutes – 1 hour) — complex research, multi-agent collaboration, iterative refinement D) Very long (1+ hours) — extended autonomous work, large-scale data processing

Interpret → ai_constraints.agentic.task_duration: A → "quick", B → "medium", C → "long", D → "very_long". Default: B → "medium".

Q26 — Do you want to migrate incrementally?

A) Yes — run my existing models (OpenAI/Gemini) on AWS infrastructure first, then swap to Bedrock models later when I'm confident B) No — do a full model swap to Bedrock in one go C) I'm not sure

Interpret → ai_constraints.agentic.incremental_migration: A → true, B → false, C → auto-select based on migration_approach. Default: true for Harness path, false for retarget path.

Category G Combination Logic

Category H — Startup Programs (Always fires when Category F fires)

Fire when: ai-workload-profile.json exists (same trigger as Category F). Ask once, after Q26 if agentic, or after Q22 if non-agentic.

Q27 — Have you applied for AWS Activate credits?

Rationale: AWS Activate credits apply directly to Bedrock usage (including Claude, Llama, Nova, and other third-party models). Surfacing eligibility at the migration decision moment helps startups reduce the cost of the migration itself. This takes 30 seconds to answer and can unlock $5K–$200K in credits.

Activate eligibility: Pre-Series B, founded in the last 10 years, AWS Account on Paid Tier Plan, and either new to Activate Credits or requesting more credits than previously received.

AWS Activate credits offset Bedrock costs during and after migration — including Claude, Llama, and Nova models. Eligible startups can get $5K–$200K depending on funding stage.

A) Yes — already have AWS Activate credits B) No — haven't applied yet (self-funded or pre-VC) C) No — VC/accelerator-backed but haven't applied D) I don't know

If ai_monthly_spend is ">$10K": also flag AWS Credits for AI Startups ($200,000+, invite-only for startups ready to scale post-Activate-Portfolio — contact your AWS Account Manager; aws.amazon.com/startups/credits).

If ai_monthly_spend is "$2K-$10K" or ">$10K" AND agentic_profile.is_agentic == true: also flag AWS Generative AI Accelerator (up to $1M credits, 8-week cohort — adjacent cohort program, distinct from the credits-hub funnel): aws.amazon.com/startups/generative-ai/accelerator

Interpret → startup_program_status: A → "has_credits", B → "eligible_founders", C → "eligible_portfolio", D → "unknown". Default: D → "unknown".

Preferences Output — ai_constraints.agentic

Category G answers are stored in preferences.json → ai_constraints.agentic:

{
  "ai_constraints": {
    "agentic": {
      "migration_approach": "retarget|harness|strands|undecided",
      "memory_requirement": "none|session|cross_session",
      "task_duration": "quick|medium|long|very_long",
      "incremental_migration": true
    }
  }
}

Field contract (consumed by Design phase):

• migration_approach — Routes Design to the correct path: "retarget" uses existing model-swap flow, "harness" loads design-ref-harness.md, "strands" loads design-ref-agentic-to-agentcore.md

• memory_requirement — Determines whether AgentCore Memory is included in design

• task_duration — Determines AgentCore Runtime recommendation and session limit warnings

• incremental_migration — Determines whether incremental migration artifacts are generated