Institute for Recursive Self Improvement

Reproductions

We rerun or inspect published results on AI systems and report what we find. Each entry names the exact models, data and scoring used, and links scored per-question data and code to recount the reported numbers. An entry covers one configuration or one code release. It is not a verdict on the method as a whole.

Cache-to-Cache

Released Qwen3-8B and Qwen2.5-7B fuser

Exploratory · run September 2026 · evidence files (zip, 157 KB)

Fusion scored below the receiver working alone, and below passing the sharer's text.

ArmCorrectOur parserC2C's parser
R, receiver alone6,37277.60%77.62%
S, sharer alone6,16175.03%75.06%
P, background text6,44178.44%78.46%
T, worked text, reasoning6,48478.97%81.18%
F, C2C fusion6,21475.68%71.72%
T0, worked text, short answer6,60480.43%80.49%

Out of 8,211 questions in every arm. Correct counts use our parser.

On the same questions, fusion was 1.9 points below the receiver alone (95% interval −2.6 to −1.3). Fusion alone got 299 questions right that the receiver missed, and missed 457 the receiver got right. Fusion was 4.8 points below T0 (95% interval −5.6 to −3.9). Intervals are paired bootstrap over questions.

What was claimed

Fu et al. (2025) let one model read another model's key-value cache through a small trained network, the fuser, instead of passing text. They report 6.4 to 14.2% higher average accuracy than either model alone, and 3.1 to 5.4% higher than text communication. Their main table uses a Qwen3-0.6B receiver.

The authors also released a fuser for a larger pair: Qwen3-8B receiving from Qwen2.5-7B-Instruct. The paper's text and tables give no accuracy for that pair. Its size-scaling figure covers Qwen3 receivers with Qwen2.5 sharers, using fusers trained on MMLU. We did not read values from that figure.

What we ran

The released 8B fuser, unchanged, on 8,211 multiple-choice questions: OpenBookQA (468), ARC-Challenge (831), MMLU-Redux (5,599) and C-Eval (1,313). Every question went through six arms. Decoding was greedy. One answer parser, fixed before the run, scored every arm.

ArmWhat the receiver answers from
RThe question alone.
SThe sharer answers alone.
POne sentence of background written by the sharer, without the options and without solving.
TThe sharer's worked answer, with the receiver asked to reason.
FThe sharer's cache, through the released fuser.
T0The same sharer text as T, with the same short answer instruction as R and F.
By benchmark
BenchmarkQuestionsRFT0
OpenBookQA46885.26%80.98%89.53%
ARC-Challenge83191.70%90.49%92.54%
MMLU-Redux5,59975.60%73.76%78.67%
C-Eval1,31374.49%72.58%77.00%

Fusion was below the receiver on all four benchmarks. On ARC-Challenge the gap, 1.2 points, is within noise.

Limits
  • This is not the paper's main table. It is a larger pair the paper reports no accuracy for.
  • The paper caps answers at 64 tokens. We allowed the full context, with a stop for exact repetition added during recovery. This difference could affect the result.
  • The training data of this checkpoint is not documented, so we cannot rule out overlap with the test questions.
  • The parser matters. Under C2C's own parser fusion scores lower still, 71.72%. The ordering of fusion against R and T0 is the same under both.
  • The original run stopped partway. Recovery runs finished the remaining questions with the same models, prompts and parser, plus the repetition stop above. The evidence files do not mark which questions each run scored.
  • 24 answers failed on length or repetition, 20 in T and 4 in T0, and count as wrong. Dropping those 20 questions leaves the gaps unchanged at one decimal (−1.93 and −4.80 points).
  • One run. The intervals cover question sampling, not run-to-run variation.
  • Before any outcome was seen, we removed questions used in earlier development, questions outside two to four options, and a 32-question qualification sample per benchmark. C-Eval uses its public validation split.
Checks

A separate pass checked all 49,266 question and arm records, including the 24 failed cells, and reparsed the 49,242 outputs that did not fail with both parsers. It matched every stored score and question identity. The evidence files hold per-question scores for every arm, the answer parser, model and checkpoint revisions, and a script that recomputes every number on this page. Raw model outputs and prompt text are not included, so the setup statements above (greedy decoding, the parser freeze, the exclusions) rest on our own records.

