• Developer wants to build an agent on AWS and doesn't know where to start
• Developer wants to create a new AgentCore project
• Developer is choosing between frameworks (Strands, LangGraph, GoogleADK, OpenAI Agents)
• Developer just ran

  agentcore create

  and wants to know what to do next

• Environment/prerequisite issues (CLI not found, credentials broken) → use

  agents-debug

• Adding capabilities to an existing project (memory, tools, policies) → use

  agents-build

  or

  agents-connect

• Migrating an existing Bedrock Agent → use

  agents-build

  (loads

  references/migrate.md

  )

$ARGUMENTS

• A framework preference: "using LangGraph", "with Strands"
• A protocol: "MCP server", "A2A"
• A description of what the agent should do: "a customer support agent"
• Empty — the skill will guide framework selection

agentcore --version

Your AgentCore CLI is out of date (found vX.Y.Z, need v0.9.0+).

agentcore update

agentcore

The AgentCore CLI isn't installed. Run

npm install -g @aws/agentcore

(requires Node.js 20+). If you're having trouble with installation, I can run the

agents-debug

skill (which loads

references/doctor.md

) to diagnose your environment.

• Exploring → Go to Step 2 (framework comparison). Present the options, answer questions, and wait. Do not construct a

  create

  command until they signal they're ready.
• Ready to create → Skip to Step 3 (create the project). If they already specified a framework, skip Step 2 entirely.
• Already has a project → Look for

  agentcore/agentcore.json

  in the current directory. If found, read it and skip to Step 5 (what to do next). Don't re-scaffold.

$ARGUMENTS

Strands

LangChain_LangGraph

GoogleADK

OpenAIAgents

Note on naming: The CLI flag value is the exact string to pass to

--framework

. In prose use the shorter names.

• "Do you have existing agent code in LangGraph or OpenAI Agents?" → use that framework
• "Do you need complex graph-based workflows with conditional branching?" → LangGraph
• "Starting fresh with no preference?" → Strands

POST /invocations

GET /ping

1. agentcore create --name <ProjectName> --defaults

   to scaffold the project structure

2. agentcore add agent --type byo --build Container --language <Language> --code-location <path>

   to register your code
3. Write a

   Dockerfile

   that builds and runs your agent

4. agentcore deploy

   handles ECR push, CDK infra, and runtime creation

--language Other --build Container

--language TypeScript --build Container

--language Other --build Container

• Strands + Bedrock (default) — AWS-native everything
• Strands + Anthropic — Strands orchestration, direct Anthropic API for the model
• LangGraph + Bedrock — LangGraph orchestration, Bedrock for the model
• OpenAI Agents + OpenAI — OpenAI everything

agentcore create

• Length ≤ 23 characters (this is shorter than most developers assume —

  MyCustomerSupportAgent

  is 22 chars and fits;

  CustomerSupportChatbot

  is 22 and fits;

  MyCustomerSupportBotApp

  is 23 and just fits;

  MyCustomerSupportChatBot

  is 24 and fails)
• Alphanumeric only — no hyphens, underscores, dots, or spaces
• Must start with a letter

<suggestion>

Here's the command I'd recommend based on what you've told me:

bash

agentcore create --name MyAgent --framework Strands --model-provider Bedrock --build CodeZip --memory none

This creates a Strands agent using Bedrock models, deployed as a code zip (no Docker needed). Memory can be added later.

Want to run this, or change anything?

agentcore create --name <ProjectName> --defaults

agentcore create \
  --name <ProjectName> \
  --framework <Framework> \
  --model-provider Bedrock \
  --build CodeZip \
  --memory none

--name

--framework

Strands

LangChain_LangGraph

GoogleADK

OpenAIAgents

--protocol

HTTP

MCP

A2A

HTTP

--build

CodeZip

Container

CodeZip

--model-provider

Bedrock

Anthropic

OpenAI

Gemini

--memory

none

shortTerm

longAndShortTerm

--network-mode

PUBLIC

VPC

PUBLIC

--dry-run

• Protocol: Use

  HTTP

  unless the developer specifically needs MCP tool serving or A2A agent-to-agent communication
• Build: Use

  CodeZip

  unless the developer needs custom system dependencies (CodeZip is faster to deploy and doesn't require Docker locally)
• Model provider: Use

  Bedrock

  unless the developer has a specific reason for another provider (Bedrock doesn't require managing API keys)
• Memory: Start with

  none

  — memory can be added later via

  agents-build

  (loads

  references/memory.md

  ) when the developer needs it

agentcore/agentcore.json

tree <ProjectName>/ -L 3

<ProjectName>/
├── agentcore/
│   ├── agentcore.json      ← Project config (agents, resources)
│   ├── aws-targets.json    ← AWS account + region
│   ├── .env.local          ← Local environment variables (gitignored)
│   └── cdk/                ← CDK infrastructure (auto-managed, don't edit)
└── app/
    └── <AgentName>/
        ├── main.py          ← Your agent code — this is where you build
        ├── mcp_client/      ← Pre-wired example MCP client (see note below)
        └── pyproject.toml   ← Python dependencies

• app/<AgentName>/main.py

  — the agent's entry point. This is where the developer adds tools, system prompts, and logic.

• agentcore/agentcore.json

  — the project config. Resources are added here via

  agentcore add

  commands.

• agentcore/.env.local

  — local environment variables. After deploy, resource IDs are written here for local dev.

main.py

get_streamable_http_mcp_client()

mcp_client/client.py

tools

agentcore dev

1. It will become a silent no-op if you repoint it at a gateway that isn't deployed yet. The common path is to swap the example endpoint for

   os.getenv("AGENTCORE_GATEWAY_<NAME>_URL")

   . That env var is only populated after

   agentcore deploy

   . If the developer repoints and runs

   agentcore dev

   before deploying,

   get_streamable_http_mcp_client()

   returns a client with a

   None

   URL and the agent starts with zero MCP tools — no error, no warning. See the "Local dev gap" section in

   agents-connect

   for the guard pattern:

   if not GATEWAY_URL: tools = []

   .
2. If the developer doesn't need MCP tools at all, remove the

   mcp_clients

   list and the loop that appends it to

   tools

   . The scaffold includes it as a convenience, not a requirement.

agents-connect

agentcore dev

curl

8080

8000

9000

agentcore dev --port <N>

ps

• Memory is not available in

  agentcore dev

  — it requires a deploy
• Gateway URLs are not available locally — they require a deploy
• The local server uses the model provider configured in the project

agentcore deploy

1. Show a preview of AWS resources to be created
2. Ask for confirmation
3. Build and deploy via CDK

agentcore invoke "Hello, what can you do?"

agentcore status

• A clear path from "I want to build an agent" to a running deployed agent
• The

  agentcore create

  command tailored to their choices
• An explanation of the generated project structure
• Concrete next steps based on their intent

• The

  agentcore create

  command uses only valid flags from CLI v0.9.1
• Framework recommendation is based on the developer's context, not a generic default
• The developer understands what each generated file does
• Next steps are specific to what the developer wants to build, not a generic list of all features