Hyper proposes, tests, and iterates on novel ML methods with no
human in the inner loop. Given a problem — a formal definition,
an evaluation suite, and the current SOTA — it surveys the literature, proposes
first-principles alternatives, validates a proof of concept, then implements and
evolves the survivors until they beat the best baseline. Before expensive ML
experiments it calibrates on lower-stakes domains like board games and
combinatorial optimisation, then lifts onto low-compute ML tasks.
Two abstractions hold the loop together. A Problem is the
tuple (definition, evaluation suite, current SOTA). An
Approach is a research direction defined by a SOTA deficiency,
a proposed alternative, and a falsifiable hypothesis that predicts the
improvement. Everything below moves Approaches through the loop and pins their
implementations to a canonical code library, so fitness differences reflect
the strength of the principle rather than implementation noise.
Problem
Definition, evaluation suite, current SOTA.
↓ problem in
Hypothesis Generator
Population of diverse approaches; literature search, AI debate, and one-shot experiments filter them. Reads the Knowledge Graph; samples a parent from the QD Archive.
↓ an Approach (deficiency · alternative · H1)
PoC Agent
Breaks the approach into verifiable sub-questions, runs fast falsification, builds a minimal prototype via a CODER agent. H1 disproven → back to the generator.
↓ proof of concept passes
QD Loop
Implements the approach in full from Code Republic blocks, evaluates it, and evolves it (ShinkaEvolve). Scores return to the QD Archive, seeding the next generation.
Figure 1 — Hyper's discovery loop. A Problem enters the
Hypothesis Generator, which emits an Approach. The PoC Agent kills weak
hypotheses cheaply before any full build; survivors pass to the QD Loop,
which implements and evolves them and returns scores to the QD Archive that
seeds the next generation. The Knowledge Graph informs proposals and records
results; Code Republic supplies the canonical implementation blocks that
keep the principle signal above implementation noise.
Sub-systems
Hypothesis Generator
searches research directions
Maintains a population of diverse candidate approaches instead of betting on one path early.
Searches the literature and extends and queries the Knowledge Graph while brainstorming.
Filters via agent debate and one-shot experiments before any PoC work begins.
Samples a parent approach from the QD Archive to mutate.
PoC Agent
proves it before building it
Breaks an approach into a dependency graph of verifiable sub-questions.
Runs lightweight experiments before any prototype — fast falsification kills weak ideas cheaply.
Builds a minimal prototype via a CODER agent with a self-repair loop.
Tuned by max_debug_depth and debug_prob; draws blocks from Code Republic.
QD Loop
implements · scores · evolves
Implements the full approach from PoC building blocks.
Runs it against the problem's evaluation suite for a QD score and behavioral descriptor.
Drives iterative improvement via evolutionary code search (ShinkaEvolve).
On improvement, updates the Archive and announces the breakthrough.
QD Archive
diverse population store
A diverse population seeded with current SOTA via Quality-Diversity methods.
Prevents collapse onto a single high-scoring region of the search space.
Supplies the parent approaches the Hypothesis Generator mutates.
Updated by the QD Loop's scores at the close of each generation.
Knowledge Graph
organises what's known
Structures knowledge from both the literature and Hyper's own experiments.
Surfaces clusters, connections, and underexplored regions to guide search.
Queried by the Hypothesis Generator; updated by the PoC Agent and QD Loop.
Central to avoiding redundant work and pruning intractable directions.
Code Republic
canonical implementation library
A coding-agent system that accumulates a library of stable sub-problem implementations.
Bounds implementation noise, so fitness differences reflect principle strength.
Each experiment amortizes its implementation cost across future runs.
Tachyon's commercial wedge — open-source infrastructure for agents.
→ CR / Hyper synergy — how Code
Republic and Hyper reinforce each other.
→ Brain vs. LLM — the existence proof for
the region of design space Hyper searches.