# ARCS maritime study: pre-registration

**Recorded 28 October 2026, 21:08 Eastern, before any model was asked anything.** This is the
study's README as it stood then, with the SHA-256 of every file in the package (at the end).
The answer key's hash commits to every answer without showing one. A run is valid against this
record only if `sea_cases.jsonl`, `sea_protocol.py` and `study.py` hash as listed: the runner
writes those three hashes into its journal each time it opens the run, refuses to go on if they
change, and journals the hash of every prompt it sends.

---

# The study: every night stop, ten years

The full run of the October 24 pilot. The pilot asked four U.S. models about 400 night stops
drawn from the ten-year archive; this study asks the Colosseum's whole panel about **every stop in
the archive whose outcome the record shows: 1,031 of the 1,047**. Same question, same batches of
25, same YES/NO with a confidence from 1 to 10. Every call goes into a sealed, hash-chained
record, and the scoring below is fixed before the first call.

**Before running anything:** `python3 verify.py`. All checks must pass. Then see "Running the
panel" below.

## The question, and how the answer is known

*Will this vessel be inside the 12-nautical-mile line (U.S. territorial waters) within six hours
after this stop?*

The answer comes from the vessel's own later AIS track, as the stop-at-sea sweeps recorded it,
on the sweeps' own clock: hours from the moment it stopped to its first fix inside the line
(`in_us_waters_h_after`, the clock behind the lists' "did next" column and the pilot's answers):

| Answer | Rule | Vessels |
|---|---|---|
| YES | its first fix inside the line came 6.0 hours or less after the stop | 751 |
| NO | its first fix inside the line came later, or it never came in and was still heard 6.0 hours or more after | 280 |
| left out | it never came in, and the record lost it less than 6 hours after: the answer cannot be known | 16 |

The 16 left out are listed in `excluded_stops.csv`. Three of them are the smoke test's practice
cases (ARCS-SEA-9001 to 9003): real stops, never scored, never among the study's.

**A second clock.** The lists also carry `hours_until_inside_12nm`, worked out separately. It
gives a different answer for 19 of the 1,031 vessels: 16 that crossed the line within about an
hour of the six-hour mark, where the two clocks fall on either side of it, and 3 where one clock
has the vessel come in and the other has it stay out. The answer key keeps both
(`other_clock`), and every lift is shown again on the 1,012 vessels where the clocks agree.

**The base rate: 72.8%** (751 of 1,031) came in within six hours: 72.8% off Texas and western
Louisiana (305 of 419), 72.9% off California (446 of 612).

## The stops

Every full-pattern stop in the Coast Guard's AIS archive (NOAA MarineCadastre daily files),
2015-2024, off Texas and western Louisiana (24.5-30.5 N, 98-92 W) and off California: a cargo
ship, tanker or service craft making way at 4.5 knots or more that slowed below 3 knots for 5 to
30 minutes and made way again, at night (sun more than 6 degrees down), 12 to 24 nautical miles
from the nearest U.S. land, outside harbours and routine slow water. NOAA has no files for
January-June 2024. The two lists in `source/` are the stop-at-sea sweeps' own
(`Texas_full_pattern_stops_2015-2024.csv`, 424 stops; `California_full_pattern_stops_2015-2024.csv`,
623), byte for byte; `verify.py` checks their SHA-256.

The 1,031 vessels: 488 tankers, 486 cargo ships, 57 service craft; 612 off California, 363 off
Texas, 56 off western Louisiana; 493 came from sea, 465 out of a U.S. port or anchorage, 73
through U.S. waters. They are **778 hulls**: stops by the same MMSI, or by the same valid IMO
number, are one hull (a ship keeps its IMO number when a change of flag gives it a new MMSI;
eight did). 120 hulls stopped more than once, and three of them 16 to 25 times. That is why the
ranges are worked out by hull (below).

## What the panel sees

Each case is one compact JSON line: the case ID and the vessel as the record showed it at the stop.

- **What and where:** coast (Texas, Louisiana, California), vessel (cargo ship, tanker, service
  craft), length in whole metres, position to 0.01 degree, nautical miles to the nearest U.S.
  land and to any land, whether the nearest land is foreign.
