r/place A fruit fly for organization science

Authoritative source, reproduced unchanged. Exact Markdown · Agent copy with resolved links. These instructions govern research runs, not checkpoint interviews.

Stage B2. Assignment: the pilot.

Model: build and check legs as arm.json sets (your platform file lists them); dispatch outside your session, the dispatch sending packets to the routine readers on the platform's reader route (FLEET.md). Legs: per round, build, dispatch, check; the check leg of round k decides whether round k+1 opens. This stage freezes the scheme. You hand it, with a small set of deliberately hard second-order themes, to fresh readers, and treat every divergence as a defect in the description rather than in the reader.

Steps: B2a-r1 build round 1 (it ends at --cut packets-out), the dispatch, B2b-r1 check round 1; then B2a-r2, B2b-r2 ... while a round is needed; after the freeze, B2c builds the gold round and the two stability rounds (it ends at --cut packets-out), three dispatches, and B2d checks them. Each leg is named by its step (STANDING §2).

Safe stops: after the packets are written (the build leg), and after each section of the check leg. At a safe stop, check for .pause (ls .pause); if it is there, log where to pick up, your working hypothesis and the next room or item (mem.py log "<hypothesis>; next: <item>" --kind pause), and close with done.sh B2 --pause (STANDING §2).

Startup packet: _head.md, this file, FLEET.md, the last five diary entries, validate.py --open B2. In a check leg the harness adds one line: the readers left their files in _fleet_raw/B2/round-k/.

Reads allowed: scheme.md, scheme.jsonl, families.jsonl, confusions.md, notes-B1.md; the corpus through cite.py; second-order themes through mem.py theme, concepts through codes --sub; _fleet_raw/B2/ in check legs. Forbidden: your room notes, the running file and findings.jsonl to any reader; gold_items.jsonl to any reader; exemplars to any reader in this stage.

Outputs: author_items.jsonl; gold_items.jsonl; RETURN-B2.md; pilot_rounds.jsonl; scheme_edits.jsonl; exemplar_candidates.jsonl; stability-B2.md; pilot_report.md; the frozen scheme_final.md and scheme_final.jsonl; notes-B2.md; a run_manifest.json entry.

1. Build leg, round 1: the hard set, the gold set, the declarations

Place every item yourself first, into author_items.jsonl, each with confidence (clear|arguable), which stage B4's transmission rows split on, before any packet exists. Whether a reader holding only the scheme lands where you would have landed has an answer only if your answers were written down first; a scheme edited with your own placements in front of you is edited to justify them. Three sources, mixed and shuffled so a reader cannot tell them apart, sizes declared in notes-B2.md before round 1: the second-order themes you nominated in confusions.md to expose each ranked pair, at least half sibling pairs inside one family, since that is where a scheme of hundreds divides readers (the pilot scores that prediction); the ten biggest bags from notes-B1.md; a random sample, seeded and recorded. Forty to sixty items.

The gold set: a second hard set by the same rule and seed discipline, placed by you, shown to no pilot reader, written to gold_items.jsonl with placements, confidence and reasons, and kept outside the readers' directory (FLEET.md). It is scored once, after the last round (§5). Stage B3 seeds it unannounced into the live batches at the rate you declare.

Declared before round 1, in notes-B2.md: the stopping threshold (pairwise agreement on the hard set at which rounds stop); the agreement definition stages B3 and B4 reuse unchanged (whether ["T3-004"] against ["T3-004","T3-011"] is agreement, disagreement or partial: agreement on sets by Jaccard where rule 0 allowed more than one placement, alpha computed on it; and whether chance correction is over themes, over sets, or over presence and absence per theme); the gold policy (count, seeding rate, and that they are seeded; never the items); the batch cap stage B3 runs under, set from §4 below after round 1.

RETURN-B2.md, the one return specification (FLEET.md): the return line below, rule 0 in the contract's words and not restated (a reader that places a second theme owes rule 0 its line in multiplacement_log.jsonl, here as at stage B3), the end marker, and the line telling the reader to confirm it reached the marker. packets.py B2 builds one packet per reader under the 50 KB ceiling: scheme.jsonl as it currently stands, served as stage B3 serves it, the index page whole and the families opened as the reader needs them; the hard set's items with label, theme_note and concepts; and no exemplars: stage B3 may ship them; this stage measures the description alone. From the round after 2026-10-11 (J) the return line also carries also_present: {} unless item_is_a_bag is true, and then every theme beyond the one placed, each with its own concept ids (rule 0 as amended); support holds the concepts behind the primary, and each further theme's concepts are in its multiplacement_log record. Rounds sent before the amendment are scored as they were sent. Oversized items are served in parts to the same reader (MANIFEST.json groups, as stage B3 serves a large room), never dropped for size.

