1. Kopi Run: your first agent in five minutes

Read the system prompt and the place_order tool below. You'll paste the prompt and the full tool list into the console in the next two steps.

Both files live in the repo, so you can read them there:

cat $WORKSHOP/kopi-run/system-prompt.md &&
cat $WORKSHOP/kopi-run/tools.json

First, you'll need the Lambda function's ARN. Run this in the code editor terminal and copy what it prints:

echo $KOPI_API_ARN

1. Open the Amazon Bedrock AgentCore console. Check the region is Asia Pacific (Singapore).

2. Choose Gateways in the navigation pane, then Create Gateway. A four-step wizard opens.

3. Step 1, Define gateway details. The name box is filled with a generated name. Replace it with kopi-gw. Under Permissions, leave Create default role selected. Choose Next.

   Screenshot: Define gateway details

   

4. Step 2, Configure Inbound Identity. The default is JSON Web Tokens. Change Inbound Auth type to Use IAM permissions. Choose Next.

   Screenshot: Configure Inbound Identity

   

5. Step 3, Add targets. Leave the protocol as MCP target. Replace the generated Target name with kopi-api. Set Target type to Lambda ARN and paste the ARN you copied into Lambda ARN. Under Target schema, choose Define an inline schema and paste the full tool list below into the editor. Leave Outbound Auth as IAM Role. Choose Next.

   Screenshot: Add targets

   

6. Step 4, Review and create. Check the details and create the gateway. Wait until its status says Ready.

[
  {
    "name": "get_menu",
    "description": "List the drinks on today's menu at Block 88 Kopitiam, with prices in SGD.",
    "inputSchema": { "type": "object", "properties": {} }
  },
  {
    "name": "place_order",
    "description": "Add drinks to today's run for one person. If that person already has the same drink on the run, the quantity is added to it.",
    "inputSchema": {
      "type": "object",
      "properties": {
        "person":   { "type": "string", "description": "First name of the person the drinks are for" },
        "drink":    { "type": "string", "description": "Full drink name, for example kopi-o siew dai peng" },
        "quantity": { "type": "string", "description": "How many" }
      },
      "required": ["person", "drink", "quantity"]
    }
  },
  {
    "name": "get_order_history",
    "description": "Get a person's recent orders, newest first.",
    "inputSchema": {
      "type": "object",
      "properties": { "person": { "type": "string", "description": "First name" } },
      "required": ["person"]
    }
  },
  {
    "name": "get_run",
    "description": "Show everything on today's run: who ordered what, quantities and the total.",
    "inputSchema": { "type": "object", "properties": {} }
  }
]

Start by creating an AgentCore project, then add the gateway and its target:

cd $WORKSHOP &&
agentcore create --project-name KopiRun --no-agent &&
cd KopiRun &&
agentcore add gateway --name kopi-gw --authorizer-type AWS_IAM &&
agentcore add gateway-target \
  --type lambda-function-arn \
  --name kopi-api \
  --lambda-arn "$KOPI_API_ARN" \
  --tool-schema-file "$WORKSHOP/kopi-run/tools.json" \
  --gateway kopi-gw &&
agentcore deploy -y

A project is a folder that describes AgentCore resources. agentcore/agentcore.json lists them, and agentcore/cdk/ holds the infrastructure code the CLI generates for you. --no-agent gives you an empty project so you can add the pieces one at a time. Nothing exists in AWS until you deploy, and the last command deploys the Gateway straight away: the agent you define next needs to look the Gateway up, so it has to exist first. It takes a minute or two.

1. In the AgentCore console, choose Harness in the navigation pane. Open the arrow on the Quick create Harness button and choose Advanced create Harness. You need the advanced form to add a tool and a limit.

2. Name: replace the generated name with kopi_agent. Harness names allow letters, numbers and underscores only, and can't be changed later.

3. Model and system prompt: leave Model source as Bedrock and the model as Claude Sonnet 4.6. The System prompt box says You are a helpful assistant. Replace that with the prompt from the first step.

   Screenshot: name, model and system prompt

   

4. Memory: leave Enable Memory on and Create new Memory (managed by Harness) selected. It uses semantic memory and summarisation, and keeps raw events for 30 days.

5. Tools: switch on Gateway and choose kopi-gw from Select gateway.

   Screenshot: memory and tools

   

6. Open Advanced configurations, then Invocation limits, and change Max Iterations from 75 to 20.

   Screenshot: invocation limits

   

7. Permissions: leave Create default role selected.

Hold off on creating it for now, and read the next step first.

agentcore add harness \
  --name kopi_agent \
  --model-provider bedrock \
  --system-prompt "$(cat $WORKSHOP/kopi-run/system-prompt.md)" \
  --max-iterations 20 &&
agentcore add tool --harness kopi_agent --type agentcore_gateway --name kopi --gateway kopi-gw &&
$WORKSHOP/scripts/set-memory.sh kopi_agent &&
cat app/kopi_agent/harness.json

app/kopi_agent/harness.json is your agent: the model, the system prompt, the Gateway tool, the memory setting and the iteration limit. agentcore add harness leaves memory off, so set-memory.sh switches on managed memory (semantic facts and summaries), the same as the console's default. You'll need it for the regulars step at the end.

Choose Create Harness. In the console, creating the harness also deploys it. Wait for the status to show Ready. The managed memory takes three to five minutes to provision, so this is a good moment to read the box below.

agentcore deploy -y

