Skip to main content

Where to Start: Become an Agentic AI Engineer in Days, Not Months

You don't have months to learn AI. Good news: you don't need them. Everyone starts the same way — six Foundations courses in a browser, nothing installed, whether or not you can code — then makes one decision (use AI to do your work, or build AI that does it for you), and walks the courses from there. Engineer is the destination, not the prerequisite.

This section is the shortest path from beginner to shipping Agentic AI Engineer — measured in days, not semesters: productive with AI in a matter of hours, your first Digital FTE in a weekend, and the full Agent Factory stack inside a month of focused evenings.

Why Days, Not Months​

That promise sounds impossible until you see the method behind it. It is the same method anyone uses to survive a new job with little background. First, you get an overview of the work. Second, you identify the few topics that are critical to actually doing the job. Third, you learn the 80% of each topic that gets used routinely, you start working, and you pick up the rest as you go — with reference material at your elbow.

Two ways to learn a new field, contrasted. The exhaustive way: try to learn it all first, months pass, and the work burns out and never ships. The 80% way: five steps — 1 get an overview, 2 identify the critical topics, 3 learn the useful 80%, 4 start working, 5 pick up the rest through real use — ending in shipped work. Cover the critical 80%, get working, and let the rest fill in through real use.

Trying to learn every detail of every topic up front takes months. You would burn out before you shipped anything. Our pedagogy is built on the opposite philosophy: cover the critical 80%, get you working, and let the rest fill in through real use. Every crash course in this section is designed exactly that way.

How This Is Organized (Start Here)​

You don't learn this by reading everything; you learn it by walking one clear path — so here is that path, the only map you need to hold. It is the same one the sidebar already shows you: Foundations first, then General Agents, then Personal Agent Harnesses — where everyone gives themselves a persistent agent of their own — then one of two tracks — Mode 1 or Mode 2 — and finally References & Companions. The whole thing turns on a single decision in the middle (which mode), and everything before that decision is shared by every reader.

The curriculum as a map. A shared trunk runs top to bottom: Foundations, then General Agents, then Personal Agent Harnesses (own a persistent agent). From Personal Agent Harnesses the path reaches a "pick a mode" fork that splits into two tracks — Mode 1, Problem-Solving (solve a problem once), and Mode 2, Manufacturing (build a worker that does it) — and both tracks converge at the bottom into References & Companions. Everything before the fork is shared by every reader; the mode is the one big decision.

Start by reading the thesis. It comes in two versions — one for technical and business professionals, and one for absolute beginners — so everyone can follow regardless of background. After the thesis come the Foundations: what a language model actually is, prompting, the two document languages of agentic work, commissioning code you never write, teaching AI a task once and connecting it to your apps, and learning how to think in the AI era. Every reader takes these before picking a mode.

Where do you start? In a browser. Your first six courses, the Foundations, run in a chat tab — Claude.ai, ChatGPT, or Gemini — with nothing installed, whether or not you can already code. That browser tab is where most everyday AI value already lives. When the work needs your real files, you graduate to a general agent on your own machine, and the three layers of agentic work begin.

The mental model you'll need: work in the AI era happens in three layers. You use general agents to solve problems. You build AI Workers to do specialized jobs. You assemble those Workers into AI-Native Companies. Every professional engagement starts the same way — a human directing a general agent. The only question is which agent, which depends on what you're trying to accomplish.

note

A quick naming note. Throughout this book, AI Worker, Digital FTE, and AI Employee refer to the same idea — a specialized agentic system doing a real job under human-defined policy. We use Digital FTE when emphasizing business value, AI Worker when emphasizing implementation, and AI Employee when emphasizing role inside the company. For any other unfamiliar term, the glossary is your friend.

Those same three layers are the arc this section walks you along, from where you are now to where it gets you:

The seven-stage journey from Beginner to AI-Native Company Architect, color-coded to the three layers. Layer 1, use a general agent: Stage 1 Beginner — the six Foundations from prompting to thinking, all in a browser (you are here); Stage 2 Agent User — direct a general agent like Claude Code or Cowork on real work; Stage 3 Personal Agent Harnesses — own a persistent agent (OpenClaw or Hermes), which everyone does before picking a mode. Layer 2, build AI Workers: Stage 4 Agent Builder — build your first agent with the OpenAI Agents SDK; Stage 5 Worker Builder — turn that agent into a durable Digital FTE. Layer 3, build an AI-Native Company: Stage 6 Workforce Builder — govern a workforce with a control plane, hiring, and a delegate; Stage 7 AI-Native Company Architect — prove every Worker with evals and deploy to the cloud. Most readers stop at stage 4 or 5.

