GCP To AWS

_fragment: ai _of_phase: clarify _contributes:

• preferences.json (ai_constraints section, startup_constraints.startup_program_status)

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

Fragment unit. See clarify.md for how it is composed into the phase.

This fragment asks nothing on the wizard path. It reads the AI workload profile, resolves what it can, assigns a disposition per row, and returns rows. clarify-assemble.md presents them. (The "ask me everything" Full Flow variant in clarify.md presents these questions directly in batches — see that file — because the user explicitly opted out of the sheet-first wizard.)

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

No canonical shared file governs this category — azure-to-aws's clarify-ai.md asks a closely parallel but independently-maintained question set for the same reason clarify-ai-only.md on both skills does: AI/Bedrock model selection, capability matching, and agentic-framework questions are close in shape between GCP and Azure sources, but every answer option and consequence line here was authored against GCP-sourced signals (ai-workload-profile.json's integration.pattern/gateway_type, Vertex/Gemini detection). Unifying this category into a shared file is future scope, not part of this restructure — see references/vendored/clarify/ for the categories that already are shared (region, compliance, availability, cost-appetite, multi-cloud).

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 primary Clarify orchestrator or its 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, document_extraction, image_analysis, speech_transcription, 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., Stable Image Core (cost) / Ultra (quality)
   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
   document_extraction	Traditional-AI (non-LLM) class	GCP Document AI detected — no Q16–Q22 questions; routes to Design's ai.md rubric (Textract / Bedrock Data Automation), not a Bedrock model pick
   image_analysis	Traditional-AI (non-LLM) class	GCP Vision API detected — no Q16–Q22 questions; routes to Design's ai.md rubric (Rekognition / Bedrock Data Automation), not a Bedrock model pick
   speech_transcription	Traditional-AI (non-LLM) class	GCP Speech-to-Text detected — no Q16–Q22 questions; routes to Design's ai.md rubric (Transcribe / Bedrock Data Automation), not a Bedrock model pick
   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 → 1

• LiteLLM imports or config files → 2

• OpenRouter base URL in code/config → 2

• PortKey, Helicone, Martian SDK imports → 2

• Kong AI Gateway, Apigee AI config files → 2

• Custom proxy class wrapping the AI client → 2

• LangChain/LangGraph imports → 3

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

• CrewAI imports, Crew and Agent class definitions → 4

• AutoGen imports, ConversableAgent patterns → 4

• Custom multi-agent loop with dispatcher logic → 4

• OpenAI Agents SDK / Swarm imports → 5

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

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

• A2A protocol config or SDK imports → 6

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

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

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

Partial detection — confirm, don't re-ask (preferred over the full taxonomy): When detection produced signals but not full resolution (e.g. one framework import found alongside unexplained raw HTTP calls), present a confirm card instead of the full option list:

I detected [framework, e.g. LangChain] ([evidence, e.g. langchain in requirements.txt]) — plus some direct API calls I couldn't attribute.

1. That's right — LangChain plus some direct calls

2. Edit — show me all framework options

3. Just [detected framework] — the direct calls are part of it

Accept → record detected value(s) with chosen_by: "user" (confirmed). Edit → fall through to the full question below. Only present the full taxonomy cold when detection found no signals at all.

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

1. No framework — direct API calls to OpenAI/Gemini

2. LLM router/gateway (LiteLLM, OpenRouter, PortKey, Kong, Apigee)

3. LangChain / LangGraph

4. Multi-agent framework (CrewAI, AutoGen, custom)

5. OpenAI Agents SDK / custom agent loop

6. MCP servers or A2A protocol

7. Voice/conversational agent platform (Vapi, Retell, Bland.ai)

(Multiple selections allowed)

Never recommend classic Bedrock Agents (bedrock-agent) as a migration target. It is in maintenance mode and closed to new customers as of July 30, 2026 (AWS announcement). Agentic targets are AgentCore Harness (config-based, default) or AgentCore Runtime (code-defined loops) — consistent with Q23–Q26.

Combination Logic

If answer includes 2 and no other selections, skip or abbreviate SDK migration steps. If answer is 1 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 your AI/LLM providers per month?

Personalize the wording: substitute the detected provider names from ai-workload-profile.json → models[].provider when available (e.g. "on OpenAI" or "on OpenAI and Gemini, per your detected usage"). Do not assume providers the profile did not detect.

