AlgoGens LibraryBrowse the library
Menu

Curated shortlist of 99 systems · 11 scientific & engineering domains · 5 architectural regimes

Harnesses give a model tools.
AlgoGens pair it with algorithmic authority.

Real systems where algorithms and AI are woven into one hybrid. 99 of them in a curated shortlist across the literature, each checked against its sources. A generative model proposes formal candidates; a solver, prover, verifier, evaluator or physical simulator decides what holds.

Browse the libraryTry the live solver proofWhat is an AlgoGen?See the 4 lab receipts ↓

Figure 1 · The Authority Ladder: From Script to AlgoGen

What changes at each step is not the size of the model, but who holds epistemic authority in the loop.

  1. 01 · Classical AlgorithmA cartoon propeller airliner standing on two legs

    Is it a script?

    Flies the same route every time.

    Authority
    Fixed code or solver
    Ceiling
    Exact on fixed inputs; cannot read open-ended intent or invent candidates.
  2. 02 · Prompted ModelA cartoon caped hero in flight

    Is it a skill?

    Improvises, follows instructions.

    Authority
    Next-token likelihood
    Ceiling
    Reads any request, but arithmetic, invariants and deep proofs drift by feel.
  3. 03 · Agent HarnessA cartoon robot covered in gauges, pipes and tools

    Is it a harness?

    Model plus machinery: tools, memory, guardrails.

    Authority
    Pointwise pass/fail check
    Ceiling
    Checks the one guess in front of it; cannot prune or prove across the space.
  4. 04 · AlgoGen HybridA cartoon rocket with long eyelashes and a warm smile

    It's an AlgoGen.

    Algorithms and AI woven into one hybrid. A harness can be an AlgoGen. An AlgoGen can go much further.

    Authority
    Solver, prover or oracle
    Unlocks
    Model proposes formal candidates; an algorithm searches, scores, prunes or proves.

Four results from Google DeepMind and Microsoft Research

Here is what came out. How they got there comes next.

Google DeepMind

AlphaGeometry

25/30

Olympiad geometry problems solved, out of 30

14: symbolic engine alone

FunSearch

512

points in a cap set in 8 dimensions, larger than any known before

Lower bound on cap set capacity
2.2180previous best (Tyrrell, 2023) to 2.2202FunSearch

Only 4 of 140 runs reached 512 (Nature SI A.3), but once found, the Python construction is verified and runs without the model.

AlphaEvolve

49Strassen, 196948AlphaEvolve

Multiplications to multiply two 4x4 complex-valued matrices

For complex-valued matrices, nobody had beaten Strassen's 49 in 56 years, by the paper's account.

0.7%of Google's fleet-wide compute, recovered on average by a scheduling rule it foundGoogle DeepMind's own report, not independently replicated.

Microsoft Research and partners

AutoVerus

137/150

Rust verification tasks proved, out of 150

GPT-4o prompted repeatedly, up to 10 minutes per task

67 of 150

AutoVerus, at most 3 tries

137 of 150

122 of 150 passed on attempt 1 via structured proof agents; verifier-error repair rounds added 15 more to reach 137.

Logos belong to their owners and show who built each result. AlgoGens is not affiliated with or endorsed by either lab.

How? All four did the same thing.

What do these four have in common?

The usual guesses, and what the evidence says.

  • A bigger model?Not size alone.

    Not size alone. In the same seat, suggesting points to the same engine, GPT-4 solves 15 of 30 and AlphaGeometry's own 151-million-parameter model, trained for exactly that job, solves 25. AutoVerus runs GPT-4o as it comes. AlphaEvolve does use frontier Gemini models, and its paper finds a stronger model helps, but its ablations also find that taking away the evolution loop hurts.

    Sources: AlphaGeometry, AutoVerus, AlphaEvolve

  • A cleverer prompt?The loop writes the prompt.

    AlphaGeometry has no prompt at all: its model was trained from scratch on synthetic proofs. FunSearch's prompt is two of its own earlier programs, picked by score, plus the header of the function to write. The loop writes the prompt.

    Sources: AlphaGeometry, FunSearch

  • More human data?No human proofs, no extra training.

    AlphaGeometry trained on 100 million synthetic proofs and zero human ones. FunSearch used a pretrained code model that was never trained on cap sets. AutoVerus uses GPT-4o as it comes, with no extra training.

    Sources: AlphaGeometry, FunSearch, AutoVerus

Something else

A model proposes. An algorithm judges.

Yes. Each one pairs a model that proposes with an algorithm that judges, in a loop where each judgment steers the next try. The algorithm judges in one of two ways: it scores (FunSearch, AlphaEvolve: better and better answers, with no proof that one is the best) or it proves (AlphaGeometry and AutoVerus: every accepted answer is proved correct against its stated goal or spec).