{"sub": "...", "theme_id": "...", "batch": "...", "agent": "...", "replicate": 1, "position": 23,
 "third_order": ["T3-007"], "multi": false,
 "why": {"T3-007": "what about THIS theme put it here rather than its nearest neighbour"},
 "confidence": "clear|arguable", "read": "whole|theme-block", "exemplar_read": null,
 "families_opened": ["G03", "G09"], "t_start": "...", "t": "...", "support": ["c0013"],
 "also_present": {}}

Append the round's manifest entry: readers' model, seed, decoding, count. Every later fidelity is compared against this stage's figure. Stop here. Close with done.sh B2 --cut packets-out. Your session ends; nothing more of this stage runs on your model until the check leg. The dispatch runs without you, on the platform's reader route. The next launch of stage B2 is the check leg, and its packet tells you one thing: the readers left their files in _fleet_raw/B2/round-k/.

2. Dispatch leg

Not yours. The dispatch sends each packet to three fresh readers, collects the returns into _fleet_raw/B2/round-k/, validates them against RETURN-B2.md, reissues what fails the schema, and closes. Nothing in it reads your files. A partial return is not a return: its unwritten items are gaps, not verdicts, and are reissued; when reissues are exhausted the stage stops and you rebuild the packets (FLEET.md). No reader gets a stronger model for a hard item: readers are interchangeable or fidelity means nothing. In the check leg copy fleet.py's counts into notes-B2.md: readers, reissues, durations. Counts, not readings.

3. Check leg: the three numbers and the edit

You are relaunched. Validate, then score, in this order: fidelity against author_items.jsonl, the primary figure; pairwise agreement among the three readers, secondary, since three readers can agree with each other and all diverge from you; your own consistency, by re-placing ten of the hard set blind (after the last round only): open a blind window first (mem.py blind on --reason "..."), read the ten through mem.py theme and the packets' family pages, write your placements, then mem.py blind off; the read log is the evidence that the window held. If you disagree with yourself more than the readers disagree with you, the fleet is not the problem. Every item where any two disagree is a finding and the material for the edit. One line per round in pilot_rounds.jsonl:

{"round": 1, "n_items": 52, "agents": 3, "exemplars": false, "fidelity_vs_author": 0.0,
 "agreement_pairwise": 0.0, "alpha": 0.0, "items_with_disagreement": ["..."], "seed": 0}

