What if a robot tried 100 trading strategies while you slept?

The Experiment Loop

Claude Code (an AI coding agent) runs this loop over and over, fully autonomously:

Constraint: The AI can only edit one file. Everything else is locked.

From Simple to Spectacular

The robot discovered that removing fancy features (pyramid trading, BTC filters, correlation weighting) made the strategy dramatically better.

The Winning Strategy in Plain English

The final strategy works like a panel of 6 judges voting on every trade:

Repository Architecture

Data Pipeline & Backtesting Engine

The Scoring Formula

The AI optimizes a single composite score — not just raw returns:

score = sharpe * sqrt(min(trades / 50, 1.0))
        - drawdown_penalty
        - turnover_penalty

Strategy Interface & Contract

Every strategy must implement a Strategy class with a single method:

class Strategy:
    def __init__(self):
        ...  # initialize state

    def on_bar(self, bar_data, portfolio) -> list[Signal]:
        ...  # return target positions

Signal(
  symbol="ETH",
  target_position=8000.0  # USD notional
)   # +long, -short, 0=flat

The Six-Signal Ensemble

The winning strategy uses a majority-vote ensemble requiring 4/6 agreement:

Volatility-Adaptive Thresholds

Entry signals use a dynamic threshold that adapts to current market volatility:

realized_vol = std(log_returns[-36:])
vol_ratio    = realized_vol / 0.015   # target vol
dyn_threshold = 0.012 * (0.3 + vol_ratio * 0.7)
dyn_threshold = clamp(0.005, 0.020)    # floor/ceiling

Exit Mechanics

Three independent exit triggers, any one closes the position:

peak = max(peak, current_price)
stop = peak - 5.5 * atr
if price < stop: exit()

The Autonomous Research Loop

Defined in program.md — instructions the AI agent follows:

Strategy Evolution: 7 Phases

103 experiments across 7 distinct phases of discovery:

The Great Simplification

Removing complexity improved performance.

Each "sophisticated" feature was tested — and hurt the score:

The RSI Period Discovery

The single most impactful parameter change in the entire research:

Code Walkthrough: on_bar()

The core execution path each bar (simplified):

def on_bar(self, bar_data, portfolio):
    signals = []
    for symbol in ["BTC", "ETH", "SOL"]:
        closes = bar_data[symbol].history["close"].values

        # 1. Compute dynamic threshold from realized vol
        dyn_threshold = calc_vol_threshold(closes)

        # 2. Calculate 6 signals
        mom_bull    = ret_12h(closes) > dyn_threshold
        vshort_bull = ret_6h(closes)  > dyn_threshold * 0.7
        ema_bull    = ema(7) > ema(26)
        rsi_bull    = rsi(8) > 50
        macd_bull   = macd_hist(14,23,9) > 0
        bb_bull     = bb_width_pctile(7) < 90

        # 3. Majority vote (4 of 6)
        bull_votes = sum([mom, vshort, ema, rsi, macd, bb])
        if bull_votes >= 4: go_long()

        # 4. Exit: ATR trail | RSI extreme | signal reversal
        if price < peak - 5.5*atr: exit()
        if rsi > 69 and is_long(): exit()
    return signals

Full implementation: ~250 lines of Python. No external models, no ML — pure signal processing.

Benchmark Strategies

5 reference strategies are provided in benchmarks/ for comparison:

Final Results

Pattern: Dead Code via Extreme Thresholds

The strategy file contains "dead" features neutralized by setting params to unreachable values:

# These features exist in code but are effectively disabled:

FUNDING_BOOST     = 0.0       # multiplier = 1.0, no effect
TAKE_PROFIT_PCT   = 99.0      # never triggers at 99x
BTC_OPPOSE_THRESHOLD = -99.0 # BTC filter effectively off
PYRAMID_SIZE      = 0.0       # adds 0 to position
HIGH_CORR_THRESHOLD = 99.0   # correlation never this high
DD_REDUCE_THRESHOLD = 99.0   # drawdown never reaches 99%

This is a fascinating artifact of autonomous code evolution — code that documents its own failed hypotheses.

Broader Lessons