Module 2 · Tools, Knowledge, Memory & Research Design · scripted

Exercise: The Relay

45 minoutcomes: knowledge-systems, context-engineering

The goal: design what survives

Everything you just learned — teaching your future self, naming for the searching agent — has been advice. Now it becomes an experiment with numbers attached. In this exercise a chain of agents works through a scenario, one task each. Every agent is a fresh conversation: it has never seen the earlier tasks, and it dies when its task ends. The only thing that passes between them is a shared filesystem — and the only thing you control is the methodology: the standing instructions, injected into every agent's system prompt, for what to write down, where, and how. Bad methodology, and facts silently die between tasks. Good methodology, and the fifth agent answers a question only the first agent was ever told.

The relay

Agent 1fresh conversation → task 1 → writes files → dies

Agent 2fresh conversation → task 2 → reads + writes → dies

⋮

Agent Nfresh conversation → task N: needs a fact from task 1

The filesystem is the baton. Your methodology decides what's written on it.

Where to run it

Open The Relay →. Pick a task pack — a scenario whose tasks are chained: information arrives in one task's prompt and is demanded back, tasks later, by another. Write your methodology, then run the relay one agent at a time (watching each one work) or all the way through. Each agent's full transcript is kept: every search, every read, every write, every token. The filesystem is inspectable at any moment, the scoreboard grades every task on whether the facts survived, and finished experiments can be archived and compared.

The tools every agent gets

list_files(path?)what exists

search_files(pattern, path?)grep: names + contents

read_file(path)the full text

write_file(path, content)create — or overwrite, but only after reading it

edit_file(path, pattern, replacement)targeted change, only after reading it

The read-before-write rule is real: an agent cannot blindly clobber a file it has never looked at.

What the numbers mean

The scoreboard

facts keptdid the agent's ANSWER contain the facts the task demanded? (graded automatically, per task)

callshow many tool calls the agent needed

tokensthe estimated cost of its whole conversation — every search result and file read, compounding

bootstrapsearches before the first read: the price of FINDING the entry point

Read the pairs together: an agent with many searches and a failed fact check got lost — your names didn't match its vocabulary. An agent with huge tokens and passing checks is paying a re-orientation tax — it survived by reading everything. The methodology you want scores high on facts and low on everything else.

Step 1 · The naive baseline

Pick The Participant Pipeline, leave the methodology at its one-line default, and run the whole relay. Then read the wreckage like an examiner: open the failed agents' transcripts. Find the moment an agent searched for something that was never written down, or confidently reported a stale fact because the correction never reached the file it read.

Capture — end of Step 1

The scoreboard totals: facts kept, calls, tokens.

The single best failure: which fact died, in which task it was

born, and where the losing agent looked for it.

Step 2 · Design the methodology

Now write a real methodology, and let the lessons dictate its clauses: where things are recorded (containers that match the shape of the information); what names files carry (the words a task would search for); one concept, one name; an index or signpost a searching agent will hit first; and a correction rule — when a fact changes, the old value must not survive anywhere it could mislead (the edit tool exists for exactly this). Name it, save it, reset, and rerun the same pack. Archive both experiments and put the comparison side by side.

Capture — end of Step 2

Your methodology, verbatim.

The compare table: naive vs yours — facts kept, calls, tokens.

The clause that earned its keep: one specific agent that

succeeded BECAUSE of one specific line in your methodology.

Step 3 · Inherit the mess

Switch to the Inherit the Mess pack: the filesystem starts polluted — leftover procedures, a contradicting update, noise. The early tasks force the agents to decide which record to believe, and your methodology must handle a corpus it didn't create. This is the searching-agent trap with the stakes live: does your methodology tell agents how to mark what's stale, or only how to write what's new? Run it, read the transcripts of the tasks that touch the old files, and refine one more time if the first result embarrasses you.

Capture — end of Step 3

What your methodology says about OTHER people's files.

The moment an agent chose between the stale record and the

current one — what it chose, and what made the difference.

Deliverable

Three captures plus your archived compare table. In the group comparison we will build the leaderboard for each pack — facts kept against tokens spent — and then read the winning methodologies aloud. Expect convergence: the winners will have independently rediscovered indexes, task-vocabulary naming, and a correction rule. That convergence is the finding.

As you compare

Whose methodology kept the most facts for the fewest tokens — and which single clause does the work?
Did anyone's methodology make agents write MORE and score WORSE? Where is the point at which recording becomes noise?
The correction tasks: append a new note, or edit the old record in place? What did each choice cost the later agents?
What would break first if the relay were 50 tasks long instead of 8?