Most explanations of AI agents start with boxes and arrows. Let's start with a food truck instead.
A customer walks up and says, "The usual, but no onions, and quickly." The cook doesn't need a flowchart. They listen, decide, grab the right tools, cook, check the order and remember you for next time. That is an AI agent. Here is every part of the truck, mapped to AWS.
The truck, mapped
On the truck | In your agent | On AWS |
|---|
The cook's brain | The model that understands and decides | Amazon Bedrock |
The cook's routine: listen, decide, cook, check | The agent loop | Strands Agents |
Grill, fryer, payment tablet | Tools the agent can call | Python functions, AWS Lambda, APIs |
The printed menu board | Facts the agent must stick to | Bedrock Knowledge Bases (RAG) |
The regulars' notebook | Memory of past customers | AgentCore Memory |
The owner's rules ("no off-menu promises, no big refunds without me") | Safety limits | Bedrock Guardrails |
The staff-only door | Who is allowed to give orders | AgentCore Identity / Amazon Cognito |
The truck itself, open for business | Hosting and scaling | AgentCore Runtime |
The order tickets and kitchen camera | Logs and traces | AgentCore Observability / CloudWatch |
The monthly fuel and ingredients bill | Token and service cost | AWS Budgets |
Three stories that explain the hard parts
1. The cook who invents menu items
Ask a truck with no menu board for "a vegan lobster roll" and a bad cook says "coming right up!" and improvises something awful. That is a hallucination. The fix is the menu board: ground the agent in real documents with a Knowledge Base, so it answers from facts, not guesses.
2. The regulars problem
A good cook remembers your usual. Without memory, your agent greets every returning customer as a stranger. Memory turns a demo into something people want to use. It also needs rules, because one customer's notes must never show up in another's order.
3. The festival weekend
On a normal Tuesday the queue is short. On festival Saturday it is ten times longer. One truck can't clone itself, but a managed runtime can add capacity so each customer's order is handled separately. That is the difference between an agent on your laptop and one that survives real traffic.
The cook in 12 lines
from strands import Agent, tool
@tool
def check_regulars(customer: str) -> str:
"""Look up a customer's usual order."""
regulars = {"Sam": "spicy wrap, no onions"}
return regulars.get(customer, "new customer, no usual order yet")
cook = Agent(tools=[check_regulars])
cook("Sam just walked up. What should I make?")
The agent decides on its own to call check_regulars , reads the result and responds. You wrote one function, and Strands handled the loop.
Running the truck on a student budget
- Use a small pan for small orders. Simple steps don't need your most expensive model.
- Cap the loop. A cook who keeps stirring forever burns gas. Limit iterations and output length.
- Set a budget alert before you start. Do this first, not after the surprise bill.
- Test in the driveway, then hit the road. Build and test locally, deploy last.
- Park the truck when you're done. Delete deployed runtimes you aren't using.
Your turn
Pick one tool for your cook (a menu lookup, a price calculator, a weather check) and build it in 15 minutes.
Which part of the truck would you add that I missed? The delivery driver, the second truck (multi-agent!), the health inspector? Tell me in the comments.
Loading article