Building AI agent harnesses with Strands Agents: a free 14-video course
A free 14-video course on building AI agent harnesses with the open-source Strands Agents SDK, from the agent loop through multi-agent orchestration, evaluation, and production deployment.
It seems like everyone wants to build AI agents, but not everyone knows where to start.
That's exactly why I built a 14-video learning series that teaches you how to build agent harnesses using the open-source Strands Agents SDK , starting from the agent loop and ending with evaluation and cloud deployment. Every video has runnable code in the companion GitHub repo , so you can clone it and follow along in your own AWS account.
The course runs about two hours total, with videos between 5 and 15 minutes each. You'll need Python proficiency and a basic understanding of how LLMs work, but no prior agent framework experience. Let's walk through what you'll learn.
What's an agent harness, anyway?
Here's the core idea the whole course builds on: models are stateless. They process one request, produce a completion, and forget. On their own they can't take action, access live data, or coordinate multi-step work.
An agent is a model wrapped in a runtime system that gives it tools, memory, and a reasoning loop. That runtime system is the harness. It handles the agent loop, tool execution, context management, lifecycle control, and observability. The short version is: model + harness = agent
Frameworks like Strands give you components for building agents. A harness is what you get when you compose those pieces deliberately for your use case. This course teaches you the primitives one at a time, then shows how they fit together.
Chapter 1: How AI agents really work
We start with the agent loop, because everything else in the course adds to it. The model receives context (system prompt, user input, tool list, conversation history), reasons about it, decides whether to call a tool, gets the result back into context, and repeats until the task is done.
With Strands, a working agent is genuinely this small:
Python
from strands import Agentagent = Agent()response = agent("What are the key differences between REST and GraphQL APIs?")print(response)
That's a complete agent loop. The rest of the course is about what you add to it and why.
Chapter 2: Switching model providers
Strands is model-agnostic. The samples default to Claude on Amazon Bedrock, but swapping to a different provider is a one-line change, and the course shows you exactly how. This matters more than it sounds: it means your harness code isn't married to any single model, and you can benchmark providers against each other without a rewrite.
Chapter 3: Give your agent tools using MCP
Tools are how agents interact with the world and their environment. This chapter covers writing your own tools with the
@tool decorator, then connecting to the broader tools ecosystem through the Model Context Protocol (MCP). You'll build a small coding agent that uses MCP servers, and learn tool filtering, which matters because handing an agent forty tools when it needs five can cause reliability problems.
Chapter 4: Callbacks and response streaming
Nobody wants to stare at a spinner for thirty seconds while an agent works. Callbacks let you observe the loop as it runs, and streaming gets tokens in front of your user as they're generated. The chapter walks through async streaming and wires it into a FastAPI endpoint, which is the shape most real agent backends end up taking.
Chapter 5: Control your agent with hooks
This is where harness engineering starts to get a bit more in depth. Hooks are lifecycle interception points: code that runs before a tool executes, after the model responds, at any point in the loop where you need control. The samples include a rate limiter and a human-approval interrupt that pauses the agent before it takes a sensitive action. If you've ever wanted an agent to ask permission before deleting something, this is the chapter.
Chapter 6: Agent plugins and skills
Plugins bundle related capabilities (tools, hooks, prompts) into reusable units. Skills are one example of plugins with Strand. Skills power on-demand instructions the agent loads only when a task calls for them, instead of stuffing everything into one giant system prompt. The running example is a customer service agent with separate skills for order tracking, refunds, and account troubleshooting. This customer service agent sticks around for the next several chapters, growing as you learn each primitive.
Chapter 7: Improve agent reliability with steering
It's common that AI agents don't always follow directions, and that's one of the biggest reasons they never make it from POC to production. Though models are getting better at following system prompts, the model still can and likely will drift from them. Steering gives you programmatic enforcement instead. A steering handler watches what the agent is about to do and redirects it when it goes off the rails, so your workflow rules get enforced by code rather than hoped for in a prompt.
In my experience this is the primitive people are most surprised by, and the one that changes how they think about agent reliability.
Chapter 8: Context engineering and conversation management
Context windows are finite, and long-running agents fill them. This chapter covers what goes into the context window, when, and how, plus conversation management strategies like compression so a long session doesn't degrade into confusion or blow past the token limit. Employing context engineering strategies will not only help you save on token cost, but also can increase reliability.
Chapter 9: Persistent memory with session managers
Everything so far forgets when the process exits. Session managers persist conversation history so your agent picks up where it left off across restarts and across sessions. You'll learn the session manager abstraction and how to back it with real storage, which is the difference between a chatbot demo and a product a user can return to tomorrow.
Chapters 10 through 12: Multi-agent patterns
One agent with a thousand tools and a super long prompt may not actually work as intended. The fix is usually decomposition, and the course covers the three patterns you'll reach for, in order of increasing coordination complexity:
Agents as tools (Chapter 10): wrap a specialized agent so another agent can call it like any other tool. An orchestrator delegates to a research agent or a billing agent the same way it would call an API. This is the simplest multi-agent pattern and the one I'd start with.
Graph workflows (Chapter 11): when you know the shape of the work in advance, define it as a graph with explicit nodes and edges. Each agent handles its step, and the structure guarantees the order of operations. Deterministic where it counts, model-driven inside each node.
Agent swarms (Chapter 12): when you don't know the shape in advance, a swarm of agents collaborates with shared context and hands off work dynamically. More flexible, less predictable.
Chapter 13: Evaluating agents
"It seemed to work when I tried it" is not an evaluation strategy. This chapter covers evaluating agents with Strands Evals: LLM-as-a-judge scoring for response quality and trajectory validation for checking the agent took a sensible path, not just that it landed on a good answer.
Chapter 14: Deploying agents to the cloud
The finale takes your agent to production with Amazon Bedrock AgentCore . You'll see what changes when an agent stops being a script on your laptop: runtime hosting, identity, and the operational concerns that come with real users.
Getting started
Everything you need is in the repo:
Bash
git clone https://github.com/aws-samples/sample-building-with-strands-course.gitcd sample-building-with-strands-coursepython3 -m venv .venvsource .venv/bin/activatepip install strands-agents strands-agents-toolscd samples/01-agent-looppython simple_agent.py
You'll need Python 3.10+ and an AWS account (free tier works for most samples; SETUP.md has the credential walkthrough). If you hit Bedrock throttling on the free tier, the repo README shows how to swap to Amazon Nova models with one line.
By the end of the fourteen videos you'll have a complete mental model of how agent harness primitives compose: loop, tools, hooks, steering, context, memory, multi-agent orchestration, evals, and deployment.
Links
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article