Extrapolation Under an Exact Verifier

A frozen language model with an external memory loop generated a 26-circle packing that was proven to be non-isomorphic to the published record. The result was not retrieved from existing data, produced through interpolation, or reached through local descent. The full reasoning trace, along with all 91 attempts, has been published.

We report a single, fully verified instance in which a frozen language model, coupled to an external memory that stores distilled records of its previous attempts, produced a configuration that extends beyond the published solutions and the search path represented by its own incumbent. Our analysis shows that the configuration is non-isomorphic to the published record and cannot be obtained through interpolation or local descent from the incumbent.

We publish the reasoning trace of the successful attempt together with the complete archive of the 91 attempts that preceded it.

This is an existence result. It demonstrates one documented instance in which an external memory loop enabled the system to produce a configuration outside the solutions and search paths available to it during the process. We make no broader claim about memory and extrapolation. The result is supported by machine-checked arithmetic criteria, allowing the conclusion to be evaluated independently of human judgment.

Code and data: github.com/blankline-org/extrapolation-n26 contains the coordinates, exact verifier, full reasoning trace, and archive of all 91 attempts. Three scripts reproduce the numerical claims below. The repository requires Node 18+ and has no dependencies or installation step. All file paths in this paper are relative to the repository root.

1. What we claim, operationally

“Extrapolation” is a contested term, so we define precisely what we mean before using it. We consider the result to satisfy three independently testable conditions:

Independent of retrieval. The configuration does not reproduce published coordinates available in the model’s training data.

Beyond interpolation. The configuration cannot be described as a perturbation or convex combination of published solutions.

Beyond local descent. Starting from the search’s own incumbent, local improvement does not lead to the configuration. It belongs to a different contact graph, with no descent path connecting it to the state from which the search proceeded.

A fourth condition provides the basis for testing the others:

Verified. The configuration satisfies all required constraints under exact arithmetic.

Conditions 2, 3, and 4 are established below through direct measurements. Condition 1 relies on a self-report in the model’s trace. We regard this as corroborating evidence rather than proof, and we identify it as the weakest of the four conditions wherever it is discussed.

What would falsify the result. A memory-free random-restart run with a matched inner budget that reaches the same contact graph would provide a direct test. We have not yet performed this experiment at the scale warranted by the claim (§9.3). If such runs recover the same structure at a meaningful rate, the evidence for condition 3 would disappear. The result would then amount to a demonstration of multimodality in circle packing, a phenomenon that is already well established.

2. The result

We publish pack26-discovery/gen3b-best.json, which contains a packing of 26 circles in the unit square with a total radius of 2.635917599028 and a maximum constraint violation of 2.78e-17.

The task is to pack n disjoint circles inside a unit square while maximizing the sum of their radii. It is a standard benchmark for program synthesis and global optimization systems, with an actively contested public record.

The value itself is not our main contribution. We include it here to provide a reference point for the discussion that follows. Six published results exceed this value, including a simulated-annealing heuristic with no model in the loop and an independent result produced by an individual researcher in July 2025. We discuss all six results in §10.

On tolerance. Tolerance conventions differ across this literature, so the figures above are not directly comparable without adjustment. AlphaEvolve validates at atol = 0; ShinkaEvolve reports results at both atol = 1e-7 and atol = 0; and OpenEvolve and ThetaEvolve use atol = 1e-6. Rather than assign our result to a tolerance class, we report the measured maximum constraint violation directly: 2.78e-17.

Under a literal atol = 0 requirement, this would require a uniform radius reduction on the order of 1e-16, reducing the score by approximately 2.6e-15. Our criterion is therefore not the strictest in the table; AlphaEvolve uses the stricter standard. We report the measured quantity because it can be independently checked by the reader.

Converting results reported under a looser tolerance to atol = 0 reduces the score by approximately 26·(t/2). This is an upper bound, since in practice only a small number of pairs are typically close to the tolerance boundary. Under this conversion, none of the results discussed above falls below ours.