Sources: AlphaGeometry, FunSearch, AlphaEvolve, AutoVerus

  1. AlphaGeometry

    The model proposes: New points and lines for the figure

    An algorithm judges: A symbolic engine derives what followsJudges by: proves

    The judgment steers the next try: The bigger figure goes back to the model

  2. FunSearch

    The model proposes: Small Python programs that build a solution

    An algorithm judges: An evaluator runs each one and scores itJudges by: scores

    The judgment steers the next try: The best programs go into the next prompt

  3. AlphaEvolve

    The model proposes: Edits to existing code, from Gemini

    An algorithm judges: Evaluators run each version and score itJudges by: scores

    The judgment steers the next try: High scorers are kept and shown again

  4. AutoVerus

    The model proposes: Proof notes for Rust code, from GPT-4o

    An algorithm judges: The Verus verifier proves it or lists errorsJudges by: proves

    The judgment steers the next try: The reported errors drive the next repair

One loop, drawn as a ring that never ends: the model proposes, an algorithm judges, the loop keeps what works, that steers the next try, and the next try goes back to the model.Model proposesAlgorithmjudgesKeep what worksSteer thenext tryOne loop

Take one half away

  • Model alone
  • Solved by the engine
  • Engine alone, plus what the model adds
Same 30 problems, same paper (Trinh et al., Nature 2024, Table 1).
SetupProblems solved, of 30
GPT-4 alone, writing full proofs (Model alone)0
Symbolic engine alone (Solved by the engine)14
Engine plus GPT-4 suggesting points (Engine alone, plus what the model adds)15
Engine plus hand-written human rules (Solved by the engine)18
AlphaGeometry: engine plus its own small model, in a loop (Engine alone, plus what the model adds)25

average IMO gold medallist: 25.9 of 30 (Fig. 2)

Each half alone stalls. Bolting a famous chatbot onto the engine adds one problem. A small model trained to propose inside the loop adds eleven.

Thirty geometry problems is a small test, and the gold medallist average is still a hair above AlphaGeometry. A later preprint pushes the symbolic side further, to 21 with no language model, and to 27 with AlphaGeometry added, on a partly re-translated set.

The pattern has a name

The term was coined in a 2024 working note to describe this hybrid pairing in one line:

Introduction to Algogens, section 1.2.1

“a cutting-edge framework integrating the precision of algorithmic processes with the creativity and adaptability of generative artificial intelligence”*

Shachar, Introduction to Algogens, 2024, §1.2.1 · arXiv:2403.01426
  • "precision of algorithmic processes" is the algorithm half, the part that checks and judges.
  • "creativity and adaptability of generative AI" is the model half, the part that proposes.

The test for what this library lists: the algorithm does real work, searching, deducing or proving, and code runs the loop across candidates. If the model decides whether to run the check and what to do with the result, the check is a sensor in a harness. A harness can still be an AlgoGen, but it falls outside this library's scope.

This library catalogs the peer-reviewed systems across computer science and the natural sciences that put that loop to work.

Definition 1 · Formal Anatomy & Broad Scope

What makes a system an AlgoGen: A = (G, X, V, S, F)

To capture the strongest hybrid papers across computer science, mathematics, operations research and the physical sciences, the library uses a five-part structural definition. Any system that couples a generative model G and a non-neural authority V inside a non-trivial search or verification topology S over formal candidates X qualifies as an AlgoGen.

Generative Proposer
An LLM, diffusion model, graph neural network, chemical language model or learned policy-value network that samples candidate structures.
Formal Candidate Space
A machine-checkable representation: MILP/PDDL specs, executable programs, Lean/Verus proof steps, assembly code, 3D crystals or proteins.
Algorithmic or Physical Authority
A non-neural judge that evaluates candidates: an exact solver (Gurobi, CP-SAT), formal kernel (Lean 4, Z3, DD+AR), sandbox scorer or DFT/wet-lab oracle.
Search or Control Topology
The search discipline over X: branch-and-bound, MCTS, evolutionary islands (MAP-Elites), diagnostic repair (CEGIS) or active-learning rounds.
Steering Feedback
How judgment steers generation: pruning dead proof branches, returning localized compiler counterexamples, re-ranking an archive or updating weights.

Why the scope spans beyond chatbots

An AlgoGen does not require the generator G to be a large language model, nor does the loop have to run only at chat time. Protein and materials generators (RFdiffusion, MatterGen, GNoME) couple 3D diffusion or graph networks to quantum DFT and biophysical filters. Offline algorithm discoverers (AlphaTensor, AlphaDev) use neural Monte Carlo Tree Search to discover exact matrix and sorting routines that then run as standalone deterministic code.

Why pre-generative paradigms hit a wall

Classical Operations Research (1940s), early Neuro-Symbolic AI (1990s), and CEGIS (Solar-Lezama, 2006) forged the verification and search authorities (V and S), but predated general generative intelligence: CEGIS had to enumerate hand-written syntax sketches, OR relied on manual mathematical formulation, and early neuro-symbolic systems wired narrow classifiers to logic rules. Pairing those exact authorities with a general generative prior G collapses blind combinatorial enumeration into prior-guided manifold search across all five regimes.

What a score can and cannot certify