You don't have to walk the whole path. Most readers stop at stage 4 or 5, and that's enough for a serious career or a first startup. The full path is there if you want it.

Pick Your Mode​

Here is that decision up close — the fork between using AI and building AI that works for you. Make it first in the abstract, then by finding your own row.

The thesis section The Two Modes of General Agent Use describes the two ways people actually use general-purpose agents. Mode 1 if you want to use AI to do your work. Mode 2 if you want to build AI that does the work for you. The label "Manufacturing" sounds industrial, and it is — building Workers is a different discipline from using them.

One thing the decision does not change: everyone picks a general agent (Course 9 or Course 10) right after Foundations. The mode decision routes you to a track; it does not decide whether you use a general agent. You always do.

Mode 1 versus Mode 2. In Mode 1 — Problem-Solving, you direct a general agent and the agent does the work; you use AI to do your work faster. In Mode 2 — Manufacturing, you direct a general agent and it builds a Worker that does the work again and again; you build AI that does the work for you.

Mode 1 — Problem-SolvingMode 2 — Manufacturing
Pick this if you...Want AI to help you do work fasterWant to build AI Workers that do work for you
Who it's forAnyone — engineers or knowledge workersEngineers (or a knowledge worker paired with an engineer)
Your toolClaude Code/OpenCode or Claude Cowork/OpenWorkClaude Code/OpenCode for building; the course pages teach concepts you read on your own first, then ask the agent to build
Start withCourse 9 (engineers) or Course 10 (knowledge workers)Course 28 — Build AI Agents
You produceCompleted workA Worker that produces work, on its own
Governed bySeven Principles of Problem SolvingSeven Invariants of the Agent Factory

A note before the fork. Before you pick a mode, everyone takes one shared step: give yourself a persistent personal agent of your own. That is the Personal Agent Harnesses section (OpenClaw with General Agents, Course 19, and Hermes with General Agents, Course 20). It is a step on the shared path, not a mode — you build your own agent here, then choose Mode 1 or Mode 2.

A note on Mode 2. The general agent's output is not the outcome — it is the Worker that produces the outcome. A developer uses Claude Code to spec, build, and deploy a code-reviewing Worker. A finance analyst, paired with an engineer, uses Claude Code to spec a close-process Worker that runs every month-end. Same tool, same discipline, different domain.

Your Starter Path​

If the Mode picker still feels abstract, here is the same decision in fully concrete terms — pick the row that fits you and start with the leftmost course. Every path begins with the universal Foundations (Courses 1–6).

You are...Your starter pathFirst milestone
Absolute beginnerThesis → Course 1 (What AI Is) → Course 2 (Prompting) → Course 3 (Markdown & HTML) → Course 4 (Code You Never Write) → Course 5 (Skills & Connectors) → Course 6 (Thinking)Foundations laid; continue with a mode below
Knowledge workerFoundations (Courses 1–6) → Course 10 (Cowork) → Course 19 or 20 (own a harness, via a coding agent) → Course 21 (Is This an Agent Problem?) → Course 22 (Principles)Ship real knowledge work with AI
EngineerFoundations (Courses 1–6) → Course 9 (Claude Code) → Course 19 or 20 (own a harness) → Course 28 → Course 30 (FTE)Ship your first Digital FTE
Workforce builderThe Engineer path, then Course 34 (Paperclip) → Course 37 (Evals) → Course 38 (Deploy)A governed AI workforce, deployed to the cloud

The Courses​

You've made the call — so here is every course, grouped exactly as the sidebar shows them, with the one fastest route and the time at each depth called out before the full list.

tip

Several courses include a Reader track — a conceptual, no-build pass you take to understand and direct the work rather than implement every line. Using it where offered, the fastest path to a shipped Digital FTE is Foundations (Courses 1–6) → Course 9 → Course 28 → Course 30 → Course 37 (Reader track) — about 15 hours of focused work. The remaining courses turn that Digital FTE into a governed workforce, but you don't need them to ship your first one.

Total time by depth: Mode 1 (productive with AI) ~8h · Mode 2 minimum (first Digital FTE) ~15h · Mode 2 full (governed workforce) ~28h · Full Agent Factory mastery ~48h (with the cloud deployment course).

