The common chassis
The common chassis
Curriculum Module 0 / Lesson 2. Lab shape: build. Runtime: in-browser Python (Pyodide — a Python runtime that runs in the browser).
Watch it fail
A team spent three months building a coding agent on a strong model. First week with real users, it failed five ways:
- It reported “done” with nothing on disk.
- It called one tool hundreds of times and never stopped.
- It pasted a secret into a log file.
- It forgot the plan after a long run.
- A human watching it go wrong could not interrupt it.
Five failures. Five missing parts. The team did not know those parts had names until production taught them — hard, in front of users. [ILLUSTRATION — assumed]
Here’s the thing: every one of those failures was predictable from a map. Not exotic genius foresight — a checklist of what every working harness already figured out.
This lesson is that list.
Before you scroll: which of those five scares you most for a harness you would ship? Write one sentence.
The mental model
Across many production harnesses — different labs, languages, and models — the same thirteen mechanisms keep showing up. Not vaguely similar. The same jobs. Nobody coordinated this; it is convergence. When enough teams hit the same failures, they invent the same fixes.
Think of a car chassis. Sedan, truck, race car — different clothes, same skeleton: wheels, steering, brakes, a frame. Nobody debates whether a car needs brakes. The thirteen mechanisms are that skeleton for agent harnesses.
One sentence: every good harness is the same thirteen mechanisms wearing different clothes.
The mechanism
The thirteen, one line each, grouped the way you will meet them in the course:
The loop — how the agent moves through time:
- Think-act loop (with clear stop conditions). Reason, act, observe — with explicit turn boundaries. Often called a ReAct-shaped loop (reason then act). (Module 1)
- Saved run history. “What now?” comes from a persisted log, never from RAM alone. Crash recovery falls out of the log. (Module 1)
- Helper agents (with depth limits). Child agents return distilled results, not raw transcripts. Depth has a budget. (Module 9)
The truth — how the harness knows anything worked:
- Check the real files. The check reads the artifact on disk. Chat prose is not success. (Module 5)
- Block cheating the check. Detectors in the loop; graders get stress-tested before they are trusted. (Module 5)
The memory — how the agent survives long runs:
- Shrink old context. Shrink context on purpose near the limit, with reserved budget — do not fill the window by accident. (Module 6)
- Reuse a fixed prompt start. Append, do not mutate; keep order deterministic so prompt caches stay stable. (Module 6)
- Load tools when needed. Tools and skills load on demand. Stuffing everything into the prompt is the anti-pattern. (Modules 2–3)
The safety — how damage is contained:
- Ask before risky actions (allow / ask / deny). Never only on/off. Ask never silently becomes allow. Contested — see dissent below. (Modules 4 and 10)
- Sealed workspace for shell work (operating-system sandbox). Network off or proxied by default. Contested — see dissent below. (Module 4)
- Stop repeated actions. Decode failures that teach the retry; identical tool spam gets interrupted. (Module 2)
The people — how humans stay in charge:
- One agent edits at a time. One writer per session; snapshot before each model step. Version control, not file locks. (Module 9)
- Human sign-off at the plan and the merge. Approvals become durable policy. Corrections are cheap; waiting is expensive. (Module 10)
Production breakdown (once per module)
Walk one anonymized production harness — real users, many runs a day — against the map:
| Design choice (anonymized) | Chassis part | Why it matters |
|---|---|---|
| Checked transition table; illegal moves throw | #1 Think-act loop | The loop cannot drift into undesigned states |
| Append-only event log; resume means replay | #2 Saved run history | Crash recovery is free, not a bolt-on |
| Verifier runs tests and reads the exit code | #4 Check the real files | The agent cannot talk past the check |
| Ask / allow / deny per tool, with a human queue | #9 Ask before risky actions | Authority is explicit |
| Compactor near the limit with reserved budget | #6 Shrink old context | Long runs survive by design |
Sound familiar? String-matching “PASS” from Lesson 1 is what #4 replaces.
Question for you: if you only shipped #1 and #4, which Lesson 1 failure modes would still bite you?
The honest dissent
Two parts are contested (#9 ask before risky actions and #10 sealed workspace). Some serious teams ship without per-tool approvals and without a sealed workspace in the core product — arguing the security boundary is a product choice (trust at load time, containerize the process), not a law of nature. This course teaches those two as the consensus, and keeps that dissent visible. The still marks them debated. The chassis is where the field converged — not scripture.
Public coding agents (for example Claude Code, OpenCode, or Codex-class tools) advertise loops, tools, and permissions at a high level; this lesson does not invent their private internals. Stick to what vendors document and to the anonymized pattern above.
The failure mode
Checklist religion. “We implemented all thirteen — why do we still fail?”
Because mechanisms interact, and the list does not show the interactions. A file check without a sealed workspace (Lesson 1 harness E). Shrinking context that drops evidence the file check needs. Permissions that are three-valued on paper but auto-approve ask after a short timeout in practice.
The chassis is necessary, not sufficient. Later modules teach how these parts bite each other.
The lab
Open the practice cell. Place every mechanism number into one of five group tags (loop, truth, memory, safety, people). Mark the two contested numbers. Choose any three to build first (must be distinct). Name one you distrust. Write a one-sentence harness thesis.
Every blank starts as None. Asserts fail with a hint until the map matches the lesson grouping and the other fields are filled sanely. Practice seed is locked at 0. No API key.
Explore first (browser page, no API key): chassis explorer — illustration cards for all thirteen.
One-line close
Thirteen mechanisms. One map. The rest of the course builds it.
What breaks next: labs agree on the chassis, then compete on three axes. Next lesson: pick your battleground.
Home numbers / honesty table
| Item | Value | Label |
|---|---|---|
| Mechanism count | 13 | ILLUSTRATION consensus map |
| Group count | 5 | ILLUSTRATION teaching grouping |
| Contested parts | #9 and #10 | ILLUSTRATION of field dissent |
| Production table | anonymized walk-through | ILLUSTRATION pattern, not a named vendor dump |
| Benchmark scores | none | — (do not invent) |
| Lesson video | not shipped | no playable file in the app |
Video
No rendered lesson video is shipped in this build. A Manim script for a chassis-assembly scene exists in the curriculum docs under the repo; it is a plan for a future render, not a playable file linked from this page.