The curriculum
Twelve things that decide whether it survives contact with production.
Every one of these is the thing that breaks a working prototype three weeks
later. We teach them in the order you hit them, on your own systems, with your own
credentials, in your own repository.
One
Agent architecture
The loop, the tools, the stopping conditions. Why most things called agents are a
prompt in a while-loop, exactly how that fails, and what separates one that recovers
from one that spirals.
Two
Building and managing skills
Writing skills that hold when someone else runs them, versioning them, and a shared
library the team actually maintains — plus the judgment call of when a job is a
skill and when it needs to become an agent.
Three
Managing context
What goes in the window, what gets retrieved, what gets compacted, what gets
remembered between runs. The difference between an agent that stays sharp for four
hours and one that forgets its own instructions.
Four
Managing token spend
Tokens are the meter that is always running. Caching, compaction, budgets per run,
and knowing your cost per task to the cent — before finance asks, not after.
Five
Choosing and switching models
The frontier model where judgment matters, the small fast one for mechanical steps.
Routing between them, falling back when one is down, and upgrading when a new one
ships — with your evals as the safety net.
Six
MCP servers
Connecting the system that has no integration and never will. You write one against
your own internal API in the room — resources, tools, auth — and point an agent at
it.
Seven
Tool design
The single largest determinant of whether an agent works, and the one nobody spends
time on. Naming, schemas, defaults, and writing error messages the model can actually
act on rather than apologize about.
Eight
Human-in-the-loop
Where the gates go and what an approval actually locks. Making "it drafted it and
waited" the default, so the interesting question becomes which gates you are
confident enough to remove.
Nine
Evals
How you know it still works after the model changes underneath you. Building a small
suite out of three real failures from your own logs, and wiring it so a regression
fails loudly instead of quietly.
Ten
Guardrails and permissions
Least privilege per agent, secret handling, audit trails, the accounts it must never
reach — and the prompt-injection attacks your inputs will eventually carry. Written
down, scoped, and demonstrated.
Eleven
Observability
Traces, retries, failure modes and alerts. What to watch, what to ignore, and how to
tell a bad day from a broken system when nobody was in the loop overnight.
Twelve
Deployment
Scheduled, triggered and on demand. Version control for prompts and skills, staging
versus production, and rolling back at nine on a Sunday night without a heroic
effort.