Everyone shares the same six Foundations below; after those, the path splits by mode.

Foundations (Everyone)​

  1. What AI Actually Is — A no-math, no-code mental model of the machine sitting under every other course: nine ideas that explain why a language model predicts rather than looks things up, why it sounds certain even when wrong, why it miscounts the letters in "strawberry," and why its skill is jagged. Read it first and every "why did it do that?" in the courses below already has an answer waiting. About 45 minutes.

  2. AI Prompting in 2026 — A 45-minute, 13-concept primer on using ChatGPT, Claude, and Gemini well in 2026: context, reasoning modes, deep research, multimodal, and AI desktop apps. The mechanics every chapter of this book assumes you already know.

  3. Markdown In, HTML Out — A 13-concept primer on the two document languages of agentic work: writing Markdown specs precise enough for a machine (headings, lists, fences, links, and the spec skeleton with its grade-to-9 validation loop), and demanding HTML output rich enough for a human, with the publishing ladder that turns an artifact into a shareable link. About 90 minutes including the closing prompts. Prereq: Course 2.

  4. Code You Never Write — A 13-concept primer on getting AI to write, run, and verify code you never read. Which tasks are code problems (Volume, Precision, Repetition, Files), how to write a five-section brief with no technical words in it, how to force computation over estimation, how to verify a result you cannot read, and the five surfaces where AI runs code for you: Claude.ai, Claude Code, OpenCode, Cowork, and OpenWork. About an hour, plus forty minutes of closing prompts and four projects. Prereq: Courses 2 and 3.

  5. Skills & Connectors — A no-code primer on the two upgrades that turn a chat box into a coworker. A Skill teaches AI a task once (a SKILL.md it loads only when your request matches) so it works your way every time; a Connector gives AI safe, permission-scoped access to your real apps — Drive, Gmail, Slack, a tracker — over the MCP standard. When to reach for each, how to use the built-in ones, how to have AI build your own (it writes the file for you), and how to do it all safely, across the same five surfaces, with notes on the ChatGPT and Gemini equivalents. These plugins are portable — what you make here travels with you to every tool you use later. Built for accountants, doctors, marketers, engineers, and students. About 75 minutes including the closing prompts and projects. Prereq: Courses 2–4.

  6. How to Think in the AI Era — The cognitive discipline that separates people who get real value from AI from those who don't: when to reach for an agent, when not to, and how to frame problems so an agent can actually help.

General Agents (Pick Your Co-Worker)​