1. < $500/month

2. $500–$2,000/month

3. $2,000–$10,000/month

4. $10,000/month

5. I don't know

Do not map spend bands to AWS Activate Founders vs Portfolio. Funding stage is not inferable from monthly AI spend — ask Q27 instead.

Interpret → ai_monthly_spend. Default: 2 → "$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.

1. Best quality/reasoning — accuracy matters most, willing to pay more

2. Fastest speed — response time is the primary constraint

3. Lowest cost — high volume, budget tight, good-enough quality at scale

4. Specialized capability — rely on a specific feature (covered in Q17)

5. Balanced — no single dimension dominates

6. I don't know

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

Q17 — What is your MOST CRITICAL specialized AI feature?

1. Function calling / Tool use

2. Ultra-long context (> 300K tokens)

3. Extended thinking / Chain-of-thought

4. Prompt caching

5. RAG optimization

6. Agentic workflows

7. Real-time speed (< 500ms)

8. Multimodal with image generation

9. Real-time conversational speech

10. None — standard features are sufficient

Interpret → ai_critical_feature. Default: 10 → no override.

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

Volume half auto-resolves: If openai-usage-profile.json, openrouter-usage-profile.json, and/or anthropic-usage-profile.json exists with non-zero usage AND (for each profile that exists) metadata.partial_window is false (a partial window is not a monthly volume for that profile — fall through to asking normally if EVERY existing profile is partial), derive the volume tier from the SUM across every full-window profile of Σ usage_by_model[].input_tokens + output_tokens — for openrouter-usage-profile.json, that means prompt_tokens + completion_tokens (OpenRouter's field names; normalize before summing, do not treat a missing input_tokens key as zero-and-move-on) — Anthropic's usage_by_model[] already uses input_tokens/output_tokens (same field names as OpenAI, no normalization needed for those two), but ALSO carries cache_read_tokens/cache_creation_tokens, which MUST be added into this sum (the opposite of the OpenRouter reasoning_tokens case: Anthropic's input_tokens field is populated from the Admin API's uncached_input_tokens, which by definition excludes cached tokens — omitting the two cache fields would understate volume, not double-count it; see estimate-ai.md's Prerequisites section for the full uncached_input_tokens + cache_read_input_tokens + cache_creation_input_tokens contract) — (< 1M → "low", 1–10M → "medium", > 10M → "high") and ask ONLY the cost-tolerance half ("Your usage data shows [tier] volume. Is budget tight enough to prioritize cost control over model quality? [Y/N]"). Record ai_token_volume from the data (chosen_by: "extracted", source: "openai-usage-profile:usage_by_model" and/or "openrouter-usage-profile:usage_by_model" and/or "anthropic-usage-profile:usage_by_model", whichever contributed), not the answer. Reading only one profile when more than one exists and is full-window understates the tier — e.g. a workload with 1M/0.1M tokens direct plus 9M/0.9M via OpenRouter is "medium" (10M total), not "low" (1M from OpenAI alone); a third Anthropic profile sums in exactly the same way. Also add a full-window gcp-publisher-metrics-profile.json (input_tokens + output_tokens only; do not add cache-write tokens). A partial_window publisher profile is not monthly volume. Name it in source as gcp-publisher-metrics-profile:usage_by_model. Batch and spillover rows still count in this monthly sum. A 100k-token direct profile plus 20M publisher tokens is "high", not "low".

1. Low volume + quality priority — small-scale, quality matters most

2. Medium volume + balanced — moderate production use, balanced approach

3. High volume + cost critical — high scale, budget is tight, need cost control

Interpret → ai_token_volume: 1 → "low", 2 → "medium", 3 → "high". Default: 1 → "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. If openai-usage-profile.json, openrouter-usage-profile.json, and/or anthropic-usage-profile.json exists, prefer the top model by token volume across ALL profiles combined (normalizing OpenRouter's prompt_tokens/completion_tokens before ranking, and summing Anthropic's input_tokens + cache_read_tokens + cache_creation_tokens + output_tokens — including the cache fields, which are additional volume, not a sub-accounting of input_tokens — do not rank by usage_by_model[0] from just one profile when more than one exists, since that profile's own #1 may not be the combined #1) as the baseline — billed usage is stronger evidence than code detection — and mention the runner-up models to the user rather than re-asking.

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

Partial detection — confirm, don't re-ask: When models were detected but below the confidence bar, or several tie, present a confirm card listing only the detected candidates — never the full catalog:

I found [model_id 1] and [model_id 2] in your code. Which is your primary production model?

1. [model_id 1]

2. [model_id 2]

3. Something else — show all options

Cold path — family first, then branch: When nothing was detected, do NOT present the full option list below in one message. Ask a short family question first — "Which provider family is your primary model? 1. Gemini 2. OpenAI GPT 3. OpenAI o-series (reasoning) 4. Other / not sure" — then present only the matching subset of the options below. The full list remains the reference catalog for interpretation.

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

Same-model availability outranks Q16. When Q19 identifies a model that is available on Bedrock (GPT-6 Astra, GPT-6 Sol, GPT-6 Luna, GPT-6.1 Sol, GPT-6.1 Terra, GPT-5.6 Sol / Terra / Luna, GPT-5.5, GPT-5.4 — see references/shared/openai-on-bedrock.md), the recommendation is that same model, and a balanced/unset Q16 must not move it to another family. Q16 = cost adds a cheaper alternative alongside it rather than replacing it. Only a Q17 hard feature override the source model cannot serve displaces it.

1. Gemini 3.5 Flash (GA — current flagship Flash model)

2. Gemini 3.5 Flash Thinking (thinking budget enabled)

3. Gemini 3.1 Pro

4. Gemini 3.1 Flash-Lite (high-volume, low-cost)

5. Gemini 2.5 Flash (standard, no thinking budget)

6. Gemini 2.5 Flash Thinking (thinking budget enabled — variable output pricing)

7. Gemini 2.5 Pro

8. Gemini 3 Pro / 3.1 Pro Preview

9. Gemini Flash (2.0 Flash) or Gemini Flash 1.5 (EOL Sep 2025 — flag for source model upgrade)

10. Gemini Pro 1.5 (EOL Sep 2025 — flag for source model upgrade)

11. GPT-3.5 Turbo

12. GPT-4 / GPT-4 Turbo

13. GPT-4o

14. GPT-5.4 / GPT-5.4 Mini / GPT-5.4 Nano

15. GPT-5 / GPT-5.x (older)

16. GPT-5.5 / GPT-5.5 Pro

17. o-series (o1, o3)

18. GPT-5.6 Sol / Terra / Luna

19. GPT-6 Astra / Sol / Luna / 6.1 Sol / 6.1 Terra

20. Other / Multiple models

21. 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; Gemini 2.5 Flash Thinking + Q16=cost → evaluate Nova Lite only if it meets the required capabilities and quality bar; do not select Sonnet 5 for expected savings solely because the source uses full thinking mode.

Same-model examples (Q16 does not displace these): GPT-5.5 + Q16=balanced → GPT-5.5 on Bedrock; GPT-5.5 + Q16=cost → GPT-5.5 on Bedrock, with Sonnet 5 offered as a 68%-cheaper alternative the user can accept or decline; GPT-5.6 Luna + Q16=cost → Luna on Bedrock as the same-model default, with Haiku 5.5 offered as a cost alternative the user can accept or decline (at equal billed volumes and 2:1 input/output, US Geo Haiku is 56.25% cheaper up to 100K prompt tokens; Luna is 54.29% cheaper above 100K while Luna remains within 272K; recount each model's tokens, and present both Haiku tiers if request size is unknown); GPT-5.4 + Q17=speech → Nova 2 Sonic (Q17 hard override wins — the source model cannot serve speech-to-speech).

Claude Sonnet 5 figures use $2/$10 — the launch rate, made the standard price on Sep 1, 2026 (the scheduled increase to $3/$15 was cancelled). Earlier revisions priced Sonnet 5 at $3/$15; any cached estimate built on that rate overstates Sonnet 5 by a third.

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".

1. Text only

2. Vision required — model must process images

3. Audio/Video inputs needed

Interpret → ai_vision. Default: 1 → 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.

1. Critical (< 500ms) — users staring at a loading spinner

2. Important (< 2s) — quick response expected, brief pause acceptable

3. Flexible (2–10s) — users can wait, background/async acceptable

Interpret → ai_latency. Default: 2 → "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.

1. Simple (classification, short summaries, extraction)

2. Moderate (analysis, structured content, few-shot)

3. Complex (multi-step reasoning, tool use, agentic workflows)

Interpret → ai_complexity. Default: 2 → "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" and evidence is LiteLLM → Default to 1 (retarget). 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.

• gateway_type is "llm_router" and evidence is OpenRouter → Default to 1 (retarget) only when the underlying model is an OpenAI model with a Mantle target (same-model Mantle move, per design-ai.md's OpenRouter guidance). Otherwise surface the full option set — an OpenRouter → Mantle move changes the base URL, credential type, and model-ID format, so it is not the same one-line change LiteLLM users get. Set migration_approach: "retarget" with chosen_by: "extracted" only in the Mantle-eligible case; otherwise ask Q23.

• langgraph, crewai, autogen → Default to 1 (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 2 (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:

1. Retarget — Keep your current framework ([framework name]), swap the model layer to Bedrock. Fastest path, lowest risk. Your orchestration code stays the same.

2. AgentCore Harness — Declare your agent as configuration (model + tools + prompt). Get managed runtime, memory, identity, and observability. Good for simpler agents or incremental migration. (GA — all commercial regions where AgentCore is available)

3. 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.

4. 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 2 or 3. This is not a fourth path — it's a Phase 0 step within 2 or 3.

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

Interpret → ai_constraints.agentic.migration_approach: 1 → "retarget", 2 → "harness", 3 → "strands", 4 → "undecided" (treated as "retarget" in Design unless overridden). Default: auto-detect based on framework.

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

1. No — each request is independent, no memory needed

2. Within a session — conversation history during a single interaction, but fresh start each time

3. Across sessions — remember user preferences, past interactions, accumulated knowledge between separate conversations

Interpret → ai_constraints.agentic.memory_requirement: 1 → "none", 2 → "session", 3 → "cross_session". Default: 2 → "session".

Q25 — How long do your agent tasks typically run?

1. Quick (< 30 seconds) — simple tool calls, single-turn responses

2. Medium (30 seconds – 5 minutes) — multi-step reasoning, several tool calls

3. Long (5 minutes – 1 hour) — complex research, multi-agent collaboration, iterative refinement

4. Very long (1+ hours) — extended autonomous work, large-scale data processing

Interpret → ai_constraints.agentic.task_duration: 1 → "quick", 2 → "medium", 3 → "long", 4 → "very_long". Default: 2 → "medium".

Q26 — Do you want to migrate incrementally?

1. Yes — run my existing models (OpenAI/Gemini) on AWS infrastructure first, then swap to Bedrock models later when I'm confident

2. No — do a full model swap to Bedrock in one go

3. I'm not sure

Interpret → ai_constraints.agentic.incremental_migration: 1 → true, 2 → false, 3 → 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). Q27 is ESSENTIAL in wizard mode — ask in the Step 4 essentials batch after Q15 (and after Q26 if agentic). Do not place Q27 on the assumption sheet; funding stage cannot be defaulted from spend.

Q27 — Have you applied for AWS Activate credits?

Presentation: Ask Q27 as its own short follow-up after the technical AI essentials are answered — not mixed into the same numbered batch. It is a funding question, not a technical one; separating it keeps the technical batch focused and makes clear that skipping it never affects the architecture (only the credits guidance). One-line lead-in: "Last one, and it's about money rather than tech:".

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.

1. Yes — already have AWS Activate credits

2. No — haven't applied yet (self-funded or pre-VC)

3. No — VC/accelerator-backed but haven't applied

4. 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: 1 → "has_credits", 2 → "eligible_founders", 3 → "eligible_portfolio", 4 → "unknown". Default: 4 → "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 vendored/ai/design-ref-harness.md, "strands" loads vendored/ai/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

Status — build step 5 (restructure)

Implemented. Frontmatter and fragment framing added for consistency with the other clarify-*.md fragments; no change to firing rules, question text, defaults, or interpretation. The wizard path's presentation moved to clarify-assemble.md; the Full Flow ("ask me everything") variant continues to present these questions directly, unchanged, as documented in clarify.md.