🤝

Coop Quest

New: 2026-10-13Updated: 2026-10-12

Work that outlives every model's memory — how a family of AI sessions takes, owns, reports and closes work without anyone remembering to

Workers start assigned work without taking its record. They finish long work after losing the reminder to close it. Then a human repairs the ledger by hand. Coop exists because that happened often enough to measure, and because no prompt can fix a failure that begins where a model's context ends. This quest walks the engine that keeps two facts alive across every context loss: which actual session accepted which exact work, and which accepted work still owes an outcome. You will see why a shared markdown file is the wrong concurrency primitive, how one writer is enforced by a SQL function only the owner defines, why a launch never claims anything, why native harness signals are observations rather than guarantees, how a report can hide in a line that renders as nothing, and how the result finally reaches the one person it is for.

8 tracks · 36 lessons · ~9h · difficulty: intermediate-to-advanced

Level 0Loose Note

0 XP0/36 lessons0/12 achievements

0/100 XP to next level100 XP to go0% complete

Coop is the collaboration engine of a family of AI sessions — Claude Code and Codex chats on several Macs, a chief-of-staff conversation, a calendar app — all of them reading and writing one ledger of todos, requests, letters, history and lessons learned. It began as four markdown files at the root of a repository and became a SQLite ledger in May 2026; in September 2026 it gained an engine that alone may write that ledger. This quest teaches both halves from the code, with the incidents that forced each rule. You start where every team starts: a TODO.md that bloats, conflicts, holds no state and is mis-edited by whoever touched it last, and the ledger that replaced it — seven tables, a roster of identities that may write, lifecycles with a legal fast path, a first close that is the record, and letters whose body is the handoff. Then the single writer: an exclusive lock, a fence that turns every outside write into an error, an owner file that makes the old client fail closed instead of writing locally, idempotency keys that remember their answer, a change feed, and a cutover that refuses to restore an older snapshot over newer truth. The middle of the quest is admission: an assignment written before anything moves, a random marker that finds the exact new chat, an invitation that carries no work envelope and no permission to start (only the todo's body and replies, for review, when replies exist), a token the worker must say, and one transaction that takes, binds and obligates or claims nothing at all. Native doors come next — a single frame into a private socket, receipts read from the transcript, a policy that can hold and silently drop a message, a Codex queue whose turns list runs ahead of its items list — and why every one of them is evidence rather than authority. Then reporting: Korean lines for Dad above a hidden link-reference line, four outcomes, prose finals kept as notes, every reply acknowledged and answered. Then the obligation that stays owed until a decision lands, and the chief who holds Dad's authority to make it. Then the road to Dad: notifications as rows without a session, one line into his Master Chief conversation, one control facade behind Telegram and the coop tool, and follow-up checks armed before a turn returns. It ends across the fleet — one code path for the office and every other Mac, the keychain an ssh session cannot read, origin as the meeting point, a CLI take adopted in place — and with a small ledger of your own. Conceptual open-sourcing: the architecture is the deliverable, never a repository to clone.

Tracks

01📒From Markdown to a Ledger
0/4 lessons
Why many AI sessions cannot share a text file, and what they share instead
Coop began as four markdown files at the root of a repository, read and edited by every AI session that passed through. By the time they were retired the TODO file was 811 lines long under a header that asked, in capital letters, to stay small. This track starts there and works out why: a text file has no item identity, no state you can check, and no write that can lose, so concurrent writers silently overwrite each other. From that diagnosis you follow the ledger that replaced it — seven legacy tables in SQLite, each with one job; an identity roster that went from convention to a write-door guard; lifecycles where a claim is one guarded UPDATE and the first close is the record; and session letters whose body must carry the handoff itself, enforced by a guard that has deliberately no override.
The ledger, made visible: every row has one owner, one state, and a history behind it.
Lesson list (4)
Quiz · 4 questions→
02🔒One Writer
0/5 lessons
How a ledger with many hands came to have exactly one, and how it refuses the rest
Track 1 ended with a ledger that many sessions wrote at once. This track is how it came to have exactly one writer, and, more interesting, how that writer refuses everyone else without asking them to cooperate. You will take apart the two guards that make it true: an exclusive file lock that stops a second engine, and a SQL function that only the owner's connections define, so every outside write fails before it starts. Then come the owner file that turns every old caller into a client that fails closed, the idempotency key that remembers a write's answer (and why reads stopped leaving receipts once one answer reached 236 KB), the change feed that captures every mutation inside the write's own transaction, and the 2026-09-27 cutover, whose recovery path refuses to let an old snapshot replace newer truth.
Lesson list (5)
Quiz · 4 questions→
03🎟️A Launch Never Claims
0/5 lessons
Opening a chat, starting a process or saying yes takes nothing; one transaction does
A worker that starts without taking its record, or finishes without closing it, leaves Dad repairing the ledger by hand. This track follows the path Coop built so that ownership never depends on anyone's memory: an assignment row written before any app opens, a fresh chat found by a random marker in its first message rather than by the folder it happens to open in, an invitation that carries a one-use nonce and never the permission to start (a todo's body and replies ride along only when it has replies to acknowledge), and a single transaction that checks every revision, takes the work, binds the exact session and creates the outcome obligation, or claims nothing at all. Then the two things that keep that ownership honest over time: session generations that fence a stale adapter the way a fencing token fences a paused lock holder, and shared checkouts that are disclosed instead of refused, so two sessions can work in one repository without either one tidying away the other's changes.
Lesson list (5)
Quiz · 4 questions→
04🚪Native Doors Are Observations
0/4 lessons
Writing into chats you do not own, and knowing only what the far side records
Coop does not run its workers. It reaches into chats that belong to Claude Code and Codex through doors those vendors built for other purposes: a private inbox socket that takes one JSON frame and never answers, and a thread queue that accepts an input and echoes back an id. This track walks through both doors and the lesson they share. A successful write proves only that bytes left; whether the harness received them, whether the worker agreed and whether the work finished are separate facts, read afterward from the receiver's own transcript or turn history. You will see a receiver policy silently drop invitations and why the only answer is a deliberate Send again, a status field that called a running turn interrupted, a hook that let work through when it timed out, and a version allowlist that blocked every assignment and was finally deleted. Everything native is evidence; nothing native is an outcome.
Enrollment is explicit and per session — a chat the engine has not enrolled is an observation, never a door it controls.
Lesson list (4)
Quiz · 4 questions→
05📮Reporting Back
0/5 lessons
How a worker's last words become a record, and why a question about finished work stays a question
Accepting work is half of a contract; the other half is saying what happened to it. This track follows a worker's final answer from the chat to the ledger. It starts with a single Markdown line that every CommonMark renderer draws as nothing, so Dad reads a few Korean lines while the engine reads the JSON beneath them, and with the one angle bracket that broke it open. Then the four outcomes the engine accepts, why blocked is not an ending, and the single transaction that closes an item, resolves its debt and tells Dad together. Workers do not always follow the format, so you will see what happens to a final written in plain prose and to a report the engine refuses. Finally, replies: how a correction on live work reaches the exact worker, why every reply needs its own answer before done, and why a question about finished work is delivered and relayed but never reopens it.
Lesson list (5)
Quiz · 4 questions→
06⚖️Obligations and the Coop Chief
0/4 lessons
A debt written with every take, and Dad's proxy who decides what pays it
Accepting work in Coop writes a debt in the same transaction: an outcome obligation that only a real disposition can pay. This track follows that debt. You will see why a turn that ends without a report can make the obligation eligible for review and never closes it, and why a review is owed on evidence (a real status transition, a fresh worker note, a lost session) and never on an adapter repeating what the engine already knew. Then you meet the reviewer: the Coop chief, an ordinary Pippa conversation the engine wakes even with the browser closed, which has held Dad's full authority over the ledger since his ruling of 2026-09-30 and answers in a machine envelope the engine checks line by line. It is not Master Chief. The track ends with the walls around that reviewer, the conversation rotation, and the review that found 74 wakes changing nothing and an outbox nobody read.
The chief acts as Dad — with every power written down, and a counter that says when its conversation should start over.
Lesson list (4)
Quiz · 4 questions→
07📣Reaching Dad
0/4 lessons
From a row no worker will claim to one line Dad actually reads
Most of Coop happens out of Dad's sight, and that is the point. But an engine that never tells its owner anything is a black box with good intentions, so this track follows the road from the ledger to Dad. It starts with Coop's quietest design decision: a notification is just an outbox row with no session, written in the same transaction as the change it announces and carried by one reader whose retry is bounded and whose failures stay visible. It crosses into cwkPippa through a narrow, loopback-only door that writes one line into Master Chief, Dad's continuous conversation, and rings Telegram once per row, and it tells the story of the bug that rang twice. Then it turns around: the single control facade that Telegram and Pippa's tool share to send work the other way, and the follow-up Pippa arms before a turn returns, so that "I'll let you know" is a durable record instead of a promise nobody keeps.
Lesson list (4)
Quiz · 4 questions→
08🛰️Across the Fleet
0/5 lessons
One writer on office, workers on any Mac, and the remote where their work meets
Coop has exactly one writer, and it lives on office. Then Dad's office Claude account ran out while the laptop's had room, and the engine had to follow a worker on another Mac without growing a second brain. This track follows how. You will see the one outbound ssh connection that carries a stdlib helper inline, so the hands on the far side are always the engine's own version and nothing is installed there; the launch that kept saying "Login expired" until a measurement showed that an ssh-born process cannot read the keychain; the paragraph that tells a remote worker origin is where two Macs meet, and that a pushed commit is not done until office has pulled it through; and the adoption pass that finds the exact chat behind a CLI take and makes its record managed in place. It ends with you building the whole ledger in miniature, in one file you can run.
Lesson list (5)
Quiz · 4 questions→

Spotted a bug or have feedback on this page?Report an Issue

Comments 0

🔔 Reply notifications (sign in)

No comments yet — be the first.

Tracks

01📒From Markdown to a Ledger

02🔒One Writer

03🎟️A Launch Never Claims

04🚪Native Doors Are Observations

05📮Reporting Back

06⚖️Obligations and the Coop Chief

07📣Reaching Dad

08🛰️Across the Fleet