gain: +11.5 pts integrity: PASS reproducibility: R1 · reproduced from analysis data maturity: grade B referee reports: 7 review items addressed: 116

version: 1.1 · November 2026 pages: 77 figures: 17 tables: 38 numbered equations: 2 references: 63 words: 35 800

files: 177 Python: 53 files LaTeX: 26 files Shell: 1 files

🧠 In one sentence (revised, peer-reviewed version 1.1) — Asks whether a residual-stream state that one transformer uses to execute an operator can be grafted into a transformer that never learned it: in a micro-world of decoders trained from scratch, a donor-in-the-loop graft of one orthogonally mapped row raises the recipient from chance to 0.966 on held-out programs in 9 of 9 pairs, but a mechanism battery shows it injects the donor's already-computed value rather than a computation, and on four open-weight models task-vector transfer is supported in 0 of 7 pairs.

# 🔬 Peer review at a glance

This paper went through the full multi-referee review of the UQO working-paper series: 7 independent referee reports, 116 review items, an editorial decision (claims not supported as written → reframed and revised), re-execution of the analysis, a complete revision of text, figures and tables, and an independent verification before sign-off. The revised manuscript and every change live on the branch review-20261103 of this repository (36 commits ahead of main, head 6e60ae2, 2026-11-09).

Review scores before and after revision

Dimension	Submitted	Revised	Δ
Originality	65.4	67.0	+1.6
Rigor	57.1	74.0	+16.9
Identification	56.9	72.0	+15.1
Data & reproducibility	69.0	81.0	+12.0
Robustness	64.1	78.0	+13.9
Writing	69.3	70.0	+0.7
Figures & tables	56.7	73.0	+16.3
Literature	62.9	78.0	+15.1
Weighted total	62.1	73.6	+11.5

Scientific integrity: PASS · Reproducibility: R1 · reproduced from analysis data · Maturity: grade B

# What the review changed

Peer review found that the original thesis of capability transfer was not supported as written. The revision adds a mechanism battery showing that the graft injects a value the donor has already computed, re-runs the controls through the primary map, relabels the protocol as pre-specified in-session, and reports every hypothesis outcome, including the open-weight null.

