Strategy Evolution

One call to iteratively improve a strategy through generate → backtest → analyze → regenerate feedback loops.

┌──────────┐     ┌──────────┐     ┌──────────┐     ┌──────────┐
│ Generate │ ──▶ │ Backtest │ ──▶ │ Analyze  │ ──▶ │ Feedback │
└──────────┘     └──────────┘     └──────────┘     └─────┬────┘
      ▲                                                  │
      └──────────────────────────────────────────────────┘

Quick Usage

import vibetrading

result = vibetrading.evolve(
    "BTC momentum strategy with RSI and SMA crossover, 3x leverage",
    iterations=3,
    model="gpt-4o",
    interval="1h",
)

print(f"Best score: {result.best_score}/10")
print(f"Improved: {result.improved}")
print(result.best_code)

How It Works

Each iteration:

1. Generate — LLM produces strategy code from the prompt (or regenerates from prior feedback).

2. Validate — Static analysis catches structural errors before execution.

3. Backtest — Runs the strategy against historical data.

4. Analyze — LLM evaluates backtest results: score (1-10), strengths, weaknesses, suggestions.

5. Feedback — Analysis is formatted and fed back to the generator as context for the next iteration.

The loop stops when iterations is reached or when the score meets score_threshold (default: 8).

EvolutionResult

Field	Type	Description
best_code	str	Strategy code from the highest-scoring iteration
best_analysis	BacktestAnalysisResult	Analysis from the best iteration
best_backtest	dict	Backtest results from the best iteration
best_iteration	int	Index of the best iteration
history	list[EvolutionStep]	Full record of all iterations
total_iterations	int	Number of iterations executed
prompt	str	Original natural language prompt

Properties

result.best_score    # int — score from best iteration (1-10)
result.best_metrics  # dict — metrics from best backtest
result.improved      # bool — True if later iterations scored higher than first

EvolutionStep

Each iteration produces an EvolutionStep:

Field	Type	Description
iteration	int	0-based iteration index
code	str	Generated strategy code
validation_passed	bool	Whether static validation passed
backtest_results	dict | None	Raw backtest output
analysis	BacktestAnalysisResult | None	LLM analysis result
error	str | None	Error message if iteration failed
score	int (property)	Score from analysis, or 0

Parameters

vibetrading.evolve(
    prompt,                         # Natural language strategy description
    iterations=3,                   # Max iterations
    model="gpt-4o",                 # LLM model for generation and analysis
    interval="1h",                  # Backtest candle interval
    initial_balances={"USDC": 10000},  # Starting balances
    start_time=None,                # Backtest start (auto if None)
    end_time=None,                  # Backtest end (auto if None)
    exchange="binance",             # Exchange for data
    data=None,                      # Pre-loaded data dict
    assets=["BTC"],                 # Target assets
    market_type="perp",             # "perp" or "spot"
    max_leverage=5,                 # Max leverage allowed
    detail_level="standard",        # Analysis detail: brief/standard/detailed
    score_threshold=8,              # Early stop when score reaches this
    on_iteration=None,              # Callback fn(step: EvolutionStep)
)

Tracking Progress with Callbacks

Use on_iteration to monitor each step:

def on_iteration(step):
    status = "OK" if not step.error else f"ERROR: {step.error}"
    print(f"[Iteration {step.iteration}] score={step.score}/10 {status}")

result = vibetrading.evolve(
    "ETH mean reversion with Bollinger Bands",
    iterations=5,
    model="gpt-4o",
    on_iteration=on_iteration,
)

Using StrategyEvolver Directly

For advanced control (separate models for generation vs analysis, custom kwargs):

from vibetrading.evolution import StrategyEvolver

evolver = StrategyEvolver(
    model="gpt-4o",
    generator_kwargs={"temperature": 0.8},
    analyzer_kwargs={"temperature": 0.3},
)

result = evolver.evolve(
    "BTC grid strategy with 0.25% spacing",
    iterations=5,
    interval="1h",
    score_threshold=9,
)

# Inspect full history
for step in result.history:
    print(f"Iteration {step.iteration}: score={step.score}")
    if step.analysis:
        for s in step.analysis.suggestions:
            print(f"  → {s}")

Pre-loading Data

Avoid re-downloading data on every iteration by passing data:

import vibetrading.tools

data = vibetrading.tools.download_data(
    ["BTC"], exchange="binance", interval="1h",
)

result = vibetrading.evolve(
    "BTC momentum with RSI",
    iterations=3,
    model="gpt-4o",
    data=data,
    interval="1h",
)