An evaluator can certify primal claims, such as “this object has value at least v”. Those are NP-type: short to verify once you hold the object. Optimality claims, such as “nothing in X scores higher”, need a dual certificate, a bound or proof that covers all of X, and a score alone is not one. Generative models propose candidate structures; solvers and verifiers supply the checks and the bounds. See the Theory page.

Artifact persistence & zero runtime cost

In Regime IV (Offline Program & Heuristic Discovery), the generative loop executes offline at design time. Systems like AlphaTensor, AlphaDev, and FunSearch discover exact matrix algorithms, sorting routines, and mathematical heuristics. Once verified by the non-neural authority, the resulting code runs on bare metal forever with zero token cost, zero latency overhead, and zero runtime hallucination. A software factory is a natural place to deploy and maintain that discovered code, but the discovery itself still needs the verifier.

Architectural Taxonomy · 5 Engineering Regimes

Five ways a model and an algorithm share authority

Select a regime to inspect its control flow, when to use it, what holds epistemically, its failure mode, and landmark papers in the library.

Regime I · Formalize and solve

Formalize & Solve: Natural-language compilation into exact solvers and planners

Browse regime in library →
1. Generator (G)LLM compiles unstructured rules into MILP, CP-SAT or PDDL
2. Candidate (X)Formal constraint specification or solver code
3. Authority (V)Exact solver (Gurobi, HiGHS, CP-SAT, Fast Downward) + syntax/type checks
4. Search / Loop (S)Branch-and-bound, simplex or A* search with optional diagnostic repair
When to use this regime
Your problem has crisp constraints and an objective (scheduling, routing, MILP, PDDL planning), and an off-the-shelf solver can solve the formalized model.
What holds (epistemic scope)
Certifies feasibility or global optimality relative to the generated formal specification; deterministic once formalized.
Known blind spot
Silent semantic drift: if the model misstates an English rule in a way that still compiles and solves feasibly, the solver optimizes the wrong specification.

Landmark papers in this regime:

Regime II · Verifier-guided repair

Verifier-Guided Repair: Counterexample- and diagnostic-driven synthesis (Neural CEGIS)

Browse regime in library →
1. Generator (G)LLM agents propose invariants, proofs, patches or plans
2. Candidate (X)Annotated source code, formal proof scripts or structured plans
3. Authority (V)Sound verifier (Verus/Z3, Lean, Isabelle, sanitizer, constraint bank)
4. Search / Loop (S)Bounded generate-verify-critique repair loop gated by the verifier
When to use this regime
You have a sound formal checker, compiler, SMT solver or constraint critic that returns localized error messages when a candidate fails.
What holds (epistemic scope)
Every accepted output passes a sound formal or programmatic check; failed attempts do not corrupt accepted results.
Known blind spot
Vacuous or incomplete specifications still pass, and local diagnostic edits can stall inside the retry cap when global restructuring is needed.

Landmark papers in this regime:

Regime IV · Program evolution

Evaluator-Driven Evolution: Population-based code and heuristic search under automated scoring

Browse regime in library →
1. Generator (G)LLM mutates and recombines parent programs from an elite archive
2. Candidate (X)Executable functions, priority rules, CUDA kernels or symbolic equations
3. Authority (V)Deterministic sandbox evaluator scores correctness, bound size or latency
4. Search / Loop (S)Evolutionary islands, MAP-Elites archives or reflective population search
When to use this regime
No exact solver exists for your open problem, or you want a fast new heuristic, kernel or mathematical construction that can be scored cheaply in a sandbox.
What holds (epistemic scope)
Discovered artifacts are deterministically verified by the scorer and run standalone without the LLM; search itself is stochastic and does not prove global optimality.
Known blind spot
Evaluator gaming (exploiting loopholes in the test harness or precision limits) and high sampling cost across thousands of candidates.

Landmark papers in this regime:

Regime V · Oracle-trained generation / Active-learning generation / Offline solver discovery

Oracle & Offline Discovery: Scientific generators and RL agents coupled to physical or algebraic oracles

Browse regime in library →
1. Generator (G)Diffusion model, GNN, chemical RNN or RL policy-value network (often non-LLM)
2. Candidate (X)3D proteins, periodic crystals, SMILES molecules or tensor/assembly primitives
3. Authority (V)DFT quantum mechanics, docking, AlphaFold2 + wet-lab assays, or CPU/tensor checks
4. Search / Loop (S)Active-learning rounds, RL weight updates or MCTS offline algorithm discovery
When to use this regime
Candidates are molecules, crystals, proteins or low-level instruction sequences, and feedback updates model weights, training sets or offline search trees.
What holds (epistemic scope)
Offline-discovered algorithms (AlphaTensor, AlphaDev) are formally verified; physical sciences systems improve hit rates orders of magnitude over unguided screening.
Known blind spot
Surrogate-to-reality gap: 0 K DFT hulls, docking scores and structure-prediction filters are approximations of wet-lab synthesis and clinical activity.

Landmark papers in this regime:

Big labs, big problems. Here is the same machine on a problem small enough to check by hand, in its strictest form: the model writes the rules and a solver searches every roster, so it can prove which one is best.

One request, four ways

