Technical report / 5 October 2026

What survives
the handoff?

Carrier R03 asks what survives when evidence is selected, compressed, and passed to another machine. A fixed requirement-aware reranker made retrieved sets less repetitive, yet lowered pooled ranking quality and failed to improve coverage on the original final subset. Reference checks and transfer accounting establish narrower engineering properties. The handoff experiment tests factual retention and justified uncertainty in a controlled synthetic setting.

Study question and scope

A useful context must preserve the particular fact needed for the next decision. A definition can be relevant to a topic without supplying that fact; a verified identifier can point to authentic text without supporting the claim beside it. R03 separates three questions: whether selection retains distinct task requirements, whether bounded machine memory preserves accepted facts and unknowns, and what reference integrity and repeated transfer actually cost. These components have different units and controls. Their results cannot be combined into a single measure of intelligence.

The retrieval component reuses public R02 material. The conversation component uses eight newly authored fictional operational logs. The engineering component uses the existing checked corpus and synthetic keys. No Carrier records were modified and no private prior conversations were included. Existing public historical credits remain in the source material. There are no human receivers, no human grading of the new handoffs, and no measurement or assumption of superintelligence.

Evidence displacement: materials and fixed method

The unchanged R02 corpus contains 6,257 records. Its 48 public tasks contain 192 prewritten requirements and 666 task–document pairs judged by AI. Candidate pools are incomplete: they are not exhaustive relevance judgments over the corpus. R03 adds no tasks, labels, or fresh holdout to this component. “Original final36” identifies a historical R02 partition that is already public. Results on that partition are exploratory, even though its name contains “final.” The historical typed setting was selected using R02 development labels; it remains a fixed comparator here.

One requirement-aware method was specified and frozen before this run opened grades. It retains the existing document and question vectors, and encodes each original requirement separately with the pinned local MiniLM ONNX model. Requirement text is neither rewritten nor expanded. Encoding follows R02: attention-mask mean pooling, L2 normalization, a 256-wordpiece limit, batches of 16, and CPU thread settings of 4/1. Question and requirements form equally weighted facets. For a task with m requirements, each facet receives weight 1/(m+1).

For each facet, the method takes the positive part of its cosine similarity to every candidate, then divides by the maximum over the complete task pool. An all-zero facet remains zero. For a selected set S, the objective is the sum of the best normalized similarity for each facet, less the sum of positive document-pair cosines divided by ten, with the entire expression divided by m+1. Ten is the number of pairs in five documents. The complete duplication penalty therefore has a maximum cost equal to one facet's weight at the five-document budget.

Selection starts empty and takes five greedy steps. At each step it chooses the unselected candidate with the largest marginal objective gain; exact ties use the smaller checked identifier. Selection order becomes ranking order. No subsequent reranking or coefficient search is performed. This design rewards coverage in embedding space and penalizes duplication, but neither score proves that a document supports a requirement. Method files, vectors, score inputs, and label-free rankings were hashed before outcomes were opened. A file-open barrier recorded local ordering; it is not external preregistration or independent blindness to an already public benchmark.

Retrieval results: diversity is insufficient

Across all 48 tasks, agreed requirement coverage rises from 0.739583 for dense selection to 0.765625 for the fixed method, while pooled nDCG@5 falls from 0.692666 to 0.604827. On the original final36, coverage falls from 0.736111 to 0.729167 and nDCG@5 falls from 0.674080 to 0.593081. The all-task coverage increase therefore does not persist in the historical final partition. Relative to dense selection, the method gains 17 task-specific requirements and loses 12 across all 48 tasks. A positive net count does not erase those losses.

Mean positive pair cosine falls from 0.393643 to 0.183913 across all tasks. Yet the mean number of selected documents with no agreed requirement rises from 1.916667 to 2.541667 out of five. Label redundancy also falls, from 0.373418 to 0.268800. This metric counts repeated agreed document–requirement assignments relative to all assignments, and equals zero when no assignments exist. Less repetition can thus accompany missing evidence. Documents without agreed requirements are not automatically wholly irrelevant, but the increase prevents interpreting diversity alone as improved support.

