Wie man Loop Engineering nutzt, um ein selbstoptimierendes quantitatives Handelssystem zu entwickeln

Ich werde genau erklären, wie man die Loops baut, die ein komplettes quantitatives Handelssystem eigenständig betreiben.

Fangen wir direkt an.

Merke dir das

- Ich bin Roan, ein Backend-Entwickler, der an Systemdesign, HFT-artiger Ausführung und quantitativen Handelssystemen arbeitet. Meine Arbeit konzentriert sich darauf, wie sich Prognosemärkte tatsächlich unter Last verhalten. Für Vorschläge, durchdachte Kooperationen oder Partnerschaften – DMs sind offen.

Eines, womit ich heute beginne.

Wenn du ein quantitatives System baust, kurz davor bist anzufangen oder auch nur darüber nachdenkst, schick mir eine DM, woran du arbeitest, oder antworte einfach unter diesem Artikel, und ich melde mich bei dir (du kannst mir auch einfach einen Screenshot deiner aktuellen Architektur schicken).

Ich werde persönlich die ersten 20 Setups durchgehen und dir die Lücke zwischen dem, was du hast, und einem System, das tatsächlich Alpha generiert, zeigen.

Die meisten Quants prompten immer noch Claude. Sie tippen. Sie warten. Sie lesen die Ausgabe. Sie tippen erneut.

Die klügsten Entwickler auf dem Planeten haben damit aufgehört.

Sie schreiben Loops. Die Loops prompten Claude. Die Loops verifizieren die Ausgabe. Die Loops entscheiden, was als Nächstes passiert. Die Loops laufen weiter, nachdem der Laptop zugeklappt ist.

Boris Cherny, der Leiter von Claude Code bei Anthropic, hat es vor zwei Wochen klar gesagt. „Ich prompte Claude nicht mehr. Ich habe Loops am Laufen, die Claude prompten und herausfinden, was zu tun ist. Mein Job ist es, Loops zu schreiben.“ Dieser einzige Satz hat die Denkweise jedes ernsthaften KI-Ingenieurs auf der Erde neu ausgerichtet. Und er passt perfekt zum quantitativen Handel.

Die meisten privaten Quants werden das lesen und sagen, dass es nicht auf sie zutrifft, weil sie zu klein sind. Sie liegen falsch. Je kleiner dein Kapital, desto mehr zählt das. Ein selbstlaufender Loop ist der einzige Weg, wie ein einzelner Entwickler jemals den Abstand zu einem Fonds mit 100 Doktoren schließen kann.

Denn quantitativer Handel ist bereits ein Loop. Daten abrufen. Signale generieren. Backtesten. Ausführen. Risiko überwachen. Wiederholen.

Jeder Fonds an der Wall Street durchläuft genau diesen Zyklus. Renaissance läuft ihn seit 1988. Citadel lässt ihn mit Teams von Ingenieuren laufen, die jede Stufe überwachen. Two Sigma, Jane Street, alle.

Der einzige Unterschied ist, dass sie Hunderte von Menschen brauchen, die im Loop sitzen. Du nicht.

Ich habe diesen Loop bereits für mich selbst gebaut. Er zieht termingerecht Marktdaten. Er führt Alpha-Recherchen durch. Er verifiziert jedes Signal über einen separaten Agenten. Er führt nur das aus, was die Verifizierung besteht. Er schreibt jede Lektion zurück in den Speicher.

Dieser Artikel ist alles, was ich über Loop-Engineering gelernt habe und wie man es in ein komplettes autonomes Handelssystem einbindet.

Am Ende dieses Artikels wirst du wissen:

Den genauen Unterschied zwischen dem Prompfen eines Agenten und dem Entwickeln eines Loops.

Die sechs Teile, die jeden funktionierenden Loop in der Produktion antreiben.

Wie man diese sechs Teile von Grund auf zu einem selbstverbessernden quantitativen Handelssystem zusammenschaltet.

Tauchen wir ein.

Teil 1: Der Unterschied zwischen Prompfen und Loop-Engineering

In den letzten zwei Jahren sah die Arbeit mit KI so aus.

Du hast einen Prompt eingegeben. Du hast gelesen, was zurückkam. Du hast den nächsten Prompt basierend auf dem, was du sahst, eingegeben.

Du warst der Loop.

Der Agent war ein Werkzeug. Du hast ihn die ganze Zeit gehalten. Jeder Schritt warst du, der an deiner Tastatur saß und entschied, was als Nächstes zu tun ist.

Loop-Engineering beendet das.