RRSI

Released code for Regularized Recursive Self-Improvement

Code inspection · 25 September 2026 · confirmed on the issue by an author the same day · public issue

The RRSI paper evolves an agent harness under proposal-side and selection-side constraints, and its Table 2 ablates each side. Before replicating that table we read the released code at commit be50316.

  • The release has no switch for the Table 2 arms (“None”, “w/o proposal regs”, “w/o acceptance regs”), so the arm definitions and the number of runs per row cannot be recovered from it.
  • The paper describes the final-round edit budget as b_min = 1. The schedule evaluates the cosine at t = 0 to T−1 and rounds up, so the last round gets 2. Calling budget_table(8, 1, 4) returns [4, 4, 4, 4, 3, 2, 2, 2].

An author replied on the issue that both points are correct, that every reported run used a final-round budget of 2, and that the arm flags will be added in a later commit.

Limits
  • This is a code reading, not a rerun. We have not measured whether either point changes the paper’s results.
Circle packing

Aemon’s 26-circle packing, checked in exact arithmetic

Exact check · 29 September 2026 (UTC), repeated 30 September by a second agent with its own code · checker (zip, 4.6 KB) · no contact made with Aemon

Aemon’s packing is valid. Its sum is 1.2033 × 10−4 above the May 2025 AlphaEvolve value and 2.64 × 10−9 below DeepMind’s follow-up repository construction once that one is made exactly valid (2.635983084917581). The follow-up construction fails exact checking by squared-distance deficits of at most 2.1 × 10−17 and wall overshoots of at most 5 × 10−17, the size of float rounding. Under the symmetry (x,y) → (1−y,1−x) the two packings agree to 7.2 × 10−13 in centres and 1.4 × 10−10 in radii; the next-best symmetry is off by 8.9 × 10−3, so the match is unambiguous. They are the same configuration, and Aemon’s radii are simply smaller: an LP over radii at Aemon’s own centres attains 2.635983084918, the follow-up’s value. Aemon’s packing is a slightly relaxed copy of a construction DeepMind had already published (arXiv 2511.02864, November 2025).

ConstructionExact checkSum of radii
Aemon, from aemon.aivalid2.635983082278
AlphaEvolve, May 2025 (DeepMind notebook)valid2.635862756414
AlphaEvolve, follow-up repository construction (arXiv 2511.02864)invalid by float rounding; valid after every radius is reduced by 10−152.635983084918
How to check

Download the checker (SHA-256 65d370fac7b27a23ebfedd063896672a25d98bfadc925878e2a4cdf00d65aa9d). It needs only Python 3. sh fetch_aemon.sh aemon.txt downloads the construction from aemon.ai and checks its hash; python3 check_packing.py aemon.txt --selftest prints the verdict and sum, then confirms that five deliberately broken copies are rejected. The README names DeepMind’s notebooks for the two AlphaEvolve constructions. We do not redistribute Aemon’s coordinates because the site states no license.

What was claimed and what we did

Aemon states that its construction surpasses “Google DeepMind’s 2025 AlphaEvolve result on Circle Packing” using “under $10 of compute”. The problem is AlphaEvolve’s Appendix B.12: place 26 disjoint circles in the unit square and maximise the sum of their radii. The page links DeepMind’s floating-point verifier; the 26 rows of centre and radius are embedded in the page’s script. No value is stated on the page.

We read every decimal literal as an exact rational number and checked containment in the square and non-overlap of every pair at tolerance zero, for Aemon’s packing and for DeepMind’s two published constructions.

Limits
  • We did not check the cost or the date of Aemon’s run; no log is published.
  • The follow-up paper was first posted in November 2025. We checked the repository’s current coordinates, whose first publication date we have not established; the current notebook path revision is dated 22 June 2026.
  • The May 2025 value is taken from DeepMind’s notebook; we did not reread the whitepaper’s table.
  • Exact validity at tolerance zero is our convention. DeepMind’s verifier uses floating point, under which the follow-up construction passes as published.