- **When:** the month and the local clock time; the sun's elevation.
- **How it stopped:** minutes stopped; knots before, slowest and after; km moved while stopped.
- **Who was near:** vessels within 1 km while it stood still ("alone", or "a pilot boat 540 m
  away", "a vessel of AIS type 'tanker' 420 m away"); how many short stops other ships made
  within 2 km of the spot over the ten years.
- **The chart:** the charted route it was on (fairway, lane, precautionary area) and the km to
  the nearest one; the nearest charted anchorage and the nm outside it; the nearest offshore
  platform standing that day (Gulf of Mexico).
- **The 72 hours before:** where it came from (from sea; through U.S. waters; out of a U.S. port
  or anchorage), hours since it left the 12-mile line, where it last held still inside the line
  and how long before, the last anchorage or harbour it was in and how long before.
- **Weather:** a tropical storm within 400 km, its distance and its winds.

The prompt explains the fields that need it. **Left out:** names, MMSI, IMO and call signs;
dates and years; the AIS type code (NOAA's files changed numbering systems in 2018, so the code
would date the case); the source's number formats (the early files write a length as 225.0000);
storm names (a name dates a storm); the names of the vessels nearby (a pilot boat is called a
pilot boat, as anyone on watch would see); and everything after the stop. `verify.py` checks
every case for each of these.

The case format is rebuilt here from the stop lists, following the pilot's description of what
its models saw (Brief No. 1, Section 4); the pilot's own case files are not in this package.

## Two arms

| Arm | What changes | Why |
|---|---|---|
| `plain` | nothing: the pilot's condition | the pilot, on every stop |
| `told` | one sentence: "in this ten-year record, about 73 of every 100 vessels that made a stop like these were inside the 12-nautical-mile line within six hours after it" | the pilot suggested that AI readers not given the base rate "default to suspicion"; this measures it |

The same 1,031 cases, the same batches and the same words otherwise (`verify.py` checks the two
prompts differ by that sentence alone). Each seat finishes `plain` before it starts `told`. The
base rate stated is the share in this record, the way a watch floor would know it from history.

## The bars, fixed before any call (`answer_key_DO_NOT_FEED/bars.json`)

| Bar | Right on | |
|---|---|---|
| Say YES every time (the base rate) | 72.8% | **the bar**: every result is lift over it |
| The hand rule | 76.8% | NO only for a vessel that held still in a U.S. port or anchorage in the 72 hours before and left the 12-mile line less than 6 hours before it stopped (a ship just out of port is outbound). Shown beside the bar as a harder one |
| Brier score of the base rate as a forecast | 0.198 | the reference for Brier skill |

## Scoring rules, fixed before the first call (`score_panel.py`)

- **Lift, never raw accuracy.** Each seat's accuracy minus the bar's on the same vessels it
  answered, with a 95% range from a bootstrap over hulls: a ship's stops are resampled together,
  because one ship's habits make its stops alike (10,000 resamples; `arcs_stats.py` gives the same
  numbers on every Python and machine). Each range draws from its own seed, named for the arm, the
  seat and the measure, so it comes out the same whatever else is scored beside it. Lift over the
  hand rule is shown beside it, and the lift again on the 1,012 vessels where the two clocks agree.
- **Confidence becomes a probability by the Colosseum's declared map:** YES p = 0.5 + c/20,
  NO p = 0.5 - c/20 (1 = 55% sure, 10 = certain). Brier skill against the base rate.
- **Earned confidence:** at a stated 7 or more, how often the seat was right (Wilson 95% range),
  against what it claimed and against the base rate on the same vessels.
- **Suspicion:** how often the seat said NO, against the 27.2% that stayed out; how often a NO was
  right; how many of the vessels that stayed out it called.
- **The reported panel is the U.S. labs' seats** (Anthropic, Google, OpenAI, xAI), as in the
  pilot. Every seat is scored and shown; the others are comparison only. On vessels answered by
  4 or more panel seats:
  - the majority's lift over the bar;
  - **breaks from the baseline:** 4 in 5 or more of the answering seats say NO against the base
    rate's YES (counted in whole numbers: 4 of 5 and 8 of 10 are breaks, 3 of 4 is not). How many of those vessels stayed out (Wilson range), against what the base rate
    expected and what the hand rule's groups expected on the same vessels, and what share of all
    the vessels that stayed out the breaks caught;
  - all agreeing and all wrong; a lone dissenter, how often it was right, and which seats;
  - the same again over every seat.
- **The arms:** each seat's change from plain to told on the vessels it answered in both, with
  its range, its NO rate in each, and how many answers it changed.
- Failed calls and no-answers are counted and reported, never scored.
- With many seats, two arms and several measures, some results will clear their range by chance.
  A single lift near its line is a lead, not a finding.

## Files

