A trading rig that tests its own strategies every hour — and never places an order

Client: GrN.dk — internal build
Sector: Quantitative research tooling and automation
Period: Built July 2026 · running hourly since 25 July 2026

crypto-dash.grn.dk

At a glance

crypto-dash.grn.dk is the public window onto a strategy-research rig that runs on our own server and trains itself. Every hour it backtests a fresh batch of trading-strategy configurations against five-minute crypto candles, scores each one on data it was not fitted to, keeps a running leaderboard, promotes the configurations that hold the top into a simulated book, and demotes them again as soon as their forward behaviour drifts away from what the backtest promised.

It is paper trading only. The installation holds no exchange keys, calls no order endpoint and has no account to spend from. Every fill, every position and every P&L figure on that page is simulated — which is why the page prints PAPER ONLY on itself, in orange, at the top of every hourly regeneration.

Paper trading only — no exchange keys, no order endpoints, no real money

Every hour: a 600-second backtest budget over 60 symbols and 30 days of 5-minute candles

649 strategy configurations scored in the rig's first five hours (26 July 2026)

The challenge

The domain already had a tenant. Since January 2026 it served one hand-picked strategy — an RSI-dip paper book that bought a fixed $100 per signal and showed the running result. It worked, and it taught us its own limitation: a single fixed strategy tells you almost nothing. It cannot say whether it is good, only what it did.

The decisive evidence was a negative result. That earlier rig's own research runner was pointed at its proposed improvements — a stop floor, a profit lock after a position doubles, a delayed entry, post-loss recovery gates — as a 58-case train-and-test grid. In July 2026 the grid rejected every one of them: each variant came out negative out-of-sample, and the nominal best exit rule finished only $5.36 ahead of doing nothing, which is not evidence of anything. Nothing was changed on the live page as a result. That honestly-recorded failure is what set the brief: stop hunting for the strategy by hand, and build the thing that keeps searching — and that is rigorous with itself about what it has actually found.

Three constraints shaped it. Overfitting is the default outcome: any search across enough parameters will eventually produce something that looks brilliant on the data it was fitted to and is worthless on the next week. The machine is not idle: the same server runs a fleet of production sites, mail, backups and other people's jobs, so an open-ended backtesting loop had to be a well-behaved neighbour rather than something that eats the box for an hour at a time. And a self-directing trading system is exactly the kind of software that must not be quietly wired to money — the safety property had to be structural, not a setting somebody could flip by accident.

The solution

Isolation first, so "paper only" is a fact about the installation and not a promise. The rig runs as its own locked-down system user with its own clone of our in-house backtesting engine and its own candle cache — 14.4 million rows, copied once from the existing cache and never written back to it. There are no exchange credentials, no order-placing code path and no secrets anywhere under the install, so there is nothing to leak and nothing to accidentally arm. The service unit itself is the seatbelt: a read-only home, a memory ceiling, a CPU quota and a low priority, so the production jobs that share the machine never feel the sweep running.

One hourly tick, six phases. It updates its own copy of the engine (pulling and reinstalling only when the code actually moved), tops up five-minute candles for the top hundred USDT pairs by volume, runs a budgeted strategy sweep, runs the paper round, regenerates the public page, and writes a structured log line. A failure in any one phase never aborts the rest: failures are collected as shapes — phase plus exception type — and each shape mails the administrator at most once a day while it persists.

The sweep is budgeted, not exhaustive. Each round gets 600 seconds of wall clock and a hard cap of 400 configurations, evaluated over a 30-day window that is quantised to the day, with the last 30% of it held back as out-of-sample and realistic commission and slippage charged on every side. Candidates come from three places, woven together so exploration is never starved: the curated baseline strategies, one-step parameter neighbours of the current top scorers, and pure random combinations. The ranking score is out-of-sample robustness minus an overfit penalty — a configuration that dazzles in-sample and stumbles out-of-sample scores worse than a boring one that does neither.

