About the library

What an AlgoGen is

An AlgoGen is a system in which algorithms and AI are woven into one hybrid: the algorithmic side provides precision, search discipline, and verification, while the AI side provides open-ended synthesis, semantic abstraction, and adaptability across unstructured domains.

Formally, each system is defined by a five-tuple: A = (G, X, V, S, F):

• G (Generative Proposer): An LLM, diffusion model, graph neural network, or chemical sequence model that samples structured candidates.
• X (Formal Candidate Space): Machine-checkable artifacts, such as executable programs, Lean/Verus proof steps, mathematical formulations, 3D crystal lattices, or protein backbones.
• V (Non-Neural Authority): An exact solver (Gurobi, CP-SAT), formal proof kernel (Lean 4, Z3, Coq), compiler, deterministic sandbox evaluator, or physical simulator that evaluates candidates.
• S (Search or Control Topology): The search discipline governing exploration over X, including branch-and-bound, Monte Carlo Tree Search, evolutionary archives, or diagnostic repair loops.
• F (Steering Feedback): The error signal or counterexample trace returned by V that informs subsequent proposals.

This design marks a clear departure from earlier couplings of machine learning and algorithms. Traditional machine learning and discriminative deep learning are predictive and interpolative: they score, regress, or classify pre-extracted features within fixed, human-defined schemas. An AlgoGen is synthesizing and extrapolative: the generative model constructs complex candidate objects from scratch and adapts zero-shot across modalities without retraining task-specific weights.

Why AlgoGens go beyond pre-generative paradigms

Classical Operations Research (1940s), early Neuro-Symbolic AI (1990s), and Counterexample-Guided Inductive Synthesis (CEGIS) (Solar-Lezama, 2006) established the foundations of automated search and verification (V and S). However, all three traditions predated generative foundation models. By definition, none of them could pair algorithmic authority with general generative intelligence, and each hit a structural boundary without it:

Theoretical and empirical foundations

The strength of the AlgoGen framework rests on four concrete principles across complexity theory, error dynamics, algorithmic architecture, and systems engineering:

1. What an Evaluator Can Certify

An evaluator can certify primal claims, such as “this object has value at least v”. Those claims are NP-type: short to verify once you hold the object. Optimality claims, such as “nothing in X has higher value”, need a dual certificate, which is a bound or proof that covers all of X. A score alone is not one. This is a proposition we state without proof, and we make no claim of an unconditional complexity separation. It predicts that discoveries driven only by an evaluator, of the AlphaEvolve type, are new constructions and not proofs of optimality; we have not yet tested that prediction. In an AlgoGen the generative model proposes candidates, while the algorithmic backbone checks them and, where the problem allows, supplies the bounds.

2. Independent Errors & Diagnostic Feedback

In self-refinement and multi-agent debates, the critic shares the generator's model weights, tokenization biases, and prompt context. Because their errors are positively correlated, self-critique can amplify initial errors or fail to detect structural inversions when the input prompt is noisy. In contrast, an external algorithmic authority V (such as a proof checker, compiler, or solver) evaluates the candidate artifact directly, independent of prompt context. Ideally its errors are independent of the generator's. In practice a validator is sound but incomplete, so some wrong answers still pass it.

On one planning benchmark (PDDL domain compilation, n = 109), GPT-5.4 self-refinement scored under 1% accuracy while validator-guided repair reached about 70% with no regressions. This was one exploratory run through an unpinned model alias. Details and caveats are on the Theory page. Results under prompt perturbations are being re-verified.

3. Three-Phase Intra-Algorithmic Architecture

AlgoGens extend far beyond simple outer-loop wrappers where a chatbot invokes a tool. Across several classical algorithm families, generative intelligence can be placed inside three internal execution phases. Where the model only makes a choice the algorithm leaves open (a tie-break, a branching variable), correctness is kept. Where it replaces a component the guarantee depends on (an A* heuristic), the guarantee holds only if that component passes a checkable contract such as admissibility:

• Phase 1 (Semantic Preprocessing): Generative geometry analysis for adaptive mesh refinement in finite element methods, prior synthesis from scientific literature for Bayesian inference, and structural sparsity pattern recognition for matrix solvers.
• Phase 2 (Inner Execution Loop): Context-aware heuristic adjustment inside search loops (such as dynamic heuristic steering in A* search), predictive mutation and crossover operators in evolutionary algorithms, and variable selection heuristics in branch-and-bound.
• Phase 3 (Postprocessing & Closed-Loop Co-Adaptation): Domain consistency auditing and outer-loop parameter refinement based on execution traces.

4. Artifact Persistence & Zero-Inference Runtime

In typical agent systems, organizations pay inference latency and token costs on every single production query. In Regime IV AlgoGens (such as AlphaTensor, AlphaDev, and FunSearch), the generative loop executes offline at design time to discover deterministic algorithms, C++/CUDA kernels, or mathematical heuristics. Once verified by the non-neural authority V, the resulting code runs on bare metal with zero token cost, zero latency overhead, and no model in the loop at runtime.

Frontier scientific and industrial impact

The AlgoGen pattern addresses three fundamental challenges across modern computing:

• Breaking the Synthetic Data Wall: As frontier AI models exhaust the public supply of human text, training on unverified model outputs leads to model collapse. AlgoGens offer one way to generate verified synthetic data, such as Lean-checked proofs in AlphaProof or DFT-screened crystals in GNoME, which can then be used to train later models. Whether this fully prevents model collapse is not settled.
• Enabling Safety-Critical Deployment: Regulated and safety-critical domains (aviation, electrical grid management, radiotherapy dosing, and smart contracts) cannot deploy probabilistic models that offer only approximate confidence. By providing explicit formal certificates from V or dual optimality bounds from S, AlgoGens can supply part of the verification that critical systems need. A certificate covers only what the specification says.
• Navigating High-Dimensional Non-Human Spaces: In molecular docking, 3D crystal lattice symmetry, and low-level assembly instruction scheduling, human visual inspection is impossible. Algorithmic verification and systematic search are often the most reliable source of ground truth in these domains.

How systems are chosen

Systems are shown because they fit the AlgoGen pattern. At all times, this website features a curated, living shortlist of 99 landmark and representative AlgoGens across the scientific and engineering literature, selected for architectural clarity, domain breadth, and primary-source verification rather than as an exhaustive ranking. To qualify for inclusion in the shortlist, a system must satisfy five technical criteria:

1. Formal candidate artifact (X): The generative model proposes structured, machine-checkable candidates (programs, proofs, specifications, schedules, assembly routines, crystal lattices or protein structures) rather than unverified free-text prose.
2. Non-neural algorithmic or physical authority (V): Candidates are judged by an exact solver, theorem kernel, compiler/verifier, deterministic sandbox evaluator or physical simulator/assay, not by LLM self-critique or LLM-as-a-judge.
3. Non-trivial search or control topology (S): The authority drives tree search, branch-and-bound, counterexample-guided repair, evolutionary archive selection or active-learning rounds, rather than a single pointwise pass/fail check.
4. Primary-source verification: Every quantitative claim is checked against the peer-reviewed paper, technical report or official release, with baseline and ablation context preserved.
5. Explicit epistemic boundary: Every entry documents what its verification regime does not establish (specification drift, evaluator gaming, retry caps or surrogate-to-wet-lab gaps).

How results are reported

Headline results are the developers' own reports, checked against their sources. Deployment numbers on the home page are Google DeepMind's own reports on its AlphaEvolve impact page. This library has not reproduced them. Every entry states what it does not prove.