Agreement requires both judges to identify the same requirement in the same document. Coverage uses every prewritten requirement as its denominator, including requirements absent from the judged pool. nDCG evaluates ranked relevance within those pools; it is neither a corpus-wide recall measure nor downstream answer accuracy. Descriptive uncertainty uses 10,000 paired task bootstrap draws, seed 129300. For the all-task coverage difference, the percentile interval is −0.0365 to +0.0938; for nDCG it is −0.1407 to −0.0354. These intervals characterize this selected, model-judged dataset and do not turn reuse into a confirmatory test.

Two prespecified cases expose the tradeoff. In A21, about repeated looks at a website experiment, sequential statistical analysis restores an omitted stopping-rule requirement. Coverage improves from two of four requirements to three. Effect-size evidence remains unselected despite being available in the pool, and the method also selects two grade-zero documents: the binding of Isaac and Buddhist two-truths doctrine. A useful repair and irrelevant diversity occur in the same five slots.

In B18, about lake restoration, the method restores environmental monitoring relative to the historical typed selection and preserves dense coverage of three of four requirements. It also selects grade-zero material on memoization and internal mutual support alongside external subjection. No document in this pool has agreed support for the requirement concerning delayed responses or feedbacks. That gap cannot be repaired by rearranging the same candidates. Neither example licenses a claim that the method should replace dense retrieval.

An exhaustive diagnostic enumerates all 121,036 five-document subsets across the 48 pools. Using the labels, it reaches agreed coverage of 0.885417. Twenty-two of 192 requirements have no agreed supporting document anywhere in their pool. Every pool-attainable requirement can fit within five slots, so the measured oracle loses no further coverage solely to that budget. It maximizes labeled coverage, breaks ties using labeled nDCG, and orders by mean grade. Its nearly perfect nDCG follows partly from this construction. It is an upper-bound diagnostic using unavailable answer information, not a deployable retrieval system.

Machine handoffs: controlled design

The handoff design crosses eight base cases, four representations, and two evidence conditions: 64 trajectories with two successive stages, specifying 128 machine outputs. Each output answers six fixed questions and includes memory subject to a 900-byte UTF-8 limit. Cases concern fictional activities such as library collection, translation review, and sensor exports. Accepted decisions and recorded observations determine answers; proposals do not alter state. Questions distinguish a current value, scope, condition, authority, a second mutable field, and a fact explicitly left unknown.

The four formats are prose with inline definitions, ordered turn JSON with inline definitions, generic versioned references, and Carrier references. The same semantic turns, questions, updates, and three concept definitions accompany each format. Across the eight cases these are 24 definition assignments drawn from 16 distinct Carrier records; the handoff component does not sample all 6,257 concepts. A local harness resolves pinned references and logs their materialization before supplying definitions. Agents are not being tested on autonomous discovery or operation of a resolver. Generic and Carrier reference mechanics are intentionally equivalent, providing a control against attributing ordinary reference behavior to the Carrier name. The envelopes are experimental JSON; this is not a standardized USL1 or CVP2 transport evaluation.

In the complete condition, the log contains the sole evidence for every known answer. In the displaced condition, one essential scope turn is replaced by a relevant but non-answering Carrier definition. The corresponding answer becomes unknown; the other five questions remain unchanged. This intervention tests the response to a specific missing fact. The concept definitions supply interpretive distinctions, while the logs determine the answer values. Because the definitions are supplementary rather than necessary, this design cannot demonstrate that Carrier concepts are required for correct answers.

Stage one receives the source and definitions, then answers and writes memory. A fresh stage-two agent receives only that memory, the same resolved definitions, the questions, and an accepted update changing exactly two answers. The source log and first answers are withheld. The update preserves other fields and does not restore the removed scope fact. An oversized first memory is passed through in full and flagged; it is not silently truncated or replaced with a better attempt. First outputs remain part of the record.

