the problem
most tutorials show you a single agent loop: llm → tool → llm → tool → answer. production systems rarely look like that. they look like teams — small units with narrow jobs, handing off to each other, calling into shared skill libraries, driven by a router or a plan. the pattern is the glue; the llm is just the engine.
this course is about that glue.
what a pattern is, and isn't
a pattern is a recurring shape you reach for to solve a recurring problem. for agents, patterns aren't a framework — they're closer to what "patterns" meant in the gang-of-four book: if you see this situation, reach for this shape first. no ceremony, no inheritance hierarchy — just a named shape other engineers already recognise.
three things a pattern isn't:
- not a framework. strands, langgraph, crewai, and pydantic-ai each bake in one or two patterns. patterns pre-date any of them, and outlive them.
- not a prompt template. prompts implement patterns. the pattern is the structural decision; the prompt is one encoding of it.
- not a model feature. patterns live above the model. swap claude for gpt-5 and the shape stays the same — the prompts change, the architecture doesn't.
the four primitives
the rest of this course is built around four building blocks. treat these as the vocabulary. every pattern in later lessons is a combination of these, stacked or nested.
- skills a small, named capability an agent can invoke — not just a tool call, but a tool call plus the prompting, validation, and return-shape glue around it. think "book this calendar slot" or "parse this invoice". a skill is reusable across agents.
- extensions anything that wraps or augments the base loop: memory injection, retrieval, safety filters, telemetry, caching, retries. the pattern equivalent of middleware.
- personas the identity an agent takes on. a bundle of prompt, voice, allowed skills, and guardrails. swap the persona and the same underlying loop behaves completely differently.
- handoffs how one agent passes control to another, with just enough context to be useful without over-sharing. the most undervalued primitive — most "the agent got confused" bugs are bad handoffs in disguise.
a minimal pattern, end to end
the smallest complete example: a triage agent hands off to one of two specialists. the whole thing is two personas, four skills, and a handoff.
four things to notice:
- triage doesn't answer — it routes. that is the entire job. conflating triage and response is the most common early mistake.
- the handoff payload is explicit. no shared blackboard quietly leaking state between agents. what you pass is what the next agent sees.
- skills are stand-alone. they aren't attached to any persona permanently; each persona picks a subset it's allowed to use.
- personas compose skills, not the other way around. a persona is a curated bundle; a skill has no idea which persona is using it. that's how you keep skills portable.
this is the shape you'll see repeated — with more personas, more skills, and smarter routers — in every real agent system worth studying.
what this course is and isn't
seven lessons. each one is a pattern, with a minimal implementation and notes on when the pattern breaks. examples are framework-agnostic typescript pseudocode — when we need something concrete (a queue, a memory store, a router) we'll name a specific tool, but the pattern itself is portable.
lesson seven is evals: how you know a pattern is actually working, not just demoing well. it's the lesson most "build an agent" courses skip, and the one you'll reach for most often once something is in production.