General Agents
The tools that don't just talk — they do. Learn to drive one; everything else in the book builds on it.
Foundations taught you what AI is and how to keep your own judgment while using it. This section is where you pick up the tool you will use for the rest of the book: a general agent, an AI that does not just answer, it acts. It opens your files, reads them, writes and runs code, and uses other apps to get a task done.
You do not have to install anything to begin. Your first step in this section happens in the same browser tab where Foundations ran:
- General Agents on the Web — the front door to the whole section. Direct your first real agent from a browser tab, with nothing installed: what a remote session is, where your files actually live, how an approval reaches your phone, and how to read any new agent product through one shared shape. Everyone starts here, on day one, whether or not you can code.
When you are ready to bring an agent onto your own machine, there are two doors into the rest of the section, and which you take depends only on who you are:
- Claude Code and OpenCode — for people who work with code.
- Cowork and OpenWork — for everyone else: the same power in a desktop app, aimed at professional and knowledge work.
Same idea, different audience: an AI you direct to do real work, rather than one you only chat with.
This is the hinge of the whole book. Almost everything after it assumes you can drive a general agent. Mode 1 (solve a problem once) and Mode 2 (manufacture a permanent worker) are both, at heart, "you and a general agent." Even the optional Personal Agent Harnesses bridge installs and runs its harness through one of these tools. So this is the single most-reused skill you will learn. And later, the same general agent you drive here becomes the tool you use to build workers. Same tool, bigger job.
The section in three stages
The courses here move you along one line: from holding the tool every second, to directing it precisely, to designing a loop that runs it for you, hardening the harness that loop runs in, then measuring whether the checker at its center can be trusted.
Stage 1 — Drive
Learn to operate a general agent well. Everyone starts on the web with nothing installed; then do the installed-tool course that matches you, and pick up the others later.
- General Agents on the Web — start here, in a browser, with nothing installed. Direct your first agent on the July 2026 web work surfaces (Claude Cowork on the web and ChatGPT Work): remote sessions, where your files live, the approval that reaches your phone, and the six-part lens for reading any agent product. Everyone takes this first, whether or not you can code; then pick an installed tool below.
- Local AI: Agentic Coding on a Model You Run — the coding track's first stop. Get a coding agent running on a model on your own machine, free and offline, and see what is under the hood before you lean on the cloud: your agent is a harness plus a swappable brain, and here you own the brain. It helps to have driven a coding agent already, but if you have not, its one-command install stands one up for you. Knowledge workers can skip this and go straight to Cowork.
- Agentic Coding: Claude Code & OpenCode — for people who work with code. Plan mode, context management, the rules file, skills, subagents, and connectors (MCP): how to drive a coding agent so it reads your files, proposes a plan, makes the edits, and lets you check the result.
- Cowork & OpenWork for Professionals — for everyone else. The same kind of agent in a desktop app built for professional work (documents, spreadsheets, slides, research), so you do not need to touch a terminal to put one to work.
Stage 2 — Direct
Driving gets you results; directing gets you the right result, every time.
- Spec-Driven Development — stop giving the agent vague instructions and start handing it a written spec: exactly what to do, on what, and what "done" means. A clear spec is the difference between an agent that guesses and one that hits the target, and it is the very first thing you carry forward when you cross into Mode 2.
Stage 3 — Delegate the loop
The last three courses are the first taste of autonomy, still inside the tools you already know: design the loop, harden the harness it runs in, then prove the checker at its center with evals. A fourth then answers the question all three raise: once a loop is trusted, where should it live?
- Loop Engineering — the leap from holding the tool to designing a system that prompts the agent for you. You build a small loop that wakes up, looks at what changed, decides what is worth doing, hands each job to an agent, checks the result, and calls you only for the decisions that really need a person. The valuable skill moves from the prompt you write to the loop you design. It is the natural doorway to everything that comes next.
- Harness Engineering — the trust half of the same leap. A loop that runs while you sleep needs a layer that decides what the agent may do, what it must know, how its work is proven, and what happens when it goes wrong. That layer is the harness — Claude Code and OpenCode each ship one — and this course teaches you to engineer it on purpose: permission walls, sandboxes, automatic checks, and the habit of turning every caught mistake into a rule that makes repeating it impossible.
- Trusting the Checker — the loop runs, the harness proves the work, and at the center sits a checker that says PASS or FAIL. But how do you know the checker is any good? This course teaches evals: you build a small folder of test cases from real failures, grade the reviewer several times instead of once, calibrate it against your own judgment, and gate every change on the result. It turns "the checker said PASS" into a number you can defend, using only files, shell, and jq.
- Leaving the Laptop — the runtime decision. A loop proven on your laptop is trapped on one machine; this course moves it to where it runs for real (a cloud schedule, a managed runtime, or your own process) without losing the track record it earned. It closes Stage 3: the loop runs, the harness guards it, the checker is trusted, and now it lives somewhere that does not sleep when you do.
Four words, one inside the next
The three stages above use four words that the industry mixes up constantly: prompt, context, harness, and loop. Fix them in place now, because every course in this section owns exactly one of them, and half of the confused writing you will meet online comes from treating them as synonyms.
| Word | What it is | Unit of work | The course that owns it |
|---|---|---|---|
| Prompt | The message you send: the ask, the examples, the format. | One message | AI Prompting in 2026 |
| Context | Everything the model sees for one response: files, history, rules, tool results. | What stays in the window, step by step | Agentic Coding, Parts 2–4 |
| Harness | The rules inside one run: what the agent may do, how its work is proven, what happens when it fails. | One run | Harness Engineering |
| Loop | The schedule around everything: starts runs, grades them, remembers between them. | Many runs, over days | Loop Engineering |
The four are not steps in a line. They are layers, one inside the next. A good prompt fails inside bad context. Good context fails inside a bare harness. A good harness sits idle without a loop to run it. This is why an agent that works in a demo so often dies in production: the demo needed only the inner layers, and the outer layers were never built. The model was not the problem. The layers around it were missing.
Most writing online draws the harness and the loop with one pen and calls the whole thing "the harness." This book keeps them apart, on purpose: a missing permission rule and a missing schedule are different bugs, fixed on different surfaces. Loop Engineering, Concept 1 teaches the split; the Harness Engineering course defends it. When an outside writer's "harness" seems to include the schedule, translate: they drew two of this book's layers as one.
A good prompt gets you a clever answer. The four layers together get you something you can ship.
What you need first
Do the Foundations section first, especially How to Think in the AI Era (keeping your judgment) and Skills & Connectors (the plugins a general agent uses to reach your tools and data). You do not need to be a programmer: if you are not, take the Cowork & OpenWork door and you will be fine.
Where it leads
Once you can drive, direct, loop, and harden a general agent, the rest of the book opens up. The optional Personal Agent Harnesses section sits just ahead, if you want to own a worker that runs on your own infrastructure. Then comes the fork the whole book turns on: Mode 1 — Problem-Solving, where you use a general agent to solve a problem once, and Mode 2 — Manufacturing, where you build a permanent worker that solves it forever.
The book's arc in one line: Foundations to understand, General Agents to drive, the two modes to put to work.
Start in the browser with General Agents on the Web — everyone can, on day one, with nothing installed. Then, when you bring an agent onto your own machine, pick the door that fits you: Claude Code & OpenCode if you work with code, Cowork & OpenWork if you do not.
Continue to General Agents on the Web →