Du hörst auf, das Ding im Loop zu sein. Du wirst zum Architekten, der ihn entwirft.

Ein Loop ist ein rekursives Ziel. Du definierst einen Zweck. Der Agent iteriert darauf hin. Der Loop läuft weiter, bis eine echte Abbruchbedingung erfüllt ist.

Der Agent vergisst zwischen den Durchläufen. Der Loop nicht.

Diese eine Tatsache ist die gesamte Architektur.

Das meinte Boris, als er sagte, sein Job sei es, Loops zu schreiben. Er hörte auf, Anweisungen einzeln einzutippen. Er baute Systeme, die die Anweisungen für ihn senden, die Ergebnisse lesen und entscheiden, was als Nächstes passiert.

Fürs Programmieren ändert das, wie Software ausgeliefert wird.

Für den Handel ändert das alles.

Denn noch nie hat ein Quant Geld verdient, indem er einen Prompt eingegeben hat und weggegangen ist. Der Vorteil kommt daher, denselben Zyklus tausende Male zu durchlaufen, bei jeder Iteration ein Prozent besser zu werden und niemals zu schlafen.

Genau das tut ein Loop.

Wenn du immer noch Prompts in Claude eintippst, einen Trade nach dem anderen, tust du das, was Boris vor zwei Jahren aufgehört hat. Der Hebelpunkt ist eine Ebene nach oben gerückt. Du schreibst nicht mehr bessere Prompts. Du schreibst das System, das die Prompts schreibt.

Der Unterschied zwischen Prompfen und Loop-Engineering

Teil 2: Die sechs Teile, die jeden funktionierenden Loop antreiben

Ein funktionierender Loop besteht aus sechs Teilen. Fehlt eines, bricht der Loop leise.

1. Die Automatisierung.

Das ist der Herzschlag. Ein Cron-Zeitplan, ein Webhook, ein /loop-Befehl oder ein Hook innerhalb von Claude Code, der ausgelöst wird, ohne dass du tippst.

Es gibt zwei Varianten, die man kennen sollte. /loop wiederholt sich in einem festen Rhythmus, unabhängig vom Zustand. /goal läuft weiter, bis eine von dir geschriebene überprüfbare Bedingung tatsächlich wahr ist, wobei ein separates kleines Modell bewertet, ob die Arbeit erledigt ist.

Im Handel ist /loop dein Datenabruf jede Minute. /goal ist „iteriere weiter an diesem Signal, bis der Backtest-Sharpe über 1,5 liegt."

2. Die Fertigkeit (Skill).

Ein Skill ist ein Verfahrenshandbuch, das der Agent liest, anstatt ihm jede Sitzung von Grund auf neu gesagt zu bekommen.

Er lebt in einer Datei SKILL.md. Er enthält deine Konventionen, deine Regeln, dein „das machen wir nicht so wegen dieses einen Vorfalls."

Ohne Skills startet jeder Loop-Durchlauf bei Null. Mit Skills akkumuliert sich die Absicht.

3. Die Zustandsdatei.

Eine Markdown-Datei. Meistens STATE.md oder PROGRESS.md genannt.

Sie überlebt zwischen den Durchläufen. Der Agent vergisst. Die Datei nicht.

Der Agent liest sie zu Beginn jedes Durchlaufs. Er schreibt am Ende zurück, was passiert ist.

Das klingt zu dumm, um wichtig zu sein. Es ist tatsächlich das Rückgrat jedes funktionierenden Loops.

4. Der Verifizierer.

Der Agent, der den Code geschrieben hat, ist der schlechtestmögliche Richter darüber, ob der Code korrekt ist.

Wende das auf den Handel an. Der Agent, der das Signal generiert hat, ist der schlechtestmögliche Richter darüber, ob das Signal echtes Alpha oder Rauschen ist.

Du brauchst einen separaten Agenten mit anderen Anweisungen, idealerweise einem anderen Modell, dessen einzige Aufgabe es ist, die Arbeit zu verifizieren.

Das ist das Maker-Checker-Muster. Jeder Eigenhandel an der Wall Street ist intern so strukturiert. Bei Jane Street genehmigt der Händler, der einen Trade vorschlägt, den Trade nicht. Bei Citadel validiert der Forscher, der das Modell baut, das Modell nicht.

5. Die Worktrees (Arbeitsbäume).

Sobald du mehr als einen Agenten gegen dieselben Dateien laufen lässt, beginnen sie zu kollidieren.

Git-Worktrees geben jedem Agenten sein eigenes isoliertes Arbeitsverzeichnis, das auf seinen eigenen Branch zeigt.