These are the general-purpose agents you'll direct in every mode that follows. Engineers pick the coding agent; knowledge workers pick the desktop co-working agent. Both are reused in Mode 2: they aren't Mode-1-specific, they're the tool layer beneath every mode. The coding track opens with Open Source LLMs, which runs an open model at all three scales (your laptop, a server you control, and the cloud) so you see what is under the hood from the start. From there you pick your co-worker — Agentic Coding for engineers, Cowork for knowledge workers — then run five disciplines on whichever one you picked: Spec-Driven Development, Loop Engineering, Harness Engineering, Graph Engineering, and Trusting the Checker. Specify what to build, design the loop that builds it for you, engineer the harness that makes that loop safe to trust, give your loops a shared memory once you run more than one, then prove the checker at its center with evals.

  1. General Agents on the Web — Your first general agent, driven from a browser tab with nothing installed. A 12-concept tour of the July 2026 web work surfaces (Claude Cowork on the web and ChatGPT Work): what a remote session is, where your files actually live (the three-tier exit discipline), connectors as reach and exit door, the approval that reaches your phone, the four-step delegation loop, and scheduled tasks that run with no device online. Its lasting lesson is a reading lens: every agent product is the same six parts, so each new tool becomes a half-hour read. The gentlest on-ramp to the whole section; everyone starts here in a browser, whether or not you can code, before you install any tool.

  2. Open Source LLMs: Your Laptop, Your Server/Cluster, the Cloud — The coding track opens here, and it opens with the full range of choices open models actually give you. Three standalone parts, one per tier. Part 1 (local, Ollama): stand up a model on your own machine, free and offline, point Claude Code or OpenCode at it, and meet the two walls every local setup must clear (a capable model, and fast-enough hardware). Part 2 (server, vLLM): serve the same Qwen3 8B from a GPU machine you control, fire fifty concurrent requests at both serving layers, and draw your own two curves showing one crawl while the other climbs. Part 3 (cloud, OpenRouter): drive frontier open models like Kimi K3 and DeepSeek V4 Pro, which no individual can host, from the same two agents, then put one router in front of all three tiers. The lasting idea is one sentence: your agent is a harness plus a swappable brain, and the brain is just an address. Reading takes 2 to 4 hours; Part 1 alone takes about 60 to 90 minutes and needs nothing but a free install. Helpful to have driven a coding agent before; if not, the one-command install gets you there, and Course 9 teaches the driving. The open-model on-ramp to the coding track; pairs with the skills crash course.

  3. Agentic Coding Crash Course: Claude Code and OpenCode — A 90-minute, 15-concept tour of Claude Code and OpenCode. Same vocabulary, slightly different keybindings; skills transfer cleanly between the two tools. The general-agent starting point for engineers.

  4. Cowork Crash Course — A 90-minute, 15-concept primer on Claude Cowork: delegating real desktop knowledge work, the autonomy ladder, prompt-injection defenses, and the plan-review habit that prevents most regrets. The general-agent starting point for knowledge workers.

  5. Website Design Crash Course — A 15-concept applied build course that points everything you just learned at one job: design, verify, and ship a real client website, single-page and multi-page, that looks made rather than generated. Taste as a file the model loads, a four-lane media pipeline from free photos to paid video, screenshots used as tests, and a live URL at the end. Your first real build with the agentic machine.

  6. Spec-Driven Development — A 13-concept primer on agreeing what to build before you generate how it gets built: the project constitution, the four phases (Research, Specify, Clarify, Build), and the same discipline run three ways, in claude.ai, Claude Code, and OpenCode. A thinking discipline, not a coding skill, so non-programmers run it too. About 90 minutes plus a twice-built worked example and six hands-on projects. The discipline that makes whichever co-worker you picked reliable.

  7. The Four Layers — A 12-concept map of the words this field keeps arguing about, and deliberately the shortest course in the section. Prompt, context, harness, and loop are not four skills you choose between, and not four rungs you climb: they are four containers, each one inside the next, each defined by its own unit of work (one model call, the window, one beat, the whole run). You learn the failure signature of each layer, the one success signal a maker beat has by itself and why no prompt can fix it, why the human gate is an exit rather than a stop, which layers you actually own in Mode 1 versus Mode 2, and where graphs fit (which is not as a fifth layer). Ends with an eight-case diagnosis drill and an honest account of when the framework fights you. The payoff is a habit: when an agent burns an afternoon repeating itself, you stop rewriting the prompt and start asking which layer actually broke. About 50 minutes, nothing to install. Prereq: Course 9 or 10; read it before Course 14 (Loop Engineering).

  8. Loop Engineering — A 15-concept primer on the shift from prompting an agent turn by turn to designing the loop that prompts it for you. You learn a loop's six parts — a heartbeat, worktree isolation, a skill, the maker–checker sub-agent split, a connector, and the state spine that survives between runs — built once in both Claude Code and OpenCode, then composed into a single morning-triage-to-PR loop. Covers dynamic workflows as the codified body of a beat, the cost-by-cadence discipline that keeps a loop affordable, and why the durable skill lives at the two ends a loop can never automate: intent and accountability. About two hours to read, longer to build. Prereq: Course 9; builds directly on Courses 12 (Spec-Driven Development) and 13 (The Four Layers).

  9. Harness Engineering — A 12-concept primer on the layer around the model that turns raw intelligence into an agent you can trust: Agent = Model + Harness. The five verbs that organize every harness surface (constrain, inform, verify, correct, escalate), permission rules sorted by blast radius, sandboxes that make damage impossible instead of forbidden, hooks that check work automatically, typed output a program can validate, the four failure classes, and the ratchet habit that turns every caught mistake into a permanent fix. Ends by hardening Loop Engineering's morning-triage loop end to end, in both Claude Code and OpenCode, plus eight practice harness builds. About two hours to read. Prereq: Course 9; builds directly on Course 14 (Loop Engineering).

  10. Graph Engineering — A 16-concept primer on shared memory for many agents, once one loop is no longer enough. The thesis is one sentence: the agent forgets, the graph does not. Agents write what they learn as typed, connected records instead of leaving it in transcripts that die with the session. You keep two graphs and never collapse them — a commit DAG for the work (Karpathy's autoresearch and AgentHub) and a knowledge graph for the facts (Anthropic's Knowledge Graph Cookbook): extraction by schema instead of a trained pipeline, entity resolution that keeps its receipts and stays reversible, and a provenance rule on every edge. Then working from it — hand agents bounded subgraphs, never dumps, and make the checker cite the edge or demand it, so "triple not found" replaces "seems off." A fifth part adds the governance graph: the four ways a single loop breaks, the counter-metric that catches gaming, and the anchors no loop can argue with. Ends by upgrading Loop Engineering's morning-triage loop from a prose spine to a queryable graph — three JSON files, jq, and a pre-commit hook, no database — plus eight practice builds. Includes the honest case against itself: most systems should not build a graph, and the course tells you how to know. Core reading about two hours, three with the deeper notes. Prereq: Course 9; builds directly on Courses 14 and 15 (Loop and Harness Engineering). Take it when you run a second loop; skip it while you run one.

  11. Trusting the Checker: An Evals Crash Course — A 12-concept primer on evals at operating size: how to test the tester so "the checker said PASS" becomes a number you can defend. An agent is a distribution, so grade the pass rate, not the single run; the three depths a run can be graded at (answer, actions, trace); building the golden set from real caught failures (the ratchet becomes cases); anchoring the rubric and calibrating the judge against your own blind grading; running the set as a regression gate on every change and on a schedule to catch drift; and staying honest against Goodhart's law with sealed hold-outs. No frameworks: a folder of cases, a shell runner, and jq, in both Claude Code and OpenCode, ending by testing the morning-triage reviewer itself. About two hours to read. Prereq: Course 9; builds directly on Course 15 (Harness Engineering).

  12. Leaving the Laptop: A Runtime Crash Course — A 12-concept primer on the runtime decision: where a proven loop should live once it has earned trust, and how to move it without losing the track record. One question sorts every option (who operates the loop, and where the work executes), and four homes answer it: your session, a cloud schedule (Routines or scheduled GitHub Actions), a managed runtime (Claude Managed Agents), or your own process. Headless mode is the bridge every move crosses; the minimum unattended kit keeps a lidless loop honest; the suitcase test separates the discipline that travels from the mechanics that get rebuilt; and trust is re-earned in the new home, not transferred. Four questions pick the home and blast radius sets the speed, in both Claude Code and OpenCode. About 90 minutes to read; the moves take longer. Prereq: Course 9; builds directly on Course 17 (Trusting the Checker), and closes the Stage 3 trilogy.

