Strata · Strategies

Keep the test with the idea.

Write a strategy, test it out of sample, and deploy it only after it has earned it. Every run keeps its inputs, so a result can be reproduced, not just remembered.

In the app

Backtest of the opening-range breakout on NQ over 20 simulated sessions: net profit $2,571, 20 trades, 60% win rate, profit factor 2.54, Sharpe 6.89, maximum drawdown −$679, an equity curve and results split long and short.
A backtest of the opening-range breakout on 20 simulated NQ sessions.

Strata reads like the idea.

Parameters carry their ranges and steps, so optimisation knows what it may try. Risk sits in its own block. The editor checks it as you type.

Prefer plain words? Describe the idea to the Agent and it drafts the strategy for you to read, test and change. Nothing runs until you choose to run it.

The opening-range breakout example strategy, exactly as it appears in Alpha’s editor.

strategy OpeningRangeBreakout "Stop-entry breakout of the first N minutes of the regular session, fixed bracket, one trade per session"

param or_bars: int = 15 in 5..60 step 5 "Opening range length (bars)"
param stop_ticks: int = 40 in 8..200 step 8 "Stop loss (ticks)"
param target_ticks: int = 80 in 8..400 step 8 "Profit target (ticks)"

settings {
  exit_on_session_close = true
  entries_per_direction = 1
}

var or_high: float = 0
var or_low: float = 0
var done: bool = false

risk {
  stop_loss ticks stop_ticks
  profit_target ticks target_ticks
}

on bar {
  if session.first_bar {
    or_high = high
    or_low = low
    done = false
  } else if session.bar_index < or_bars {
    or_high = max(or_high, high)
    or_low = min(or_low, low)
  }
  if position.size != 0 {
    done = true
  }
  if session.bar_index >= or_bars and position.size == 0 and not done {
    if close > (or_high + or_low) / 2 {
      enter long at stop or_high + tick_size name "OrbLong"
    } else {
      enter short at stop or_low - tick_size name "OrbShort"
    }
  }
}

From idea to deployment, in order.

  1. BacktestOn recorded or simulated history, with fees.
  2. OptimiseAcross the declared ranges, nothing outside them.
  3. Walk-forwardRolling in-sample and out-of-sample windows. Validation only after a passing walk-forward.
  4. Monte CarloResampled trade sequences, so one lucky order is visible as luck.
  5. DeployTo a simulation account. Each deployment trades its own attributed book and runs the version it was deployed with.

Research cards, reproducible.

Correlations, return distributions, volatility cones and simulations of your own trades. Each card stores its inputs and their hash and can be reproduced as a new, immutable revision: or refreshed with new data as a separate one.

The market-regime study goes further: before it shows any regime, it compares a hidden-Markov model with a single distribution on held-out data, and says so when the regime model is not supported.

A research card made by the Agent: return correlation of NQ and ES over 60 one-minute intervals on simulated data, with paired counts, its inputs hash, the note that it is descriptive history and not a forecast, and buttons to reproduce and export.
A research card: what it measured, from which inputs, and what it is not.

What is built.

  • Strata strategiesIn the app

    Written in the native editor with live diagnostics; backtested, optimised, validated by walk-forward and Monte Carlo, then deployed to a simulation account.

  • Custom indicatorsIn the app

    Custom indicators in JavaScript, Python, C, Rust or WebAssembly, each in an isolated process.

  • Market regime studyIn the app

    A causal hidden-Markov study of a saved capture that says when the regime model is not supported.

  • Historical Data ManagerIn the app

    Saved one-minute history you can audit, or your own CSV and JSON files, labelled IMPORTED and UNVERIFIED until you trust them.

  • Options chain and GEX (model)In the app

    A model chain and gamma exposure, labelled MODEL throughout.

    No real options or dealer-positioning feed is connected.

Systematic traders: tell us what your current backtester gets wrong.