The edit, every one logged in scheme_edits.jsonl with stage B4's taxonomy, so the pilot and the run share one set of names: scheme-ambiguous (the belonging test or the discriminator does not decide; fix the sentence); item-is-a-bag (the coder's theme holds two practices, so no single placement is right; not a scheme defect; flag the item and move on); reader-error (the file does decide and the reader missed it; suspect this last: two independent readers making the same miss is a scheme defect that looks like a reader error); author-error (you were wrong and the readers were right; a pilot that never returns it measures obedience); genuine-joint (the material satisfies two gates and one placement cannot carry it, rule 0's exception on the record; check that the readers actually differed rather than one recording the exception).

{"round": 1, "theme": "T3-007", "field": "must_not_show", "caused_by": ["sub/theme_id", "..."],
 "was": "...", "now": "...",
 "why": "two of three readers placed a coordination-of-labour item here because the test said nothing about who was named"}

An edit with no caused_by is not allowed; stage C1 opens scheme_edits.jsonl before it revises anything. Every edit is a tier_history line with its move (relabelled or rescoped, move asking questions or splitting). Never tighten by narrowing until a theme becomes rare: it looks like success here and makes that theme's prevalence wrong everywhere after. Watch every theme's base rate across rounds and report it.

Every edit owes its rechecks (J, 2026-10-11). After you change a gate, place again every placement of yours it could move: the items of author_items.jsonl and gold_items.jsonl on the edited theme, or on a theme its old or new sentence names. mem.py rechecks --owed lists them (the edit is edit:<n>, its line in scheme_edits.jsonl; above thirty a seeded sample of thirty, and all of them once more than one in ten of the sample moves); mem.py recheck <sub>:<tNN> --change edit:<n> --theme ... --codes "T3-a=c1,c2" --reason "..." records each, with the concepts behind each theme. author_items.jsonl stays as you wrote it: from the next round report fidelity twice, against it and against the rechecked placements, and say in each moved recheck's reason whether it is an author-error or the edit doing its work. The close refuses an edit whose rechecks are missing. Then run mem.py gates and read every pair an edited theme belongs to (mem.py gates T3-a T3-b), confirming each with --confirm --reason: a discriminator that runs one way, or a must_not_show that sends material to a theme with no discriminator against it, is fixed before the packets are rebuilt, and the freeze refuses a scheme that carries either.

Then decide: another round opens if no stopping condition holds (§5), and its build leg rebuilds the packets from the edited scheme.

4. Two things this stage owes the fleet

How long a convention takes to form. Compare each reader's first ten items against its last ten on the arguable rate and on agreement with the other two; report where the curve flattens. If either still improves inside a round, formation is still happening and stage B3's cap is too small; the fix is a warm-up block that does not count, not a bigger batch. Which items make good exemplars. Export the items that divided readers to exemplar_candidates.jsonl; stage B3's exemplar arm draws from them, not from clear cases.

5. Stopping, the freeze, stability, the gold score

Rounds stop when one holds: a round produces no scheme edit; pairwise agreement on the hard set clears the declared threshold; four rounds. After four, a scheme that still divides three readers is telling you about the tier, not the wording: report it and carry it into B3.

Freeze the scheme as scheme_final.md and scheme_final.jsonl, the rare tier inside it under "tier": "rare", families.jsonl beside it. Then, in B2c, the dispatches on the frozen scheme: one round of fresh readers on the gold set (packets.py B2 --round gold --items gold_items.jsonl); and the stability check (FLEET.md), the gold set served to the same reader arm under two rewordings of the brief that change no test (out/brief-stab-1.md and out/brief-stab-2.md, written by you; packets.py B2 --round stab-1 --items gold_items.jsonl --brief brief-stab-1.md, and the same for 2), whose disagreement with itself is written to stability-B2.md and is the floor every later figure is read against. Report gold fidelity beside the last pilot round's fidelity (close means clearer, much worse means fitted); pairwise agreement and alpha on the gold set beside the final round's; per-family agreement, and per theme only where a theme has three or more items in the set, since at hundreds of themes over sixty items a per-theme figure is one item wide; your confusions.md predictions scored: which pairs confused readers, in what order, and how the observed rate compared with your estimate.

Gold fidelity is a trend against this stage's frozen figure, not a level: the set was drawn hard, and the figure is agreement with your own placements. Wherever a figure from this stage appears, say what it licenses in FLEET.md's words, and which claim you are making: what you would have produced at a scale one analyst cannot reach is supported; what any competent reader would have produced is not.

6. pilot_report.md

The rounds, with agreement climbing or not; every edit grouped by theme with the disagreement that caused it; the gold number beside the last pilot number and what the gap means; the author-error verdicts, listed; the themes that never stabilised, named, with what stage B4 should expect from them; the prediction scorecard; the stability figure; what it cost: readers, items, tokens (tools/tokens.py --dispatched gives the tokens each packet cost, as the gateway counted them).

Moments to log

Each declaration; each round opened and closed with its three numbers; each edit; the freeze; the stability result.

Final message

Rounds run; fidelity at round 1 and at the end; the gold figure with agreement and alpha beside it; the stability figure; author-error count; your blind re-placement score; edits by field; which predicted confusions were real; themes that did not stabilise; any theme whose base rate fell while tightened; the one sentence in the scheme you are least confident a stranger reads as you meant. A return value.

Close

done.sh B2 at every leg (its close-check is validate.py B2; paste the report into notes-B2.md); --cut packets-out at every build leg; where a check leg's edit recuts a theme, the move logged with mem.py log --kind move and snapped with python3 tools/snap.py B2 move-<move>-<n>; handback-B2.md; the head; the closing diary line.