Personal Agent Harnesses​

The shared step between using an agent and picking a mode. Here everyone gives themselves a persistent personal agent — one that remembers across sessions and runs on infrastructure you own — instead of starting fresh in every chat. You build it by directing a coding agent (Claude Code or OpenCode), which does the install for you, so even if Cowork is your daily driver you point a coding agent at this one step. Own your agent here, then pick Mode 1 or Mode 2.

  1. OpenClaw with General Agents — A 90-minute, 6-scenario hands-on course where your general agent installs and configures a Personal AI Employee on OpenClaw: from zero to an AI Employee on your phone, with one custom skill, one MCP tool, one heartbeat task, and a closing ACP-spawn demo where the AI Employee summons a coding agent of its own. Karpathy's "little skill," expanded. Prereq: Course 9.

  2. Hermes with General Agents — A 90-minute, 6-scenario hands-on course where your general agent installs and runs Hermes (Nous Research), the memory-first, self-improving harness: persistent cross-session memory so it carries what it learns between runs, a learning loop that writes its own skills from the hard tasks it solves, model-agnostic so you avoid vendor lock-in, all running on infrastructure you own. The same Personal AI Employee idea as Course 19, built on a harness designed to compound what it learns. Prereq: Course 9; pairs with Course 19 (OpenClaw).

Mode 1 — The Problem-Solving Track​

