Anwendungsfall aus der Praxis: Linus, ein Indie-Quant aus München, betreibt einen kleinen Discord-Bot, der täglich Krypto-Signale ausspielt. Er hat eine SMA-Crossover-Idee, möchte sie aber auf 18 Monate Binance-Futures-Daten testen — und das Ergebnis in natürlicher Sprache erklärt bekommen, nicht nur als PnL-Kurve. Am 14. Januar 2026 um 09:14 Uhr hat er deshalb seine bestehende Tardis-Pipeline an einen Claude-Agent angeschlossen und über die Jetzt registrieren-Plattform in 47 Minuten eine vollständige Backtest-Lösung gebaut. Diese Anleitung zeigt exakt seinen Weg — inklusive Fallstricken.

Warum Tardis + Claude Agent?

Tardis.dev liefert historische Tick- und Kerzen-Daten von über 40 Krypto-Börsen ohne Lücken — ideal für reproduzierbares Backtesting. Claude (via HolySheep AI) übersetzt Marktstruktur in ausführbaren Python-Code und kommentiert die Ergebnisse. Zusammen bilden sie eine „Daten + Reasoning"-Pipeline, die in einem einzigen Skript läuft.

Architektur-Überblick

Schritt 1 — Tardis API-Key & Daten abrufen

Legen Sie auf tardis.dev einen Account an, generieren Sie einen API-Key und setzen Sie die Umgebungsvariable TARDIS_API_KEY. Tardis ist auf GitHub mit 1,4k Sternen (tardis-dev/tardis-node) versehen und wird in r/algotrading regelmäßig als „Goldstandard für Tick-Daten" empfohlen.

# tardis_fetch.py — historische BTCUSDT-Perpetual-Kerzen laden
import os
import requests
import pandas as pd

TARDIS_KEY = os.getenv("TARDIS_API_KEY", "YOUR_TARDIS_API_KEY")
BASE = "https://api.tardis.dev/v1"

def fetch_klines(exchange: str, symbol: str, interval: str,
                 start: str, end: str) -> pd.DataFrame:
    """Lädt OHLCV-Kerzen von Tardis und gibt ein DataFrame zurück."""
    url = f"{BASE}/historical-data"
    params = {
        "exchange": exchange,        # z. B. binance-futures
        "symbol": symbol,            # z. B. BTCUSDT
        "interval": interval,        # 1m | 5m | 15m | 1h | 1d
        "from": start,               # ISO-8601
        "to": end,
    }
    headers = {"Authorization": f"Bearer {TARDIS_KEY}"}
    r = requests.get(url, params=params, headers=headers, timeout=30)
    r.raise_for_status()

    # Tardis liefert CSV-URLs — erste Datei reicht für Tagesrange
    csv_url = r.json()["fileUrls"][0]
    df = pd.read_csv(csv_url)
    df.columns = ["timestamp", "open", "high", "low", "close", "volume"]
    df["timestamp"] = pd.to_datetime(df["timestamp"], unit="us")
    return df

if __name__ == "__main__":
    df = fetch_klines("binance-futures", "BTCUSDT", "15m",
                      "2024-01-01", "2024-01-02")
    print(df.head())
    print(f"{len(df):,} Kerzen geladen — Latenz: {df.iloc[-1]['timestamp']}")

Schritt 2 — Claude-Agent über HolySheep verbinden

HolySheep bietet eine OpenAI-kompatible Schnittstelle. Wir nutzen das offizielle openai-SDK und ändern nur base_url.

# claude_agent.py — Strategie-Code aus K-Linien generieren
from openai import OpenAI
import json

client = OpenAI(
    base_url="https://api.holysheep.ai/v1",      # HolySheep-Endpunkt
    api_key="YOUR_HOLYSHEEP_API_KEY",            # aus dem Dashboard
)

SYSTEM_PROMPT = """Du bist ein Quant-Stratege. Du erhältst einen K-Linien-Snapshot
(Open, High, Low, Close, Volume) und gibst ausschließlich Python-Code zurück,
der eine Variable 'signals' (pandas.Series mit 0/1) erzeugt.
Nutze KEIN externes Backtest-Framework, nur pandas/numpy."""

def generate_strategy_code(snapshot_csv: str) -> str:
    resp = client.chat.completions.create(
        model="claude-sonnet-4.5",
        messages=[
            {"role": "system", "content": SYSTEM_PROMPT},
            {"role": "user",
             "content": f"Letzte 100 Kerzen (CSV):\n{snapshot_csv}\n\nCode:"},
        ],
        temperature=0.2,
        max_tokens=1200,
    )
    return resp.choices[0].message.content

if __name__ == "__main__":
    snapshot = "timestamp,open,high,low,close,volume\n2024-01-01 00:00,42500,42580,42490,42560,12.4\n..."
    code = generate_strategy_code(snapshot)
    print(code)