We do not rely on the tolerance comparison to support our result.

3. The trace

results/reasoning-live.heavy.log contains 214,223 bytes of the model's verbatim reasoning trace. At line 3018, during the final attempt and before the resulting configuration had been generated, the model attempts to retrieve a published answer:

*"But wait — the log says local polish of the incumbent is already maxed out. So just squeezing the incumbent won't help unless… I have access to a KNOWN BETTER configuration. The Packomania value is 2.635983085 with a 'strict' bar. Do I know the Packomania coordinates for n=26?"*

"Hmm, do I remember actual coordinates? Not precisely. I don't have memorized coordinates for the n=26 optimal solution. But maybe I can reconstruct something close."

"Actually, let me think about this differently. The best-known structure: for maximizing sum of radii with 26 circles, the known good solutions typically have a certain structure. Let me try to recall what's known."

— results/reasoning-live.heavy.log, L3018–3024

We quote the passage in full, including the two continuations that qualify the initial interpretation. The sequence is better described as attempted retrieval → reported failure → further retrieval attempt → strategy change. The model does not immediately abandon lookup. Instead, it makes additional retrieval attempts before changing strategy.

The retrieval cue was supplied by the harness by design. src/problems.mjs:19-20 and :382-384 provide the model with published target values, including AlphaEvolve's 2.63586276 and ShinkaEvolve's 2.635983283. The passage above therefore reflects the model responding to information explicitly provided by the experimental setup. We treat this as part of the design rather than as a contaminating factor. Informing the system that a stronger result exists creates a direct retrieval probe: the trace records the model following that probe, reporting that it could not retrieve the target, and then changing strategy. We disclose this here rather than in the limitations section because it is part of the experimental design and is necessary for interpreting the quoted passage.

Self-reports about model knowledge do not establish non-contamination. A model's statements about what it does or does not contain cannot by themselves establish the absence of memorized information. The passage therefore provides supporting evidence for §4 but does not replace the analysis presented there. In §5, however, we report a case in which a self-report about the model's own history can be independently checked and is consistent with the recorded history.

4. Testing the three conditions

4.1 Not interpolated

The multiset of 26 radii matches none of the published packings in our reference set. When sorted and compared with the radii reported by Packomania, the largest difference for any single radius is 2.15e-3, or roughly 2% of a typical radius. This is substantially larger than the scale expected from a perturbation of a known solution, and no convex combination of the solutions in our reference set produces the observed configuration.

The stronger evidence comes from the structure of the packing. We compute the contact graphs using a threshold of 1e-7:

Under index matching, our packing shares 10 of 96 contact edges with the record family, giving a Jaccard similarity of 0.104. Because index matching depends on the labeling of the circles, we use a label-invariant comparison instead. Degree sequences are invariant under relabeling. Our degree sequence differs from that of the record family, which proves that the two contact graphs are non-isomorphic. This is an exact structural result rather than an estimate, and it holds at both 1e-7 and 1e-6 contact tolerances.

Our configuration achieves essentially the same total radius with ten fewer contact edges and six fewer wall contacts. The record family is more densely coordinated, including six circles of degree 6, whereas our configuration contains only one. In this sense, our solution represents a sparser arrangement with comparable objective value.

Figure 1. The two packings with their contact graphs overlaid. Shared edges are dimmed, highlighting the edges that differ between the configurations. Shared edges are matched by circle index, which provides the weaker comparison; Figure 2 gives the label-invariant structural comparison.

Figure 2. Degree distributions for the two contact graphs. Both configurations have ten degree-4 circles, but their degree distributions differ in the tails. Our configuration has five degree-2 circles, five degree-3 circles, and one degree-6 circle, with no circles of higher degree. The record family has two degree-2 circles, three degree-3 circles, six degree-6 circles, and one degree-7 circle. Because degree sequences are invariant under relabeling, graphs with different degree sequences cannot be isomorphic. This provides the label-invariant structural comparison that Figure 1 illustrates only through the chosen circle indexing.