An algorithm does the sums exactly but can't read the words. A language model reads every word but does the sums by feel. A harness checks the model's guesses until one fits, so the rules hold, but a check only judges the guesses it is shown, so it can't prove no better answer exists. Pick a request and run it a few times.

Nurse shifts

Exhibit AWhat it shows: search beats luck

The request

next week's roster please. two nurses every friday night, david's off wednesday for his kid's play, nobody does a night and then the next morning, and keep everyone around 40 hours, no overtime, and emily and brian would love the weekend off if you can swing it

Five nurses, 12-hour day ☀ and night ☾ shifts, at most one shift a day each. Shown small; a real ward has 30 nurses and a month.

One roster request answered four ways (an illustration with scripted answers)
ApproachDeterministicsame rules in, same answer outSmartreads plain wordsKeeps your rulesevery rule, every runProves it's the bestruled out every other optionThis run
AlgorithmsFixed roster steps, every time. Cannot take personal wishes.YesNoNoYes
  1. Roster tool puts David on Wednesdayno field for "his kid's play"

Why

A scheduling tool fills in the fields it was built with: cover, rest, hours. "His kid's play" isn't one of them, so David lands on Wednesday. Every sum is right. It answered a slightly different request.

LLMsReads every word. Guesses hours and rest rules by feel.NoYesNoNo
  1. Run 1Sarah works 4 shifts, 48 hourssaid everyone is at 36
  2. Run 2Emily: Thursday night, then Friday morningsaid every rule holds
  3. Run 3All rules hold, weekend off for bothfits this time

Why

A language model writes the likeliest next words. "Everyone's at 36 hours" sounds right, so it says it. Nothing added up Sarah's shifts. Ask again and you get a new roster with a new slip.

HarnessesThe model proposes rosters; checkers test the rules.NoYesYesNo
  1. Run 1All rules hold, 2 weekend shifts leftpasses every check, not the best
  2. Run 2All rules hold, weekend offbest this time; it can't tell
  3. Run 3All rules hold, 1 weekend shift leftchecks pass; a better one exists

Why

Here the model guesses and a checker tests each guess against the rules, so whatever comes back fits. In this harness the checker only judges the guesses it's shown. Of the 3,923,568 rosters that fit, 246,648 give Emily and Brian the weekend off. Nothing in this loop goes looking for them.

AlgoGensThe model writes the ward rules; a solver finds the best roster and proves it.YesYesYesYes
  1. 36 hours each, rules hold, weekend offall rules plus wish, every run

Why

In this AlgoGen, each part does the job it's good at. The model reads the request and writes it down as rules. A solver searches the rosters those rules allow, skipping whole branches that can't win, and keeps the best one. Same rules in, same roster out.

The rules the model wrote

  • each nurse: at most one shift a day
  • every shift: 1 nurse · Friday night: 2
  • David: off Wednesday
  • no night followed by the next morning
  • everyone: at most 3 shifts (36 h)
  • wish: fewest weekend shifts for Emily and Brian

Ways to fill the week: 12,207,031,250. Keep every rule: 3,923,568. Weekend off for both: 246,648.

Flight to a Tuesday talk

Exhibit BWhat it shows: lowest price beats first fit

The request

talk in london tuesday 9am, flying from tel aviv monday. cheapest that works: under $600, no layover over 2 hours, and i need 4 hours in a hotel bed before the talk

The hotel is 1¼ hours from Heathrow, up at 7:30. Shown: 6 flights; a real search has hundreds.

One flight request answered four ways (an illustration with scripted answers)
ApproachDeterministicsame rules in, same answer outSmartreads plain wordsKeeps your rulesevery rule, every runProves it's the bestruled out every other optionThis run
AlgorithmsFixed flight filters, every time. Cannot plan hotel bed rest.YesNoNoYes
  1. $390 direct, lands 03:30, 2h45 in bedno field for "hours in bed"

Why

A flight-search filter only checks the fields it was built with: price and layover. "Hours in a hotel bed" isn't one of them, so it picks the $390 red-eye landing at 03:30, leaving 2h45 in bed. Every sum is right. It answered a slightly different request.

LLMsReads the schedule. Guesses time zones and layovers by feel.NoYesNoNo
  1. Run 1$430 via Rome, layover really 2h40said 1h40, mixed up time zones
  2. Run 2$420 direct, lands 02:40, 3h35 in bedsaid 5h35 in bed
  3. Run 3$480 via Rome, lands 22:50fits this time

Why

A language model reads clock times across time zones by feel. On one run it subtracts Rome time from Tel Aviv time and calls a 2h40 layover 1h40; on another it calls 3h35 in bed 5h35. Ask again and you get a new flight with a new slip.

HarnessesThe model picks flights; tools check layovers and price.NoYesYesNo
  1. Run 1$560 direct, lands 17:20fits, $80 more than needed
  2. Run 2$480 via Rome, lands 22:50cheapest this time; it can't tell
  3. Run 3$520 direct, lands 18:50fits, $40 more than needed

Why