Each stage uses eight cohorts, each processing eight different cases. An independent packet audit after stage-one deliveries, before any answer scoring or stage-two generation, found an allocation mismatch: the original written rule added the case index, while its implementation subtracted it. The implemented rule confounded receiving cohort with evidence condition. The original protocol, code, and key are preserved under checks/pre-stage2-assignment, with the audit and checks/stage2-assignment-amendment.json. Before stage-two inputs were generated, allocation changed to a fixed three-cohort rotation. Each receiving cohort therefore receives all eight format/condition cells and eight different cases; every numerical cohort changes. Source material, prompts, first memories, answers, and scoring rules were unchanged. This is a disclosed design correction before outcome scoring, not outcome-based tuning.

No cohort sees a base case twice within its stage, but sequential processing of different cases permits carryover. Fresh contexts use the same configured model family as the orchestrator; model builds are not independently authenticated. File-access restrictions are instructions to agents, not an independently enforced sandbox. These implementation limits constrain what “fresh” and “controlled” establish.

Handoff outcomes and interpretation

768 scored fields across 128 actual agent outputs: 100.0% matched the frozen keys. There were 0 unsupported non-unknown field answers and 0 incorrect abstentions. Updated-field accuracy was 100.0%; unchanged-field accuracy after the update was 100.0%. Requested memory-limit violations: 0; mean memory size 708.4 bytes, maximum 859 bytes.

The concepts were supplementary and the eight case templates were deliberately simple. Equal success across formats is a ceiling on this test, not proof of equivalence, Carrier superiority or general hallucination reduction. Only six closed-world answer fields per output are scored; every free-prose memory claim is not independently graded.

Scoring uses exact normalized answers and accepted strings fixed with the cases. The outcomes separate known-answer accuracy, justified unknown responses, unsupported non-unknown answers, update success, retention of unchanged facts, and memory-budget compliance. A correct unknown response differs from an incorrect answer to a known field. A changed field tests update handling; an unchanged one tests preservation. The eight base cases are the relevant independent case units, not 128 independent participants.

Any observed format difference belongs to this small authored design, configured agent family, and two-stage procedure. Six exact answer fields do not measure every claim in the prose memory and cannot supply a general hallucination rate. The task author knows the Carrier definitions, the logs make their governing rules unusually explicit, and the intervention removes one designated fact. Natural conversations may involve ambiguity, longer dependencies, conflicting authorities, or incomplete updates. The recorded comparison should guide a harder test rather than settle those questions.

Reference integrity and transfer costs

A separate resolver experiment gives generic and Carrier references equal-length identifiers and identical checks against the same pinned local corpus head and exact definition hashes. All 16 programmed assertions pass: eight for each namespace. Valid cold and warm references resolve; wrong heads, stale cache heads, altered cached definitions, missing identifiers, and mismatched definition hashes reject. A valid identifier accompanying a false, unrelated claim still resolves. This expected behavior separates evidence identity from entailment. The fixtures are engineered checks, not naturally occurring error rates.

Corpus validation checks the raw JSONL predecessor chain, final head, and equality of the existing evidence projection. The first attempt failed before timing because historical checked records sometimes omit relations while the projection uses an empty list. The correction normalizes absent relations to an empty list, records an amendment, and preserves the failure. Chain consistency relative to a trusted local head does not independently authenticate a remote operator or prove a definition true.

The additive full-registry figure assumes provisioning a resolver and then paying the receiver’s initial cache miss. If the receiver itself is preloaded with the entire compact registry and resolves locally, the comparable 100-handoff total is 3,327,002 bytes: 2,955,102 provision bytes plus 371,900 reference-message bytes. Neither scenario saves bytes against inline evidence in this particular 100-handoff workload.

