An autonomous quant-research loop whose job is to reject ideas — not to find alpha.
Across its pre-registered trials so far it has approved exactly zero strategies, and that is the point. This repository is a curated, public excerpt of the framework — the discipline machinery, not the proprietary signal library. It shows how the loop enforces research integrity, not which edges it is chasing.
The audit machinery is the product. In an efficiently-arbitraged market, ideas are cheap and rigor is the scarce asset.
This project descends from a hard lesson. A predecessor strategy once printed a Sharpe of 10–15. A forensic audit walked it back to ≈ 0: underestimated execution cost, an OHLC-sequencing simulator artifact, hindsight universe bias, selector overfit, and trading delisted tickers. The headline was honest arithmetic stacked on five quiet errors.
So instead of building another strategy, this project builds the thing that kills them — an always-on loop that continuously scouts genuinely new ideas but only spends real compute on candidates that survive deterministic triage, and then subjects each survivor to a full leakage / synthetic-null / cost / multiple-testing audit before anything can be called alpha.
It never trades. Promotion to capital is a separate, explicit, human-gated step.
⏱ SCHEDULED TICK (headless, unattended)
│
orchestrate one tick = one structured record
│
┌──────────────────────────┴───────────────────────────────────┐
▼ │
TRACK A · SCOUT (cheap model, every tick) │
web search (papers/posts/macro) → normalize → dedup vs registry │
│ new │ duplicate │
▼ ▼ │
idea inbox drop ("nothing new" = a valid result) │
│ │
▼ │
TRACK B · TRIAGE (deterministic Python · $0 · every tick) │
classify each card ─► REJECT_UNTESTABLE │
├────────────────► REJECT_DUPLICATE │
├────────────────► WATCHLIST (below priority bar) │
├────────────────► DATA_UNLOCK ─► TRACK C ┐ │
▼ fresh · on-panel · priority ≥ bar │ │
TRACK C · DATA-UNLOCK: plan a NEW point-in-time input ◄─┘ │
scored backlog → a PIT-safe build plan + explicit human action │
│ unlocks a new research lane │
▼ │
TRACK D · VALIDATION (full audit — ONLY if a real candidate) │
🧊 PRE-REGISTER & FREEZE spec + sha256 · a small design set │
▼ │
real backtest on a point-in-time panel (L/S spread + long book) │
▼ │
AUDIT BATTERY (frozen gates): │
predictive t > 2 · beats a synthetic null (PSR) │
Deflated Sharpe > 0.95 (deflated by CUMULATIVE trial count) │
cost survives · not a sector bet · holdable long-only │
IS/OOS split · factor-residual (FF5 + momentum) alpha │
▼ │
survivor? ──yes──► ⚔ ADVERSARIAL REFUTATION (default: refute) │
│ │ │
└──────── no ──────────────┤ │
▼ │
┌── VERDICT ──┐ │
PASS │ │ MARGINAL / NO_PASS │
▼ ▼ │
curated real-alpha home archive (honest write-up) │
│ │ │
└──────┬──────┘ │
▼ │
tested-ideas registry (NEVER re-test) │
▼ │
╔════════════ the fine-tuning loop ════════════╗ │
║ open / close research "lanes" ║ │
║ ⬆ the Deflated-Sharpe bar RISES every trial ║────────────┘
╚═══════════════════════════════════════════════╝
PASS → (human-gated) live-readiness → paper trading [SEPARATE; never automatic]
A rendered version of this diagram is in docs/process_flow.html
(open in a browser) or docs/process_flow.mmd (paste into
https://mermaid.live).
A known-factor "zoo" already tested dozens of published single anomalies and found essentially nothing that survives an honest multiple-testing bar net of cost. Pure single-factor alpha is gone. The open frontier — this loop's mandate — is interactions, conditioning, macro-regime timing, and genuinely new point-in-time data.
The audit is deliberately hostile to its own findings:
- Pre-register and freeze the full spec (with a
sha256) before a single backtest runs. If results disagree with the frozen spec, the spec wins — archive, do not tune. - Beat a synthetic null, not just a t-stat. A signal must clear a within-date permutation null (Probabilistic Sharpe Ratio vs the null distribution), a realistic cost sweep, an IS/OOS split, and a factor-residual (FF5 + momentum) alpha test.
- A rising Deflated-Sharpe bar. The multiple-testing deflation uses the cumulative trial count, so every trial you take makes the next "discovery" more likely to be luck. The bar rises as the program runs. It is never reset or lowered.
- Adversarial refutation, from more than one angle. Any survivor is handed to a panel of separate reviews — leakage, rentable factor beta, real-world cost/capacity — each instructed to refute it by default. Promotion needs all of them to independently disagree.
- Never re-test a logged idea. Every verdict is recorded, hash-chained, so the search never loops and the ledger itself can't be quietly rewritten after the fact.
- The bars are frozen and fingerprinted, not just written down. Every statistical threshold lives in one hashed manifest; the hash is stamped onto every result. Loosening a bar without saying so is a failing test, not a quiet edit.
Rules that never bend: never lower a gate to manufacture a pass; a documented NO_PASS is the normal, valuable outcome; no backtest ever approves capital.
The deliverable is a rigorous, cumulative, honest map of what does not work, which is exactly what tells you where an edge cannot be hiding.
The most interesting result to date is an honest near-miss: an alternative-data signal with factor-residual alpha around t ≈ 2.4 and near-zero factor R², whose long-only book is IS/OOS-consistent and which survives a Treasury-duration control — and which is still NO_PASS, because the Deflated-Sharpe bar sits far above it after the program's cumulative trial count. An honest near-miss is not alpha. (The signal's construction is intentionally not published here.)
This is a readable excerpt of the framework, not the full private system. It is meant to be read — and the deterministic core can also be run.
README.md ← you are here
docs/
ARCHITECTURE.md ← how each part fits together
process_flow.html / .mmd ← the loop diagram
engine/
README.md ← which files run standalone vs. are reference-only
registry.py ← tested-ideas registry: dedup + a tamper-evident hash chain
card_schema.py ← the idea-card contract + the one-way cost-parameter clamp
triage_inbox.py ← Track B: deterministic, $0, zero-model triage + priority scoring
claude_runner.py ← the safety wrapper: per-stage tools/model-tier/budget + no trading
orchestrate_tick.py ← the one-tick orchestrator (the track entry point)
run_cycle_tests.py ← Track D: frozen prereg → backtest → audit battery → verdict
parallel_research.py ← the batch drain + the adversarial-refutation panel
program_review.py ← Track E: the periodic, frontier-tier research-lead review
gates.py ← the frozen, hashed manifest of every statistical gate
integrity.py ← runtime tamper-evidence (code seal + registry chain)
attach_usage.py ← per-stage cost/token accounting (spend-by-stage observability)
prompts/
scout_prompt.md ← the idea-sourcing brief (Track A)
validation_prompt.md ← the validation-cycle brief (Track D)
program_review_prompt.md ← the research-lead brief (Track E)
reports/
CYCLE_2026-06-27/ ← ONE example cycle report (see below)
examples/
crypto_venue/ ← a NEW venue, onboarded end to end, fully runnable (see below)
To keep this a framework people can learn from — not a copy of the research — the following are omitted: the proprietary signal library (the actual factor math), the point-in-time factor panel and all market data, the full idea logs / tested-ideas history / strategy notes, and the scheduler wiring. The engine excerpt here therefore reads end-to-end but does not reproduce a live research result on its own.
reports/CYCLE_2026-06-27/ is a real, unedited example cycle. It
tests 16 combinations of well-known published anomalies (value × profitability, value-trap
conditioning, momentum-crash conditioning, macro regime rotation — all fully cited in
prereg.json), and the verdict is 0 PASS / 16
NO_PASS. Two independent adversarial reviews confirm the negative result is honest, not a bug,
and the cycle even documents a harness bug it caught and fixed. It is included precisely because
it shows the machinery working on public factors — with no proprietary edge exposed.
examples/crypto_venue/ is a different kind of example: not an
excerpt of the private engine, but a complete, self-contained pair of scripts that fetch real
BTC/ETH perpetual-futures funding-rate data from a free public archive and test the classic
funding-rate-carry hypothesis with the same discipline as everywhere else in this repo. Nothing
in it is proprietary, so it can be — and is — 100% runnable as-is. The real, unedited result:
MARGINAL. The historical edge is real (Sharpe 1.84, OOS-consistent, survives a bootstrap
significance test) — and a recent-regime check the historical Sharpe alone can't see shows the
funding regime has gone quiet in the last 180 days. Read
examples/crypto_venue/EXAMPLE_REPORT.md for the
full write-up, including a real bug the fetch script hit (an undocumented archive format change
partway through Binance's own historical data) and how it was handled.
The $0, no-model parts run on plain Python (3.9+, standard library only):
# See what's already tested (the dedup source of truth)
python engine/registry.py stats
# Check whether an idea is a duplicate before proposing it
python engine/registry.py check --text "value quality profitability"
# Classify an inbox of idea cards into test-now / needs-data / watchlist / reject
python engine/triage_inbox.py
# The frozen gate manifest + its content hash
python engine/gates.py
# Is this checkout's tracked code unmodified, and is the registry chain intact?
python engine/integrity.py
# The research-lead's dossier — program coverage, without calling any model
python engine/program_review.py --dossierSee engine/README.md for which files run standalone and which are
reference-only (they depend on the omitted signal library and data panel).
Research and educational material only. Nothing here is investment advice, and nothing here trades or approves capital. Any model-call wrapper in this repo hard-disables order-placement tools by construction. Published-factor citations belong to their original authors.
MIT.