Mode 1 is a three-course arc: diagnose, solve, cross. You decide whether a task even belongs in an agent and which mode it is (Course 21), solve it well inside a single session (Course 22), and — when a solve proves worth keeping — promote it into a permanent worker (Course 23, the bridge into Mode 2).

  1. Is This an Agent Problem? — The ten-minute triage you run before opening any agent. Three gates: is this even an agent job (or a regular tool, or a chatbot that just answers), will you do it once or every week (Mode 1 or Mode 2), and what does "finished" look like? Three gates, three wrong turns, one clear path — closing with a reference card that maps each answer to the right 2026 tool. The course that stops you burning a whole session on a task that never belonged in an agent. Written for beginners and an international audience. The on-ramp and first page of Mode 1.

  2. Problem Solving with General Agents — A 90-minute, 7-principle crash course in the operating discipline that turns any general agent — Claude Code, OpenCode, Cowork, or OpenWork — from a clever toy into a tool you can ship real work on. The seven principles apply across all four tools: Bash as the key, code as the universal interface, verification as a core step, small reversible decomposition, persisting state in files, constraints and safety, and observability. Includes the four-phase workflow — explore, plan, implement, commit — and a capstone exercise.

  3. From One-Off to Worker: The Handoff to Manufacturing — The bridge that ends Mode 1 and opens Mode 2. When a task you keep solving by hand is proven enough to become a permanent worker, and how to promote it: one signal (the method has stopped changing), four promotions (your brief → a spec, your eyeball check → an eval, you-in-the-loop → an escalation rule, your session → a runtime), and one fork (own a personal harness, or manufacture a Digital FTE). It turns the Mode 1 → Mode 2 crossing from a cliff into a walkable step, and shows that a worker is mostly promotion, not invention. The last page of Mode 1; hands into the Mode 2 track (Course 24 onward).

Mode 2 — The Manufacturing Track​

First, a gateway. Every course here assumes you can read the Python your agent writes, so if you have never coded, start with Python in the AI Era. The track then runs in three phases. Building Blocks first — the pieces a worker is made of: the connector-native app you ship before you ever own a loop, the plugin that extends your coding agent, and the identity layer that lets a worker act as you. Then Build Workers: you own the agent loop, give it a searchable memory, assemble it into a Digital FTE, and wrap it in a durable nervous system. Finally Scale the Workforce: one trustworthy worker becomes a governed, deployed, earning team — run as human-agent teams, designed for people to trust, and proven measurably trustworthy with evals. Without that last move, manufacturing is unprovable — Workers you can't measure are Workers you can't actually ship.

Phase 1 — Building Blocks​

  1. Python in the AI Era — A read-before-you-write primer for people who have never coded. You don't write Python from a blank page; you learn to read, predict, test, and verify the Python your agent generates, using the PRIMM-AI+ method and the Test-Driven Generation (TDG) loop. 17 concepts and six small projects, with a companion base that turns your agent into a disciplined tutor. The literacy gateway every Mode 2 build course assumes. Prereq: Course 9.

  2. Connector-Native Apps — The pre-loop build course: ship a remote MCP server a free-tier Claude user adds with one pasted URL and one Authorize click, before you ever write an agent loop. Fourteen concepts on the four invariants of a connector-native app — one gateway, tools only, prove identity from the verified sign-in, fail closed — built into a Reading Room worked example with OAuth 2.1, a two-table Postgres memory, a session-init gate, and a one-command live run in claude.ai. The host brings the model and the loop; your server brings tools, state, and identity. About 90–120 minutes to read, a focused day to build. Prereq: Courses 9 and 24 (Python); Build AI Agents, further on the path, gives you the loop.

  3. Plugins for AI Agents — Build and ship one real plugin that extends an AI agent you don't own (Claude Code or OpenCode), and watch the portable skill inside it travel to claude.ai. Thirteen concepts on the four invariants of an agent plugin and its four levers (a skill, a subagent, an MCP server, a hook), plus the deterministic exit-2 guard that turns advice into a guarantee. A tested starter carries you from an empty folder to a plugin a teammate installs in one command. The mirror of Connector-Native Apps: there you extended the chat app; here you extend the coding agent. Prereq: Course 24.

  4. AI Identity: Human Sign-In and Agent Access — The identity and access layer, in two halves: own your sign-in (email and social login, sessions, two-factor, and an OAuth/OIDC server that issues real tokens, built on Better Auth), then give an AI worker its own credential and a scoped, time-boxed, revocable, human-approved way to act on a person's behalf. The through-line: whose identity is this, and how does authority pass from a human to an agent? Human sign-in is production-grade today; agent identity is still settling, so the course anchors on durable primitives. Prereq: Course 24.