Thesis: capability transfer → value injection in a code shared up to rotation (value readout 0.994; operand-swap graft emits the donor's value in 0.993 of items)
Layer specificity: transfer requires the right layer → withdrawn, since rows from later layers transfer 1.000/1.000 in nine pairs through the primary map
Protocol status: preregistered → pre-specified in-session, with a dated deviations table
Regression-fitted maps: failure by annihilation of directions → failure by relabelling of the donor's value onto the recipient's own state
Conventional-learning comparison: the pre-declared adapter comparator is now reported, giving a negative contrast of −0.456
Open-weight tier: transfer supported in 0 of 7 pairs under the frozen rule; a vector-free instruction prefix removes every supported verdict

# Limitations stated in the revised paper

The micro-world establishes that a computed value can be grafted through a shared code; it does not establish that a computation the recipient would have to execute, a multi-step reasoning state or an open-ended skill can. The toy models are tiny and share their whole training distribution except one operator.
The graft that works depends on the donor at inference; the donor-free variants that would matter for deployment are the weaker ones.
The protocol was fixed in-session on the same trained models used for exploration, with no external timestamp; the design protects against item-level overfitting only.
The open-weight query pools are underpowered for the frozen rule, four models and four tasks do not support claims about families or scales, and results differ between chips.

# Where to find the reviewed material

What	Where
Revised manuscript (PDF, 77 pages)	`paper/main.pdf` on `review-20261103`
Revised sources, code, figures and tables	branch `review-20261103`
Commit-by-commit revision history	`review-20261103` commits
All branches (submitted `main` vs revised)	branches

# 🏆 Headline results (revised version)

Result	What it is
0.071 → 0.966	recipient accuracy on held-out Ω programs, from chance to the donor-in-the-loop graft of one orthogonally mapped post-layer-0 row (sd 0.039, min 0.889 over nine donor–recipient pairs); the control stratum stays at 0.992
0.771–0.893	gain over a matched placebo (an unrelated-skill donor or a recipient of another seed through the same map), in 9 of 9 pairs
0.994 vs 0.091	value readout of Ω(v) on the donor's grafted post-layer-0 row against its pre-MLP row: the value is already computed in the row that is grafted
0.993 vs 0.0003	share of items where an operand-swap graft makes the recipient emit the donor's value for the swapped operand, against the value the rule would give for its own operand; pre-MLP and MLP-ablated-donor grafts stay at chance (0.112, 0.104)
−0.456	pre-declared contrast of the donor-free adapter graft against a supervised adapter of the same size; supervised learning or distillation on the same items is perfect, so grafting is not a cheaper way to learn
0 of 7 pairs	open-weight donor–recipient pairs (Qwen2.5-1.5B/3B/7B, Llama-3.2-3B) where task-vector transfer is supported under the frozen rule; a vector-free instruction prefix removes every supported verdict, and the pre-specified query pools are underpowered (minimum detectable differences 0.522–0.585)
up to 0.215	shift of individual pair estimates when the model matrix is retrained on another machine; the pre-specified decision is reproduced in every pair, and a same-hardware re-run is bitwise identical

📄 Abstract

Can a residual-stream state that one transformer uses to execute an operator be grafted into a second transformer that never learned it? We study the question in a micro-world where it is identifiable: decoder transformers trained from scratch on an invented operator language, a recipient that never saw one operator Ω, interchange interventions that locate where the donor executes it, six graft families tested against sham, random, shuffled, unrelated-donor and other-seed controls and against conventional learning, and a decision rule pre-specified in-session. A donor-in-the-loop graft of one mapped post-layer-0 row, through an orthogonal Procrustes map fitted on task-free rows, raises the recipient from chance to 0.966 on held-out programs (control stratum 0.992; placebo-adjusted gain 0.771–0.893 in 9 of 9 pairs). A mechanism battery shows what moves: the donor’s already-computed value, read out in a code the two models share up to rotation (value readout on the grafted row 0.994; an operand-swap graft emits the donor’s value for the swapped operand in 0.993 of items; pre-MLP and MLP-ablated-donor grafts stay at chance). The graft is value injection, not transfer of a computation the recipient executes, and the pre-declared necessity criterion is not Ω-selective. On Qwen2.5-1.5B/3B/7B and Llama-3.2-3B, task-vector transfer is supported in 0 of 7 pairs under the frozen rule, and a vector-free instruction prefix removes every supported verdict (2 one-task partial verdicts remain).

🧩 Contributions

An operational vocabulary for transplantable subsystems — Explicit estimands, a control battery matched on the alignment-map family, a persistence taxonomy, and an elementary proposition on regression-fitted maps whose hypotheses are tested rather than assumed (they fail on these rows).
A micro-world where the question is identifiable — A capability gap manufactured by construction, causal localization before any transfer, exact hook semantics, six pre-specified hypotheses reported with every outcome, a dated deviations table and an append-only registry of every run.
Evidence on the content of the grafted row — Value probes, an operand-swap graft, pre-MLP and MLP-ablated-donor grafts, value-subspace projection and donor-side ablation separate two readings of a successful graft and decide for value injection: the recipient executes nothing it did not already execute, and the subsystem is sufficient but not Ω-selective.
A map of the failure boundaries — Regression-fitted maps fail by relabelling the donor's value onto the recipient's own state; a saved affine adapter scores zero on unseen operands; weight grafts move part of the operator at a cost on the control stratum; steering vectors move nothing; open-weight task-vector transfer does not pass the controls.
A withdrawn control, reported as such — Donor rows from any later layer, grafted through the same map family, work as well as the located row (1.000/1.000 in nine pairs), so the earlier claim that transfer requires the right layer is withdrawn.

🗄️ Data

Synthetic micro-world — An invented operator language with eight operators, one of which (Ω) the recipient never sees; 17 trained decoder transformers (4 layers, 0.80 M parameters) covering three donor seeds, three recipient seeds, unrelated-skill donors and width, depth and stride variants; evaluation on 1,000 held-out programs with a target stratum, a control stratum and held-out compositions. All data are synthetic.
Open-weight models — Qwen2.5-1.5B, Qwen2.5-3B, Qwen2.5-7B and Llama-3.2-3B instruction-tuned checkpoints, with the capability defined as performing a verifiable task without demonstrations; pre-specified query pools of n = 22–40 and enlarged pools of n = 133–150; seven donor–recipient pairs.

⚙️ Methodology

Localization before transfer — Interchange interventions on clean and corrupted program pairs, zero-ablation and per-head patching locate the donor's execution of Ω at the post-layer-0 residual row at the read positions.
Alignment maps fitted on task-free rows — The primary map is an orthogonal Procrustes map fitted on 3,000 task-free items; ridge and whitened regression maps on task rows are compared, and a random orthogonal map serves as the sham that defines the estimand.
Six graft families and matched controls — Activation, subspace, steering, adapter, weight and persistent-adapter grafts, against sham-map, norm-matched random, shuffled-item, unrelated-skill donor and other-seed recipient controls routed through the primary map, and against a supervised adapter and full-model distillation on the same items.
Mechanism battery — Value readouts fitted on rows without Ω, an operand-swap graft from a twin program, grafts of the pre-MLP row and of an MLP-ablated donor, value-subspace projection and donor-side ablation of the Ω-contrast directions.
Pre-specified decision rule and inference — A rule fixed in-session before the confirmatory run, paired contrasts against the sham map with a cluster bootstrap over programs, multiplicity adjustment across families, and repetition on a retrained model matrix and on 25 pairs with two new seeds per role (mean 0.879).
Open-weight protocol — Few-shot minus zero-shot last-token task vectors mapped and added at the recipient's best layer, tested against random, unrelated-task and sham-map vectors, a shuffled-query state and a vector-free instruction prefix, under a frozen rule requiring a lower bound above 0.10 on at least two tasks.

♻️ Reproducibility

Every run has a manifest with the git commit, per-file code hashes, configuration and split hashes, seeds, library versions and hardware; the registry is append-only and lists every planned, failed, completed and invalidated run.
Figures, tables and inline numbers are regenerated from the committed results by one script; a fresh clone with the archive reproduces every table and number byte-for-byte on another machine.
The trained models, per-item outputs and open-weight caches are archived outside the repository with checksums; open-weight checkpoints are used under their licences and no derived weights are released.
Training determinism across devices is not claimed: a retrained model matrix reproduces the decision in every pair but moves individual estimates by up to 0.215.
Open-weight inference is deterministic per chip but differs between two chips on roughly one cell in six, enough to move one verdict between partial and supported.

Keywords mechanistic interpretability · activation patching · model stitching · representation alignment · value codes · causal abstraction · open-weight language models
JEL C45, C63, C88, O33

# 📚 How to cite

bibtex

@techreport{boucher2026wpai1,
  author      = {Simon-Pierre Boucher},
  title       = {The Neural Organ Transplant Experiment: Donor-in-the-Loop Activation Grafts Move a Computed Value, Not a Capability, Between Transformers},
  institution = {Université du Québec en Outaouais},
  type        = {UQO Working Paper No. AI-0001},
  year        = {2026},
  note        = {Version 1.1, November 2026, revised after peer review},
  url         = {https://git.spboucher.ai/wpai0001_uqo}
}

ℹ️ Below: documentation of the main branch (the version submitted to review). Numbers and claims that the review corrected are superseded by the block above and by the branch review-20261103.

# 🧠 The Neural Organ Transplant Experiment

UQO Working Paper No. AI-0001 — Causal Transfer of Cognitive Capabilities Across Local Large Language Models

$Paper$

TL;DR — Can a bounded, causally identified subsystem that implements a measurable capability in a donor language model be transplanted into a recipient that demonstrably lacks it, without full-model training? This repository holds the preregistered protocol, the experiment harness (toy transformers with exact hook semantics; MLX/Transformers backends planned), the registry of runs and the paper. Result (Tier 0, preregistered confirmatory run, 2026-11-09): a donor-in-the-loop activation graft — the recipient's post-layer-0 residual row at every read position replaced by the donor's row through an orthogonal Procrustes map fitted on task-free rows — lifts the recipient from chance (0.06–0.10) to 0.966 on held-out Ω programs (control-adjusted effect +0.875, lower bound above 0.25 in 9/9 pairs; control stratum 0.992), carries the rule to unseen operands (0.77 vs 0.94), needs eight of 128 dimensions, survives width, depth and stride-2 mismatches, and is anchored by ablation → rescue (0.11 → 1.00; sham 0.11). Regression-fitted maps (ridge, CCA) annihilate the capability (Proposition 1); donor-free adapters cache; conventional learning on the same items is perfect. Tier 1 (Qwen2.5-1.5B/3B, Llama-3.2-3B) and Tier 2 (Qwen2.5-7B) runs: see status.

# 📌 Status

Item	Value
Version	0.1 protocol draft (November 2026)
SSRN	not yet submitted
Journal	to be assessed after results (ML / mechanistic interpretability venue)
Code & data	synthetic data regenerated from seeds; every run has a manifest in `experiments/manifests/`
Gates	A ✔ · B ✔ · C ✔ · D ✔ · E ✔ (Tier 0 confirmatory) · F in progress

# 🎯 What this paper does

Prior work maps whole residual streams or concept directions between models (model stitching, activation buses, cross-model steering) and the one controlled attempt at activation-mediated capability transfer reports a null. We (i) causally localize a capability in the donor by interchange interventions, (ii) manufacture or verify the recipient's lack of it, and (iii) compare each transplant family (activation, subspace, circuit, weight, adapter, persistent) against matched sham, random and unrelated-donor controls on held-out, leakage-controlled tasks. Estimands:

text

Δ_T      = Q_T(R') − Q_T(R)                         transfer gain
Δ_T^adj  = Δ_T − [Q_T(R_sham) − Q_T(R)]             control-adjusted transfer (primary)
ρ_c      = Q_c(R') / Q_c(R)                         retention on control strata
N_D      = Q_T(D) − Q_T(D \ S_D)                    donor necessity

# 🏆 Headline results

Object	Estimate (run)
Donor vs recipient, target stratum	1.000 vs 0.092; Ω-step 1.000 vs 0.062; control 1.000 both (`pilot_tier0_opseq_451ef5087182`)
Localization of Ω in the donor	residual row at the read position restores 1.00 at every layer; L0 attention 1.00; L0–L2 MLPs 1.00/0.90/0.83; sham 0.00 (pilot)
Primary graft (confirmatory)	target 0.966 (min 0.889), control 0.992 (min 0.946); Δ_T^adj +0.875, lower bound > 0.25 in 9/9 pairs → H2 supported; H4 (≥ 0.95 retention everywhere) not supported (`graft_tier0_confirmatory_0c2257f6803e`)
Controls (confirmatory)	sham map 0.091 (control 0.100), norm-matched random 0.091, shuffled item 0.103, shuffled layer 0.186, unrelated-skill donor 0.076
Subspace k = 8 vs random k = 8	0.927 vs 0.077 (+0.850 [+0.837, +0.862])
Rule vs cache	graft 0.941 seen / 0.768 unseen (ratio 0.82, H5 supported); donor-free adapter 0.702 / 0.000
Ablation → rescue	0.113 → 1.000 (sham 0.106)
Conventional learning on the same 3 000 items	supervised adapter 1.000; distillation 1.000
Tier 1 / Tier 2	runs in progress (`tier1_taskvector_*`)

# 🗂 Repository layout

text

wp-ai-0001/
├── CLAUDE.md · docs/MANDATE.md       # binding rules and the verbatim research mandate
├── src/wp_ai_0001/                   # datasets (OPSEQ/FSA/MORPH), models + hooks, training, localization,
│                                     # evaluation, statistics, instrumentation, orchestration, visualization
├── tests/{unit,causal_sanity,...}    # generators, bootstrap, hook no-op and intervention algebra
├── scripts/                          # audit_environment, run_pilot, build_figures, build_paper
├── experiments/{registry,manifests,summaries}
├── artifacts/                        # models, per-item outputs, figures (git-ignored)
├── docs/                             # RESEARCH_GAP, PREREGISTRATION, EXPERIMENT_PLAN, COMPUTE_BUDGET,
│                                     # RISK_REGISTER, REPRODUCIBILITY, EXPERIMENT_LOG, DECISION_LOG, TASKS
├── literature/                       # verified arXiv records + BibTeX; unverified candidates listed apart
└── paper/                            # main.tex + sections/ + references.bib → main.pdf

# 🚀 Quick start

bash

python3 -m pip install -e ".[dev]"
python3 -m pytest tests -q
python3 scripts/audit_environment.py --cluster
python3 scripts/run_pilot.py --quick --device cpu --seeds 0 1 --n-boot 200   # ≈ 25 s CPU
python3 scripts/run_pilot.py --seeds 0 1 2 --steps 3000                        # ≈ 5 min on an M5 Max (MPS)
python3 scripts/build_figures.py --run <run_id> && scripts/build_paper.sh

# 🗃 Data

Synthetic micro-worlds generated from seeds (src/wp_ai_0001/datasets/), validated by exact recomputation, hashed and checked for item-level disjointness across splits; see data/README.md. Tier-1 checkpoints (Qwen2.5-1.5B/3B-Instruct, Llama-3.2-3B-Instruct, bf16) are cached locally and not redistributed.

# 🔬 Methodology

Gap qualification (Phase 1) — scripts/run_pilot.py, training/train_toy.py, evaluation/metrics.py.
Causal localization (Phase 2) — localization/patching.py (interchange, ablation, heads).
Alignment (Phase 3) — alignment/ (to implement: Procrustes, ridge, CCA, random, unrelated-data).
Transplant families and controls (Phases 4–5) — transplantation/ (to implement).
Robustness, mechanism, confirmatory (Phases 6–8) — planned, see docs/EXPERIMENT_PLAN.md.
Statistics — statistics/bootstrap.py (cluster bootstrap over programs; seed-level summaries).

# 🖼 Figures & tables inventory

Figure	Content	Source run
`fig_gap_tier0.pdf`	donor/recipient accuracy per stratum, seeds, chance	`pilot_tier0_opseq_451ef5087182`
`fig_localization_patching_tier0.pdf`	layer × position restored-answer rate, 3 families	idem
`fig_localization_ablation_tier0.pdf`	layer × position accuracy after zero-ablation	idem
`fig_localization_heads_tier0.pdf`	layer × head patching at Ω token and read position	idem

# ⚠️ Limitations

Tier-0 capability is a per-step map once the trace is visible (risk R1); multi-step claims need trace_stride > 1 and Tier ≥ 1 evidence.
No transplant, alignment or control battery has been executed; the paper contains placeholders.
Length generalization fails for both roles (absolute positions); it is a stratum, not a target.

# 📝 Citation