Anna.exe and Emergent Computation: Overview

Anna.exe and Emergent Computation: Overview

0. For visitors

In June 2026, CFB (Come-from-Beyond) released a small Windows binary, Anna.exe, with a one-billion-QU bounty (which CFB flagged playfully himself) for anyone whose run reaches "score 0." We took the binary apart, rebuilt its algorithm from scratch, and then used the rebuilt substrate to run a careful experiment about a single question: what part of an algorithm can be discovered automatically by evolution, and what part cannot?

The result is precise and deliberately un-hyped. It is not a claim that we "found AI." It is a proposed decomposition (a hypothesis, not a proven theorem): in our experiments, every component normally called "the algorithm" could be made to emerge from mutation and selection on tiny examples, and we argue that exactly one primitive cannot.

Two chapters carry the detail:

• Emergent length-generalization, the controlled study (the proposed decomposition, the 15 phases, the irreducibility argument, the pre-registered noise law).
• Reverse-engineering Anna.exe, what the binary is, how it was disassembled and reimplemented, and the finding that composition succeeds where monolithic search stalls (in our modified model).

An interactive companion lives in the Evidence section as the Anna.exe & Emergence lab tab.

1. What Anna.exe is

Anna.exe is CFB's binary, verified against his own Discord notes. It is an Aigarth evolution engine, not the published Anna Matrix and not part of qubic/core. It is a PE32+ executable that imports only KERNEL32, holds everything in a ~5.84 MB RAM arena, and does no file or network I/O.

It trains a 100-cell ternary lookup-table cellular automaton with a (1+1) evolution strategy, mutate one trit per epoch, accept if the score did not get worse, run for one million epochs, on the task of signed 7-bit addition, x and y from -64 to 63 (16,384 operand pairs, which equals Anna's 128×128 element count). The score is the number of wrong output bits, driven toward 0. CFB's framing: "Once the score reaches 0, your PC is holding AI."

A reproducibility-relevant detail: the binary uses the hardware RNG (RDRAND) for both task generation and every mutation, so every run is unique and not reproducible. Our reachability analysis finds the bounty effectively unreachable by blind monolithic search (the error floor rises sharply with problem size). Versions v1 to v4 (all built 10–13 June, SHA-256 verified) added auto-unsticking, a manual key-driven mode, and a state snapshot; none changed the core difficulty.

2. The central finding: composition succeeds where monolithic search stalls

Earlier versions claimed that a hand-built adder proves the unmodified substrate capable with under a third of the cells. The re-check did not confirm this: the construction uses 37 cells, base 3 instead of base 4, unsigned instead of signed addition, and separate control cells instead of the output cells as halting cells. Run with the binary's halting rule, it stops after one tick and gets 13,468 of 16,384 sums wrong. It is a correct unsigned adder only in its own modified model. The binary's monolithic (1+1) search stays in a high-error regime far above 0, CFB's own screenshot shows ~41% wrong partway through the run, and the error floor rises sharply with problem size.

The resolution, in our modified model, is composition. Evolve a one-bit full adder (0 error in a few hundred evaluations), then wire seven copies in a ripple-carry chain, and the result is a perfect 7-bit adder: 0 of 131,072 output bits wrong over all 16,384 pairs. This is exactly CFB's own 2019 "Scratch" vision (evolve A+B, then drag-and-drop to compose), carried out end-to-end.

The honest reading: "score 0" is a learned arithmetic circuit, not intelligence. At the 64-task scale we tested, the raw engine memorizes rather than generalizes.

3. The proposed decomposition (hypothesis)

Stated narrowly, as a hypothesis: for a computation that must generalize to unbounded input size, every component of the algorithm can be made to emerge by mutation and selection on small examples alone, and exactly one primitive cannot. The evidence is a finite set of selected constructions plus an informal argument; there is no formal model with quantifiers and no proof. The per-phase results below are reported, not all independently re-run.

The single irreducible primitive is the substrate's capacity to apply a rule repeatedly and halt on a state predicate (a bare while-loop). This is not a search-budget limit: a finite genome that generalizes to unbounded input must reuse a finite rule across the input, so iteration is the precondition for there being any generalizing computation to emerge at all. In our experiments, everything usually called "the algorithm" sat above this floor and self-assembled. Full detail and the per-phase evidence are in Emergent length-generalization.

4. The honest novelty review (the turning point)

Four independent adversarial literature passes converged on one verdict: the novelty is methodological, not phenomenal. The real contribution is the exactly-decidable, exhaustively-verifiable substrate plus matched controls and a pre-registered (and once-falsified) law, an instrument that turns hard-to-falsify claims into decidable experiments, plus the unification of a ladder previously shown piecemeal and approximately.

Every headline phenomenon has a named predecessor: the noise law restates Kashtan & Alon (2005); modularity-via-connection-cost is Clune, Mouret & Lipson (2013); evolved arithmetic is Miller & Thompson (2000); the emerged few-shot learner is Mitchell's version-space elimination; evolved in-context learning is the VSML / Kirsch line. The one narrow new identification is reading an emerged few-shot learner bit-exactly as a known symbolic algorithm. We do not claim a phenomenal first.

This is the finding that drove the pivot: no pure-science moonshot here resolved to a breakthrough; each resolved to known theory or to a clean toy.

5. What did not work (recorded honestly)

• HyperIdentity (a self-improvement loop): tested directly; the compression form converges to a fixed point rather than diverging toward a singularity (improvement-move probability ~0.017, exactly 0 for 20 of 30 teachers; self-application's last improvement at step 846 of 4000). Open-ended growth requires expanding the task, not iterating a function-preserving map.
• Pioneer-1 (is evolution a volume-sampler or a robustness-sampler?): ~13,000 exactly-evaluated configurations gave an exact null, the two posteriors are concordant (≤0.056 apart, never flipping the winner). It sharpens Mingard's result; it is not a breakthrough.

6. Why the deterministic substrate matters more broadly

The entire emergence program ran on exact deterministic integer/ternary substrates precisely because that is what makes a computation exactly re-verifiable by an independent party. That property, deterministic-kernel re-verification, is what makes verifiable AI computation possible at all: integer arithmetic is associative and therefore bit-identical across any hardware, while IEEE floating point is not. The substrate that made emergence provable is the same substrate that makes an AI computation independently checkable.

Scope and what is not claimed

This is emergent generalizing computation, demonstrated and bounded. It is not "artificial intelligence found," and it is not consciousness; consciousness is not operationalizable on this substrate and no such claim is made. The developmental scaffold (one tiled module, one channel, a fixed readout) is supplied, not emergent, this is emergence given a reuse prior, not emergence from nothing. The contribution is the proposed decomposition (a hypothesis), the irreducibility argument, and the noise law, with constructive and reproducible experiments behind each.

Reproducibility

Runnable, zero-setup verifiers and the core phase scripts are published at /data/emergence-artifacts/: a one-file browser verifier (verify_emergence.html, double-click), a dependency-free Python verifier (verify_emergence.py), and the numpy phase scripts (synthesis_proof.py, modcount_emergence.py) with a README. The reimplementations use a seeded PRNG and are fully deterministic, in deliberate contrast to the RDRAND-driven original; verification is exhaustive over the full input space rather than statistical where feasible.