Im Handel ermöglicht dir das, Signalrecherche, Backtesting und Risikoüberwachung parallel laufen zu lassen, ohne sich gegenseitig in die Quere zu kommen.

6. Die Konnektoren.

Ein Loop, der nur Dateien lesen kann, ist ein kleiner Loop.

Konnektoren, die auf dem Model Context Protocol basieren, ermöglichen es dem Loop, eine Broker-API anzusteuern, eine Datenbank abzufragen, eine Nachricht an Slack zu senden, Aufträge an die Börse zu senden.

Das ist der Unterschied zwischen einem Loop, der Trades vorschlägt, und einem Loop, der sie tatsächlich platziert.

Diese sechs Teile sind universell. Sie tauchen in Claude Code auf. Sie tauchen in Codex auf. Sie tauchen in jedem funktionierenden agentischen System auf dem Planeten auf.

Jetzt zeige ich dir, wie man sie zu einem kompletten Handelssystem zusammenschaltet.

Teil 3: Wie man einen selbstverbessernden quantitativen Handels-Loop baut

Der quantitative Handels-Loop hat fünf Phasen. Jede Phase ist ein eigener Sub-Loop mit eigenem Skill, eigener Zustandsdatei und eigenem Verifizierer.

Phase eins. Dateneingabe.

Eine Automatisierung wird je nach Anlageklasse jede Minute, jede Stunde oder jeden Tag ausgelöst.

1@loop(interval="1h")
2def ingest_data():
3    data = fetch_market_data(symbols=universe, lookback="30d")
4    state.write("latest_data.parquet", data)

Die Daten gehen in eine gemeinsame Zustandsdatei, die die nächste Phase liest.

Phase zwei. Signalgenerierung.

Hier findet die Alpha-Recherche statt.

1@loop(trigger="data_updated")
2def generate_signal():
3    data = state.read("latest_data.parquet")
4    signal = claude.run_skill("alpha_research", data)
5    state.write("pending_signal.json", signal)

Der Signalgenerierungs-Agent liest aus einer SKILL.md-Datei, die deine Alpha-Recherche-Regeln enthält.

1# alpha_research_skill.md
2
3## Ziel
4Generiere Signale mithilfe linearer Regression auf den letzten 30 Tagen Preis- und Volumendaten.
5
6## Regeln
7- Sharpe Ratio muss in 3 der letzten 5 Backtests über 1,5 liegen
8- Positionsgröße auf 2 Prozent des Kapitals pro Signal begrenzt
9- Signale an FOMC-Ankündigungstagen überspringen
10- Signale 48 Stunden vor Gewinnveröffentlichungen überspringen
11
12## Gelernte Lektionen
13- 2026-02-14: 4,2 Prozent während der Gewinnwoche verloren. Neue Regel: Jedes Signal 48 Stunden vor Gewinnveröffentlichungen überspringen.
14- 2026-03-08: Sektor-Expositionsverstoß verursachte 6 Prozent Drawdown. Neue Regel: Sektor-Exposition auf 30 Prozent begrenzen.
15- 2026-04-22: Momentum-Signal explodierte am FOMC-Tag. Neue Regel: Alle Momentum-Signale an FOMC-Tagen töten.

Der Skill wächst mit der Zeit. Jeder Verlust schreibt eine neue Lektion zurück. Jede Lektion wird zu einer neuen Regel für den nächsten Durchlauf.

Das macht das System selbstverbessernd.

Phase drei. Verifizierung.

Das Signal geht an einen völlig separaten Agenten. Anderes Modell. Andere Anweisungen. Keine Kenntnis davon, wie das ursprüngliche Signal begründet wurde.

1@checker
2def verify_signal(signal):
3    result = claude.invoke(
4        skill="backtest_verification_skill.md",
5        signal=signal,
6        rules=[
7            "Sharpe ratio above 1.5",
8            "Max drawdown below 10 percent",
9            "Newey-West t-stat above 2.0",
10            "Out of sample period at least 2 years"
11        ]
12    )
13    return result.verdict

Wenn die Verifizierung fehlschlägt, wird das Signal getötet. Wenn es besteht, geht es zur Ausführung.

Der Verifizierer sieht nie, was der Maker begründet hat. Diese Trennung ist der gesamte Vorteil.

Du kannst auch ein stärkeres Modell für den Prüfer als für den Maker verwenden. Claude Opus für die Verifizierung, Claude Sonnet für die Generierung. Verschiedene Modellarchitekturen fangen verschiedene Arten von Fehlern. Das ist dieselbe Logik, die Ensemble-Methoden im maschinellen Lernen verwenden.