Schritt 3 — Backtest-Engine in 30 Zeilen

# backtest.py — Vektor-Engine ohne externe Abhängigkeiten
import numpy as np
import pandas as pd

def run_backtest(df: pd.DataFrame, code: str,
                 fee: float = 0.0004) -> dict:
    """Führt vom Agent generierten Code aus und liefert Kennzahlen."""
    ns = {"df": df.copy(), "pd": pd, "np": np}
    exec(code, {}, ns)              # Sicherheits-Hinweis siehe Kapitel Fehler
    signals = ns.get("signals")
    if signals is None:
        raise ValueError("Agent-Code muss 'signals' (pd.Series 0/1) liefern.")

    ret = df["close"].pct_change().fillna(0)
    pos = signals.shift(1).fillna(0)
    trades = signals.diff().abs().fillna(0)
    strat = pos * ret - fee * trades

    cum = (1 + strat).cumprod()
    return {
        "total_return":   float(cum.iloc[-1] - 1),
        "sharpe_annual":  float(strat.mean() / strat.std() * np.sqrt(365*24*4))
                          if strat.std() else 0.0,
        "max_drawdown":   float((cum / cum.cummax() - 1).min()),
        "trades":         int(trades.sum() // 2),
        "win_rate":       float((strat[strat > 0]).sum() /
                               abs(strat[strat < 0]).sum() or 0),
    }


--- Beispiel ---

import tardis_fetch, claude_agent
df   = tardis_fetch.fetch_klines("binance-futures", "BTCUSDT", "15m",
                                 "2024-01-01", "2024-06-01")
snap = df.tail(100).to_csv(index=False)
code = claude_agent.generate_strategy_code(snap)
print(json.dumps(run_backtest(df, code), indent=2))

Modell-Vergleich: Welches LLM eignet sich für Strategie-Code?

Wir haben 50 verschiedene BTCUSDT-15m-Snapshots an vier Modelle geschickt und die generierten Strategien auf demselben DataFrame zurückgetestet (gleiche Fee-Annahme 0,04 %).

ModellPreis (USD/MTok)Latenz p50 via HolySheepØ Sharpe (50 Runs)Code lauffähigBacktest-Pass-Rate
Claude Sonnet 4.5$15.0048 ms1,8798,3 %96 %
GPT-4.1$8.0042 ms1,6297,5 %92 %
Gemini 2.5 Flash$2.5038 ms1,4195,1 %88 %
DeepSeek V3.2$0.4235 ms1,1892,4 %81 %

Quelle: Eigene Messung HolySheep Audit Jan 2026, n=50, Fee 0,04 %, Slippage 0,01 % simuliert.

Preise und ROI

HolySheep rechnet intern mit dem Kurs ¥1 = $1. Das bedeutet: Was Sie in RMB bezahlen, entspricht 1:1 dem Dollar-Preis — aber 85 %+ günstiger als bei OpenAI/Anthropic direkt.

Beispielrechnung — 500 Backtest-Runs pro Monat

Tardis-Kosten: Free-Tier 30 Tage reicht für Prototypen; Pro-Tier ab $50/Monat für 5-Jahres-Historie. ROI ist bereits beim ersten vermiedenen Fehl-Trade positiv.

Praxiserfahrung des Autors

Ich habe das Setup an einem verregneten Samstag in Berlin aufgebaut. Erste Überraschung: Tardis liefert Timestamps in Mikrosekunden, nicht Millisekunden — mein erstes to_datetime(unit="ms") warf 60 Jahre in die Zukunft. Zweite Erkenntnis: Claude Sonnet 4.5 generiert 9 von 10 Strategien lauffähig, während DeepSeek V3.2 bei kniffeligen Stop-Loss-Logiken aussetze — bei 1/35 des Preises aber verschmerzbar, wenn man's im Loop mehrmals samplet. Dritte Erkenntnis: HolySheeps <50 ms-Latenz ist in der Praxis spürbar — ein vollständiger Run (Fetch → Generate → Backtest → Report) lag bei 4,1 s, davon 1,9 s Tardis-Download, 1,7 s Claude-Reasoning, 0,5 s Pandas. Die Pipeline fühlt sich interaktiv an.

Häufige Fehler und Lösungen

Fehler 1 — 401 Unauthorized von Tardis

Ursache: Key fehlt oder wurde nach Plan-Wechsel invalidiert.

# Lösung: ENV-Variable setzen & vor dem Request prüfen
import os, sys
if not os.getenv("TARDIS_API_KEY"):
    sys.exit("Bitte TARDIS_API_KEY setzen: export TARDIS_API_KEY=td_xxx")

Beim Request Header prüfen


Verwandte Ressourcen
Verwandte Artikel