Here the model guesses a flight and a checker tests price, UTC layover, and hotel rest, so whatever comes back fits. In this harness the checker only judges the flight it's shown. Of the 3 flights that keep every rule, 1 is the cheapest at $480, and others cost up to $560.

AlgoGensThe model writes flight constraints; a solver finds the cheapest itinerary and proves it.YesYesYesYes
  1. $480 via Rome, lands 22:50cheapest that fits, every run

Why

In this AlgoGen, each part does the job it's good at. The model reads the request and writes it down as rules, including the transfer from Heathrow and wake-up time. A solver checks all 6 flights against those rules in UTC and keeps the cheapest one that fits.

The rules the model wrote

  • ticket price: at most $600
  • each layover: at most 2 hours in UTC
  • hotel rest: at least 4 hours before 07:30 wake-up (75 min transfer)
  • wish: lowest ticket price

Flights shown: 6. Keep every rule: 3. Cheapest that fits: 1 ($480).

Stock sale for a down payment

Exhibit CWhat it shows: language sets the rules, math cuts the tax

The request

need $20k in my account after tax for a car down payment this week. sell whatever costs me the least tax, but leave my tech stocks alone, i think they're going up

Tax is 25% of the gain; a loss lowers it. Shown: 6 holdings; a real account has dozens of lots.

One stock-sale request answered four ways (an illustration with scripted answers)
ApproachDeterministicsame rules in, same answer outSmartreads plain wordsKeeps your rulesevery rule, every runProves it's the bestruled out every other optionThis run
AlgorithmsFixed formulaic sales, every time. Cannot honor 'leave tech alone'.YesNoNoYes
  1. Software, Index, Oil: $21,000, tax $0no field for "leave tech alone"

Why

A tax-loss tool only checks the fields it was built with: cash after tax and tax owed. "Leave my tech stocks alone" isn't one of them, so it sells Software to offset gains and pay $0 tax. Every sum is right. It answered a slightly different request.

LLMsReads the cash goal. Guesses tax and net proceeds by feel.NoYesNoNo
  1. Run 1Index, Bonds, Bank: $18,950 in handsaid $20,000; that's before tax
  2. Run 2Index, Oil, Bank: $18,300 in handsaid $20,200; skipped tax, added loss
  3. Run 3Index, Bonds, Oil: $20,500, tax $500fits this time

Why

A language model does portfolio arithmetic in prose. On one run it reports $20,000 in hand before subtracting the $1,050 tax; on another it adds Oil's $1,200 capital loss as if a loss were extra cash. Ask again and you get a new sale with a new slip.

HarnessesThe model proposes sales; tools check the tax arithmetic.NoYesYesNo
  1. Run 1Index, Bonds, Oil, Bank: $24,250, tax $750fits, $250 more tax than needed
  2. Run 2Index, Bonds, Oil: $20,500, tax $500least tax this time; can't tell
  3. Run 3Index, Bonds, Oil, Bank: $24,250, tax $750fits, $250 more tax than needed

Why

Here the model proposes a sale and a calculator checks net cash and the no-tech rule, so whatever comes back fits. In this harness the checker only judges the sale it's shown. Of the 2 non-tech sales that clear $20,000, tax ranges from $500 to $750.

AlgoGensThe model writes portfolio rules; a solver finds the least-tax sale and proves it.YesYesYesYes
  1. Index, Bonds, Oil: $20,500, tax $500least tax, both rules kept

Why

In this AlgoGen, each part does the job it's good at. The model reads the request and marks which lots are tech. A solver searches all 63 non-empty subsets of holdings, nets gains against losses at the 25% rate, and keeps the sale with the lowest tax.

The rules the model wrote

  • net cash after tax: at least $20,000
  • tax rate: 25% of net gain (losses offset gains)
  • tech holdings (Chip and Software): do not sell
  • wish: lowest tax owed

Ways to pick holdings: 63. Keep every rule: 2. Lowest tax ($500): 1.

Why the checks can't tell you it's the best

Checking one roster against the rules takes a computer a moment. Saying no better roster exists means ruling out every other one, and doing it without trying them all.

Check one roster

  • Each nurse: at most one shift a day
  • Cover
  • David off Wednesday
  • Rest
  • Hours

One look per rule.

Find the best

12,207,031,250

ways to fill the week

Watch the options explode

Shown for 5 nurses over 1 week.

12,207,031,250

ways to fill the roster

A computer checking a billion rosters a second would need about 12 seconds.

Shown: every way to staff each shift, before the other rules. The rules cut it a lot: for this week, to 3,923,568.

What the search proves

Best possible: 4 of 5

No roster that keeps the rules does better. The search accounted for all 12,207,031,250 ways to fill the week after visiting 1,214 partial rosters. A branch is dropped when it breaks a rule, or when even its best case can't beat the best roster found so far. Of the 3,923,568 rosters that fit, 2,952 reach 4.

Empirical Receipt · Why Self-Correction Can Fail

Why models cannot reliably grade themselves: the self-correction mirage

