You give every worker a write set that belongs to nobody else and a deliberately capped context budget, so parallel workers neither overwrite each other nor drown in context. You then watch the contract checker PV judge three agents editing one README and refuse each planted cheat, naming the rule it broke, and see a gate decide a build-and-review workflow from its receipt. You finish with Simpson's rule ported from a textbook under contract, where a planted one-character change to a weight turns the gate red and the fix turns it green again.

You compare a cold worker that loads its model for every request with a resident worker that stays warm, and learn why only a latency measured in a recorded run counts. You then watch two agents share one local model server, a writer and a checker, and see that a sequential and a pipelined schedule produce identical bytes. Finally you write that workflow down as an ontology with shapes and attack it with planted mutants to see what the shapes catch and what they cannot.

You meet the traffic cop: one minter that hands out tickets, one reducer that merges finished work, and one inbox that is the only door between a worker's private output and shared state. You learn why one model run three times is still one reviewer, and why a quorum needs lanes from different models where any single fail blocks the result. You then watch three agents fan out in the Antigravity app, each in its own workspace, and see the line stop when one goes red so that nothing merges.

You learn why a red result should stop the line until someone understands it, and why a rerun that happens to pass is not a fix; five whys takes a failure past a shallow story to a mechanism you can change. You then study a release that sat stuck for over a day and the process rules that fix it, from letting one run finish to giving the release a priority lane, and close with a recap of the course's patterns.