| File | What it is |
|---|---|
| `sea_cases.jsonl` | **The study.** 1,031 cases, ARCS-SEA-0001 to 1031, IDs in random order (seed 20261028). **The only study file the panel sees.** |
| `sea_practice.jsonl` | Three practice cases for the smoke test (ARCS-SEA-9001 to 9003): stops whose outcome is unknown. |
| `excluded_stops.csv` | The 16 stops left out, and why. |
| `answer_key_DO_NOT_FEED/sea_answer_key.csv` | Each case's answer, the hand rule's call, and the stop it came from (ship, MMSI, IMO, time). Keep it away from the panel. |
| `answer_key_DO_NOT_FEED/bars.json` | The bars above. |
| `source/` | The two stop lists the study is built from. |
| `make_cases.py` | Builds every file above from `source/`. Standard library only. |
| `verify.py` | Rebuilds everything byte for byte and checks the sources, the answers (a second reading), the cases for anything that names or dates a vessel, every fact against its source row, the IDs, the bars and the batches. |
| `sea_protocol.py` | The words of both arms, the batches (25 cases a call, in case-ID order, the same for every seat) and the reply reader. Version `arcs-maritime-1`. |
| `study.py` | This study as the runner sees it. Its hash, with the cases' and the protocol's, pins the study. |
| `run_panel.py` | The runner, the same file for every ARCS panel study. |
| `colosseum_adapter.py` | The bridge to the Colosseum's seats, the same file for every study (see below). |
| `score_panel.py`, `arcs_stats.py` | The scorer and its statistics. |
| `tests/` | `test_protocol.py`, `test_score_panel.py`, `test_runner.py` (the whole study against simulated seats in `fake_adapter.py`), `test_adapter.py` (the bridge against a copy of the board's own code), `test_shared.py`. No network, no keys. |
| `SHARED.sha256` | The files this study shares with the grid study, and their hashes. |

## Running the panel

Standard-library Python 3.9 or later. Nothing calls a lab until asked to.

1. `python3 verify.py`: every check passes.
2. `python3 tests/test_protocol.py`, `python3 tests/test_score_panel.py`,
   `python3 tests/test_runner.py`, `python3 tests/test_adapter.py` and
   `python3 tests/test_shared.py`: all pass, with no network and no keys.
3. `python3 run_panel.py --plan`: the seats on the Colosseum's roster and the calls a full run
   makes: 84 a seat (42 batches of 25, plain arm then told). Asks no one.
4. `python3 run_panel.py --smoke`: the three practice cases to every seat at once. It shows
   whether each door opens, whether each reply reads, and roughly how many tokens a full run
   takes, then prints the command for step 5 with the seats that passed.
5. `python3 run_panel.py --run --seats ...`: the study. No lab gets two calls at once. Ctrl-C
   stops it cleanly; the same command resumes where it stopped and never asks a settled batch
   again. `--arm plain` runs the pilot's arm alone.
6. `python3 run_panel.py --score`: writes `runs/arcs-maritime-1/answers.jsonl` and prints the
   tables above.
7. `python3 run_panel.py --verify`: checks the journal's hash chain. The head hash in
   `runs/arcs-maritime-1/SEAL.txt` is the run's seal; publish it with the brief.

The record, in `runs/arcs-maritime-1/`: `journal.jsonl` holds every call (the prompt's hash, the
reply exactly as returned, its reading, tokens, timing, the model version the lab reports, any
error), each line chained to the one before; `prompts/` holds every prompt sent; `runner.log` the
progress lines; `hub_archive/` (beside it, under `runs/`) the raw replies.

**The bridge.** `colosseum_adapter.py` calls each seat through the Colosseum's own caller
(`colosseum/fighters.py`): the seat's own key, endpoint and model, the board's sampling contract
and its rule for whose fault a failure is. It finds the board through its launchd job (the folder
it runs in and the key file its daemon sources). It is read-only: it runs only the board's
`hub.py` and `fighters.py` (never its package `__init__.py`), writes nothing in the board's
folder, and takes any copy of a key out of a reply before archiving it.

**How a failed call counts,** as in the Colosseum: a lab's door that refuses (timeout, 5xx, 429,
a reply that broke off) is not the seat's fault, and the batch is retried after 30 s, 2 min and
5 min; a call voided on our side (a 4xx, a reply cut off at the token limit, an empty reply, a
key not set) is recorded and not retried until the cause is fixed (`--retry-void`); a reply that
leaves a case out is that seat's no-answer. One exception, as in the pilot (where Claude Fable
5.1 declined 3 of its 16 batches and answered all three when asked again): a reply that answers
none of its cases is asked once more, after the seat's other batches in that arm, and the second
reply stands.

**The bells.** Calls never crowd the board: while the Colosseum is sealing a window (its own
window journal says so), from 10 minutes before each bell (05:00, 10:00, 18:00 Eastern), and for
up to 25 minutes after one until the seal begins, every call waits, and the runner says so.