A common claim is that frontier reasoning models can verify and refine their own outputs without an external algorithm (Self-Refine). Controlled experiments on formal PDDL planning compilation (Planetarium Gripper benchmark, n = 109) show one case of the problem: when a model critiques itself, the critic shares the generator's weights, biases, and prompt contamination.

Receipt A · Cross-Model Blind Spot (n = 109)

When self-critique shares the generator's blind spot, iterating can make the answer worse

GPT-5.4 One-Shot (1 call, no loop)2.8%

3 of 109 correct

GPT-5.4 Self-Refine (4 calls, model critiques itself)0.9%

Lower than one-shot (0.9% against 2.8%): self-critique did not help here

GPT-5.4 + AlgoGen Repair (validator V + bounded repair)69.7%

+66.9 pp over one-shot; 73 fixed, 0 regressions. Against self-refine: Cohen h = 1.78, 75:0 discordance, p < 10⁻²²

All three GPT-5.4 rows come from one exploratory run through an unpinned model alias. Treat the numbers as a single observation, not a stable benchmark.

Receipt B · Robustness to Prompt Perturbations

Under re-verification

An earlier version of this comparison used numbers from a draft that disagrees with other drafts, so it has been withdrawn. Canonical numbers will appear with the paper's preprint.

Cov(eG, ecritic) > 0

Neural self-critique can drift: Generator and critic condition on the same weights and context. Correlated blind spots can turn extra test-time tokens into regressions.

Cov(eG, eV) = 0 (idealized)

Independent errors help: A non-neural verifier V (solver, compiler, proof kernel) checks the artifact X directly. In the idealized case its errors are independent of the generator's, so extra checks add information. A real validator is sound but incomplete, so some wrong answers still pass it. Read the argument →

Chatbot, harness, AlgoGen

From a fixed script to an AlgoGen: add an intelligence layer, add tools and checks, then hand the search to a solver.

  1. ScriptsChatbots and skills

    Fixed rules and exact sums. Cannot read plain words.Now a model reads plain words. Still no automatic check on its reply.

    Cron jobs, SQL queries, fixed roster or tax scripts.Now a chatbot or skill: it reads the request, and you judge the reply.

    If you add a language model, a fixed script becomes a chatbot or skill.

    Now it reads plain words: a skill.

    Algorithm's job:fixed rules onlynone in the loop

  2. Chatbots and skillsHarnesses

    No automatic check. You read the answer and judge it.Tools around the model, plus checks it can run, like tests that pass or fail.

    ChatGPT, Claude or Gemini as plain chat. A skill is saved instructions the model reads.Now a harness with tools and checks, like Claude Code, Codex, or Cursor.

    If you add tools and automatic checks, a skill becomes a harness.

    Now it is a harness that checks.

    Algorithm's job:none in the loopchecks

  3. HarnessesAlgoGens

    Tools around the model, plus checks it can run, like tests that pass or fail.The model writes the rules. A solver searches them.

    Claude Code, Codex, Cursor.Like the nurse rosters above.

    Wikipedia: an agent harness is the software around a model. Agent = model + harness.

    If the model writes the rules and a solver does the search, the harness becomes an AlgoGen.

    Now this loop is an AlgoGen.

    Algorithm's job:checkssearches or proves

  4. AlgoGens

    The algorithm does the search or the proof. The model proposes.

    FunSearch and AlphaEvolve search and score. AlphaGeometry deduces and proves.

    Algorithm's job:searches or proves

Click any upgrade button below a column to evolve it into the next framework
  • A harness can load skills.
  • When the model writes the rules and a solver searches them, the harness becomes an AlgoGen, as in the nurse rosters above.
  • An AlgoGen can go further: the algorithm runs the loop and calls the model, as FunSearch, AlphaGeometry and AlphaEvolve do.

Where AlgoGens go further

The systems in this library go further in 14 ways. Each comes with the systems that do it.

A domain authority judges

A domain authority decides what passes: a proof assistant or verifier for formal results, a simulator or docking score for computed estimates that are not lab results.

68 systems do this:

and 62 more in the library

The output outlives the model

What comes out is an artifact (an algorithm, a heuristic, a proof, a molecule) that is useful without the model.

64 systems do this:

and 58 more in the library

Inverted control

The algorithm is in charge and calls the model as a subroutine, instead of the model deciding when to call tools.

51 systems do this:

and 45 more in the library

The algorithm is the solver

The algorithm solves the problem. The model is one part of it, not a chat agent with tools around it.

49 systems do this:

and 43 more in the library

The generator is not an LLM

The generative part can be a diffusion model, a variational autoencoder or another model type.

23 systems do this:

and 17 more in the library

Feedback retrains the generator

Judgment flows back into the generator's weights through reinforcement learning, fine-tuning or active learning.

21 systems do this:

and 15 more in the library

An infallible formal kernel

A proof assistant or formal verifier checks every step with zero hallucinations allowed.

19 systems do this:

and 13 more in the library

Intra-algorithmic surgery (inside the while-loop)

Generative intelligence is injected inside the inner execution loop of a classical algorithm (steering A* heuristics, MCTS branching, or genetic operators) while the outer algorithm preserves its mathematical authority.

