Foundations of AI Agents (AA-101)
A support script answers three questions correctly, then confidently books a refund it was never allowed to issue. A "research assistant" spins in a loop, calling the same search over and over until someone kills the process. A demo that dazzled the whole room falls apart the moment a tool returns an error nobody planned for. None of these is a model that got dumber overnight. Each is an AI agent — a system that uses a large language model (LLM) to plan, call tools, and act over multiple steps — behaving exactly as its design allows. This course teaches you to see that design clearly, so the behavior stops surprising you.
AA-101 is the entry point to the School of Agentic AI. It is the mental-model course: you will write no LLM calls, spend nothing, and need no cloud account. Instead you build the vocabulary and judgment every later course lands on — what actually separates an agent from a workflow, how a tool call is described, validated, and bounded, and how state and planning let an agent take more than one step without going off the rails. You finish able to explain an agent as an observe, plan, act loop, and to hand-build one in a hundred-odd lines of plain Python, so that when you reach for a framework in AA-201 it never feels like magic.
- Explain what makes a system an agent rather than a fixed workflow or a linear prompt chain, in terms of the observe, plan, act loop - Describe a tool as a named, schema-bound action, and explain why validation and bounded autonomy sit between a proposed tool call and its execution - Reason about memory as the state an agent carries between steps, and about planning as decomposing a goal into an ordered sequence of tool calls - Read an agent's observable trace — its plans, tool calls, and observations — and locate where a run succeeded, stalled, or should have stopped - Hand-build a bounded, deterministic agent loop with two tools, an iteration cap, and an explicit stop condition, without any LLM or framework
Who this course is for
This is the front door of the school. It is written for four kinds of learner:
- The data engineer automating their stack with solid Python, SQL, and orchestration experience, who wants agents that build and repair pipelines, not chatbots.
- The generative-AI practitioner leveling up who has shipped prompt chains and retrieval apps and needs the jump to planning, tools, memory, and state.
- The backend engineer entering AI with strong API skills who wants agents framed as software systems: contracts, validation, and bounded actions.
- The tech lead or architect deciding whether agentic systems belong in production, who needs sound intuition about failure modes before approving an architecture.
Prerequisites
You need intermediate Python — functions, classes, dictionaries, and comfort running a script locally — plus the LLM and prompting fundamentals from GA-101 (School of Generative AI) or a passing placement quiz. You do not need a machine learning background, a paid model API, a GPU, or a cloud account. Every hands-on segment in this first slice of the course either deep-links into the Agent Builder playground or runs in a few lines of standard-library Python on your own machine, so it stays free and offline.
This course teaches you to reason about agents from what they observe and emit — plans, tool calls, and observations recorded in a trace. It does not ask you to inspect a model's private, hidden reasoning; that is not an observable artifact and not something you build systems on. Everywhere in AA-101, "the agent decided" means "the agent produced an observable action you can read in the trace."
Modules
AA-101 is roughly twelve hours of effort across six modules. This first slice delivers three foundational lessons and your first hands-on lab, covering the core of Modules 1 through 4.
| # | Module | What you leave with |
|---|---|---|
| 1 | What is an agent? | The observe, plan, act loop; agent vs. workflow vs. chain |
| 2 | Tools from first principles | Tool schemas, tool-call parsing, validation, bounded actions |
| 3 | Planning strategies | Decomposition, plan-then-act, and replanning on failure |
| 4 | Memory | Working state, and why an agent carries it between steps |
| 5 | Failure modes 101 | Hallucinated calls, infinite loops, premature stops |
| 6 | The agent design canvas | Goal, tools, memory, stopping criteria, reading a trace |
The three lessons and the lab below cover the core of Modules 1 through 4 and give you the loop-and-tool reasoning the rest of the school builds on.
Outcomes
By the end of AA-101 you can:
- Draw the observe, plan, act loop for a task and say precisely where it differs from a fixed workflow.
- Describe any tool as a name, an argument schema, and a bounded action, and explain what validation happens before the call runs.
- Explain memory as the state threaded between loop iterations, and planning as turning a goal into an ordered sequence of tool calls.
- Read an agent trace and point to the iteration where it should have stopped — and know why a bounded loop is a safety property, not a nicety.
Where this leads
AA-101 gates every Practitioner course in the school. It pairs most directly with AA-201: Building Agents with Modern SDKs, where the loop you hand-build here becomes something a framework runs for you — sessions, tool registration, structured outputs, and interrupts — and with AA-202: MCP and Tool Ecosystems, where the tool schema you learn to write by hand becomes a served, discoverable interface. The bounded-autonomy instinct you build in this course is exactly what AA-303: Safety and Guardrails turns into an engineering discipline. Start here, and those courses land on prepared ground.
Do the lessons in order. Each introduces vocabulary the next assumes, and the lab at the end turns the loop, tools, and memory ideas into a small agent you run yourself — no API key, no cost, fully deterministic.