The engine
Fast on decisions. Exact on money. One engine everywhere.
We built our own trading engine. That choice shapes everything else.
Why we built it
Off-the-shelf engines trade opacity for convenience. We need traceability — every result tied to code you control, with nothing opaque between your strategy and the fill.
How it runs
Fast on hot paths. Indicators, conditions, decisions — each runs under a strict per-candle budget. Stutter mid-decision and you stop trusting the tool.
Exact where money moves. Fills, fees, and ledger math stay precise.
One rule: rendering can get lighter; meaning cannot change. A faster chart never shifts a backtest number.
One core, three contexts
Backtest, paper, and live share one engine — not three simulators. What you test is what you trade.
The harness
The AI wires the pieces together. It never writes its own code.
Most AI tools write code. Ours doesn't.
The constraint
We built our AI harness around one rule: the AI never writes its own primitives. It does what it's genuinely good at — understanding intent, reasoning about logic, selecting and connecting pieces the engine already guarantees. The harness enforces correctness at every step.
Why the constraint is the feature
Generated code is hard to audit. A harness-driven approach means every decision is made from parts that have already been tested — the AI routes the connection, the engine holds the contract.
The AI accelerates assembly. It doesn't source the materials. That's the difference between AI that helps you move fast and AI that quietly introduces risk.
The building blocks
Strategies are assemblies of tested primitives — the AI composes, never invents.
The engine exposes a library. The AI assembles from it.
The library
Indicators, conditions, actions, risk controls — every primitive the engine ships is tested before it becomes available. When the AI builds a strategy, it selects from this set and wires the pieces together. It doesn't invent new ones.
Why this is the architecture
A strategy assembled from known blocks can be traced. A generated script can't. When something goes wrong — and in trading, something always eventually does — you need to know exactly which part of the logic produced which result.
Composability isn't a constraint on what's possible. It's what makes what's possible auditable.
One strategy, one truth
No look-ahead, no repaint. Paper trading is the backtest, run forward.
A backtest that prints a different number each run is a guess with a curve. Reproducibility is the bar a result has to clear to exist.
What we hold
No look-ahead, no repaint — a signal you see is one you could have traded. Pinned inputs, so the same run gives the same answer.
Paper trading isn't a second engine that approximates the backtest — it is the backtest, run forward. They can't drift, because they share the same path.
Why it matters
Traders develop instinct through feedback. If the feedback isn't trustworthy — if a result changes each run, if paper diverges from live, if a signal appears that you couldn't have acted on in real time — the instinct you build is wrong.
One truth, end to end, is what makes iteration mean something.