16 systems do this:

and 10 more in the library

AI at design time

AI is used offline to discover a solver. The deployed result runs without it.

13 systems do this:

and 7 more in the library

Multi-fidelity screening ladder

Candidates pass through an escalating funnel from cheap fast filters to expensive high-fidelity verifiers.

11 systems do this:

and 5 more in the library

Continuous-discrete duality

The model formulates the problem semantically; an exact numerical or combinatorial solver finishes it.

10 systems do this:

and 4 more in the library

Recursive meta-evolution

The loop searches the space of agent architectures, workflows, or search operators themselves.

10 systems do this:

and 4 more in the library

Physical and lab grounding

The algorithmic loop directly commands laboratory instruments, robots, or physical hardware.

8 systems do this:

and 2 more in the library

Beyond Outer Wrappers · 3-Phase Intra-Algorithmic Surgery

Not just a model calling a tool: generative intuition inside the while loop

An AlgoGen is not restricted to an outer wrapper where a chatbot calls a black-box solver once. Across classical algorithm families (A*, Branch-and-Bound, Genetic Algorithms, Simulated Annealing, Finite Elements, Bayesian Inference), generative intelligence can be placed inside the algorithm's own phases. The algorithm stays correct where the model only makes a choice it leaves open, and elsewhere only if the model's output passes a checkable contract:

Phase 1 · Preprocessing

Semantic & Structural Conditioning

Before the solver starts, G conditions the state space: adaptive mesh refinement in Finite Elements, prior synthesis from literature in Bayesian inference, or sparsity preconditioner selection.

Phase 2 · Core Execution Loop

Steering Inside the while Loop

Inside the inner iteration, G dynamically adjusts heuristics h(n) in A*, selects branching variables in Branch-and-Bound, or guides semantic crossover and mutation in Genetic Algorithms.

Phase 3 · Postprocessing

Diagnostic Audit & Co-Adaptation

After execution, V and F audit formal and semantic constraints, feeding execution traces and counterexamples back to update the archive or proposal prior.

Outer-Loop Tool Wrapper (Basic Harness)Algorithm is a sealed peripheral
# Model runs the loop; solver is called as a black box
spec = model.propose(user_prompt)
if validator.passes(spec):
    return solver.run_once(spec)  # Stops at first pass or chokes
Intra-Algorithmic Surgery (Algogenic A* / Branch-and-Bound)Algorithm owns state & proof
graph, root = G.condition_space(raw_problem)          # Phase 1: semantic conditioning
while open_set:                                       # Classical loop owns state & bounds
    node = open_set.pop_min(f = node.g + node.h)      # Exact lower bound / priority
    if V.is_goal(node) and V.proves_best(node, best):
        return V.certify(node)                        # Phase 3: formal certificate
    for child in S.expand_with_prior(node, G, F):     # Phase 2: G steers inner branching
        if V.feasible(child) and S.bound(child) < best:
            open_set.push(child, h = G.heuristic(child, F))  # proof holds only if h stays admissible

Try to break it

These are the strongest objections we have heard, with straight answers.

Isn't this just a harness with tests?

A harness can be an AlgoGen, and the good ones often are. The line is what the algorithm does. In many harnesses it only stamps pass or fail on the model's answer and stops at the first one that fits. In an AlgoGen it does real work: it searches by score, like FunSearch, or through every option with a proof, like the nurse solver above. In the formal 5-tuple A = (G, X, V, S, F), the verifier V and search strategy S hold final authority over what is accepted.

Where do software factories fit? Did you skip a step?

No. A software factory lets an agent run longer and more on its own: scheduled jobs around the clock, layered harnesses, subagents with time and spend limits, and a person who reviews instead of steering. That changes how the agent operates. The ladder measures something else: who decides that an answer is right. In most factories that is still a pass or fail check, such as unit tests, a linter or a human approval, so a factory stays on step 03 however much it automates. It becomes an AlgoGen when a solver, a proof checker such as Lean or Verus, or a scored search like FunSearch runs its inner loop. The two fit together: a factory is a good place to run an AlgoGen, or to ship the code one found.

Does the loop always win?

No. A loop is only as good as its judge. A later study found AlphaEvolve sometimes exploiting weak evaluators, and any score that can be gamed will be. The pattern pays off most where the judge V is exact or hard to game: a proof kernel, a MIP/SMT solver, a compiler, or a physical simulator.

Next year's model will do this alone.

Models will keep improving at proposing. But five nurses over one week already allow 12,207,031,250 possible rosters. A score from one run can show that a roster is good. Showing that none of them beats yours needs a bound or a search over X, which is the job of a solver rather than of a model's answer. When a model grades itself, its critic shares the generator's weights and blind spots, so their errors tend to be positively correlated and self-refinement can drift or regress. An external verifier V checks the artifact directly, so its errors are largely independent of the generator's. Training on unchecked synthetic output can also cause model collapse, and a verifier that filters candidates before they enter a training set is one way to limit that. AlphaGeometry, AlphaProof and GNoME use verifier-filtered data in this way.

