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.
~10× measured, not guessed
15.4s screen vs 152.1s confirm on a 2-year window. The screen is an approximation; the confirm is the verdict.
Backtesting assistants
Hermes & OpenCode on the MT5 MCP pipeline — agents run terminals, build setfiles, register champions.
llama.cpp + Vulkan
1B–4B open-weight models on plain CPU + RAM. Fast enough to be useful, light enough to respect your machine.
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.
We re-ran every baseline against live terminals — including the champion's — and the rankings rewrote themselves. Some of the fixes the drift had hidden had to be rediscovered the hard way. Pre, diff and post records: kept, dated, open to inspection.
it's “we kept less than we generated, on purpose.”
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.
Every verified run joins the store
Per-run and per-logic features from confirmed executions — 3,681 logic-level real rows. No synthetic history, no curve-fit leftovers.
Pre-rank before terminals burn cycles
Gradient-boosted models over the experiment history rank candidate mutations before they cost a terminal run. Leave-one-range-out validation — honest where it fails, weak spots logged, not buried.
The tail is the money
7,941 real close-out deals. Out-of-sample accuracy 0.843. Headline finding: close method dominates the profit distribution — the tail is a config decision, not luck.
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.
Quantum & Premium Dashboard
Visual + agentic backtesting cockpit: GUI charts, terminal agents, full tool/skill stack — tests run with minimal user input.
The Lab
Five tools being finished: Copy Trader, MT5 MCP, Data Downloader, Prop Firm Lab, Risk Manager — the working surface of the ecosystem.
Rust Foreground
Rust backtesting at MT5 parity — bridge tests, then cross-checks against Quantum. The memory-safe engine under the dashboards.
Small models, specific jobs
1B–2B executors that just run tasks · 2B–4B auditors and setfile builders · larger MoE fired only for main audits. Fine-tuned on free Colab/Kaggle; RAG + skills for the rest.
Pattern mining
Bars, ticks and setfiles scanned for how price moves — ranges and deltas, not nostalgia levels. Feeds strategies, risk profiles and prop-firm conditions.
RYIUK AMN
The router brain: jobs dispatched across model tiers, agent output verified, every loop fed from a shared knowledge base.
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.