Structural difference alone is not the main claim. Circle packing at this scale is multimodal, and independent restarts can reach different basins of attraction. Finding a different contact graph is therefore relatively easy. We use the structural comparison to identify the mechanism behind the result, namely movement between basins rather than incremental local improvement. It also provides a structural property that can be established rigorously: the two contact graphs are non-isomorphic (§10).

4.2 Not reachable by descent

The loop's incumbent was an LP-verified local optimum, with all 26 circles in contact. We applied 500 seconds of perturbations and simulated annealing to the incumbent; these searches recovered only an improvement of approximately 3e-7. Every tested local step toward the winning configuration produced a lower objective value.

This is the key condition underlying our interpretation of the result. The winning configuration lies in a different contact graph, and our local-search experiments found no descent path connecting it to the incumbent. This distinguishes the result from incremental local refinement and indicates that reaching the new configuration required movement to a different basin of the search landscape. In this regime, local polishing methods such as AlphaEvolve's SLSQP stage cannot follow the same path from the incumbent, while a global NLP solver would need to identify a different basin rather than improve the incumbent locally.

4.3 Verified

The reported configuration has an objective value of 2.635917599028 and a maximum constraint violation of 2.78e-17, computed under exact arithmetic by src/problems.mjs. The candidate program has no access to the verifier during generation. For comparison, we measured the published record coordinates at a maximum violation of 1.04e-12 and the full-precision Hyra coordinates at 9.80e-10.

We also obtained a variant with an objective value of 2.635917611449, an improvement of 1.24e-8, at the cost of a 9.00e-10 overlap. We exclude this variant from the reported result. Maintaining a consistent tolerance standard is more important to our analysis than the marginal gain of 1.24e-8.

5. From the inside: what 91 attempts show

results/archive-circle-packing-26.heavy.json records 91 attempts over 32.4 hours: 73 valid and 18 invalid, with all 18 invalid attempts receiving a score of zero. Each entry includes the model's structured analysis, with fields for DIAGNOSIS, TECHNIQUE, PLAN, AVOID, and SELF-CHECK, together with the verified score, failure reason, and timestamp. This archive allows us to examine the search process itself rather than relying only on its final output.

The best-so-far value improved 33 times, with progress concentrated in several stages:

