Everything hangs off one loop.
A trading system is only as good as the loop it closes. nqant runs one, every session: ① the edges it has validated propose what's tradeable; ② the day's regime selects which of them is live and at what size; ③ the journal records what actually happened — and what the tape taught — which feeds back and reshapes ①.
The hard, unfinished part is the arm from ③ back to ①: learning into the validated edge set rather than into a drawer of good intentions. That arm is the frontier this whole self-model exists to support. Everything below keeps the loop honest.
The knowledge isn't a database. It's a forest.
Every idea carries a maturity — where it sits in its own validation life. You don't read a table of strategies; you read the health of a forest at a glance: how many trusted trees stand, how many seedlings are in line, how much honest compost feeds the ground. An idea is never just "in" or "out" — it's somewhere on this arc.
The forest is small on purpose. A handful of trusted trees, a queue of seedlings, and a deep bed of compost is not a thin book — it's an honest one.
An idea doesn't get believed. It gets tested against its null.
Most backtests look good because you picked the one that looked good. So nothing enters the book on a pretty equity curve. It has to beat a null that already knows you went looking — a benchmark deflated for every candidate you tried. Three gates in sequence:
Tests the candidate's Sharpe against a bar already raised by the number of trials. It catches the inflation that comes from searching. Most candidates die right here.
Evaluates every combination of sub-periods, purged of lookahead. It catches the edge that looks great on average and falls apart in the worst slice of history.
Estimates the chance the chosen parameters are the overfit ones. It catches the curve you tuned to the past instead of the structure that survives the future.
A book of two honest edges beats a book of twenty that never faced the gauntlet.
This is why the forest is sparse. Killing candidates is not the system failing — it's the system working. The handful that survive can be trusted precisely because the gate that admits them is the same gate that buried everything below.
We keep the dead. With cause of death.
Every killed idea is buried in the open, with a verdict attached. The graveyard isn't dead weight — it's antifragile: each headstone is a stressor the book survived, and the record that stops a killed idea from being quietly re-proposed under a new name.
The deaths rhyme. Most patterns posted positive P&L and still failed their null — selection-bias artifacts, not edges. Several held up on average but were fragile across sub-periods. The famous ones are the most instructive: textbook setups every educator teaches — opening-range breakouts among them — score just high enough to tempt you and just low enough for the gate to bury them. Popularity is anti-correlated with edge.
The graveyard is discipline made visible.
Two laws hold the book honest.
No backward sourcing
Mining your own history for "what worked" bakes selection bias straight into the edge set — you fit the footprint of your past behavior and call it a strategy, and it fails out of sample. The correct flow is a hypothesis stated before the data is run, then sent to the gate. Surviving doesn't prove an edge is real; failing proves it isn't.
The wide stop is the edge's DNA
An edge is validated at its real stop distance. Move the stop in to "afford" more size and the stats you trust no longer describe what you're doing — you're flying a map of a different territory. Size is funded by growing the buffer and ratcheting up as it compounds, never by tightening the stop on a thin one.
Eight guarantees against learning noise.
A system that learns from itself will, without guardrails, learn noise and drift into confident nonsense. These eight close the paths to that failure — the constitution the rest of the system is measured against.
Beside you the whole way.
The graph is the self-model in one view — every node a piece of the reasoning, every line a link it actually makes. Hover to light a node's neighborhood; click to read the thinking behind it. The numbers — the edges' triggers, their sizing, today's positions — live elsewhere, on purpose. What you see is how it thinks, told honestly, with the recipe left out.