Phase 2 — Build Workers​

  1. Build AI Agents Crash Course — A 90-minute, 16-concept primer on the OpenAI Agents SDK: agent loop, tools, sessions, streaming, handoffs, guardrails, tracing (your day-1 eval stand-in), human approval, sandboxed deployment on Cloudflare, and tiered model routing for cost discipline (with an optional DeepSeek swap). Prereq: Course 9.

  2. Give Your AI Searchable Context: RAG on Postgres with pgvector — A 15-concept primer on giving your AI searchable context: you direct your agent to turn Neon + pgvector into a working RAG system — schema, an embedding worker, chunking, semantic and hybrid search, eval-driven retrieval, and a read-only RAG MCP server any agent can call. The retrieval foundation the Digital FTE builds on, from the same Manufacturing base. ~2-hour read plus a build. Prereq: Course 9.

  3. From Agent to Digital FTE — A 4-hour workshop on turning a basic agent into a durable Worker: portable Skills, Neon Postgres with pgvector as the system of record, the Model Context Protocol as the wire between them, audit-trail discipline, approval as the authority model, and a worked customer-support Worker built end-to-end. 15 concepts, 8 build decisions. Quick Win in 15 minutes; cheat-sheet skim in 90; full build in roughly 3 more hours. Prereq: Course 28.

  4. From Digital FTE to Production Worker with a Nervous System — A 90-minute, 15-concept course on wrapping your Digital FTE in an Inngest operational envelope: durable execution, event-driven triggers, step memoization, concurrency and throttling, replay, and HITL gates. Extends the customer-support Worker so it survives network blips, restarts, and long-pending approvals. Prereq: Course 30.