2.080 (#2) → 2.229 (#3) → 2.498 (#4) → 2.617 (#11) → 2.620 (#18) → 2.622 (#36)
→ 2.624 (#39) → 2.625 (#44) → 2.626 (#45) → 2.6265 (#58) → 2.6278 (#73)
→ 2.635871 (#77) → 2.635903 (#79) → 2.635907 (#84)

The largest jump occurs at attempt 77, when the best-so-far value increases from 2.627796 to 2.635871. This marks a clear change in the search trajectory after roughly 40 attempts with smaller incremental improvements.

5.1 Self-report fidelity

46 of the 91 attempts contain an AVOID block in which the model records and summarizes its previous failures. These blocks generally become longer over the course of the run. The first five contain 118, 0, 232, 492, and 433 characters, respectively, while the last five contain 467, 464, 1,526, 1,475, and 1,998 characters. Their content also becomes more specific, progressing from general cautions to explicit failure categories paired with corresponding countermeasures.

The final AVOID block identifies four failure classes. We checked each one against the archive:

The count of seven is exact and non-trivial. The archive contains eight import-stage failures, but the eighth, attempt #43 (best is not defined), is a ReferenceError rather than a syntax error. The model's count therefore correctly excludes it.

We report this because the fidelity of a model's self-reports is rarely directly measurable. In this case, the archive provides an independent record against which the model's statements about its previous attempts can be checked. For this particular count, the model's report agrees with the archive at the level of individual failures.

This result does not justify relying on the model's self-report about training-data contents, which is a substantially different and more difficult claim to establish. It does, however, show that the model's introspective reports are not uniformly inconsistent with the available record.

One quantity cited by the model could not be independently verified: the claimed “Adam-ℓ1 oscillation that left 1.1e-4 unclaimed.” We have no independent measurement of this quantity and therefore do not rely on or endorse that claim.

5.2 Failures do not monotonically decrease

Invalid attempts continue to occur late in the run. They appear at attempts #1, 9, 10, 13, 14, 15, 25–28, 30, 40, 42, 43, 46, 52, 75, and 78, leaving a final sequence of only 13 consecutive valid attempts. The main change across the run is therefore not the overall presence of failures but their type. Early attempts primarily fail on geometry and runtime issues, including escapes and timeouts. Mid-run failures are more often related to syntax and language semantics. The final observed failure is a tolerance issue at #78, involving nine overlapping pairs with a maximum violation of 2.00e-9.

We regard this as moderate evidence rather than a strong result. The AVOID blocks accumulate content that can be checked against the archive, and the distribution of failure modes changes over time. However, invalid attempts continue throughout the run. The data therefore do not support a claim that external memory monotonically reduces error.

6. Why n = 26 is the instrument

The result is directly verifiable. Verification uses exact arithmetic to check that every circle lies inside the unit square and that no two circles overlap. The candidate program has no access to the verifier during generation. A candidate either satisfies the constraints and receives its corresponding score or fails verification and scores zero.

The benchmark is public and the record is contested. The published results span work associated with Friedman, AlphaEvolve, FICO, OpenEvolve, ShinkaEvolve, Packomania, and ThetaEvolve. Because the objective and constraints can be evaluated arithmetically, comparisons between configurations can be checked independently of subjective assessment.

The experimental setting deliberately uses publicly available solutions. The published packings are available on the open internet, so retrieval or memorization is a plausible source of a strong result. A system that reproduces a known solution should therefore recover its characteristic structure. Our configuration has a different contact graph and a different radius multiset. We treat the public availability of the solutions as part of the experimental design: rather than hiding the benchmark answer, we make it available and then test whether the system produces a structure that differs from the known solutions.

7. The system

The system has two nested search loops. The outer loop operates over programs: the model writes a JavaScript program designed to search for a circle packing. The inner loop operates over packings: each program runs for up to ten minutes, performs its own numerical search, and returns 26 (x, y, r) triples for verification and scoring.

Memory is updated between attempts. After each attempt, a consolidation step converts the outcome into a short experience record describing what improved the score, what failed, and the likely reasons for failure. These records are stored externally. On the next attempt, the model receives the records most relevant to the strategy it is considering.

The model parameters remain fixed throughout the process; only the external memory changes. This places the system within the broader category of test-time learning, alongside Dynamic Cheatsheet, Agentic Context Engineering, and the systems evaluated by Evo-Memory (§10).

7.1 Compositional generalization

The final search program combined ring rotation, hole relocation, an SLSQP-equivalent penalty optimizer, novelty rejection, and batch screening of approximately 20 structural perturbations before selecting a candidate.

The model did not start with this combination, and none of the zero-shot prompts in our runs produced it directly. Instead, the loop assembled the strategy across successive attempts, retaining techniques that improved the verified score. The trace also reveals an important qualification: the model's reasoning about novelty rejection draws on published evidence identifying it as a decisive ablation in ShinkaEvolve.

The strategy was retrieved from published evidence; the resulting configuration was generated by the search. That distinction defines the scope of our claim.

7.2 Scope and safety position

This is an internal Dropstone research system. It is not shipped, available to customers, or integrated into any production model. If it is deployed in production, it will operate within Dropstone and will first have to pass the evaluation and safety requirements described below.

The system is a bounded, memory-level recursive loop: it improves future performance by writing to an external store that influences its subsequent inputs. It does not modify its model weights, program, consolidation procedure, retrieval function, or harness. The external store evolves, while the mechanism that updates it remains fixed.

The loop is objective-agnostic, with its behavior determined by the verifier attached to it. Before considering any production use, our evaluation gate includes misuse testing against offensive-security-style objectives on systems we own, controls for memory provenance and integrity, and isolation between tenants.

Memory integrity is our highest-priority risk because we have already observed a failure in this area. In a run with six parallel workers, all six initially read the archive as it existed at launch. Five later wrote records stating that previous attempts had failed for specific reasons, citing failures that had not yet occurred. Parallel execution therefore introduced false information into the shared memory rather than simply weakening the learning signal.

This illustrates a fundamental property of external memory: a store that accepts writes can also be poisoned. Any production system would therefore need to establish memory provenance, integrity, and isolation before relying on accumulated records. We will publish these evaluations, including negative results, before considering deployment.

8. Provenance: which component produced what

The repository is public, and the full computational lineage can be reconstructed from the published artifacts. We therefore state the provenance of the reported number directly. Three components contributed to the published result, and only the first involved a model.

Phase 1: The memory loop (src/evolve.mjs, not published; see §7.2). The loop generated search programs across 91 attempts. Its best archived score is 2.635907462261. This exceeds AlphaEvolve by 4.47e-5 and the Friedman 2012 result by 1.91e-3, but remains 8.05e-6 below FICO Xpress.

The loop is an internal research system, and its source code is not included in the public repository. Its outputs are published: results/archive-circle-packing-26.heavy.json contains all 91 attempts, including the model's analysis, verified score, failure reason, and timestamp for each attempt. The complete reasoning trace of the decisive attempt is also published. A reader can therefore audit the loop's recorded behavior, but cannot reproduce the loop itself from the repository. We discuss the implications of this limitation in §12.

Phase 2: LP radii optimization and structural relocation (scripts/relocate.mjs). With the circle centers fixed, maximizing the sum of radii can be formulated as a linear program. This step solves that LP and applies structural relocation, increasing the score to 2.635912195016 (results/best-circle-packing-26.heavy.json), a gain of 4.73e-6. No model call is involved.

We attribute this contribution to the human authors, not to the memory loop. The LP formulation was developed after observing that the model repeatedly identified the opportunity but did not implement it. Every program generated by the loop used a greedy grow-to-fit procedure. That procedure converges to a fixed point that need not be optimal for the LP, because the LP can shrink one circle slightly to allow two others to grow. This reasoning is documented in the header of scripts/lp-radii.mjs. The resulting improvement is therefore a human algorithmic contribution to the final score.

Phase 3: Seed and parent sweep (pack26-discovery/gen-next.mjs). This stage takes the best solution obtained so far, inserts it into the program as BESTCFG, changes the random seed and hop-batch count, and generates the next candidate. There are no model calls anywhere in pack26-discovery/. Running gen0 through gen3b adds a further 5.40e-6, producing the final score of 2.635917599028.

The lineage is fully recorded and monotonic:

gen2 2.635917359067 → gen3 2.635917574561 → gen3b 2.635917599028

The final number should therefore be understood as the product of a model-driven search loop, a human-authored LP and relocation step, and a subsequent non-model seed and parent sweep.

Three consequences follow from this attribution, and we accept them explicitly:

The margins over AlphaEvolve and Friedman 2012 are attributable to the memory loop. These gains are already present before either model-free post-processing stage is applied.

The margin over FICO Xpress is not attributable to the memory loop alone. Reaching that value requires both model-free stages, including the LP and relocation step that we developed as a human algorithmic contribution. It would therefore be incorrect to describe the result as “the memory loop beat FICO Xpress.”

The two model-free stages contributed a combined +1.01e-5, roughly one-fifth of the loop's own margin over AlphaEvolve. This result weakens the strongest version of our hypothesis about the role of external memory. We report it explicitly rather than leaving readers to reconstruct the attribution from the repository.

9. Controls and ablations

9.1 What we have: memory-gated coding tasks

On a separate suite in which a frozen model must infer hidden repository conventions from failing tests and apply them to unseen problems:

The third row provides the stronger test of the hypothesis. On tasks with no recurring structure to learn, the memory-enabled loop showed no meaningful separation from the control, and the benchmark records that outcome directly.

For the first two rows, the hidden convention cannot be inferred without feedback, so a memory-free control is expected to perform close to 0% by construction. These results show that the loop can extract and apply a recurring convention, but they do not establish a general learning advantage. The sample is also small, with only 12 training tasks.

9.2 The zero-shot baseline

The no-memory circle-packing results consist of five single-evaluation attempts, with scores of 0, 0, 1.246529, 0, and 2.616693. Three of the five attempts were invalid. The memory-conditioned runs, by comparison, used up to 20 evaluations and an inherited archive.

This comparison therefore measures different evaluation budgets rather than isolating the effect of memory. It does not provide a valid memory-on versus memory-off comparison, and our analysis script appropriately does not draw a conclusion from these results.

REFUSED TO CONCLUDE:
- circle-packing-26: runs used 4 different configurations — not comparable

The most unfavorable result in our data is the best zero-shot single-shot score: 2.616693, obtained from a single attempt without memory. The corresponding no-memory performance under a 20-evaluation budget remains unknown.

9.3 The ablations that would settle it

We list the following as specified experiments rather than as general intentions. The first requires neither model calls nor additional model budget: pack26-discovery/structural-search.mjs accepts --seed and --seconds and contains no model in the search loop.

Matched-budget memory-free restarts. Run N memory-free restarts with the same inner evaluation budget and report how many reach 2.63586276 and how many produce the degree sequence 22222333334444444444555556. Not yet run.

Shuffled-memory arm. Provide records retrieved from a different problem. If this produces comparable gains, the effect would be more consistent with increased prompt context than with the content of the memory itself. Not yet run.

Full stated-intent fidelity. Section 5.1 measures the accuracy of self-reported failure counts. The stronger test compares each attempt's stated PLAN with the program actually generated and with the resulting verified score change. Each attempt is classified as intent honored, score moved, intent honored, score flat, or intent absent from code. The proportion in the third category provides a verifier-based measure of disagreement between stated intent and implemented behavior. Partially run (§5.1).

10. Related work and prior claims

We list the work that places our contribution in context, including results that exceed ours.

Prior verified LLM discovery is well established. FunSearch (DeepMind, Nature, 2023) produced new cap-set constructions and achieved the largest improvement to the corresponding asymptotic lower bound in twenty years. AlphaTensor preceded it, and AlphaEvolve followed. We do not claim to be the first LLM system to make a verified discovery.

On this specific problem, six published results exceed ours. Two are particularly relevant:

An independent researcher using the handle “Alex” reported 2.63592717 in July 2025, exceeding both AlphaEvolve and FICO Xpress. The result was produced using a self-built multi-agent framework and validated with AlphaEvolve's Colab validator at atol = 0. The author also reported that the resulting arrangement was structurally different from both reference solutions. We could not locate published coordinates, so we cannot independently compare the contact graphs. This result predates ours, exceeds our score, and was produced under broadly comparable resource constraints. It would therefore be inaccurate to describe our work as the first low-budget independent result on this benchmark.

A hybrid simulated-annealing method using cosine cooling and Lévy flights reports 2.6359372 without a model in the loop.

Test-time learning with external memory for frozen models is an established research direction. Dynamic Cheatsheet (Suzgun et al., 2025) describes persistent, evolving memory for black-box models without gradient updates. Agentic Context Engineering, Memento, and MemoPilot are related approaches, while Evo-Memory directly benchmarks this category. Our loop is an instance of an established design pattern rather than a new architecture.

The complementary-learning-systems framing is also established. HippoRAG explicitly uses retrieval mechanisms motivated by the distinct roles of the neocortex and hippocampus, while HEMA, AHA, CodaRAG, and CraniMem explore related ideas. We use this framing as design motivation (§13), not as a claimed contribution.

Memory-level recursive self-improvement is an active research area, including a dedicated ICLR 2026 workshop.

What we believe is new

Against this background, we keep our contribution deliberately narrow:

A timestamped, self-reported retrieval test, coupled to an exact verifier, followed by a configuration that is provably non-isomorphic to the published record, with the complete attempt archive preserved alongside the result.

FunSearch, AlphaTensor, and AlphaEvolve all produced verified novel results, but our literature review did not identify a published trace combining an explicit retrieval attempt, a reported retrieval failure, a subsequent strategy change, and a formally verified structural distinction in the resulting configuration. Evolutionary program-search systems generally provide search artifacts rather than a narrative account of this process. “Alex” reported a structural difference, but we could not locate coordinates that would allow us to verify that claim independently.

For n = 26, our degree-sequence analysis provides a direct proof of non-isomorphism between the reported configuration and the record family. We have not found an earlier published proof of this specific structural distinction, although we do not claim exhaustive priority.

A secondary claim is that memory-level recursive search can be evaluated against a public external record rather than only against internal progress metrics. This provides a more concrete evaluation target than measures based solely on the system's own accumulated performance.

11. Limitations

The reported value is neither a record nor state of the art. Six published results exceed 2.635917599028, including a heuristic method with no model in the loop.

The result is not the first independent low-budget result on this benchmark. The “Alex” result from July 2025 predates ours and reports a higher score (§10).

The 2.09e-6 margin over FICO Xpress is not attributable to the memory loop alone. It depends on two model-free post-processing stages, including a human-authored LP that the model repeatedly identified but never implemented (§8). The memory loop's own best score is 2.635907462261.

The reported tolerance is not the strictest in the field. AlphaEvolve validates at atol = 0 (§2).

Novelty is measured against every published solution for which we could obtain coordinates, including AlphaEvolve, Packomania, and the full-precision Hyra coordinates (§4.1). We could not obtain coordinates for the FICO Xpress result, ThetaEvolve, or the July 2025 independent result, so structural comparisons with those configurations have not been performed.

The AlphaEvolve comparison is sensitive to the contact tolerance. Its published construction is not snapped to exact contact, so the inferred contact graph changes with the tolerance used in the comparison (§4.1). The non-isomorphism conclusion remains unchanged across the tolerances we tested. The precise contact graph of the AlphaEvolve coordinates is therefore less well defined than that of the record family under an exact-contact interpretation.

The retrieval test was prompted by the harness (§3). The trace documents a retrieval attempt followed by a reported failure; it does not establish spontaneous retrieval failure.

The model's self-report about retrieval is supporting evidence rather than proof. Section 5.1 shows that the model accurately reports its recorded failure history in the tested cases, but this does not establish the reliability of its statements about training-data contents.

Failure rates do not decrease monotonically over the run (§5.2).

The zero-shot baseline is limited to five single-shot runs, three of which were invalid (§9.2). This does not provide a matched-budget memory-free control.

The convention control is expected to perform near 0% without memory because the hidden convention cannot be inferred without feedback (§9.1).

The decisive memory-free ablation remains outstanding (§9.3), although it requires no additional model budget.

The experimental scope is n = 1: one problem and one run. The result is therefore an existence result rather than evidence for a general effect.

12. What can and cannot be reproduced

We distinguish these two properties because the repository supports independent verification of the result, but not end-to-end reproduction of the discovery process.

Independently verifiable from the published artifacts: the configuration and its constraint violation; the non-isomorphism of the contact graphs; the radii comparison with the record family; every statistic in §5, including the self-report cross-check; and the full provenance chain in §8. Phases 2 and 3 are published and contain no model calls, so their contribution can be reproduced directly from the repository.

Not reproducible from the published artifacts: the memory loop itself. src/evolve.mjs is an internal research system and is not released (§7.2). The repository therefore contains the loop's complete output record rather than its implementation, preventing a third party from rerunning the discovery process end to end.

A reader can audit the loop's recorded behavior and independently verify everything derived from its outputs, but cannot reproduce the discovery by rerunning the loop itself. This limits the strength of the claim in §1. The matched-budget memory-free restart experiment in §9.3 provides an independent check that requires neither access to our system nor additional model calls.

To reproduce the structural claim, compute the contact graphs at a threshold of 1e-7 and compare their degree sequences with those in packomania26.json and hyra-n26.json. Our degree sequence is 22222333334444444444555556, while the record family's is 22333444444444455556666667. The difference in degree sequences establishes that the contact graphs are non-isomorphic.

To reproduce the analysis in §5.1, parse the analysis field in the archive for AVOID blocks and compare the failure counts they report with the corresponding reason fields from earlier attempts. This provides a direct check of the model's reported failure history against the archived record.

13. Why we looked in memory

Complementary Learning Systems theory (McClelland, McNaughton & O'Reilly, 1995; Kumaran, Hassabis & McClelland, 2016) proposes that intelligent systems benefit from two learning processes with different properties: a slower system that extracts general patterns across repeated experience, and a faster system that retains specific episodes while preserving distinctions between similar experiences. The constructive episodic simulation hypothesis (Schacter & Addis, 2007) further proposes that episodic memory supports the recombination of stored elements into simulations of situations that have not previously occurred. Supporting evidence comes from Hassabis, Kumaran, Vann & Maguire (PNAS, 2007), who found that patients with bilateral hippocampal damage produced less spatially coherent descriptions when asked to imagine novel scenarios, with descriptions consisting more often of fragmented elements rather than an integrated scene.

This perspective motivated our design: keep the model's parameters fixed while providing an external memory that can accumulate and retrieve specific experience records, then test whether the resulting system can produce configurations outside the solutions represented in the model and its retrieved records.

We do not claim that our consolidation mechanism is a computational hippocampus, nor that the system reproduces the biological mechanisms described by Complementary Learning Systems theory. The correspondence is architectural rather than biological, and the theoretical framing itself is established in the literature (§10). We include it as motivation for the experimental design, not as evidence for the result. The empirical evidence is presented in §§4 and 5.

References

McClelland, McNaughton & O'Reilly (1995). Why there are complementary learning systems in the hippocampus and neocortex. Psychological Review 102:419–457.

Kumaran, Hassabis & McClelland (2016). What Learning Systems do Intelligent Agents Need? Complementary Learning Systems Theory Updated. Trends in Cognitive Sciences 20:512–534.

Hassabis, Kumaran, Vann & Maguire (2007). Patients with hippocampal amnesia cannot imagine new experiences. PNAS 104:1726–1731.

Schacter & Addis (2007). On the constructive episodic simulation of past and future events. Behavioral and Brain Sciences 30:299–351.

Romera-Paredes et al. (2024). Mathematical discoveries from program search with large language models. Nature 625:468–475. (FunSearch)

Novikov et al. (2025). AlphaEvolve: A coding agent for scientific and algorithmic discovery. arXiv:2506.13131.

Berthold, Kamp, Mexi, Pokutta & Pólik (2026). Out-of-the-Box Global Optimization for Packing Problems. arXiv:2605.04850.

Suzgun et al. (2025). Dynamic Cheatsheet: Test-Time Learning with Adaptive Memory.

Gutiérrez et al. (2024). HippoRAG: Neurobiologically Inspired Long-Term Memory for Large Language Models. arXiv:2405.14831.

Evo-Memory: Benchmarking LLM Agent Test-time Learning with Self-Evolving Memory. arXiv:2511.20857.

ThetaEvolve: Test-time Learning on Open Problems. arXiv:2511.23473.