Costs are actual uncompressed canonical UTF-8 JSON bytes. They exclude HTTP/TLS, compression, common instruction and question envelopes, model outputs, and retries. They are not model tokens or measured network packets. For 32 selected records over 100 handoffs, inline evidence totals 1,088,900 bytes. A cold lookup every time costs 1,531,900; one persistent cache starting empty costs 383,500. Charging the full compact evidence registry and index as well gives 3,338,602 bytes. Generic and Carrier totals are identical under the equal-length design.

The full compact provision is 2,955,102 bytes; the original checked JSONL with provenance is 9,477,865 bytes. Calling the compact projection a full checked chain would understate provisioning. Warm-cache accounting assumes reuse and cannot be applied to isolated fresh receivers without qualification. Every receiver still receives materialized evidence, so transfer savings are not established model-input savings. These full resolver and cache scenarios are separate from the actual conversational envelopes and do not measure their end-to-end execution cost.

Synthetic scale and limits

The lookup stress test builds 6,257, 100,000, and 1,000,000 keys, with three repetitions at each size and 20,000 precomputed queries per repetition, half hits and half misses. Values reuse 6,257 records containing 6,256 distinct definition texts. No new definition text is introduced. At one million keys, median construction takes 308.819 milliseconds and the local lookup loop averages 324.080 nanoseconds per query. Dictionary and owned key objects occupy 87,758,320 bytes; shared definition strings are reported separately.

These timings cover in-process dictionary access, branching, and checksum accumulation. They exclude definition hashing, disk, network, full resolver validation, semantic retrieval, and model calls. Memory accounting excludes process overhead and peak resident memory. Fixed size order, operating-system caches, randomized hashes, and other work on the same machine can affect results. Prior outputs, including an earlier unjustified “meanings” label, are retained; the corrected report distinguishes records, distinct text, and knowledge. One million aliases establish neither one million independent concepts nor reliable retrieval at that scale.

Context, reproducibility, and the next test

Lost in the Middle examines sensitivity to evidence position in long contexts. LongMemEval separates memory abilities including updates and abstention. ALCE evaluates answer and citation quality as distinct dimensions. LLMLingua studies prompt compression under a budget. These works motivate distinctions made here; their datasets, systems, and scores are not performance comparators for R03.

The reproducibility materials preserve component protocols and freezes, source hashes, rankings, first machine outputs, scoring rules, failures, amendments, and timing repetitions. Scientific figure checks concern exported artifacts; they do not establish verification in a separate physical browser. The publication links the executable evidence so that readers can inspect denominators and exclusions rather than infer them from headline percentages.

A falsifiable next step is an evidence ledger that reserves space for marginal obligations: which source supports each required fact, which decision supersedes it, and which answer remains unknown. Test it on a fresh, harder holdout whose judgments never tune selection, with the same memory budget and a matched generic-reference control. Success requires fewer lost obligations and unsupported answers without an unacceptable loss in relevance, update accuracy, or retained facts. R03 does not establish that success. It identifies the failure a future method must demonstrably repair.

Fresh-agent execution is attested by the parent orchestrator in m2m/cohort-provenance.json, recording each fresh task, assigned input and first-output hash. File checks prove packet contents and forwarding, not independently authenticated backend isolation.

The exploratory handoff contrast uses 20,000 paired bootstrap resamples of eight base cases (seed 1292026), comparing each format with prose at stage two. Every observed difference is zero, so those empirical intervals collapse to [0, 0]. That is a degenerate ceiling result on these cases, not an equivalence test or a bound on future error rates.

The first extracted-kit run reproduced the handoff and retrieval checks, then encountered the scale tool’s protection against overwriting its bundled self-test output. That refusal is preserved. The verification wrapper now supplies --self-test --replace, retaining the previous output before rerunning; a new extraction passed. No scientific check was weakened or experimental value altered.

python 129/tools/verify_handoffs.py
python 129/tools/handoffs.py evaluate
python 129/displacement/test_integrity.py
python 129/displacement/verify.py --encode
python 129/scale/run_checks.py --corpus-dir 129/data --replace