## Known limits

- The 12-mile line is measured from Natural Earth's 1:10m coast, not the charted baseline. A
  vessel within about a mile of the line may sit on either side of the legal one.
- The answer is what the AIS record shows. A vessel that crossed the line unheard and left again
  would be a NO here.
- "Other ships' short stops within 2 km" counts the spot's whole decade, before and after the
  stop: it describes the place, as a watch floor's history of it would.
- Hiding the date is not total: the month, the clock time, the sun's elevation and the position
  together narrow the day of the year (never the year).
- Stops are not independent: 120 hulls stopped more than once, so the lift ranges resample hulls,
  not stops. The rates shown with a Wilson range (earned confidence, breaks, lone dissenters)
  treat each stop as its own, and are narrower than a hull-level range would be.
- The answer depends on which of the lists' two clocks is read, for 19 vessels (above).
- The two arms differ by one sentence, so a seat's change between them is the effect of being
  told the base rate plus the run-to-run variation of asking the same model twice (the board
  sends its own fixed sampling settings, and no lab promises the same reply twice).

## Rebuild from scratch

```
python3 make_cases.py source/Texas_full_pattern_stops_2015-2024.csv source/California_full_pattern_stops_2015-2024.csv .
python3 verify.py
```

---

## The package, by SHA-256

| File | SHA-256 |
|---|---|
| `README.md` | `dac3eab38fbf323bbba2f42d73ab30c9f3e28f62681b9d0f3a9d2f4e6164b792` |
| `SHARED.sha256` | `35ed5cdd21ee70c2918ecc1552584671c948c31868007872e536cba6e742035d` |
| `answer_key_DO_NOT_FEED/bars.json` | `de1f6b8e5697c4c80da627359487362e61fc51f3219dd0c3e4a0e593b53bcd5b` |
| `answer_key_DO_NOT_FEED/sea_answer_key.csv` | `a86eda57a3d6cd4ba335b081e8ca10bb3b28e3499fd8288e8b27b8fccdbd5fce` |
| `arcs_stats.py` | `d78ef7accdf78282c5392a5f6f44ff182dd3240f10eb073fb4422981cf224cb6` |
| `colosseum_adapter.py` | `5749e1c85bbfeb4e930fe5bd9fc29d8caa3a1d6cd1565c0afe95db96207ddd11` |
| `excluded_stops.csv` | `882efdea62856f49629c620e2e9158dae4dd55f1fd9ab8de5f599865a8806594` |
| `make_cases.py` | `acf214ad082d08bbe89b38cc50d189ccfda0f9e97d584f1a7cd43cd6a22fcb4d` |
| `run_panel.py` | `3b1deb4a09c8ec9f68dab0824fba73b13b58dd1ca5a676fb04a99f27a8506332` |
| `score_panel.py` | `75ad27951e36ebfe277b2aae3c7e9c2c8c0cc94e970ce8f908777f68d7ec0e99` |
| `sea_cases.jsonl` | `cd96db0bdff588c5218bce10ac9c9083ccad154668e1ee7675965e66f1f6ef3a` |
| `sea_practice.jsonl` | `7417b058042f1c92e280ccb93f12cf0f1946411bf6bd7bb90bfcc440d0622984` |
| `sea_protocol.py` | `a68cafc223b2ed0cc9c34bc53adc0a73f5699ec7ef1b62270b6f88926e7d3c20` |
| `source/California_full_pattern_stops_2015-2024.csv` | `3a9374b5b1f65fc39ff865cc113b701cc97d2460dc0badd522a8bda583c00d8a` |
| `source/Texas_full_pattern_stops_2015-2024.csv` | `7a8baa18b3fa77392521c30c3173145960b0121034dcb3240ce5e10a3f239313` |
| `study.py` | `5d42f7329e0726527a6ba8af3a847676f4936f662bee07c48c8c5eb4c133490b` |
| `tests/fake_adapter.py` | `80efb5c9e13b20787b89678d4399847214174382c9a2de721472007dc82b0910` |
| `tests/test_adapter.py` | `e568d0989190ff87b9a8d572536de84217b5e7c9c515747808e15559a036475b` |
| `tests/test_protocol.py` | `9fb2a61570fbdbfc59934b4d1e5f6bb5cb4a9c29163925b46fde31eff4d62557` |
| `tests/test_runner.py` | `989d30cd23535e26ba21dd285a8630186954a34741c78474317f1b693508a5d7` |
| `tests/test_score_panel.py` | `545a79b6c963d5034defb8818cffc041d49588f37aee4580a44720a15301a6ac` |
| `tests/test_shared.py` | `7874850bc6db5173fb08b1260e14caa67ad111131716024a3ab36f62443a2907` |
| `verify.py` | `da7297ab6a31d30fa350e314069f420275d7994cdb496cc0451418f583cd9123` |

