Strategy Builder
Draw your rules on a canvas, or just describe them in plain English. Either way you end up with a strategy the platform can test, trade and grade like any other.
Entries, exits, stops, targets, filters, sizing — the things you already think in.
Describe the setup and the canvas fills in. Adjust anything it got wrong.
What you build is what gets backtested, papered and deployed. No re-implementation between steps, so no drift.
Whatever you build here is tested against real market conditions and graded out-of-sample, so you always know whether it's working — on your own strategy, not a marketing figure. How the proof engine grades.
We don't publish how a description becomes executable rules, or how the compiler keeps user-authored logic safe and honest.
We publish what a module does and what it's for. We don't publish how it works. The method is the product — and anyone holding the method holds the product.
Evaluating this for a desk? Talk to sales and we'll go as deep as an NDA allows.
- 01Your words become a graph, not a guess
A description is parsed into an explicit rule graph — entries, exits, filters, sizing — that you can see and edit node by node. You are never left wondering what it thought you meant, because the interpretation is the document.
- 02One shape from build to live
The graph the canvas produces is the same object the backtester runs, the paper book trades and the exporter writes. Most platforms re-implement a strategy between stages; every re-implementation is a chance for the tested thing and the traded thing to differ.
- 03Ambiguity is surfaced, not resolved silently
"Buy the dip" has no single meaning. Where a description is under-specified the builder asks rather than picking a default and burying it — an invisible default is how a strategy ends up being tested as something you never wrote.
- 04Nothing runs that cannot be stated
If a rule cannot be expressed in the engine's vocabulary it is refused at build time, loudly, instead of being approximated. An approximation that backtests well is worse than an error.
The same strategy carried from canvas to backtest to paper to export, compared at each handover.
- Stations the object passes through
- 5
- Parity checks run between them
- 14 / 14 pass
- Re-implementations along the way
- the point of the whole design0
Most platforms rebuild a strategy between stages, and every rebuild is a chance for the tested thing and the traded thing to differ. Here there is one object, so there is nothing to drift.
Every one of these is a thing we could ship and choose not to. They are here because the limits are the part of a research tool you actually have to trust.
An under-specified description gets questions, not a confident filling-in.
If the engine can't express what you asked for, it says so at build time.
One pipeline, one strategy shape end to end. What you backtest is byte-for-byte what papers and what exports — there is no re-implementation step where drift can hide.
Do I need to write code to build a strategy?
No. You can draw the rules on a canvas or describe them in plain English, and edit whatever the description got wrong. Code is an option, not a requirement.
Can I edit what the AI produced?
Yes — the output is an explicit rule graph, not a black box. Every node is visible and editable, and the edited version is what gets tested.
Is the strategy I build actually the one that gets traded?
Yes, and it matters. The graph the canvas produces is the same object the backtester, the paper book and the exporter all read. Nothing is re-implemented between stages.
Bring a strategy you already run. An MT5 expert or a Pine script comes in and gets held to the same standard as everything else here.
It reads the chart the way you do — structure, swings, ranges, compression, the shape of the candles — and it reads it as of that bar, never with hindsight.
Most strategies aren't good or bad — they're good somewhere and bad somewhere else. This finds which conditions carry yours, and which quietly bleed it.
Every losing trade is evidence. This reads all of them, finds what they had in common, proposes a change to the rule — and proves the change before it ships.
Every module has an opinion. This turns them into one call, with the reasoning attached — and it will only act on an edge that has actually proved out.
A backtest tells you what a strategy would have made. This tells you whether its decisions were actually any good — against history it was never shown.
It goes to paper the moment it earns it. Live stays off until you turn it on — and you're the only one who can.
A decade of minute-resolution history across thirty instruments — the thing that decides whether a backtest is evidence or an opinion with a chart attached.
Edges decay. A strategy exported six months ago is quietly rotting on someone's terminal, and nothing tells them. This does.
Bring a strategy you already trade.
Test it yourself — or bring your desk's questions to us.
No card required · sales is for desks and teams