Solvers choke on NP-hard problems.

In the worst case, yes, and nobody has a fix for that. In practice solvers prune huge parts of the search space X, and when they stop early they report an explicit optimality gap so you know how far from the best the answer could be.

What if the model writes the wrong rule?

This is the honest weak spot of Regime 1 (Formalize-and-Solve). Rules come back to you in plain words to confirm before anything runs, and systems like OptiMUS and LLM-Modulo run executable syntax, unit and constraint critics in their feedback channel F to catch broken formulations. Still, a verifier V proves only what the specification says, so a wrong spec still passes; the AutoVerus authors state this limit about their own tool.

Isn't this just Neuro-Symbolic AI, CEGIS or operations research with a chatbot?

No. Operations research (1940s), early neuro-symbolic AI (1990s) and CEGIS (Solar-Lezama, 2006) all predate generative foundation models; by definition, none of them could pair algorithmic authority with general generative intelligence. Classical CEGIS had to enumerate hand-crafted syntax sketches and hit an exponential wall past small programs; classical OR needed a human expert to hand-translate open-world problems into matrices; early neuro-symbolic AI wired narrow classifiers to logic rules. Replacing blind enumeration with a general generative prior G (an LLM, diffusion model or GNN) collapses an intractable search space into a navigable manifold across natural language, code, theorems, crystal lattices and de novo proteins.

Your examples are scripted.

The three comparative tables (Nurse shifts, Flight, Stock sale) use scripted model outputs so you can compare failure modes side by side, and are labelled as such. Every combinatorial count and the interactive branch-and-bound solver on this page run as real code in your browser, and the library curates a living shortlist of the top 99 peer-reviewed and primary-source-verified AlgoGens across the literature.

What Google DeepMind reports

These deployment results are Google DeepMind's own reports on its AlphaEvolve impact page. Each row links to that page. We have not reproduced them.

Deployment results and who reported them
AreaPartnerResultReported by
Hardware designGoogle (next-generation TPUs)

Used as a regular tool to optimize next-generation TPU design; a proposed circuit design was integrated directly into the silicon of next-generation TPUs

No numeric result is given.

Google DeepMind (source for Hardware design)
DatabasesGoogle Spanner

Reduced write amplification by 20% by refining Log-Structured Merge-tree compaction heuristics

Google DeepMind (source for Databases)
Computational materials and life sciencesSchrödinger

Roughly 4x speedup in both Machine Learned Force Field (MLFF) training and inference

Google DeepMind (source for Computational materials and life sciences)
Compiler optimizationGoogle (compilers)

Provided insights for new compiler optimization strategies that reduced the storage footprint of software by nearly 9%

Google says AlphaEvolve “provided insights” for these strategies; the saving comes from the strategies, not directly from AlphaEvolve.

Google DeepMind (source for Compiler optimization)
Show all 11 reportsShow fewer reports
Deployment results and who reported them, continued
AreaPartnerResultReported by
Quantum physicsGoogle Willow quantum processor

Suggested quantum circuits with 10x lower error than previous conventionally optimized baselines

Google DeepMind (source for Quantum physics)
Logistics (routing, Traveling Salesman Problem)FM Logistic

10.4% improvement in routing efficiency over the previous heavily optimized solutions, saving over 15,000 kilometers of distance travelled annually

Google DeepMind (source for Logistics (routing, Traveling Salesman Problem))
GenomicsPacBio (with Google Research DeepConsensus)

30% reduction in variant detection errors (improvement to DeepConsensus, a Google Research model for correcting DNA sequencing errors)

Stated as a reduction in variant detection errors; Google’s page does not give the baseline or benchmark.

Google DeepMind (source for Genomics)
Financial servicesKlarna

Optimized one of its largest transformer models, doubling its training speed while improving model quality

No quality metric given.

Google DeepMind (source for Financial services)
Earth sciencesGoogle Earth AI

Overall accuracy of natural disaster risk prediction, aggregated across 20 categories such as wildfires, floods and tornadoes, increased by 5%

Google’s page does not say whether the 5% is relative or absolute.

Google DeepMind (source for Earth sciences)
Advertising and marketingWPP

10% accuracy gains over their competitive manual model optimizations (refining AI model components on campaign data)

Google’s page does not define the accuracy metric.

Google DeepMind (source for Advertising and marketing)
AC Optimal Power FlowElectricity grids (no operator named)

Feasible-solution rate of the team's trained Graph Neural Network rose from 14% to over 88%

This is the network’s rate of feasible solutions, not a cost saving on the grid.

Google DeepMind (source for AC Optimal Power Flow)

Not just one lab

We track 99 systems from 48 lead organizations, across 11 fields. The same pairing of a model that proposes and an algorithm that judges keeps turning up.

Mathematics 4

Optimization 20

Proofs 15

Code verification 10

Chemistry 15

Materials 10

Engineering 2

Robotics 8

Security 6

Science 4

ML systems 5

Read all 99 AlgoGens

Each entry shows what the model proposes, what judges it, what steers it, its headline result and what it does not prove, checked against its sources.

Browse the library