This takes three to five minutes the first time. When it finishes, see what was created:

agentcore status

1. Choose Harness playground under Test in the navigation pane. Pick kopi_agent from Select a Harness and choose Test Harness.

   Screenshot: Harness playground

   

2. Send this message: What's on the menu today?

3. Then send: Two kopi-o siew dai for me please. I'm Priya.

4. Finally, ask: What's on today's run?

Each reply shows the tool calls the agent made. Expand one to see what it sent and what came back.

export S1=$(newsession) &&
agentcore invoke --harness kopi_agent --actor-id priya --session-id "$S1" \
  "What's on the menu today?" &&
agentcore invoke --harness kopi_agent --actor-id priya --session-id "$S1" \
  "Two kopi-o siew dai for me please." &&
$WORKSHOP/scripts/kopi.sh run

The actor ID says who's talking. Memory uses it to keep each person's data separate. kopi.sh run reads the run straight from the backend.

In the same Playground session, send:

1. The team's joining. Add five more kopi-o siew dai under my name.
2. What's on today's run?

agentcore invoke --harness kopi_agent --actor-id priya --session-id "$S1" \
  "The team's joining. Add five more kopi-o siew dai under my name." &&
$WORKSHOP/scripts/kopi.sh run

1. Open Gateways and choose kopi-gw. Under Targets, select kopi-api and choose Edit.
2. Scroll to Target schema. Make sure Define an inline schema is selected. If the In-line schema editor shows your tool list, replace the quantity line with the one above. If the editor is empty, choose the whole list below and paste it in instead; it's the same list with the fix already made.
3. Choose Update target, then wait about a minute for the target to show Ready again.
4. In the Playground, start a new session. Order a different drink so the old line doesn't get in the way:
   • Two teh peng for me please. I'm Priya.
   • Add five more teh peng under my name.
   • What's on today's run?

[
  {
    "name": "get_menu",
    "description": "List the drinks on today's menu at Block 88 Kopitiam, with prices in SGD.",
    "inputSchema": {
      "type": "object",
      "properties": {}
    }
  },
  {
    "name": "place_order",
    "description": "Add drinks to today's run for one person. If that person already has the same drink on the run, the quantity is added to it.",
    "inputSchema": {
      "type": "object",
      "properties": {
        "person": {
          "type": "string",
          "description": "First name of the person the drinks are for"
        },
        "drink": {
          "type": "string",
          "description": "Full drink name, for example kopi-o siew dai peng"
        },
        "quantity": {
          "type": "integer",
          "minimum": 1,
          "maximum": 20,
          "description": "How many cups"
        }
      },
      "required": [
        "person",
        "drink",
        "quantity"
      ]
    }
  },
  {
    "name": "get_order_history",
    "description": "Get a person's recent orders, newest first.",
    "inputSchema": {
      "type": "object",
      "properties": {
        "person": {
          "type": "string",
          "description": "First name"
        }
      },
      "required": [
        "person"
      ]
    }
  },
  {
    "name": "get_run",
    "description": "Show everything on today's run: who ordered what, quantities and the total.",
    "inputSchema": {
      "type": "object",
      "properties": {}
    }
  }
]

The project doesn't keep its own copy of the tool list. agentcore/agentcore.json points at $WORKSHOP/kopi-run/tools.json, and every deploy uploads that file for the Gateway. So the fix is: change that file, then deploy.

Make the change and see exactly what it did:

$WORKSHOP/scripts/edit-tools.sh kopi-quantity

(Prefer to do it by hand? Open $WORKSHOP/kopi-run/tools.json in the code editor and replace the quantity block inside place_order with the line above.)

Then deploy and try again on a clean run:

cd $WORKSHOP/KopiRun &&
agentcore deploy -y &&
$WORKSHOP/scripts/kopi.sh reset &&
export S1=$(newsession) &&
agentcore invoke --harness kopi_agent --actor-id priya --session-id "$S1" \
  "Two kopi-o siew dai for me please." &&
agentcore invoke --harness kopi_agent --actor-id priya --session-id "$S1" \
  "Add five more kopi-o siew dai under my name." &&
$WORKSHOP/scripts/kopi.sh run

The Playground talks to the agent as you, so on this path you play Marcus yourself.

1. Start a new session and send: Hi, I'm Marcus. My usual is a kopi-c kosong peng. Please remember that.
2. Long-term memory is extracted in the background, so wait about a minute.
3. Start another new session and send: It's Marcus. Put my usual on today's run.
4. Start one more new session and order for the team: 3 kopi-o siew dai, 1 teh peng gao, and whatever Marcus had last time.

First, Marcus tells the agent his usual:

export S2=$(newsession) &&
agentcore invoke --harness kopi_agent --actor-id marcus --session-id "$S2" \
  "Hi, I'm Marcus. My usual is a kopi-c kosong peng. Please remember that."

Long-term memory is extracted in the background, so wait about a minute. Then start a brand-new session as Marcus:

export S3=$(newsession) &&
agentcore invoke --harness kopi_agent --actor-id marcus --session-id "$S3" \
  "Put my usual on today's run."

Now Priya orders for the team, including Marcus:

export S4=$(newsession) &&
agentcore invoke --harness kopi_agent --actor-id priya --session-id "$S4" \
  "3 kopi-o siew dai, 1 teh peng gao, and whatever Marcus had last time." &&
$WORKSHOP/scripts/kopi.sh run