Phase 3 — Scale the Workforce​

  1. Human-Agent Teams: The Operating Model for Your Workforce — The operating model for running humans and Digital FTEs as one team: work in the open, one roster with clear roles, a north star, and trust that grows with verified reliability. No code; you direct your agent to draft eight operating documents (roster, role cards, north star, verification rubric, doer-verifier, weekly report, attention budget) and leave with a real team's operating manual. Doable in planning mode before your first worker exists. Prereq: Course 9 for planning mode; live mode assumes a Digital FTE (Course 30).

  2. Designing Agent Experiences — A crash course on the design craft that takes over once software acts on its own. An agentic product has two users at once: a human who must trust it, and other agents who must parse it. Across 18 concepts in four parts (the shift, the human trust surface, the machine surface, and the new craft), you learn to make an agent's judgment legible, its autonomy adjustable, and its mistakes survivable. You direct your agent to draft an Agent Experience Brief for one Digital FTE you already built, then ship an MCP App in a hands-on lab by directing a coding agent with the official create-mcp-app skill. A Reader track of about an hour covers the concepts for leaders and designers who direct the work rather than implement it. Pairs with Course 32 (Human-Agent Teams): that course writes the team's operating model; this one designs the surface where a human experiences the team at work.

  3. Building a Workforce with Paperclip — A 90-minute, 7-scenario hands-on course where your coding agent stands up Paperclip (the open-source, MIT-licensed AI-native company control plane), hires a keyless CEO agent, approves its strategy as a permanent audited board decision, then watches the CEO hire and delegate to a team that builds real files under a budget rail, and reconstructs the whole company history with one SQL query against the activity log. Every scenario runs keyless on the coding agent you're already logged into (Claude Code, OpenCode, Codex, or Gemini); the budget rail sits armed at $0 until you point a Worker at a paid, per-token model. Prereq: Course 30 or Course 19.

  4. From Fixed to Dynamic Workforce — A 90-minute, 7-scenario workshop where the workforce from Course 34 detects a capability gap, drafts a hire proposal, walks it through the same board-approval primitive you used to approve your CEO, and provisions a Reader Support Specialist on your own coding agent (Claude Code or OpenCode). Hiring as a callable function. Closes Invariant 6 (the workforce is expandable under policy). Prereq: Course 34.

  5. From Founder Bottleneck to Owner Delegate — A half-day, two-act, six-scenario hands-on build where the owner of the workforce configures an Owner Identic AI on OpenClaw: it reads routine Paperclip approval requests, clears the ones inside a signed delegated envelope, and surfaces only the decisions that genuinely need a human. The owner is the last bottleneck — this course removes it. Closes Invariant 2 (every human needs a delegate). Ships a downloadable companion base whose AGENTS.md brief has your agent stand up Claudia, a local Paperclip sandbox, and a signed governance ledger. Prereq: Course 35.

  6. Eval-Driven Development for AI Employees — The discipline that closes the manufacturing arc and wraps everything the manufacturing track built. Four learning tracks — Reader (~3-4 hours, conceptual), Beginner (~1 day), Intermediate (~2 days), Advanced (~3 days for full implementation). 15 concepts plus a 7-decision lab. Teaches the nine-layer evaluation pyramid (unit, integration, output, tool-use, trace, RAG, safety, regression, production) and the four-tool stack that fills it: OpenAI Agent Evals with trace grading, DeepEval, Ragas, Phoenix. End state: a workforce where every member is measurably trustworthy, with a weekly trace-to-regression-test promotion ritual that keeps the eval suite alive over months. Reader track for leaders; Advanced track for shipping teams. Assumes either the OpenAI Agents SDK or Claude Managed Agents runtime.

  7. Deploy Your Agent Harness to the Cloud — The course that ships everything the manufacturing track built. It teaches the harness/sandbox split: the control plane (the harness that holds secrets, runs the agent loop, and keeps state) lives in a different security boundary from the execution plane (the sandbox where the agent's generated code actually runs). You deploy one complete production path: FastAPI on Azure Container Apps for the harness, Neon Postgres for durable state, Cloudflare R2 for files, a code-execution sandbox, four-surface observability, and the Course 37 eval suite wired in as a CI gate. Four learning tracks (Reader for leaders and architects; Beginner through Advanced for shipping teams), 17 concepts, and a 9-decision agent-driven lab where your coding agent reads a companion AGENTS.md and builds the harness while you direct it. Prereq: Course 37 (Decision 8 wires its eval suite). The Reader track needs no cloud accounts.

  8. Choosing Agentic Architectures — A conceptual crash course on pattern selection: five questions about your task map to one of four core patterns (sequential workflow; single agent + ReAct + tools; planning + ReAct execution; multi-agent specialist), plus reflection as an additive layer on top. The discipline is choosing by architectural fit, not by what looks impressive: each pattern is a bet about the task, and the right one is the bet whose assumptions match reality. Teaches the five-question decision tree, the two equally common failure modes (overshooting and undershooting), the runtime signals that reveal a mismatch, and how each pattern composes with your deployment topology and your eval suite. Four learning tracks (Reader ~2-3 hours conceptual; Beginner ~1 day; Intermediate ~2-3 days; Advanced ~4-5 days), a five-case decision lab, and a printable classify-this-task worksheet for design reviews. Prereq: you can already build and evaluate agents; cross-references the agent-building, operational-envelope, and eval courses.

  9. Payment-Enabled Agents: ACP, AP2, x402, and MPP — A multi-track crash course on the four protocols that let agents move money: ACP for consumer shopping, AP2 for authorization mandates, x402 for HTTP-native machine payments, and MPP for session-based settlement. The key idea: the four are layers, not rivals. You read a use case, pick one protocol per layer (discovery, authorization, commerce, settlement), and compose them as OpenAI Agents SDK code, with the tool-input guardrail that stops a payment before it happens. Four learning tracks (Reader ~2-3 hours conceptual; Beginner through Advanced for shipping teams), 19 concepts, a five-decision lab, and the three-level spend-limit discipline that keeps a runaway agent from draining a wallet. Prereq: Course 28 (the OpenAI Agents SDK); pairs with Course 31 (Inngest) and Course 38 (cloud deployment).

References & Companions​

  1. Which AI Employees Should You Use in 2026? — Five tools matched to who you are and what you need. Find your starting point in under a minute.

  2. Cheatsheets — Interactive quick-reference cards for the key tools in this book: Claude Code, the Claude collaborative workspace, and OpenClaw.

  3. Agentic Engineering Fundamentals — A 45-minute primer on the engineering discipline that underwrites everything in this section: how to design, ship, and operate agent-based systems with the same rigor you would apply to any other production software. Optional companion read for anyone going past Course 30.

The glossary is your other constant companion. Keep both open in tabs.

What You'll Have When You Finish​

When you reach the end of this section, you won't just understand the Agent Factory thesis — you'll have built against it. You'll have used general agents to ship real work. You'll have deployed at least one Digital FTE that runs without you. You'll have connected it to a nervous system, placed it inside a Paperclip-governed workforce, watched that workforce hire its own colleagues, and freed yourself from being its bottleneck through an Identic AI. You'll have wrapped the whole thing in evals you wrote yourself, so you can prove — not hope — that every Worker is trustworthy.

That's the difference between this book and every other AI course: you don't finish with notes. You finish with a working AI workforce.

And this section stays useful after you finish: the References & Companions above are what you reach for whenever you get stuck.

Everything after this section refines what you've already built. Now pick your mode and start.