The shared files (`run_panel.py`, `colosseum_adapter.py`, `arcs_stats.py`, `tests/test_adapter.py`, `tests/test_shared.py`) are the same bytes in the grid study's package; `SHARED.sha256` lists them.

---

## Amendment, 28 October 2026, 21:40 Eastern: before the first study call

No model had been asked anything. An independent review of the runner and the bridge found ways a paid run could pay twice, start a call inside the board's bell, re-ask a silent call, misfile a refusal, or write a key into the record. They were fixed and tested (each fix proved by a test that fails without it), on Python 3.8, 3.9 and 3.13. **No case, prompt, answer, bar or scoring rule changed:** `sea_cases.jsonl`, `sea_protocol.py`, `study.py`, `make_cases.py`, `sea_practice.jsonl`, the answer key and `bars.json` hash exactly as listed above.

What changed:

- `run_panel.py` and `colosseum_adapter.py` (shared with the grid study): one runner at a time in a run; a call queued for its lab checks the bells again once it has its turn; a timeout or broken reply after the request went out is *silent*, never re-asked on the spot and asked once more at the end of the arm (no batch is asked more than twice in a way a lab could bill); refusals are the seat's own replies; a lab's own error inside a 200 and a reply the lab cut short are its door; each call records the lab's finish reason and the sampling the board sent; error text is scrubbed of keys; a run refuses to continue if the board's calling code changes under it; `--plan`, `--status`, `--score` and `--verify` only read; `--score` refuses a study changed after the calls; batches never asked export as `not_asked`; while calls hold for a bell the runner says so every 10 minutes.
- `score_panel.py`: accepts `not_asked` rows (counted, never scored). No measure changed.
- `README.md`: the runner's rules, below; the tests and `SHARED.sha256` to match.

The runner's rules as they now stand:

**How a call counts,** by the Colosseum's own rules for whose fault a failure is:

