DAAVILE FX. Backtested capital, gate-first.
The algorithm is the hypothesis.
The pipeline is the answer.
10,000+ verified backtests, an untouched out-of-sample era, Monte-Carlo stress gates, and a machine-learning oracle that reads the internals to decide which candidate deserves silicon next. This is the moat — methodology, not marketing. Operator-grade secrets stay private; the discipline is public.
Every claim has a run identity
Append-only ledger of real MT5 backtest runs. Deterministic, pattern-seeded run names; epoch rebases when the market-data base changes. Every champion number traces to a re-runnable run — nothing is anecdote.
Regimes, not a single scoreboard
Hand-curated date ranges spanning genuinely independent market regimes — institutional era, consolidation, modern tick era. Plus a completely untouched out-of-sample holdout no optimization has ever seen: the final judge.
Staged promotion, fail = blocked
Champions are survivors. Same ladder for every candidate: clean → latency (150/300/500ms + jitter) → in-EA Monte-Carlo lab (tick noise, skipped fills, spread bursts, lot jitter, exit noise) → cost stress → forward paper.
Latency as a distribution
Per-range gates: strict profitability under delay, survival under worse delay, a ceiling, and a jitter hard-veto. Ranking by probability-weighted expectation per range — never averaged into one fake global number.
The machine that reads the machine
Per-range surrogates predict outcome before a burn; feature importance surfaces which internal logics actually drive results; dead-knob detection kills wasted sweeps; Bayesian + low-discrepancy mass sweeps generate candidates; active learning ranks the next teachable experiment.
A backtest factory
Parallel MT5 terminals through a typed MCP protocol, orchestrator manifests, campaign chunking, owed-cell recovery so mid-flight kills resume cleanly, terminal-ops discipline — one driver per manifest, orchestrated like a data center.
The compounding asset
Structured plain-text knowledge base — internal logic map, per-range learnings, distilled lessons, champion doctrine — RAG-queryable by the agents today, explicitly designed as training fuel for a future LLM fine-tune. Today it's the agents' shared memory; tomorrow it's the model.
16/16, or it dies.
One gauntlet is a unit. We run thousands.
Flagship project of DAAVILE FX — the finance pillar inside RYIUK. The multi-window backtest gauntlet that decides which configs survive. The rest of the lab feeds it and ships beside it.
One gauntlet = sixteen fixed windows across regimes — crash, bears, drift, the long slog, live 2026 slices. Same setfile. Fixed lot. Risk-management levers banned from the search. Pass means every window — no partial credit. The campaign runs daily R16 epochs like it's nothing: thousands of windows, measurement blocks past +200 ranges, 5,000 prospects a day against the full bar.
The scoreboard is public because the failures are too. Growth isn't “everything works” — it's “we kept less than we generated, on purpose.”
Hypothesis in. Ledger entry out.
How the gate project runs one candidate from idea to verdict: a documented key change per setfile. A cheap screen culls what can't beat round numbers. Real-tick confirmation is the only run that counts. Then it faces the champion — or the kill ledger.
Ideas are cheap.
Dead ones keep the pipeline honest.
We might not be a quant shop. We still score like one. Recent kills — each logged, dated, kept.
We found our own data had drifted
Mid-campaign, the pre-2016 tick history on the terminals was found drifted. Everything built on it was invalid. The wrong move is usually convenient: keep the numbers.
A second kill entry is missing
This section originally held two kill entries. During the dedupe refactor only one was captured into capabilities.json and the other was dropped from the markup. Nothing was invented to fill the gap: the entry is restored from a copy of the page or left deleted, deliberately.
Models score like the strategies do
The evidence discipline we run against strategies applies to every model in the stack — feature stores from verified runs, honest validation, nothing promoted on vibes.
A model could pick the winning config on an era it never saw
HistGB over the config matrix: top-1 pick accuracy 50% across held-out eras (random = ~4%), profit capture 0.79, picked config ≈ 2.7× the range's mean outcome. That's the receipt for "distill the algorithm."
The decision layer accepted the EA's records end to end
32 range-choice records → kev option ranking on Qwen3-0.6B (LoRA-16, CPU): 0 rejected, saved clean; one epoch in-sample 37.5% vs 18.75% zero-shot. Small numbers — the fine-tune gate says more labels first (~100 outcomes), so this stays a mechanics proof, not a claim.
The algorithm stays code. The model learns its judgment.
Executor deterministic → kev-style policy ranks the options it already computes → resident 0.6B explains via RAG and abstains when no receipt matches. The LLM never sits in the tick path.
Even the tools get gated
A small packed-question decision model — Jev-style — sits in the loop as an experiment judge. Isolated per-question forward passes, each calibrated, answering things like: “violates a known dead lever?” — “targets a window regime this stack never opens?”
One stack. Every app talks to the others.
Dashboards, lab tools and backtesting engines built to connect — the LLM handles backend, configs and GUI automation; you operate from one place. Status tags reflect reality: live, in progress, or research.
multi-symbol
One account. Every symbol.
The thing MT5 cannot do.
MT5 tests one symbol at a time, with its own margin. Our portfolio engine runs N symbols through one shared account — one wallet, one margin pool, one equity curve — so a gold position and a euro position fight for the same free margin the way they would in a real account.
Shared margin, real fight
A gold position eats margin the euro position wanted. The gate refuses the second trade and counts the refusal — never a silent no-op. Pending orders reserve the pool before they fill.
Real algo DLLs, one account
The same C-ABI DLLs the terminals run drive each leg, but they see the portfolio balance and their opens hit the shared gate — the algo knows the account is shared, because it is.
Walk-forward + Monte Carlo
Every window is a full merged session judged by the gauntlet band law. The Monte Carlo shuffles the session's closed trades and reports p5/p50/p95 balance, drawdown and survival rate — deterministic under seed.
conditional statistics
Ask the data a question.
Get N and a confidence interval, not a vibe.
P(outcome | conditions) over your own bars, with the sample size and the 95% Wilson interval on every number. The law is the same everywhere: no code path prints a percentage without its sample size.
gapFill WHERE dayOfWeek = Tue
stability: 56.1% vs 48.1% · halves agree
per-year: 2024 58.9% · 2025 48.1% · 2026 47.9%
How often gold fills its opening gap, on your data, with the denominator honest and the split-half stability on the same line.
orbBreak(15, up) WHERE session = newyork
stability: 50.3% vs 51.8% · halves agree
per-year: 2024 51.2% · 2025 52.6% · 2026 48.5%
Opening-range breaks in the New York session. Every outcome composes with every condition — day-of-week, gap size, month, anything the registry can express.
the law as a library
The gauntlet, distilled to pure Rust.
Band law. Gates. Ranges. Protocol schema.
The same laws that gate every strategy — now a standalone crate that anything in the ecosystem can call: the band law (G/Y/O/R/X/U/D with the p/dd ratio ladder), the 16-cell range canon, the promotion gates, the protocol schema validator. One engine, one discipline, every surface.
Band law
Worst-band fusion, never an average: G ≥ p/dd 1.0, Y ≥ 0.5, O < 0.5, R < 0, X = blown, U = not run, D = can't run. A blown leg vetoes — a huge drawdown on a loss reads grey, not red.
Range law
16 canonical cells + OOS windows, content-hashed and immutable. Unique ids, real calendar dates, 10-year span cap, from-before-to, every phase in a stage — the structure a run binds to.
Protocol schema
Versioned JSON with strict validation: unknown keys are rejected, not dropped — a typo'd field surfaces as an issue, never a silent no-op. Schema v2 with MT5 bindings (symbol, modelling, deposit, leverage, timeframe) and sub-template references.
robustness
Stress every axis at once.
One broken corner breaks the claim.
The full cross-product grid — adverse slippage × spread-burst multipliers — each cell a full merged session judged by the band law. The verdict fuses by the worst band across the whole grid, never by the average.
Slippage × spread grid
0/1/3/5 points of slippage crossed with ×1/×3/×10 spread widening. A strategy that only works at zero slippage and the real spread reads fragile, and the report says so.
10× spread cannot help
The spread-burst axis widens every tick symmetrically around the mid before it reaches the broker, the strategy, or any algo DLL — the whole session trades a burst-spread market. Deterministic, no RNG.
live + local
The agents have eyes now.
Quotes. Your bars. The TA kernels.
Keyless live quotes for the whole basket, the vault's own bars on disk, and the same indicator kernels the strategy interpreter runs — all exposed to agents through MCP tools, no keys required for the core.
Keyless quotes
Gold, the Dow, the Nasdaq, the S&P, bitcoin, and four FX pairs — all mapped, all keyless, all live. The agents can ask "what is gold doing right now?" and get the price with a day range and a change %.
Your bars, your vault
65 GB of tick history and every bar file under the vault — the last N bars in M1 or D1, read from the .qidx sidecar without touching the network. The data is yours; the read is local.
The same TA kernels
SMA, EMA, Wilder RSI, MACD(12,26,9), Bollinger(20,2σ), ATR(14) — computed on the same bars with the same definitions the strategy interpreter runs, so the agent's read and the engine's read agree.
in build · gated ladder · kev's successor
Don't fine-tune the model first.
Teach the pipeline. Then earn the weights.
The distill program is the rung above kev's shadow lane: an explicit gate ladder from imitation to a state-conditioned selection policy that must beat the always-on champion. Every rung is scored by one yardstick on the same forward split, against a seeded noise floor — and no GPU is spent before a cheap local gate says the signal exists.
noise floor p95 0.481 · recency +0.169 · pf-gate +0.163 · state-knn +0.104
matrix 250 cells · 113 configs · 16 windows · OOS 2020–2025 sealed · tracked at daavfx/daavilefx-distill
The ladder, not the model
G0 data integrity is live and passing. G1a is a kill. G1b carries the first signal. G2 — "does the LLM add value over classical on held-out windows" — is the program's thesis gate, and the LLM is formally blocked until the matrix says it has something to learn from.
The G1a kill
Ranking configs by their parameters scores 0.421 — below doing nothing clever (0.390) and far below the static best (0.682), beating it in 7% of windows. Parameters carry no forward signal. The selection program does.
The epoch audit
839 of 4,033 ledger rows — 35% of what posed as ground truth — were a superseded epoch measured on retired terminals. The anchor's 2.05 score was irreproducible: source setfile gone, EA version unrecorded. Legacy is now excluded by default and every exclusion is counted.
Harness revisions
Thirteen single-knob selection programs scored against the seeded random floor: recency +0.169, pf-gate +0.163, min-obs +0.159, state-knn +0.104; ridge blends −0.23. Honest caveat baked into the report: at 14 windows these are hypotheses, not conclusions — the sweep confirms or kills them.
Market state, leak-free
Trailing features per window from the 478 MB bars vault, one streaming pass — computed only from bars before the window starts, so a crash inside the window cannot change its features (regression-tested). The four windows born at the vault's edge carry honest nulls. R16 trails bear: vol90 0.35, dd90 0.19.
The queue
Cross-sweep manifests are built — K=30 and K=50, 480/800 runs across all 16 windows, resumable, holdout mechanically refused. Results fold into a v2 ledger the moment they land. The LM enters as a kev-style revision proposer with calibrated abstention; weights only after it beats classical.
What we're actually building
No fake launch badges. This is the live queue across the whole lab — local LLM harness, Rust parity, finished apps, model tiering, pattern mining, and the gate project's open windows.
Daily R16 epochs are routine — the queue is wider regimes, more ranges, same 16/16 bar, zero partial credit.
llama.cpp driving the full MT5 backtesting flow end to end.
Same results as the terminal, at Rust speed.
Agents operate terminals, register champions, stop only at verified beats over the champion.
All tools, skills and scripts RAG-backed; loops built in.
Copy Trader, MT5 MCP, Data Downloader, Prop Firm Lab, Risk Manager, Quantum, Premium.
1B–2B executors · 2B–4B auditors · larger MoE for main audits. Trained free on Colab/Kaggle.
Move-based features — it moved $X, not "it was $2000 in 2020" — feeding strategies, LoRA data, risk profiles.
Executor stays deterministic; a gated ladder decides when a model earns its place. Live now: G0 integrity PASS, G1a KILLED parameter-conditioning (0.421 vs 0.682 static — parameters carry no forward signal), G1b state-conditioning first signal (+0.104 above the noise floor). Next: the K×16 cross-sweep densifies the matrix, then a kev-style revision proposer — weights only after it beats classical on held-out windows. Free-tier only. Tracked at daavfx/daavilefx-distill.