agents-get-started

Files (2)

• SKILL.md
• example-support-agent.md · references/

SKILL.md (first lines)

# get-started

Walk a developer from zero to a running agent on AWS.

## When to use

- 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

Do NOT use for:

- 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`](../agents-build/references/migrate.md))

## Input

`$ARGUMENTS` can be:

- 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

## Process

### Step 0: Verify CLI version

```bash
agentcore --version
```

This skill requires v0.9.0 or later.

If the version is older:
> Your AgentCore CLI is out of date (found vX.Y.Z, need v0.9.0+).

Offer to run the update: `agentcore update`. After the update completes, re-check the version to confirm it's ≥0.9.0 before continuing. Preserve any context the developer already provided (framework preference, project name, what they want to build) so they don't have to repeat themselves.

If `agentcore` is not found:
> 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`](../agents-debug/references/doctor.md)) to diagnose your environment.

### Step 1: Determine intent — exploring or ready to create?

Before jumping into framework selection, figure out where the developer is:

**Ask the developer:** "Are you exploring options (comparing frameworks, understanding what AgentCore does) or ready to create a project?"

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

If the developer's intent is clear from `$ARGUMENTS` (e.g., "create a Strands agent called MyBot"), skip straight to Step 3.

### Step 2: Framework selection

**Check conversation context first.** If the developer already discussed frameworks earlier in this conversation (e.g., from a previous skill invocation), don't re-present the full table. Summarize what was discussed and ask if they've decided, or if anything changed.

If this is the first time discussing frameworks, present the options:

**Supported frameworks (CLI-scaffolded, Python):**

| Framework | CLI value | Best for |
|---|---|---|
| Strands | `Strands` | AWS-native, simplest path, best AgentCore integration |
| LangGraph | `LangChain_LangGraph` | Complex graph-based workflows, existing LangChain investment |
| Google ADK | `GoogleADK` | Teams already using Google's agent toolkit |
| OpenAI Agents | `OpenAIAgents` | Teams already using OpenAI's agent SDK |

**Ask the developer to choose.** Present the options and wait for their selection. Don't assume a default unless they explicitly say they have no preference.

> **Note on naming:** The CLI flag value is the exact string to pass to `--framework`. In prose use the shorter names.

**Default recommendation** (only when the developer says "no preference" or "you pick"): Strands — AWS-native framework with the tightest AgentCore integration and the most samples/docs.

**Key decision points to surface:**

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

#### Framework not listed?

If the developer asks about a framework not in the table above, handle it:

| They ask about | What to say |
|---|---|
| **CrewAI, AutoGen, Semantic Kernel** | Not scaffolded by the CLI, but you can use them via the BYO Container path (below). AgentCore Runtime is framework-agnostic — any code that implements the HTTP contract works. |
| **Anthropic SDK / Claude Agent SDK** | This is a model SDK, not an agent framework. You can use it inside any framework (Strands, LangGraph, etc.) or standalone. For standalone use, wrap it in a container with the Runtime contract. |
| **Claude Code / Cursor / Copilot** | These are IDE tools, not agent frameworks. They're where you *write* agent code, not what you deploy. Pick a framework from the table above for the agent itself. |
| **LangChain (without LangGraph)** | LangChain is a library, LangGraph is the agent framework built on it. The CLI scaffolds LangGraph. If you're using plain LangChain chains, the BYO Container path works. |
| **Custom / homegrown framework** | BYO Container path — see below. |

**BYO Container path (any framework, any language):**

For frameworks or languages not scaffolded by the CLI, AgentCore Runtime accepts any container that implements the HTTP contract (`POST /invocations`, `GET /ping`). The workflow:

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-specific notes:**

| Language | Recommended path |
|---|---|
| Java (Spring Boot) | [Spring AI SDK for AgentCore](https://aws.amazon.com/blogs/machine-learning/spring-ai-sdk-for-amazon-bedrock-agentcore-is-now-generally-available) — handles the Runtime contract, SSE streaming, and health checks. Use `--language Other --build Container`. |
| JavaScript / TypeScript | Implement the Runtime contract in Express/Fastify/etc. Use `--language TypeScript --build Container`. |
| Go, Rust, .NET, other | Implement the Runtime HTTP contract. Use `--language Other --build Container`. |

The rest of this skill (deploy, status, logs, invoke) applies once the container builds correctly.

#### Framework vs. model provider — a common confusion

The framework is how your agent orchestrates (Strands, LangGraph, etc.). The model provider is which LLM it calls (Bedrock, Anthropic, OpenAI, Gemini). These are independent choices:

From aws/agent-toolkit-for-aws, Apache-2.0.

More from aws/agent-toolkit-for-aws