| What came back | Status | What happens |
|---|---|---|
| A reply | ok | Its answers stand; a case it leaves out is that seat's no-answer. A reply that answers none of its cases (a refusal, an empty reply) is asked once more, after the seat's other batches in that arm, and the second reply stands, as in the pilot (where Claude Fable 5.1 declined 3 of its 16 batches and answered all three when asked again). |
| A 429 or 5xx; a request that never left the machine whole; a lab's own error inside a 200; a reply the lab cut short | no_call | The lab's door, nothing billed. Retried after 30 s, 2 min and 5 min, then on the next `--run`. |
| A timeout after the request went out; a reply that broke off; an unreadable reply | silent | The lab may have answered and billed it, so it is never asked again on the spot (the board's rule). It is asked once more after the seat's other batches in that arm. |
| A 4xx; a reply cut off at the board's token limit; a key not set | void | Ours. Recorded, not asked again until the cause is fixed (`--retry-void`). |

No batch is asked more than twice in a way a lab could bill. A seat sits out the rest of a
`--run` after 3 no_calls in a row, 3 silences in a row, 2 voids in a row, or 4 replies in a row
that answered nothing, so a broken path cannot burn money; the next `--run` picks it up. Each
seat asks its plain batches before its told ones in every `--run`. Every call records why the
reply stopped (the lab's finish reason) and the sampling the board sent (`params_sent`), and a
run refuses to continue if the board's calling code or call contract changed under it
(`--allow-board-change` continues on the record).

**The bells.** Calls never crowd the board: while the Colosseum is sealing a window (its own
window journal says so), from 10 minutes before each bell (05:00, 10:00, 18:00 Eastern), and for
up to 25 minutes after one until the seal begins, every call waits, and the runner says so (again
every 10 minutes while it waits). A call queued for its lab checks again once it has its turn, so
none starts inside a hold. If the window journal is missing or in a form the bridge does not read,
calls hold from 10 minutes before each bell to 2 hours after. Each run's record says which.

| File (amended) | SHA-256 |
|---|---|
| `README.md` | `30ea66406bec8fe86cfcbdd5ca8689b14fedf1a82b4deb48de5f40e4d894cfb5` |
| `SHARED.sha256` | `1bb71c4cc256d4b2328168b2ef0622cc35f4211f48f81abc0b4634f473299e97` |
| `colosseum_adapter.py` | `668a239ed42be2e4ccaefb81e8b78de701dd198e5da63175e298d7a5c772f609` |
| `run_panel.py` | `93192bf11c45f93c075076a5d7f8488242443c32acc4fe4baef70c5876ee0257` |
| `score_panel.py` | `40c8c4d04ca1d89d809453b67f8f1f8efa34ed591e71d8599d629b05e3d54c2e` |
| `tests/test_adapter.py` | `695e793e25ed75be9af15f8c1f66bde92ab2f9de2021b74db631ffb86339dd55` |
| `tests/test_runner.py` | `dadb386da0b753b2f5b62236afa988bcf5f3de13b1e105477110f323576bb6d2` |

---

## Amendment 2, 28 October 2026, 22:15 Eastern: after the smoke test, before the first study call

No study case had been asked. The smoke test (21:40 to 21:49 Eastern) sent the three practice cases to the 11 seats on the Colosseum's roster. Its record is the first 12 lines of `runs/arcs-maritime-1/journal.jsonl`, head `555bff6816e96877a1b1221498de206f9fd5e283c87fe5d0224bc8e1e7d7cdae`.

| Seat | Model | In the smoke test |
|---|---|---|
| SEAT_CLAUDE_FLAGSHIP | claude-fable-5-1 | declined (0.9 s, no text): the same quick refusal the pilot met in 3 of its 19 calls |
| SEAT_CLAUDE_MID | claude-sonnet-5 | answered 3 of 3 |
| SEAT_GROK_FLAGSHIP | grok-4.6 | answered 3 of 3 |
| SEAT_GROK_MID | grok-4.3 | answered 3 of 3 |
| SEAT_QWEN | qwen3.7-max | answered 3 of 3 |
| SEAT_MINIMAX | MiniMax-M3 | answered 3 of 3 |
| SEAT_QWEN_FLAGSHIP | qwen3.8-max-0902 | no reply inside the board's 480-second limit (in the pilot, 9 of its 9 calls the same) |
| SEAT_GEMINI_FLAGSHIP, SEAT_GEMINI_MID | gemini-3.8-flash, gemini-3.7-flash | refused at the lab's door on account grounds (HTTP 402) |
| SEAT_DEEPSEEK | deepseek-v4-pro | refused on account grounds (HTTP 402) |
| SEAT_GLM | glm-5.2 | refused on account grounds (HTTP 429, the lab's code 1113) |

**The seats asked.** The run asks six seats: the pilot's four U.S. seats (both Claude seats and both Grok seats) and, for comparison, Qwen 3.7 Max and MiniMax M3. Claude Fable 5.1 runs under the refusal rule above, although the smoke test's own summary lists it as not ready: a refusal is the seat's own reply, and in the pilot every refused batch was answered when asked again. Without it the reported panel would have three seats, one short of the four the panel measures need. The seats were chosen on whether their door opens, before any study case was asked.

**A seat that joins later.** A seat left out tonight may join the run once its door opens, asked the same batches with the same words. The panel is then reported both ways: the four U.S. seats asked from tonight (the primary result), and with the later seat added, marked as such.

**One change to the bridge.** The longest seal the bridge treats as still running rose from 4.5 hours to 9 hours. The board's own window journal has seals that ran 299 and 480 minutes (12 October and 30 September, EVENING), so at 4.5 hours a panel call could have started beside a live seal. A new test checks that a seal 8 hours on still holds. No case, prompt, answer, bar or scoring rule changed, and neither did the runner or the scorer: `sea_cases.jsonl`, `sea_protocol.py`, `study.py`, `run_panel.py` and `score_panel.py` hash as listed above. The smoke prompt the seats received hashes `40a1a873a0386091e32543fc2b0aa1a191a9b5439e4464943cab17e7f6f534d1`, the same prompt this package builds.

| File (amended) | SHA-256 |
|---|---|
| `colosseum_adapter.py` | `c6a3ead9c561f887e934b84dd12e7a471e76cb1eea4975f216d896520a22c078` |
| `tests/test_adapter.py` | `63fd95d244ba469a99a153b284ecff8d1b0d29147ac1217a156b93976c2e50c9` |
| `SHARED.sha256` | `aa69e5aa689aa5a99c19515570134db539dfec26c70d3a8d2813e236249b82fd` |

---

## Amendment 3, 28 October 2026, 22:30 Eastern: before the first study call

The run had not started: the journal still held only the smoke test's 12 lines. One exploratory measure is added: **how independent the seats' judgments are.** No case, prompt, bar, primary measure or existing file changes.

**Why.** On the Colosseum's own sealed record (14 seats, 41,971 settled prediction-market calls, 14 August to 27 October 2026) the seats' errors move together. The mean pairwise correlation of their errors is 0.683, so the 14 seats count as about 1.4 independent forecasters. On the 3,005 market looks that 8 or more seats answered, every seat was wrong at once 436 times; if each erred independently at its own rate, that would be expected 0.11 times. Pairs of seats were wrong together 2.05 to 2.47 times as often as independence predicts (China-China 2.05, China-U.S. 2.20, same lab 2.36, U.S.-U.S. 2.47). This study asks whether the same holds on a different kind of signal: a vessel's stop at sea instead of a market's question.

**The measure,** in each arm, for the reported panel (the four U.S. seats) and again for all seats:

- A seat's error on a vessel is 1 if its answer was wrong and 0 if right; a no-answer is left out.
- For each pair of seats, the correlation (phi) of their errors over the vessels both answered; a pair with fewer than 200 such vessels is left out. The mean over pairs is rho. The n seats count as n / (1 + (n - 1) rho) independent forecasters. A 95% range for rho comes from the bootstrap over hulls used for the lifts (10,000 resamples, its own seed).
- On the vessels every seat in the set answered: how many they all got wrong, against the number expected if each erred independently at its own error rate on those vessels.
- For each pair: how often both were wrong, against the product of their two error rates.

**What counts.** Read first, on the plain arm and the reported panel:

- The Colosseum's finding **holds on vessels** if rho is 0.5 or more (the four seats count as 1.6 or fewer independent forecasters) and the vessels all four got wrong number at least ten times the independent expectation.
- It **does not hold** if rho is under 0.3 (the four count as more than 2.1).
- Anything between is reported as mixed.

The told arm and the all-seat set are reported beside it as secondary. The measure is computed by `herding.py`, added to the package before `--score` is first run; `score_panel.py` is unchanged.

---

## Amendment 4, 29 October 2026, 00:15 Eastern: during the run, before any answer was scored or read

The run started at 22:34 Eastern on 28 October. No answer file had been written and no answer had been scored or read: the runner journals each reply without grading it, and only the scorer reads the answer key. This amendment completes Amendment 3 with its script, adds secondary readouts with the script that computes them, and registers the design of a follow-up. No primary measure, case, prompt, bar or existing file changes.

**Amendment 3's script.** `herding.py` computes that measure exactly as Amendment 3 defines it. Its tests (`tests/test_herding.py`) run it on panels whose answer is known in advance: four seats that make the same mistakes (rho 1, one forecaster), four that err independently (rho near 0, about four), and two twins beside two independents.

**Operating readouts (secondary), `readouts.py`.** Each turns a registered result into a rule a watch floor could run, and shows what that rule would have produced on these vessels:

- **R2, act only on confident calls.** For each seat, and for the reported panel's majority, at confidence 6 to 10: the NO calls at or above that confidence, the share of those vessels that stayed out (Wilson range), and the share of all vessels that stayed out they caught. The panel's confidence on a vessel is the mean confidence of the seats on the majority's side.
- **R3, escalate only the breaks** (the break rule registered above): alerts per 100 stops, the share that stayed out, and the share caught, beside the hand rule's own NO list.
- **R4, rule first, AI second.** *Veto:* keep the hand rule's NO only where the panel's majority also says NO. *Add:* NO where the hand rule says NO or the panel breaks. Each against the hand rule alone and the always-YES bar, with lift ranges from the bootstrap over hulls.

Vessels the reported panel answered with fewer than four seats are left out of the panel rows of R2, and of R3 and R4, as the panel measures leave them out.

**The follow-up, registered now: Maritime No. 1b, the AI given the scored record.** The thesis it tests: an AI given a baseline scored against what really happened will be right more often than an AI given only the story in front of it, and than the baseline alone.

- **The arm.** A third set of prompts, run as its own run (`arcs-maritime-1b`): the same 1,031 cases, the same question, the same batches, the same six seats as this run, and the plain arm's words, plus two lines of scored record on each case.
- **The scored record for a case** is built only from cases whose stop came strictly before it in time, each graded on the sweeps' own clock as this study grades it. Never the case itself, never a later stop.
  - *Like this one:* of the earlier stops that match it on coast (Texas and western Louisiana, or California), vessel type, where it came from, and, for a vessel out of a U.S. port or anchorage, whether it left the 12-mile line less than six hours before, how many were inside the line within six hours. With fewer than 10 such stops, the match drops vessel type, then coast, then everything but where it came from and that split, then becomes every earlier stop. The prompt names the match used.
  - *This spot:* of the earlier stops within 10 km of this one, how many were inside the line within six hours ("none earlier" if there were none).
- **Three things compared,** on the same vessels:
  1. *the AI alone:* each seat's plain-arm answers from this run;
  2. *the record alone:* YES when the "like this one" share, smoothed as (K + 1) / (N + 2), is 0.5 or more, otherwise NO; that share is its probability for the Brier score;
  3. *the AI given the record:* each seat's answers in 1b.
- **What counts,** for the reported panel's majority first, then each reported seat: paired lifts over the always-YES bar, with 95% ranges from the bootstrap over hulls. *The record helps the AI* if 3 beats 1 with its range above zero. *The AI adds to the record* if 3 beats 2 with its range above zero. Both together is the thesis holding. Anything else is reported as it falls, including the thesis failing.
- **Secondary:** Brier skill for all three; how often each says NO and how often a NO is right; herding (Amendment 3's measure) in 1b against the plain arm, since a shared record may make the seats more alike.
- **Known limits, stated now:** the count of earlier stops grows with time, so it hints at the year; the earliest stops have little history behind them, as a system just switched on would; 1b runs on a later day than this run, so each seat's model version is recorded and any change is reported.

1b's code, prompts and hashes are registered in its own pre-registration before its first call. Running it is the owner's decision.

| File (added) | SHA-256 |
|---|---|
| `herding.py` | `88dc70e77c6c594e1d3d6017879e558d69902be0ae3f2839d2acc8b81cdf89eb` |
| `readouts.py` | `93932963ed035f44ccbf90f8083eb1f7df0b1c0cc69a7cb6b091b2dfc0818d80` |
| `tests/test_herding.py` | `47c8142d8c4693bc31d3a551c4983f840aab382e7fbb6afc53c85564f3007636` |
| `tests/test_readouts.py` | `a2bf13988b5f464ed57d1aad94c941cee7e44b0207c87ba2b9c37e499aefc910` |

---

## Amendment 5, 29 October 2026, 08:15 Eastern: the run closed as it stood, before any answer was scored

The run closed at 03:49:56 Eastern ("done"). Its journal is 404 lines, chained, with head `8335d83abf1b734edc2a327654c8473e19d26b043d0819c87ad1a8bfd2c98bc8` (`SEAL.txt`).

- **Settled in both arms:** Claude Sonnet 5, Grok 4.6, Grok 4.3 and Qwen 3.7 Max, 42 batches each.
- **Claude Fable 5.1:** answered 25 of its 42 plain batches and declined 16 (each asked once more where the rule allowed). One call was silent. It sat out at 00:36 Eastern after four declines in a row, before starting the told arm.
- **MiniMax M3:** sat out after two replies were cut off at the board's token limit.

Before any answer was scored or read, the owner chose to score the run as it stands rather than ask Fable again, for cost. What follows from that, stated before scoring:

- In the plain arm, the reported panel's four seats overlap on the vessels in Fable's 25 answered batches. The panel measures cover those vessels.
- In the told arm, the reported panel has three seats, one short of the four the panel measures need. Its panel measures are reported over every seat that answered, as registered ("the same again over every seat").
- Each seat's change from plain to told stands as registered.
- Fable's declines are reported as they fell.

---

## Note, 29 October 2026, 08:25 Eastern: a crash in `readouts.py`, fixed after scoring; no number changed

Scoring the run (Amendment 5) showed that `readouts.py` stopped with an error when it reached the told arm. In that arm no vessel was answered by four reported seats (Amendment 5), so the panel rows of R2, and R3 and R4, have no vessels, and the report tried to print a lift that does not exist. The fix prints those rows as not measurable and goes on. It changes no rule and no computation: the plain arm's readouts print the same, byte for byte, before and after the fix (checked on Python 3.8, 3.9, 3.11 and 3.13), and the told arm's per-seat R2 rows, which the crash had cut off, now print. A test checks a panel with no vessels. The README now lists `herding.py` and `readouts.py` and the commands that run them.

| File (amended) | SHA-256 |
|---|---|
| `readouts.py` | `5f8c8daee0291873dba6668e96313b84aa35196abadeac5e0482a4a2ffb0c75f` |
| `tests/test_readouts.py` | `29cd835cc40814b9b4350ccf6fc65c54551bbc01fb6621a3f99c915855c8c0ef` |
| `README.md` | `1874a60d82b832c28e78e7137349928f4205802a59f17fffc9b59a67211dabd8` |

---

## Note, 29 October 2026, 14:41 Eastern: a correction to Amendment 5; no number changed

Amendment 5 says one of Claude Fable 5.1's calls was silent. The journal has two: batch 3, which broke off at 22:44 Eastern after 64 seconds and was declined when asked a second time, and batch 15, which ran past the board's 480-second limit at 23:18 Eastern and was not asked again before the run closed. The scorer reads the journal itself, so no score changes; this note corrects the amendment's wording only.