Skip to main content

After the Signal Fires

What the engine does once entry conditions evaluate to TRUE.​

Most strategy documentation covers:

  • how to design the entry signal
  • how to define the edge
  • how to calculate stops, TPs, and sizes from research

But what actually happens after the signal fires — at runtime — is a separate, critical process.

This document explains the mechanical execution pipeline used once your entry conditions trigger.

This is not where we decide whether a trade “has edge.” That was done in research.

This is where we:

  1. Instantiate the strategy-defined stop distance
  2. Instantiate the strategy-defined take-profit structure
  3. Compute the position size from MLPT
  4. Place the order
  5. Lock in the initial risk
  6. Then follow strategy-defined behavior for the rest of the trade

Basic Flow​

┌─────────────────────────────┐ │ Strategy Runtime Engine │ └─────────────┬───────────────┘ │ ▼ ┌──────────────────────┐ │ Entry Conditions? │ │ (signal == TRUE?) │ └───────┬──────────────┘ │ yes ▼ ┌──────────────────────────────┐ │ 1. get_stop_distance() │ │ • Uses strategy research: │ │ - drawdown distributions │ │ - min hold horizon │ │ - persistence behavior │ │ - regime state │ └───────────┬──────────────────┘ │ ▼ ┌──────────────────────────────┐ │ 2. calc_take_profit_points()│ │ • Uses: │ │ - stop_distance │ │ - expected min hold │ │ - time until edge gone │ │ - convexity / R-multiple │ └───────────┬──────────────────┘ │ ▼ ┌──────────────────────────────┐ │ 3. calc_position_size() │ │ • Inputs: │ │ - MLPT (max_loss_usd) │ │ - stop_distance_usd │ │ • Output: position_size_sol │ └───────────┬──────────────────┘ │ ▼ ┌──────────────────────────────┐ │ 4. submit_order() │ │ • entry_price │ │ • position_size_sol │ │ • stop_loss │ │ • tp_levels │ └───────────┬──────────────────┘ │ ▼ ┌─────────────────────┐ │ Trade is LIVE │ └─────────┬───────────┘ │ ┌────────────────┴────────────────┐ │ │ ▼ ▼ ┌──────────────────────┐ ┌─────────────────────────┐ │ v1 (KISS baseline) │ │ Advanced behavior │ └──────────────────────┘ │ (strategy v2+ only) │ │ • SL fixed └─────────────────────────┘ │ • TP(s) fixed │ • NEVER widen SL │ │ • position size fixed │ • MAY tighten SL when │ │ • no trailing │ edge statistically │ │ • no dynamic TPs │ collapses │ │ │ • MAY adjust TP2/TP3 │ │ (no runtime modifications) │ per researched rules │ └─────────────────────────────────┴─────────────────────────┘

1. The Signal Fires (Entry Conditions = TRUE)

Your strategy’s Boolean entry logic evaluates to true.

At this moment:

  • The strategy’s edge is assumed (because the system passed research).
  • We are not re-analyzing the viability of the trade.
  • We are not recalculating the edge from scratch.
  • We are not checking “is this a good trade?”

Your strategy was only deployed because it already has positive expectancy.

So the engine goes to work.

2. Instantiate the Strategy-Defined Stop Distance

Every strategy includes a rule/function:

stop_distance_usd = get_stop_distance(strategy_params, current_market_state)

This rule was created during research using:

  • drawdown distribution
  • persistence behavior
  • expected minimum hold horizon
  • volatility regime models
  • structural characteristics of the signal

At runtime, the engine:

  • evaluates only the inputs relevant to this specific entry
  • computes the USD-native stop distance
  • prepares the exact stop price level

This does not re-decide whether the trade is valid.

It simply creates the stop price for this instance.

3. Instantiate the Strategy-Defined Take Profit Levels

Next, the engine calls:

tp_levels = calc_take_profit_points(
    stop_distance_usd,
    expected_minimum_hold_horizon,
    time_until_edge_gone
)

This generates:

  • TP1 (never moved in strategy v1)
  • TP2/TP3/etc (fixed or rule-based)
  • optional trailing behavior (strategy v2+)

The take-profit structure is derived from:

  • reward distribution
  • time-to-edge-decay
  • convexity
  • continuation probabilities

Again: these rules are defined in research — the engine simply applies them.

4. Compute Position Size (LAST)

Once stop and TP structure exist, the engine determines size:

position_size_sol = calc_position_size(
    max_loss_usd = MLPT,
    stop_distance_usd
)

Position size must always be the final step, because:

  • it depends on the stop
  • stop depends on the strategy’s research
  • the entire risk budget flows downstream

This ensures:

  • MLPT is respected
  • risk per trade is stable
  • volatility is respected

5. The Order Is Placed (Commit Phase)

After computing SL/TP/size:

submit_order(entry_price, position_size_sol, stop_distance_usd, tp_levels)

At this moment:

  • your risk is fixed
  • your SL is fixed
  • your TP1 is fixed
  • your position size is fixed
  • the trade is live

This is the commit phase — everything afterward follows the post-entry rules.

6. After Entry: What Cannot Change

Once the trade is live:

❌ You may not widen the stop​

Because:

  • MLPT is immutable
  • research assumed a specific stop envelope
  • widening destroys the risk model
  • widening destroys the statistical assumptions
  • widening exposes the account to nonlinear health decay

Stop widening turns a quant strategy into discretionary gambling.

7. After Entry: What May Change (Advanced Strategies Only)

There are two adjustments that might be allowed in more advanced strategy versions:

The basic idea is that you do additional distribution calculations after new information is gathered (after each bar) See Entry Conditions vs. Statistical-Edge Conditions for more info on how to do this.

A. Stop tightening​

Example: After 6 bars, if continuation probability drops to extremely low values, tightening the stop becomes statistically correct.

However:

  • this must be rule-based
  • this must be researched
  • this must avoid premature exits

This is a strategy v2/v3 feature, not default behavior.

B. Allowing later TPs (not TP1) more room​

Example: If persistence decays but slope remains positive, the engine may allow:

  • TP2/TP3 to float deeper into the reward envelope
  • dynamic trailing based on momentum decay
  • volatility expansion continuation models

But again:

  • this is advanced
  • this must be tested
  • this must be based on distribution shifts

Baseline strategies should not do this.

8. KISS Philosophy for Strategy Version 1

For a first-generation strategy:

  • stop is fixed
  • TP1 is fixed
  • position size is fixed
  • no trailing
  • no dynamic tightening
  • no dynamic extension of TP2/TP3

Why?

  • reduces moving parts
  • maximizes consistency
  • preserves research integrity
  • simplifies risk modeling
  • avoids emotional intervention
  • avoids spurious mid-trade re-optimization

Once the strategy has 200–500 real trades, then the edge-decay model can be extended.

9. Summary of the Runtime Execution Flow

if entry_conditions == true:
    stop = get_stop_distance()
    tps  = calc_take_profit_points(stop)
    size = calc_position_size(MLPT, stop)
    submit_order(stop, tps, size)

Once live:

  • ❌ stop never widens
  • ✔ stop may tighten (advanced only)
  • ✔ later TPs may adjust (advanced only)
  • ✔ but TP1 is fixed in v1

The trade exists because the strategy already has edge. Runtime is about materializing that edge in the form of SL/TP/size — not rediscovering it.