The leaderboard is the memory, and it is also the resume point. Each result is one row keyed by configuration and window, committed the moment it lands. A configuration is never re-tested on a window it has already been scored on, so knowledge accumulates instead of being recomputed; when the budget runs out mid-round, whatever was not reached simply comes back next hour with no queue state to maintain. Every new day is a new window, so the whole frontier gets re-scored against fresh data automatically.

Promotion is deliberately slow, and demotion is deliberately quick. A configuration only enters the paper book if it has held the top five for three consecutive hourly checks, has been scored on at least two distinct sweep windows, and carries a non-negative score — with a ceiling of six active strategies and a 48-hour cooldown before anything demoted can return. Once promoted, forward performance is tracked against the backtest's own expectation, and four separate rules pull the strategy back out: a drawdown breach at any age, a hard divergence from expectation once a handful of trades have closed, a narrower expectation band after two days of evidence, and an absolute daily floor. Every promotion, demotion and re-anchor is kept as an event, so the record of what the rig believed and when is complete.

Simulated fills are replayed, not accumulated. Promoting a strategy freezes an anchor bar and a symbol set; each tick then re-runs the deterministic backtest from that anchor and folds newly closed trades into a fills ledger under stable keys. Because the same anchor over immutable candle history always produces the same trades, the ledger only ever grows at the tail — a tick that dies halfway through cannot corrupt it, and nothing has to be serialised between runs. Positions still open are reported as a snapshot with unrealised P&L and are never counted as fills.

It repairs itself, and asks for help in writing. Transient exchange hiccups are retried with backoff before anything is called a failure; a sweep round that overruns its budget halves the next round's allowance and earns it back gradually over clean rounds. When a failure shape survives several consecutive ticks anyway — or a papered strategy is auto-paused for behaving nothing like its backtest — the pipeline writes an incident file, and a privileged drainer turns pending incidents into a single de-duplicated card on the Trello board that our AI agent works. The rig has no credentials of its own to open that card with, by design; it leaves a note, and the agent that reads the board investigates and fixes.

The dashboard is deliberately dumb. The public page is plain HTML regenerated from the SQLite state with no imports from the trading engine at all and an atomic write into place, so it keeps telling you the truth about the last known state even on a tick where the engine itself is broken. A daily digest email covers the same ground for anyone not watching the page: configurations tested, leaderboard movement since yesterday, promotions and demotions, and the paper P&L.

The results

What exists: a self-directing research loop running unattended on its own hardware, with a public status page at crypto-dash.grn.dk that regenerates every hour. In its first five hours it scored 649 distinct strategy configurations across eleven sweep rounds, accumulated 715 leaderboard rows over two evaluation windows, and promoted three configurations into the paper book — all figures read off the live page and databases on 26 July 2026, and all of them growing hourly since.

What it has not proven, stated plainly: the paper book has zero closed fills and a profit and loss of exactly $0.00. The three promoted configurations carry an out-of-sample backtest expectation of roughly +0.04% a day over the 30-day window ending 26 July 2026 — that is an expectation the rig has just set itself to disprove over the coming days, not a return that anybody earned. There is no live-money performance to report here because there is no live money, and there will be none until the owner explicitly decides otherwise. Nothing on this page is investment advice, a signal service, or connected to an exchange account.

That distinction is the actual deliverable. The valuable part of this build is not a number; it is a rig that produces numbers with a known provenance — held-out data, an explicit overfit penalty, promotion gated on persistence across windows rather than a single lucky round, and automatic demotion the moment forward behaviour disagrees with the backtest. Its own predecessor's most useful output was a grid that said "none of your ideas work", and this system is built to keep saying that when it is true.

It is also a demonstration of how the work was done: the whole thing came off a Trello board one card at a time — scaffold, sweep, paper promotion, visibility, self-heal — each picked up, built, tested and deployed by an AI agent working the board, with the self-heal phase closing the circle by filing its own cards back onto that same queue when something breaks.