What changed
  • Research note on how the engine reads the market before it acts, kept for the record and brought up to date
  • Project Green is now called Project Iris; the idea of a regime read followed by guards is unchanged
  • Today's four stages are outlined below, with the logic written as a short sketch

Updated 11 October 2026. The engine described here was called Project Green when this note was written in July. It is now Project Iris. The first version listed a fixed set of vetoes (spread, ATR, news proximity, drawdown budget, position lifespan). The set of checks has changed since then, so it has been replaced by the four stages below. The exact checks are not published.

This research note explains, in plain language, how the engine reads market structure and manages risk before and after it opens a trade.

Read the regime first

Before any signal is acted on, the engine reads the market: trend versus range, volatility, spread, session state and the news window. A signal that fires in the wrong regime is skipped and logged. This part has not changed since the first version of this note.

The four stages today

  1. Read the market. Every few seconds the engine takes a full snapshot of each market it trades: price, spread, volatility and session state. This stage can only watch.
  2. Hard stops. Some checks can veto a trade outright, for example a high-impact news blackout, the session window for that market, or a spread that is too wide.
  3. Size the position. Several further layers never block a trade. They scale the position up or down according to how much the setup agrees with itself.
  4. Manage what is open. Three independent systems manage an open position: recovery sizing that steps down rather than chasing, time-based exits, and the vault ratchet that moves realised gains somewhere a drawdown cannot reach.
Steps diagram: read the market regime, skip signals in the wrong regime, check risk guards, then open the trade only if every guard passes.Steps diagram: read the market regime, skip signals in the wrong regime, check risk guards, then open the trade only if every guard passes.
From reading the regime to a guarded trade.

The same idea as a sketch

This is a simplified outline of the order of the stages, not the engine's source code and not a specification. It shows which stages can say no and which only change the size.

def consider_trade(market, account):
    snapshot = read_market(market)            # 1. price, spread, volatility, session

    if hard_stop(snapshot):                   # 2. e.g. news blackout, session window, spread cap
        return None

    size = base_size(account)                 # limited by the account's own risk settings
    for layer in sizing_layers:               # 3. layers scale the size, they never block
        size = layer.scale(size, snapshot)

    return Order(market, size)                # 4. then the position is managed while open

Your own limits sit around this loop rather than inside it. The drawdown budget, the daily growth cap and the vault are described in Risk guard stages and on the Learn pages in your dashboard.

The goal is not to be right on every trade. It is to keep a wrong trade small and a right trade protected.
Where this lives: How Project Green reads market structureWhere this lives: How Project Green reads market structure
Where this lives: How Project Green reads market structure

What this does not do

None of this removes the risk of loss. Trading carries risk and you can lose money. The outline describes how the software is built to decide; it does not predict what will happen on any trade. Past performance is not a reliable indicator of future results.