Contents of Hands-On AIOps on AWS: Build AI Agents for DevOps
The course is laid out like a book: seven parts, each a chapter of short pages, with three opening pages and an optional appendix. 26 of 70 pages are published so far, and new parts are added each week. The free pages open for everyone; the rest open when you buy the course.
See the early-access price and what the course covers
Start here
Start here
The whole course in one real incident, what you should already know, a one-screen setup checklist, and your model key.
3 pages, all published
- Introduction: what this course buildsThe whole course in one real incident, who it is for, and how a page's video, text and code fit together. Free
- Before you startThe Python, terminal and Git basics this course assumes, and the four tools to install before the first agent. Free
- Getting a model API key and keeping it safeCreating the key the agent uses, setting a spending limit, and never committing it to Git. Locked
Part 1
Agents from zero
What a language model really does, how an agent works, and how to build one safely, first by hand and then with LangChain.
13 pages, all published
- What a language model really doesHow a model writes one token at a time, why the context window is a budget, and how to read the bill. Locked
- Talking to a model: messages, roles and temperatureWriting the instructions and messages an agent sends, with the OpenAI Responses API. Locked
- Answers you can trust in codeGetting a model to return data your program can check, instead of free text. Locked
- What an AI agent isAgent equals model plus harness, the difference between a workflow and an agent, and when not to use an agent. Free
- One agent loop, step by stepWatching every message in one agent run, so nothing about the loop is magic. Locked
- Tools for an AI agentWriting good tool descriptions, handling a tool that fails, and treating tool output as data, never as orders. Locked
- Designing tools and contextErrors that say how to fix the problem, and the context window treated as a limited budget. Locked
- Write the agent loop yourselfBuilding the loop by hand, then naming each part of it as a part of the harness. Locked
- The same agent with LangChain's create_agentRebuilding the hand-written agent with the current LangChain API and seeing what it does for you. Locked
- Give the agent an AWS toolSet up AWS safely (a budget alert, no root, a read-only user), stage a real CloudWatch incident, and give the create_agent agent two boto3 tools that find the cause. Locked
- Agent middleware: limits, retries and approvalThe controls that keep an agent from running away, including asking a person before a tool call. Locked
- Decision models for fixed choicesUsing a decision model (TypeSafe's Jev, or OpenAI's Decisions API) for yes or no choices, and why a confidence score is never a safety control. Locked
- A cost log for every model callRecording tokens, dollars and seconds for every call, so you always know what a run cost. Locked
Part 2
LangGraph from zero
Building agents as graphs: shared state, loops, pausing for a human, surviving a crash, memory and tracing.
10 pages, all published
- Why build an agent as a graphThe idea behind LangGraph before any code. Locked
- LangGraph state and reducersHow steps share information without stepping on each other. Locked
- Routing, loops and the recursion limitLetting the graph decide where to go next, and stopping it from looping forever. Locked
- Hand-offs, parallel work and streamingCommand and Send, and showing each step as it happens. Locked
- Durable agents that survive a crashSaving progress in SQLite and Postgres so an agent survives a crash, and replaying a run to debug it. Locked
- Asking a human with interruptPausing the agent for approval, and why the code after the pause must look again before it changes anything. Locked
- Timeouts, error handlers and cachingKeeping a slow or failing step from taking the whole agent down. Locked
- Agent memoryShort-term and long-term memory, what to keep, what expires and who may delete it. Locked
- Deep Agents, a ready-made harnessFiles, subagents, skills and sandboxes, and the cost of not building it yourself. Locked
- Tracing an agent with LangSmithSeeing exactly what the agent did and where the time and money went. Locked
Part 3
One DevOps agent, done safely and measured
The first real agent on the real shop, with an approval gate it cannot get around, an Ops Console, and honest numbers.
8 pages, coming soon
- The demo shop we break all courseThe realistic small system every incident in the course happens to.Coming
- The Kubernetes agent on the real shopAn agent that reads the cluster with read-only tools and finds the cause of a real fault.Coming
- The Approval Gate and the ExecutorAn approval token bound to the exact change, and a re-check just before it is applied.Coming
- The Ops ConsoleA web app where a person sees what the agent found and approves or refuses the change.Coming
- The first attack: an instruction hidden in a log lineA log line tries to make the agent delete something, and the defence holds.Coming
- What it means for an incident agent to workThe measures that matter, defined before any test is run.Coming
- The evaluation harnessTesting the agent the way you would test any other program.Coming
- Fair numbers for an agentComparing chat-model steps with decision-model steps without fooling yourself.Coming
Part 4
Tools the standard way, MCP
The Model Context Protocol, real MCP servers, a gateway that controls which agent may call which tool, and MCP security.
6 pages, coming soon
- What MCP isThe Model Context Protocol in plain words, using the 2026-07-28 specification.Coming
- Our tools as an MCP serverFirst by hand, then the standard way.Coming
- Real MCP servers for Kubernetes, GitHub and GrafanaUsing servers other people built, and checking what they can do.Coming
- Your own MCP server for security scanningA small server of your own, end to end.Coming
- The MCP gatewayOne place that controls and records every tool call.Coming
- MCP securityThe known attacks on MCP and how the gateway stops them.Coming
Part 5
From one agent to a team
Team patterns, an Incident Commander, one specialist per area, a Verifier and a Scribe, and what a team really costs.
9 pages, coming soon
- Multi-agent team patternsAnd when one agent is enough.Coming
- What a team of agents costsThe real price of more agents, in tokens and time.Coming
- Designing the context firstGiving each agent only what it needs.Coming
- The Incident Commander agentOne agent that runs the incident and keeps the record.Coming
- The specialist agentsOne page per specialist, each with its own read-only tools.Coming
- The Verifier and the ScribeProving the problem is gone, and the timeline written for you.Coming
- When an agent team goes wrongThe failures of a team, and the plain code that contains them.Coming
- Alert intake and paging a humanTurning an alert storm into one incident with the right severity.Coming
- Long-term memory for the teamWhat the team learns from past incidents, and how an attacker could corrupt it.Coming
Part 6
Production on AWS
AWS with cost safety first, Terraform, EKS with one IAM role per specialist, the AWS incidents, and an audit trail.
7 pages, coming soon
- AWS from zero, cost safety firstStarting on AWS without a surprise bill.Coming
- Terraform, practised on the laptop firstDescribing infrastructure in code before it costs anything.Coming
- Amazon EKS with one IAM role per agentPod Identity, so each agent can read only what it needs.Coming
- The Cloud agent and the AWS incidentsAccessDenied, a security group blocking the database, RDS out of connections and a bucket shared with an unknown account.Coming
- Kyverno, Secrets Manager and an audit trailThe backstops that hold even if an agent is fooled.Coming
- OpenTelemetry export inside your own networkKeeping traces inside your own network.Coming
- Approving agent changes from SlackThe approval screen, in the tool the team already uses.Coming
Part 7
Prove it
An operations report, a red team against your own agents, the final evaluation, and a comparison with AWS DevOps Agent.
5 pages, coming soon
- The operations reportThe numbers a manager will ask for.Coming
- Red-teaming your own agentsA block rate for every kind of attack.Coming
- The final evaluationAn honest result, with the failures written down.Coming
- Buy or buildWhat each option does, what it can access and how it is priced.Coming
- Capstone: a new fault and a new specialistExtending the system on your own, the way you would at work.Coming
Appendix, optional
DevOps basics, if you need them
Optional. Working DevOps engineers can skip it; everyone else can read a page whenever a part of the course needs it.
9 pages, coming soon
- Containers from zeroWhat a container is and how to fix one that will not start.Coming
- Kubernetes podsThe smallest unit Kubernetes runs, on a local k3d cluster.Coming
- Kubernetes deploymentsHow a new version replaces the old one, and how to undo it.Coming
- Kubernetes servicesWhy a service with no endpoints is one of the most common outages.Coming
- Kubernetes health probesHow Kubernetes decides a pod is healthy, and what a probe on the wrong port does.Coming
- Kubernetes storageWhere data lives in a cluster, and the errors when it cannot be found.Coming
- Kubernetes autoscalingScaling pods with load, and the usual reasons it does not happen.Coming
- Observability from zeroThe signals the agent reads, and how a person reads them first.Coming
- CI/CD and GitOpsHow changes reach production, and why Argo CD undoes a change made by hand.Coming