The Recurse Engine · offsync.io

// the recurse engine

An 18-month-old idea: a research engine that proposes, tests, and improves its own conclusions, and learns to stop trusting its own opinion. Right now it's skewed toward problems you can actually backtest (mostly trading), because the part that decides whether an idea is any good is a real test.

generations

experiments recorded

∞

dead-ends ruled out

OSS

open-sourced

ARAthe substrateFOUNDATION

Every result becomes a permanent, provenance-tagged artifact.

A knowledge vault: a browsable corpus of runs, conclusions, and the trail of how each was reached. Nothing is thrown away; the engine can always look back at what it already learned.

RecurseLoopv1FIRST LOOP

Don't answer once: propose, attack, and revise.

Generate K independent attempts, then adversarially verify each, keep what survives, and improve-or-revert before committing. The first version that treated an answer as a draft to be stress-tested, not a one-shot.

RecurseLoopv2 → v2.1THE HARD LESSON

Coverage isn't correctness: score the flaws, not the vibes.

v2 added sub-goal decomposition (break a problem into a checkable rubric), multi-frame verification, evolutionary improve/mutate/crossover, and a cross-run memory of failed approaches. But a blind A/B exposed the trap: it scored its own work a confident 100, and caught nothing. The fix (v2.1) added a correctness / flaw-penalty dimension; re-run, it caught and fixed real errors. The lesson that shaped everything after: an engine has to be able to mark itself wrong.

RecurseLooperpromotedCANONICAL

The version that won its own A/B, so it became the engine.

RecurseLoop + sub-goal rubrics + multi-frame adversarial verification + correctness scoring, promoted to the canonical engine after beating every prior generation head-to-head. General-purpose: hard, ambiguous, high-stakes questions where an iterated, fact-checked answer beats a one-shot.

RecurseLoopingv3 · the quant scientistv3

Replace the LLM judge with reality.

The biggest leap: stop asking a language model whether an idea is good, and test it against a deterministic backtest on sealed data. Blind proposers hypothesize; a frozen oracle measures real out-of-sample results; a walk-forward + multiple-testing-deflated gate decides. Pretty in-sample numbers don't matter: lookahead, too-few-trades, and fit-to-noise automatically refute a result, no matter how good it looks. Ground truth, not a rubric.

Research-OScorpus-groundedNOW

Make every run smarter than the last.

Each test now writes a RAG-optimized scientific report into a searchable corpus. The loop grounds its next hypotheses in everything already learned (prior verdicts, ruled-out dead-ends, and the still-open frontier), so it stops re-deriving the same dead idea and can even tap back into old projects for transfer. The structural fix for an LLM's worst habit: tunnelling on one framing. Packaged open-source.

// credits & lineage

recurse stands on a handful of ideas. a few are mine, most are other people's:

ARA Amber Liu et al. the persistent, provenance-tagged research artifact with first-class dead-end nodes. where this whole thing started.
RecursiveMAS the bounded recursion-loop skeleton the engine runs on.
BES bidirectional evolutionary search backward sub-goal decomposition, plus the improve / mutate / crossover that drives each round.
AutoScientists Harvard MIMS the propose, test, conclude loop, and the noise-gated check before anything gets promoted.
ARBOR RUC + Microsoft Research the published state-of-the-art twin i landed on independently: hypothesis-tree refinement and insight backprop.
Google's Co-Scientist the idea of reusing findings across projects instead of starting every search cold.

the proof is in the code and the A/B results, not the citations.