Die Aufteilung in Maker und Checker

Phase vier. Ausführung.

Nur verifizierte Signale erreichen diese Phase.

1@auto_mode
2def execute(signal):
3    if verify_signal(signal):
4        broker.send_orders(signal, max_position=0.02)
5        state.write("active_trades", signal)

Der MCP-Konnektor kümmert sich um die Broker-API. Der Loop fragt nie um Erlaubnis. Der Auto-Modus lässt ihn ohne Eingriff laufen.

Phase fünf. Risikoüberwachung.

Läuft die ganze Zeit in einem parallelen Worktree.

1@loop(interval="1m")
2def monitor_risk():
3    positions = broker.get_positions()
4    if drawdown(positions) > 0.05:
5        broker.close_all()
6        state.append("STATE.md", "Drawdown trigger hit. All positions closed.")

Das ist der Notausschalter. Er setzt Regeln ohne Verhandlung durch.

Zusammen bilden diese fünf Sub-Loops ein selbstlaufendes System.

Daten fließen ein. Signale werden generiert. Signale werden verifiziert. Verifizierte Signale werden ausgeführt. Risiko wird überwacht. Lektionen werden zurück in den Speicher geschrieben.

Dann beginnt es von vorne.

Wie der Loop sich akkumuliert

Ich habe das einmal entworfen. Seitdem habe ich keinen dieser Schritte mehr gepromptet.

Das ist Loop-Engineering. Das meinte Boris, als er sagte, sein Job sei es, Loops zu schreiben.

Eine Warnung. Ein Loop ohne echte Abbruchbedingung scheitert leise. Der Agent gibt ein Abschlusssignal aus, in dem Glauben, die halb erledigte Arbeit sei fertig. Der Loop beendet sich. Der schlechte Trade bleibt offen.

Deine Abbruchbedingungen müssen durch etwas anderes überprüfbar sein als die eigene Behauptung des Agenten. „Sharpe über 1,5 in den letzten 30 Trades." „Drawdown unter 5 Prozent." „Test Suite bestanden." Niemals „der Agent sagt, es ist fertig."

In meinem Artikel zur Spieltheorie habe ich erklärt, warum jeder Trade ein strategischer Zug in einem Mehrspieler-Spiel mit unvollständigen Informationen ist. Falls du ihn verpasst hast, wirst du ihn direkt danach lesen wollen:

https://x.com/RohOnChain/status/2066178991892119820

Der Loop ist es, der dir erlaubt, für immer an diesem Tisch zu sitzen, ohne auszubrennen.

Zusammenfassung

Quantitativer Handel ist bereits ein Loop. Jeder Fonds an der Wall Street betreibt ihn. Sie brauchen nur Hunderte von Menschen, die darin sitzen.

Loop-Engineering entfernt die Menschen.

Sechs Teile ergeben jeden funktionierenden Loop. Automatisierungen geben den Herzschlag vor. Skills enthalten das Projektwissen. Zustandsdateien enthalten das Gedächtnis. Verifizierer bewerten die Ausgabe. Worktrees isolieren parallele Arbeit. Konnektoren geben dem Loop Hände in der realen Welt.

Verschalte sie um den fünfteiligen Handelszyklus, und du hast ein selbstverbesserndes System, das eigenständig Alpha-Recherche betreibt, Signale verifiziert, Trades ausführt und Risiken überwacht.

Das System wird mit jedem Zyklus intelligenter. Jeder Verlust schreibt eine neue Lektion. Jede Lektion wird zu einer neuen Regel. Nach hundert Trades ist die Skill-Datei ein lebendiges Dokument. Nach tausend ist sie näher an institutionellem Wissen als alles, was ein einzelner Mensch sich merken könnte.

Die Fonds, die das zuerst bauen, werden im nächsten Jahrzehnt akkumulieren. Diejenigen, die noch prompfen, werden zurückgelassen.

Also hier ist die Frage, über die du nachdenken solltest.

Wenn Loop-Engineering die nächste Abstraktionsebene über dem Prompfen ist und quantitativer Handel der Loop mit den höchsten Einsätzen der Welt ist, bist du dann die Person, die immer noch Prompts eintippt, einen Trade nach dem anderen, oder bist du der Architekt, der den Loop entworfen hat, der für dich handelt, während du schläfst?

Es gibt keine falsche Antwort, aber es gibt sehr aufschlussreiche.