From answer generation to discovery systems. It reads AI discovery systems through three dimensions: how knowledge is generated, how it is verified, and how search is scaled — at the right strategy for the task. Trust depends on the structure of verification.
“The whole of science is nothing more than a refinement of everyday thinking.”
Fast and always available, but non-traceable and vulnerable to hallucination.
AI: knowledge acquired during pretraining · Human: intrinsic expertise of the researcher
Papers, datasets, published results, and live data feeds provide external grounding, but require source judgment. AI: retrieved documents, databases, and real-time APIs · Human: scientific literature, reviews, and field data
Past experiments, tests, and validated outcomes are strongest, but expensive to obtain. AI: execution feedback and validated outcomes · Human: personal experiments and verified prior results
Familiar domains rely more on priors, studied domains on retrieval, adjacent domains on analogy, and unknown domains on exploration.
Key idea: research does not start from zero — it starts from knowledge of uneven reliability, then turns that knowledge into hypotheses, tests, and verified carryover.
DeeRS reasons in depth on few candidates with rich, multi-faceted feedback. WESh explores broadly through trial-and-error on many candidates with simple score feedback. Strong systems compose both.
Key insight: where verification is strong, control can shift toward automation; where it is weak or delayed, humans stay in the loop.
Read as an investment, the further right you go the more you build rather than buy — until full autonomy, which you can either purchase off the shelf (little control, little differentiation) or engineer end to end (the heaviest commitment of all).
Key insight: memory complexity scales with the discovery horizon. The right layer is the lowest one that fits the task — over-engineering wastes effort, under-engineering caps what the system can discover.
Every discovery system depends on how it filters ideas — from formal consistency to real-world acceptance.
Discovery systems stand on two architectural stacks: verifiers (V1–V5) that filter what holds up, and memory layers that decide what is kept and reused. Both are composable.
The hard problem is not generation — it is verification, the most under-engineered bottleneck and where the researcher's effort belongs. Cheap verifiers enable scale. Expensive verifiers anchor truth.
Recent papers and platforms already show AI contributing to scientific discovery, autonomous research workflows. These systems do not all discover in the same way. What differs is their reasoning regime, their verifier profile, and how widely they search.
Reasoning-plus-tools systems can act as a real research collaborator, centered on iterative refinement, problem decomposition, cross-disciplinary transfer, formalization, and neuro-symbolic verification loops.
Introduces TTT-Discover, a test-time reinforcement learning method that keeps training the LLM on a single discovery problem during inference, instead of relying only on prompting a frozen model.
Introduces an Evolution method that evolves not only candidate solutions but also the search strategies used to generate them, allowing the system to adapt its own exploration policy over time.
Introduces an autonomous multi-agent evolution framework for open-ended discovery, where long-running agents explore, evaluate, reflect, and reuse knowledge through shared persistent memory.
Discovery operates in two regimes: Deep Reasoning Search (DeeRS) — few candidates, each explored in depth — and Wide Explorative Search (WESh) — many candidates, each evaluated by a simple signal. They differ not by quality or order, but by where information density lives: in the feedback signal or in the candidate population.
Few trajectories, but each one explored in depth. Rich, multi-faceted feedback at every step — error messages, partial proofs, tool outputs, human validation.
Many candidates, each evaluated by a single simple signal — a score, a pass/fail. Information lives at the population level: which candidates survive, which behaviors emerge, which lineages improve.
"Evolutionary" does not mean one regime. What matters is whether selection runs on a dense score (WESh) or on reasoned shared memory (DeeRS).
| Regime | What drives selection | Examples |
|---|---|---|
| WESh population on a gradient |
A dense score ranks a large population; mutation and selection run on that signal. | AlphaEvolve, OpenEvolve, DeltaEvolve |
| DeeRS reasoned shared memory |
A few agents deepen each candidate and coordinate through interpreted notes, skills, and attempts — selection by reasoning, not by a dense score. | CORAL, HMACE, Prism |
| DeeRS + WESh the open case |
Deep reasoning on every member of a large population — the most powerful regime in principle. | No clear instance yet: deep reasoning per candidate × population size is prohibitively expensive. An open direction. |
Verifiers do not simply measure truth. They progressively filter hypotheses, from logical consistency to societal acceptance. The shape, density, and cost of verification define what kinds of discovery are possible at scale.
Truth under assumptions. Formal coherence, contradiction checks, proof systems, theorem provers.
Rules, schemas, safety policies, compile validity, domain restrictions. Defines the feasible space.
A real measure or distance from a ref - baseline, groud truth: runtime, prediction error, accuracy, a computed metric.
Reality under cost. Lab experiments, deployment, field tests, operational outcomes.
Legitimacy, safety review, regulation, adoption, institutional trust, maintainability, politics.
Beyond their level, verifiers differ along axes that determine where they can sit inside a discovery loop — and how much to trust their verdict. Fidelity is not one number: it splits into bias (systematic error) and variance (noise).
Binary signal (pass/fail) or continuous score (gradient)? Optimization needs gradients; reasoning can read binaries.
Systematic, repeatable error. How far the verifier's expected verdict sits from the ground truth it stands for. Bias does not average out — it is what optimization learns to exploit.
Run-to-run noise. How much the verdict scatters across repeated evaluations of the same candidate. Variance averages out with more samples — bias does not.
Compute, latency, and human time per evaluation. Determines how often the verifier can fire inside a loop.
| Level | Density | Bias | Variance | Cost | Role in the loop |
|---|---|---|---|---|---|
| V1 Logic | Sparse | None | None | Cheap | Filter the impossible |
| V2 Constraints | Sparse | None | None | Cheap | Filter the invalid |
| V3 Evaluation | Dense | None | Low | Cheap | Drive the optimization |
| V4 Experimentation | Sparse but rich | Null if representative | Medium (noise) | Expensive | Anchor in reality |
| V5 Societal Acceptance | Sparse but rich | Null if representative | High | Very expensive | Decide what survives |
| Proxy of V4 / V5 not a level — a transform |
Added (approximation) | Reduced (stable) | Cheap | Fast stand-in inside the loop |
Note on V4 and V5 density. Their signal is sparse in frequency (rare, costly to obtain) but rich in content — a wet-lab assay produces measurements, observations, and context; a peer review produces structured rationale. This richness is interpretable in a reasoning loop, but not directly differentiable in a gradient-based loop.
Note on V4 and V5 bias — the representativeness principle. Native V4 and V5 verifiers are not biased in themselves — they scatter around the truth without systematic offset. Bias enters only through partial representativeness. A wet-lab assay (V4) measures reality faithfully, but on a sample: if that sample does not represent the target population, a bias appears. A peer-review panel (V5) is the social referent itself — globally representative, it is unbiased by definition; drawn from a single school of thought, it becomes biased. The rule is unified across both levels: a native verifier is unbiased to the extent that its sample — physical for V4, social for V5 — represents the whole. What remains when representativeness is full is pure variance: experimental noise for V4, intrinsic disagreement for V5. Variance averages out with repetition; representativeness bias does not.
The five levels are not fixed for all time. What is verified at V4 or V5 today often becomes a V2 constraint tomorrow — codified into a rule that nobody re-verifies case by case.
Newton's laws were established through centuries of V4 experimentation. Today they are V2 constraints, baked into every physics engine — no simulation re-derives F = ma at runtime.
GDPR emerged from long V5 deliberation. Today it is a V2 filter in any compliant data pipeline — a binary rule, no longer a debate to re-open case by case.
How verifiers enter a discovery loop depends entirely on the method. Population-based methods need gradients and fold them into a score. Agentic methods read them as context and call them as tools.
An agent does not need a dense gradient to make progress. It calls a verifier as a tool, reads the binary or structured output, and uses it as context for the next action.
Why it works: reasoning replaces gradient descent. The signal stays sparse, but the loop still progresses because the agent interprets the verifier output rather than optimizing against it. This unlocks the use of high-fidelity but sparse verifiers that population-based methods cannot afford.
A computational system that predicts what reality would say without paying the cost of running the experiment. Stays conceptually at V4 — answering "does it work in reality?" — but with a fidelity gap.
Examples: World models, text-to-video models, physics simulators, digital twins, code sandboxes, climate emulators.
LLMs are partial world models: they encode an implicit world description from training data, and can simulate qualitative outcomes well. But their fidelity is bounded by the textual nature of their training corpus — stronger on phenomena humans have written about, weaker on novel physical regimes.
An algorithmic system imitating expert judgment — it produces a structured argumentation, recommendation, or critique that mimics what an expert or community would say, without the binding act of real V5. Stays conceptually at V5 — answering "should we use it?" — but with a fidelity gap.
Examples: LLMs producing argued reviews, AI assemblies generating recommendations, multi-perspective LLM debates, expert-imitation systems trained on past reviews.
Search needs gradients to rank candidates. Strict binary filters waste information — a candidate one mutation away from validity gets discarded. Modern systems fold V1/V2 into a weighted composite score:
Score = α · validity(V1) + β · constraints(V2) + γ · performance(V3)
Trade-off — reward hacking: the choice of α, β, γ encodes an implicit policy. If γ dominates, the system learns to exploit minor V1/V2 violations to win on V3.
Note — selection: pure selection methods (Best-of-N, top-K, surprisal-guided) are verifier-agnostic — they can rank with V1, V2, V3, or any mix, because they only need a partial order.
Transforms a sparse-and-rich V4 signal (real or proxy) into a continuous score usable inside an optimization loop. Often by training a surrogate model on V4 outputs, distilling key features into a regressor, or learning a reward from a small set of real runs.
Examples: continuous binding-affinity scores from a docking proxy; reward models trained on simulation outcomes; surrogate models distilled from full-physics runs.
Transforms V5 judgment signals (real or proxy) into a continuous score usable inside an optimization loop. By aggregating multiple proxy V5 outputs, by learning from past human decisions, or by quantifying structured expert ratings.
Examples: ensemble of LLM judges with majority vote producing a numeric score; RLHF reward model averaging human preferences; classifier learning from past safety-board decisions; LLM-as-a-Judge templated to return a score directly, media-tone APIs like GDELT compressing global press sentiment into numeric scores.
LLMs are always algorithmic proxies, never real V4 or V5 verifiers. They are used differently depending on the method — directly as proxies in DeeRS, or compressed into V3 scores for WESh.
An LLM produces a structured output — a rich analysis, a counterfactual argumentation, a predicted simulation report. The output is text, not a score. An agent can read it, interpret it, and act on it. Used directly as input to deep reasoning loops.
Forms: LLM rendering a "review" of a proposed approach, LLM imitating a domain expert's analysis, LLM producing a qualitative simulation summary.
An LLM or ensemble of LLMs produces a numeric score, often via templated prompting or voting. The output is a gradient signal. A population-based method can rank candidates, select winners, drive optimization.
Forms: LLM-as-a-Judge with scoring template, ensemble of LLM judges with majority vote, learned reward model averaging preferences.
Divergence from the human consensus the LLM is supposed to approximate.
Position effects (first/last answer), length preference, format preference — all independent of content.
Evaluates apparent coherence rather than underlying truth. A well-written but factually wrong answer scores high.
Reflects the editorial choices of its creators. A Claude judge, a GPT judge, and a Gemini judge are not interchangeable.
Giving the same model different roles, prompts, or temperatures decorrelates sampling noise and part of the structural bias (position, length, format).
The epistemic bias baked into the shared weights — a factual blind spot, a cultural leaning, a reasoning shortcut — is present in every role the model plays. Ten roles on one model can reach false unanimity on a shared error.
V4 and V5 cannot run inside a tight optimization loop — too slow, too expensive. The verifier stack solves this through a two-loop architecture where fast V3-grade signals (proxies, compressions, native V3) drive the inner loop, and rare real V4/V5 evidence closes a slower outer loop that recalibrates the inner machinery.
The outer loop exists for one reason: a proxy's low variance hides its bias, and only real V4/V5 evidence can detect and correct it.
Turn real outcomes into a training signal that bends the proxy back toward reality — preferences from V5 (which candidate the community favored) or performances from V4 (which actually worked).
How: DPO on the proxy from real test pairs; a parametric memory model trained by SFT on a small LM running alongside the proxy (MeMo, 2026); or a LoRA adapter on the proxy LM for lightweight, reversible updates.
Effect: the proxy's added bias stays bounded instead of drifting. This is the recalibration the inner loop depends on.
Keep the raw V4/V5 evidence in an external store — databases, structured records, behavioral archives — and let the proxy condition on it at query time rather than absorbing it into weights.
How: relational or vector stores of past real outcomes; retrieval at inference (RAG over verified runs); lineage-indexed archives of which candidates passed reality.
Effect: no retraining, fully traceable — every correction points back to the real evidence that justified it. The transition to the memory stack.
For discovery pipelines, memory is not "more context". It is the substrate through which the system continuously reconstructs its relationship with its own past experiments, validated hypotheses, and discarded paths. Three layers of memory architecture exist, each fitting a specific scale of discovery task — and each carrying a distinct cost of governance.
Each layer is sufficient for a range of discovery tasks. Climbing the stack adds capability but also engineering cost and governance burden. Over-architecting wastes effort; under-architecting limits what the system can discover.
The simplest setup: everything the agent needs is loaded into a single context window. No external store, no checkpoint, no state management. This is LLM generation in normal use.
Modern LLMs handle hundreds of thousands of tokens with good performance in the first 50k. For bounded tasks, this is enough — and avoids the engineering cost of building memory infrastructure.
Single-problem reasoning, paper review, hypothesis brainstorming, mathematical conjectures explored in one session, prototyping of a proof or algorithm.
Context saturation (multi-hour tasks), lost-in-the-middle degradation (retrieval drops past ~50k tokens), or the simple need to resume work tomorrow. At that point, Layer 2 is mandatory.
The session is the natural unit of memory. State accumulates across iterations, gets pruned, summarized, restructured. Two distinct families coexist at this layer — conversational and evolutionary — each with its own grammar of operations.
The state is a sequence of messages, tool calls, and intermediate results. Three explicit operations modify it: truncate, prune, Compress.
Store raw data, not formatted text. Format prompts inside nodes when needed. This keeps the state composable, inspectable, and free of premature stringification.
Drop oldest messages when the context budget is exceeded. Simple, cheap, no LLM call required. The default policy when recency is a good proxy for relevance.
Remove specific messages from state — wrong tool calls, hallucinations, irrelevant turns. Surgical operation when trim or summarize would be too blunt.
Summarize old turns into a distilled note that stays in the state. Costs one LLM call but preserves the semantic content that trim would lose. The default when older context still matters.
A multi-step experimental study, an agent exploring a problem space over hours or days, an AI Scientist running a sequence of related experiments, any workflow with human-validation checkpoints.
LangGraph (checkpointers + state with trim_messages, delete_messages, summarize_messages), Microsoft Agent Framework (state management with durable execution).
The state is a population of candidates indexed by score or behavior. The session is a sequence of generations, not a conversation. Memory operations are mutation, selection, and archive maintenance.
A set of candidates maintained across generations. Best-so-far is preserved. New candidates derive from existing ones through mutation, crossover, or LLM-guided variation.
Indexed not by score but by behavior descriptor. One incumbent per niche. Sustains diversity over long runs. The MAP-Elites pattern, used in HMACE and CORAL.
Each candidate carries its provenance — parent candidates, mutations applied, score deltas. Enables analysis of what mutations actually contributed to progress.
Mathematical optimization (AlphaEvolve), heuristic discovery for combinatorial problems (HMACE, FunSearch), program synthesis under fitness functions, scientific equation discovery.
AlphaEvolve (DeepMind), OpenEvolve (open-source), ShinkaEvolve (Sakana), EvoX, CORAL, HMACE.
When the search must accumulate knowledge across separate runs — different problems sharing transferable insights, or a long-running discovery system that learns over months. At that point, Layer 3 is needed.
Memory persists between sessions, projects, and agents. Three independent questions organize the layer: where it lives, what form it takes, and how it is governed over time.
Relational and key-value stores, indexed file systems, versioned stores (Git, DVC, time-series databases).
Best for: retrieval by key or attribute, and reproducibility queries. The bread and butter of production systems — often underestimated in the LLM literature.
Vector stores (RAG) for similarity over unstructured content; knowledge graphs (GraphRAG, HippoRAG) for multi-hop and cross-document reasoning.
Best for: retrieval by meaning — vectors handle "what looks like this", graphs handle "what relates to this".
Knowledge in the weights: continual pretraining, dedicated memory models (MeMo, 2026), parameter-efficient adapters (LoRA family).
Best for: implicit recall through generation. Costly to update, resilient when stable.
Some systems hold several substrates as first-class types at once — MemOS's MemCube keeps textual, activation (intermediate reasoning results), and parametric memory side by side, with a scheduler orchestrating access across them.
Past hypotheses and their outcomes, stored and replayed. Future proposals are conditioned on this history to avoid redundancy and surface patterns. Promoting Layer-2 archives here lets distinct runs share elite candidates.
Distilled lessons in natural language, generated at intervals by a reflector agent (Reflexion, 2023). Compresses experience into a few sentences that re-enter the working context as priors.
Validated techniques promoted into reusable procedures, tools, or scripts that transfer across attempts and tasks.
A filesystem-structured shared memory that realizes all three roles at once: attempts/ (episodic), notes/ (semantic), skills/ (procedural). Multiple agents coordinate through the store itself — reading and writing shared artifacts — rather than messaging each other.
Distillation by heartbeat: periodic prompts make agents reflect, consolidate notes into syntheses, and promote validated techniques into skills. Ablating this knowledge layer costs ~18% on hard tasks (CORAL, 2026).
A store is not enough. Memory is a governed lifecycle — extract, consolidate, and trust — each step carrying provenance. Extraction is managed, not raw: a reader module pulls salient facts, deduplicates, and attaches metadata (source, timestamp, confidence) — as in mem0 or the MemOS MemReader. The harder question is how memory is consolidated.
Instead of a fixed truncate/prune/compress rule, the agent learns what to keep as part of its reasoning, overwriting rather than accumulating — near-constant memory over long horizons.
In practice: MEM1 (2026) — RL-trained internal state, 3.5× performance and 3.7× less memory than a model twice its size.
Confidence is not a static tag — it evolves by selection: useful entries are reinforced, unused or misleading ones decay. Retrieval favors the most valuable memory, not the most similar.
In practice: Prism (2026) — replicator-decay dynamics, Value-of-Information retrieval.
Consolidation runs off the critical path, during idle time: a background process distills raw history into rules and skills, writing only what passes promotion gates.
In practice: sleep-time compute (Letta), dream cycles. But it consolidates proxies — only reality recalibrates them.
A memory is only as trustworthy as the verifier or source that wrote it — and how well that origin survived consolidation. Traceability is not uniform: it follows the same axis as the memory layers.
Everything is fused in one window: prior knowledge, pasted sources, verifier outputs. When the model concludes, no clean boundary says which part came from where. The model's parametric prior is the least traceable memory of all — it "knows" without citing, carrying the four LLM biases with no source.
Traceable at write time (each tool call has a known origin), but consolidation destroys it: summarizing ten turns into one note severs the link to the verifiers behind each fact. The evolutionary family fares better — lineage tracking (parents, mutations, score deltas) is native provenance.
Provenance is structural: every entry carries source, timestamp, and confidence; the store is versioned and replayable. This is the only layer where a full audit is realistic — which is why long-horizon trust lives here.
DeeRS systems improve individual research by structuring thought before search scales. They work by managing context, preserving the reasoning thread, and exposing hypotheses to criticism before verification begins.
Today's most productive discovery setups are not fully autonomous. They keep the human in the loop in one of two regimes: conversational, where the human drives a chat turn by turn, and orchestrated, where a workflow runs with explicit human-validation checkpoints. Both modes have a substantial literature on what makes them effective. Reading it carefully is a prerequisite to designing anything that aims to remove the human.
Break a complex problem into smaller, tractable parts.
Refine a thought trajectory over multiple passes instead of betting on one-shot reasoning.
Retrieve the right knowledge, theorem, or paper at the right time.
Convert intuition into explicit assumptions, equations, interfaces, or proof structures.
Internal or external criticism of a candidate argument or artifact.
Multi-perspective challenge and defense to reveal weaknesses.
Revision after inspecting tracebacks, failed claims, or weak assumptions.
Specialized perspectives applied to the same problem thread.
Left unchecked, current reasoning systems can become persuasive in the wrong direction. Strong DeeRS workflows therefore require not only structure, but active error management.
If prompted to prove a conjecture, models often try to support it even when it is false. Neutral framing such as “prove or refute” is often safer than directional prompting.
Models can produce elegant but flawed reasoning: dropped constraints, subtle algebraic mistakes, or confident misuse of theorems.
Safety guardrails can sometimes block legitimate scientific exploration, especially when a system recognizes a problem as open or unsolved.
Because of these failure modes, the human researcher is not replaced. The role shifts from executing every derivation to acting as an orchestrator, auditor, and strategic director of AI reasoning. The challenge for DeeRS automated multi-agent systems is to reproduce these roles reliably in software.
DeeRS systems do not fail because they lack ideas. They fail because they can reason persuasively in the wrong direction.
Automated systems differ along two orthogonal dimensions: how reasoning is composed (one LLM or many specialized roles) and who controls the path (predefined code or the LLM itself).
Two endpoints of a spectrum. Between them, many hybrid forms exist — ReAct loops with tool use, planner-executor pairs, hierarchical multi-agent stacks, swarm coordination.
A single LLM mainly performs hypothesis generation within one trajectory, with limited internal critique and no explicit loop control.
Multiple agents can distribute not only reasoning, but full parts of the research loop: retrieval, coding, evaluation, writing, and memory update.
Beyond how reasoning is composed, an orthogonal question matters: who decides the sequence of steps?
The developer defines the steps in code. The LLM is called at fixed points with constrained roles. Predictable cost, debuggable, but rigid.
The LLM decides its own steps, tools, and routing. Flexible and capable of unforeseen paths, but harder to predict, monitor, and contain.
Source: LangGraph documentation
WESh shifts from deep reasoning on one candidate to scalable optimization over many.
WESh does not require agents in every case, but it always requires automation. Once search expands beyond what a single researcher can inspect manually, the system must automate candidate generation, scoring, selection, and often memory management.
The challenge is no longer to reason longer on one idea, but to allocate compute well across many possible ideas.
Search insight: V1–V2 define the feasible space. V3 defines the objective.
Generate many candidates independently, then keep the best according to a verifier.
Shift the generator during inference so future candidates are locally better aligned with the task.
Preserve memory, mutate good candidates, and improve populations over time.
The key question is not only how good candidates are, but where they lie relative to the model’s native distribution. Search methods differ by whether they exploit the model’s tail, shift the distribution locally, or explore multiple distant basins.
At each generation step, candidate populations are produced by a mix of sampling noise, prompt/context variation, reuse of prior high-quality solutions, and sometimes policy updates.
Every section so far describes how the machine searches, verifies, and remembers. None describes how the human sees it and takes back control. Yet the editorial position assigns the human one job — to decide what the machine cannot. A decision without visibility is impossible. Monitoring is that visibility.
The first reason monitoring must be external: an agent is a poor judge of its own success — not occasionally, but by construction.
Agents systematically overestimate their own success. Measured on real coding tasks, some that succeed only 22% of the time predict 77% — and they are 5.5× more likely to confidently predict success on a failing task than to doubt a passing one (agentic overconfidence, 2026).
RLHF rewards agreeableness, so agents declare victory on noise — reading signal into errors, inflating limited results into "seminal contributions". The optimism is trained in, and it shows up exactly where skepticism is needed (Lossfunk, 2026).
Under pressure — a timeout, a hard sub-problem — agents quietly simplify, abandoning the core idea for code that looks like the goal. The final output resembles success; the substance was dropped along the way.
The framework already names the signals. Three come from the behavioral trace; two more come from the knowledge the system builds and the space it explores.
The disruption and myth signals from the verifier stack. A high V4 with low V5 (or low V1, low V2) is a rupture candidate; the reverse is a myth. The gap is measurable — surface it.
The distance between a proxy and the real V4/V5 it stands for, widening since its last recalibration. A low-variance proxy hides its bias; only this drift exposes it.
Per-step flags on the trace: intent alignment, tool correctness, state consistency, error recovery. State-tracking inconsistency alone is 2.7× more frequent in failed runs (trajectory explainability, 2026).
Natural-language memory — a CORAL note, a skill, a session state — is the only substrate a human can audit by reading, unlike parametric or activation memory. That is its strength. Its trap is that well-written text reads as established knowledge even when nothing verified it.
A Layer-2 state is overwritten every turn; the signal is not what it says now but what was lost between turn 3 and turn 30 — a dropped constraint, a quietly reframed goal. Track the trajectory of the state, not its current value.
When a CORAL heartbeat promotes ten notes into one synthesis, or an attempt into a skill, two things happen at once: provenance is lost, and fragile knowledge becomes "established". Promotion is where the human eye belongs — each consolidation logged, the important ones validated.
Text tells you what the system thinks; a latent projection (t-SNE, UMAP) of every solution it generated shows the shape of its search — what no trace reveals. Colored by inter-verifier gap, it becomes a visual disruption detector.
Dispersed points mean broad search; a tight cluster means the system collapsed onto one idea — mode collapse, invisible in logs, obvious here.
Watch points drift into the dense basin over time and abandon the periphery. The periphery is exactly where high-V4-low-V5 ruptures live — the visual twin of a MAP-Elites archive.
t-SNE distorts: it preserves local neighborhoods, warps global distance, and shifts with its parameters. Embedding similarity is surface similarity. Use the map to triage attention, never to rule.
Passive monitoring is not enough. A decision needs a format and a trigger — and the human must intervene where the machine signals a divergence it cannot resolve alone.
A choice put before a human is never bare. It carries the artifact (the reasoning trace, the tool-call summary), the context (state snapshots, retrieved evidence), and the verification signals (rubric flags, replay-consistency). The Minimal Explanation Packet (trajectory explainability, 2026).
The human is not asked to validate everything — they would drown. Escalate where an inter-verifier gap crosses a threshold (rupture or myth), where a proxy has drifted too far since its last real recalibration, or where a decision rests on low-confidence, unprovenanced memory.
At each checkpoint, the reviewer's job is to find what breaks, not to confirm what works. Adversarial framing recovers calibration that confirmation framing destroys — and it dissolves the false consensus of agents that otherwise agree, confidently, and wrongly.
The best discovery regime depends not only on verifier level, but on the structure of the search landscape, the ability to reuse knowledge, and the cost of exploring and evaluating solutions.
Mathematics, code, science, and strategy look different on the surface. But all four rely on the same deep structure: knowledge inputs, hypotheses, verifiers, and search under constraints.
AI discovery systems do not differ primarily by domain, but by how solutions can be evaluated, improved, and scaled. These differences define four regimes of discovery.
Problems where correctness can be determined exactly through logic or execution.
Problems where a working solution exists and can be iteratively improved through measurable feedback.
Domains where hypotheses can be explored through simulations or executable models, but proxies remain imperfect.
Domains where evaluation is delayed, ambiguous, or mediated by real-world constraints and human judgment.
Unifying view: the key difference between domains is not what is studied, but how truth can be produced, verified, and iteratively improved.
Optimization is a special regime: once a valid solution exists and can be scored, discovery becomes a search problem — making WESh methods (sampling, evolution, hybrid systems) particularly effective.
Automation frontier: domains with strong and programmable feedback loops (formal reasoning and optimization) are moving rapidly toward automation, while open-world systems remain constrained by weak or delayed verification.
DeeRS and WESh are not "small vs big" — they are two methods with opposite failure modes. Each amplifies a specific kind of cognition, and each carries its own structural weaknesses. Choosing the right method, or composing them, defines what kind of discovery is reliable.
Sequential reasoning. V1, V2, V3, even V4/V5 invoked as tools. Verifiers stay faithful. Latency accepted in exchange for trust. Amplifies one researcher's reasoning.
Strength: rich feedback, complex memory, checkpointable trajectory, faithful tool invocation.
Population-based exploration. Discovers candidates beyond human-scale enumeration. Selection corrects individual errors. V3 carries the optimization load. Compresses V4/V5 into V3 to enable scale. Amplifies the research process itself.
Strength: scale, diversity, robustness to individual candidate failure, lineage tracking.
The strongest systems combine both: WESh breadth wrapped around DeeRS reasoning loops. Each level amplifies what the other cannot reach.
The cost. Hybrid systems demand persistent memory infrastructure, compute ressources, observability across two regimes, and significantly more development time.
Each regime fails in a structurally different way. Knowing where each one breaks is what makes composition possible.
The generator can reason persuasively in the wrong direction — confident hallucinations, biased framing, dropped constraints. Long reasoning chains drift between partial ideas without convergence. Intermediate results are not reliably integrated, leading to inconsistencies between assumptions, code, and conclusions.
Adversarial exposure. DeeRS agents that browse the web, read tool outputs, and write to a Layer 3 persistent memory are especially vulnerable to adversarial environments: prompt injection in fetched pages, biased context from poisoned retrieval, memory poisoning that persists across sessions, action hijacking through crafted tool outputs. The richer the interaction surface, the larger the attack surface.
Proxy collapse. The population optimizes what V3 measures, not what the goal requires — reward hacking, benchmark hacking, simulation overfitting. Loss of diversity. Search converges too early on mediocre regions and misses rare high-value candidates. Compute misallocation. Budget is spent on weak candidates, poor strategies, or expensive evaluators that do not scale.
Evaluation-aware proxy collapse. Frontier models can detect they are being evaluated and present an evaluation-mode behavior distinct from deployment-mode. Once a system can tell V3 from V4, the proxy stops being a proxy and becomes a separate game the system plays.
Future agents will rely less on isolated reasoning and more on persistent, structured memory to track, reuse, and refine knowledge over time. Memory architecture becomes a first-class engineering concern.
Progress will depend on better proxy verifiers and simulators, enabling faster, cheaper, and more reliable feedback loops. The V4 → V3 compression is the central engineering bet.
Discovery will increasingly rely on guided exploration, combining agents, memory, and selection mechanisms rather than independent candidate generation. Evolution with typed roles becomes the default.
Among the architectures this framework can read, one stands out as the most defensible today for genuine discovery: a broad generative model proposing, decorrelated reality verifiers judging, and a frontier human deciding. The broad generator earns its place for two reasons: it produces hypotheses at a scale no human can match, and — drawing on prior knowledge across every field it has absorbed — it bridges distant domains, surfacing analogies a specialist would rarely reach. Darwin reading Malthus, Schrödinger borrowing from waves: cross-domain transfer is where a generalist is strongest.
The judging is where most systems fail. Every algorithmic judge measures fidelity against past consensus — an LLM-as-a-judge, a reward model, an ensemble of critics are all compressions of what a community already accepts. The better-aligned the evaluator, the blinder to rupture. Optimize against consensus-trained verifiers and you build a machine that kills exactly what you seek. This is why reality verifiers — V1 formal, V3 measured, V4 experimental — must judge whether a thing works, decorrelated from whether it is accepted.
But here is what makes disruption tractable rather than mystical: it is a measurable gap between verifiers, not a thing only a genius can see. High V4 with low contemporary V5 — it works, the consensus rejects it — is social disruption (continental drift). High V4 with low V1 — it works, the theory forbids it — is theoretical disruption (imaginary numbers, renormalization, deep learning before its theory). High V4 with a violated V2 — it works, yet it breaks a constraint everyone held as a hard limit — is out-of-bounds disruption (the sound barrier, regimes declared off-spec that turn out stable). The framework can detect and preserve these candidates automatically: an archive that keeps the elite of each behavioral region (MAP-Elites) over inter-verifier gaps retains ruptures the consensus would discard, instead of collapsing everything toward agreement. And V5 is not only the enemy — its other face, adoptability (simple, maintainable, deployable), is a real value measurable by proxy, the one that rewards a radical simplification even when it breaks with established practice.
The human, then, does not detect the rupture — the gap does that. The human decides what to do with it: orchestrator, auditor, strategic director, and the one who carries the responsibility a measurement cannot. In practice, agentic workflows with human checkpoints placed exactly where a preserved disruption must be promoted or dropped.
On the dignity of human judgment amplified by tools — and irreplaceable precisely where machines reproduce consensus — the reader is referred to the encyclical Magnifica Humanitas (Leo XIV, 2026), a humanist position relevant to anyone building AI that interacts with, rather than replaces, human discernment.
The DMM-AI verifier stack is framework-agnostic by design. The following projects are the most credible building blocks for implementing V1–V5 verifiers inside an agentic pipeline today.
Graph-based orchestration for agentic workflows. The reference framework for placing verifiers at known checkpoints inside a controlled execution path. Neutral on verification, strong on workflow.
Best for: building hybrid workflow-agent pipelines with explicit V1/V2/V3 nodes.
Production-ready successor to AutoGen and Semantic Kernel, released as 1.0 in April 2026. Graph-based workflows with checkpointing, multi-provider support, native A2A and MCP interoperability.
Best for: enterprise-grade multi-agent pipelines with strict observability and state management.
Open-source LLM evaluation framework with Pytest-style API and 50+ built-in metrics. Most adopted in the field (400k+ monthly downloads). Excellent for post-hoc V3 evaluation of pipeline outputs.
Best for: regression-testing V3 quality, integrating evals into CI/CD.
Evaluation framework developed by the UK AI Safety Institute, used for frontier-model safety evals. Strong on V4–V5 territory (propensity, capability under pressure, red-teaming).
Best for: propensity testing, evaluation-awareness audits, safety reviews.
Stanford framework that treats LLM pipelines as compilable programs. Metrics function as embedded verifiers that drive prompt and weight optimization. Conceptually closest to the V3-as-gradient view.
Best for: optimizing pipelines where the verifier is itself a learning signal.
Library for building RL environments with reusable verifier rubrics. Originally created by Will Brown, now maintained by Prime Intellect. Native support for multi-turn tool use and agentic RL.
Best for: training and evaluating agents in verifiable environments — closest to typed-V3 rubrics.
Unified framework for factuality evaluation of LLMs, from MBZUAI. Three modules: a customizable fact-checker, an LLM factuality evaluator producing structured reports, and a meta-evaluator that benchmarks fact-checkers themselves.
Best for: auditing hallucination rates and grounding quality — a V3 verifier specialized on factual claims.
Mature SMT-based bounded model checker for C, C++, CUDA, Rust, Python, Solidity. Detects pointer safety, overflow, memory leaks, data races. Now extended with esbmc-ai for LLM-assisted code repair.
Best for: a real V1 verifier on code — formal proof of absence of runtime errors, not just tests.
General-purpose verification framework that scales scoring granularity, repeated verification, and criteria decomposition. Reaches 86.4% on Terminal-Bench 2 and 77.8% on SWE-Bench Verified as a trajectory reward model.
Best for: fine-grained V3 trajectory evaluation that goes beyond the limitations of LLM-as-a-Judge.