Ich werde genau erklären, wie man ein Hedgefonds-taugliches Multi-Faktor-Alpha-Modell mit Graph Engineering aufbaut.
Legen wir direkt los.
Lesezeichen setzen
- Ich bin Roan, Backend-Entwickler, der an Systemdesign, HFT-artiger Ausführung und quantitativen Handelssystemen arbeitet. Meine Arbeit konzentriert sich darauf, wie sich Vorhersagemärkte tatsächlich unter Last verhalten. Für Anregungen, durchdachte Kooperationen, Partnerschaften – DMs sind offen.
In meinem letzten Artikel sagte ich, ich würde persönlich die ersten 20 Setups von jedem durchgehen, der ein KI-Quant-System baut, und das meinte ich ernst.
Einige Entwickler sind bereits tief im Prozess mit mir dabei. Das Angebot steht noch.
Wenn du ein Graph-Engineering-System baust oder kurz davor bist, oder auch nur darüber nachdenkst, antworte unter diesem Artikel oder schreib mir eine DM mit deinem aktuellen Setup. Ich werde persönlich deine Architektur durchgehen und dir die Lücke zwischen dem, was du hast, und einem Schwarm, der selbstständig Alpha jagt, aufzeigen.
Wenn ich nicht antworte, warst du nicht unter den ersten 20. Sei schnell. Multi-Faktor-Investing ist die Art und Weise, wie jeder ernsthafte Hedgefonds an der Wall Street Renditen erzielt. Sie handeln nicht mit einzelnen Ideen. Sie stapeln Faktoren. Das ist der gleiche Prozess, den AQR fährt. Den gleichen Prozess, den Two Sigma fährt. Den gleichen Prozess, den Bridgewater fährt. Und es ist das erste Mal, dass er von einem einzelnen Entwickler ausführbar ist.
Das Problem war immer, dass der Aufbau ein Forschungsteam erforderte. Faktoringenieure. Statistiker. Portfolio-Konstruktionsspezialisten. Risikoanalysten. Ausführungsingenieure. Du brauchst mindestens zehn Leute pro Faktorfamilie, und kein einzelner Quant kann dieses Team aufbauen.
Deshalb bleiben Retail-Quants bei Einzelstrategien und Hedgefonds drucken Alpha. Bis jetzt.
https://x.com/RohOnChain/status/2074134246784921977
In meinen letzten beiden Artikeln bin ich auf Loop Engineering eingegangen und darauf, wie man einen Schwarm von KI-Agenten baut, der 24/7 Alpha jagt.
Sobald du Loops und Schwärme hast, ist die Schicht, die sie als ein funktionierendes System zusammenhält, ein Graph.
Graph Engineering ist die Praxis, diese Schicht zu entwerfen. Du definierst die Knoten. Du definierst die Kanten. Der Graph läuft von selbst.
Am Ende dieses Artikels wirst du nicht nur Graph Engineering verstehen.
Du wirst ein selbstlaufendes Multi-Faktor-Alpha-Modell haben, das alle 24 Stunden auf deinem Laptop feuert.
Teil 1: Was Graph Engineering eigentlich ist
Jeder Quant, der mit KI arbeitet, befindet sich irgendwo auf dem gleichen Fortschrittspfad. Zu wissen, wo du stehst, macht klar, wohin du als nächstes gehst.
Was Graph Engineering eigentlich ist
Stufe 1: Prompts.
Du gibst einen Prompt ein. Du wartest. Du liest die Ausgabe. Du gibst den nächsten ein. Du bist der Loop. Nichts überlebt, wenn du den Laptop zumachst.
Stufe 2: Loops.
Du schreibst ein Skript, das den Prompt umschließt und nach einem Zeitplan auslöst. Der Loop hält den Zustand. Er überlebt, nachdem du den Laptop zumachst. Das hat mein Loop-Engineering-Artikel vermittelt. Ein Agent, ein Job, läuft für immer.
Stufe 3: Schwärme.
Du fächerst den Loop in viele Agenten mit spezialisierten Rollen auf. Einer generiert Signale. Einer validiert sie. Einer führt sie aus. Das hat der Artikel über KI-Agentenschwärme vermittelt. Mehrere Agenten parallel, koordiniert von Hand durch Python-Klebecode.
Stufe 4: Graphen.
Du beschreibst die Koordinationsstruktur einmal. Knoten sind Agenten. Kanten sind Datenübergaben. Der Graph weiß, wann er parallelisieren, wann warten, wann wiederholen, wann eskalieren muss. Du rührst den Klebecode nicht mehr an.
Graph Engineering ist die Praxis, diese Koordinationsstruktur zu entwerfen.
Ein Graph ist kein Skript. Dieser Unterschied ist wichtiger, als einem gesagt wird.
Ein Skript bricht in dem Moment, in dem ein Agent auf einen anderen warten muss. Ein Skript bricht in dem Moment, in dem der Zustand über Zyklen hinweg erhalten bleiben muss. Ein Skript bricht in dem Moment, in dem du sechs Loops parallel auf verschiedenen Modellen haben willst. Jeder Retail-Quant, der versucht hat, ein Multi-Agenten-System zu bauen, ist an diese drei Wände gestoßen.
Die Fehlerwand hat mich gebrochen. Als mein Rentabilitäts-Agent blockiert wurde, weil er 500 Bilanzen parsen und dabei auf Ratenbegrenzungen stoßen musste, starb die gesamte Pipeline.
Ich kam am nächsten Morgen zurück zu einem gestoppten Prozess, keinem Signal und keiner Ahnung, wo der Fehler seinen Ursprung hatte. Debuggen bedeutete, einen Stacktrace zu lesen und zu raten, welcher Agent stromaufwärts des Absturzes war.
Nach zwei Monaten hatte ich mehr Zeit mit dem Debuggen der Koordination verbracht als mit der Forschung. Ich war kurz davor, das ganze Projekt aufzugeben.
Das ist der Fehlerzustand, den jeder Multi-Agenten-Quant erreicht. Es ist auch der Grund, warum es Graphen gibt.
Ein Graph hat diese Fehlermodi nicht. Parallelität ist nativ. Zustand ist persistent. Fehler sind auf den Knoten begrenzt, nicht auf die Pipeline. Wenn ein Knoten bricht, läuft der Rest des Graphen weiter, und du reparierst den kaputten Knoten, indem du den Fehler in einfachem Englisch beschreibst.
Das ist das Versprechen von Graph Engineering. Jetzt ist die Frage, was den Graphen ausführt.
Teil 2: Das Werkzeug, das den Graphen ausführt
Graphen sind Architekturdiagramme. Sie laufen nicht von selbst. Sie brauchen eine Laufzeitumgebung.
Die Laufzeitumgebung ist das, was die meisten Leute, die Multi-Agenten-Systeme bauen, falsch machen.
Sie nehmen an, der schwierige Teil sei das Entwerfen des Graphen. Ist er nicht. Der schwierige Teil ist, eine Infrastruktur zu finden, die ihn tatsächlich ausführen kann.
Ich habe Wochen damit verbracht, verschiedene Laufzeiten auszuprobieren, bevor ich eine fand, die einen Multi-Faktor-Graphen Ende-zu-Ende ausführen konnte.
Die, die ich verwende, heißt Slate. Entwickelt von @wearerandomlabs. Läuft in deinem Terminal. Greift auf deine bestehenden Modell-Abonnements zu und verteilt die Arbeit auf sie.
Was für diesen Artikel wichtig ist, ist eine Fähigkeit, die sie kürzlich ausgeliefert haben, genannt Programs. Ein Program ist ein Graph, der in JavaScript geschrieben ist und den Slate kontinuierlich für dich ausführt.
Ein Prompt läuft einmal und stoppt. Ein Program läuft weiter, bis die Aufgabe erledigt ist.
Du schreibst das Program nicht allein. Du sagst Slate auf Englisch, was du willst. Slate entwirft den Graphen.
Slate präsentiert dir dann ein Diagramm. Du stellst Fragen zum Diagramm. Du änderst Knoten. Du passt Modelle an. Erst wenn du zufrieden bist, sagst du Slate, es solle speichern und ausführen.
Wenn es bricht, chattest du mit Slate über den Fehler. Slate repariert den Graphen.
Du findest Slate unter http://randomlabs.ai/rr. Es ist heute verfügbar.
Der beste Weg, Graph Engineering zu fühlen, bevor du selbst einen baust, ist, die beiden Beispiel-Programs auszuführen, die mit Slate ausgeliefert werden.
Sie heißen
/goal
und
/deepresearch
.
/goal – Graphen, die laufen, bis sie nachweislich fertig sind
Gib Folgendes in Slate ein:
1/goal implementiere eine Newey-West-adjustierte t-Statistik-Funktion in Python und verifiziere, dass sie mit der statsmodels-Implementierung bei zehn zufälligen Renditereihen übereinstimmt
Slate feuert nicht einen Prompt auf ein Modell. Es startet einen Graphen.
**Ein Knoten schreibt die Funktion. Ein anderer schreibt den Verifikationstest. Ein dritter führt beide aus. Ein vierter bewertet, ob die Ausgaben übereinstimmen.**
Wenn sie nicht übereinstimmen, schleift der Graph mit der spezifischen Abweichung als Feedback zurück. Es geht weiter, bis ein separates, kleineres Bewertungsmodell bestätigt, dass das Ziel erreicht ist.
Dies ist das Maker-Checker-Muster in einer Laufzeit. Der Maker bewertet nie die eigene Arbeit des Makers.
/deepresearch – Graphen, die Recherche parallelisieren
Versuche Folgendes in Slate:
1/deepresearch was sagt die neueste akademische Forschung zur Out-of-Sample-Performance des Fama-French-Fünf-Faktoren-Modells in Schwellenländern von 2015 bis 2026
Der Graph, der hier hochgefahren wird, unterscheidet sich von /goal.
Es ist eine parallele Recherche-Verzweigung.
Slate entsendet mehrere Worker-Agenten gleichzeitig. Jeder bearbeitet einen anderen Aspekt der Frage.
Einer liest aktuelle Paper. Ein anderer durchsucht arXiv q-fin. Ein weiterer zieht Daten aus der Kenneth-French-Bibliothek. Ein anderer kreuzt Zitationen ab.
Sie alle berichten an einen zentralen Orchestrator, der die Ergebnisse synthetisiert. Der Grund, warum /deepresearch für diesen Aufbau wichtig ist, ist, dass es genau das Muster demonstriert, das du für die Faktorkonstruktion benötigst.
Sieben Faktor-Agenten. Jeder ist für einen anderen Faktor zuständig. Alle laufen parallel. Alle berichten an einen zentralen Orchestrator.
Das ist der Multi-Faktor-Graph, abzüglich der quant-spezifischen Aufgaben.
Verbringe 30 Minuten damit, /goal und /deepresearch zu Fragen auszuführen, die dich wirklich interessieren. So entsteht Intuition für Graph Engineering.
Teil 3: Der Multi-Faktor-Alpha-Graph
Multi-Faktor-Investing zerlegt Aktienrenditen in systematische Treiber plus einen Residualwert. Die grundlegende Version ist das Fama-French-Drei-Faktoren-Modell, veröffentlicht 1993:
R_i ist die Rendite der Aktie i. R_f ist der risikofreie Zinssatz. R_m ist die Marktrendite. SMB ist die Größenprämie. HML ist die Wertprämie.
Das Alpha α ist das, was das Modell nicht erklären kann. Dieser Residualwert ist das, was du jagst.
Carhart fügte 1997 Momentum hinzu. Fama und French fügten 2015 Rentabilität (RMW) und Investition (CMA) hinzu.
Moderne Hedgefonds verwenden einen Sieben-Faktoren-Stack. AQR, Two Sigma, Millennium, Bridgewater – alle verwenden Varianten. Hier sind die sieben Faktoren, die 2026 relevant sind.
Faktor 1: Markt-Beta.
Rollierende 60-Monats-Regression der Aktien-Überrendite gegen die Markt-Überrendite.
Faktor 2: Größe (SMB).
Small Caps übertreffen Large Caps auf risikoadjustierter Basis.
Faktor 3: Wert (HML).
Hohes Kurs-Buchwert-Verhältnis übertrifft niedriges über lange Zeiträume.
Faktor 4: Momentum (MOM).
Gewinner der letzten 12 Monate bleiben für 3 bis 12 Monate Gewinner.
Faktor 5: Rentabilität (RMW).
Robuste Betreiber übertreffen schwache Betreiber.
Faktor 6: Investition (CMA).
Konservatives Vermögenswachstum übertrifft aggressive Expansion.
Faktor 7: Niedrige Volatilität.
Aktien mit niedriger Volatilität erzielen höhere risikoadjustierte Renditen, als die Theorie vorhersagt.
Jeder Fonds betreibt eine Version davon. Einzelne Entwickler können es nicht, weil es ein Forschungsteam braucht.
Graph Engineering löst das. Jeder Faktor wird zu einem Knoten.
Hier ist der vollständige Graph. Insgesamt elf Knoten.
Faktorkonstruktionsknoten (laufen parallel)
Knoten 1: Markt-Beta-Agent.
Führt die rollierende 60-Monats-Regression durch. Gibt ein Beta für jede Aktie aus.
Knoten 2: Größen-Agent.
Sortiert nach Marktkapitalisierung. Berechnet die Small-Big-Spanne.
Knoten 3: Wert-Agent.
Sortiert nach Kurs-Buchwert-Verhältnis. Berechnet die High-Low-Spanne.
Knoten 4: Momentum-Agent.
Berechnet 12-Minus-1-Monats-Momentum. Konstruiert MOM aus der Dezilspanne.
Knoten 5: Rentabilitäts-Agent.
Berechnet die Bruttorentabilität. Konstruiert RMW.
Knoten 6: Investitions-Agent.
Berechnet das jährliche Vermögenswachstum. Konstruiert CMA.
Knoten 7: Niedrig-Volatilitäts-Agent.
Berechnet die rollierende 60-Tage-realisierten Volatilität. Konstruiert Low Vol aus der Dezilspanne.
Koordinationsknoten (laufen sequenziell)
Knoten 8: Der Validator.
Führt Newey-West-adjustierte t-Statistiken für jeden Faktor durch. Bootstrap-Resampling mit 10.000 Iterationen. Entfernt jeden Faktor mit einer In-Sample- vs. Out-of-Sample-Verschlechterung von über 30 Prozent.
Läuft auf einem stärkeren Reasoning-Modell. Der Maker validiert nie die eigene Arbeit des Makers.
Knoten 9: Der Regimeprüfer.
Segmentiert die 20-jährige Geschichte in drei Regime unter Verwendung eines Hidden-Markov-Modells auf Volatilität und Renditen. Entfernt alles, was nur in einem Regime funktioniert.
Knoten 10: Der Portfolio-Konstrukteur.
Kombiniert die überlebenden Faktoren zu einem Long-Short-Portfolio unter Verwendung von Risk-Parity-Gewichten. Setzt Sektor-, Beta- und Dollar-Neutralität durch.
Knoten 11: Der Risiko-Zerleger.
Regressiert das Portfolio gegen die sieben Faktoren plus Stil- und Makrofaktoren. Berichtet das Residual-Alpha und die t-Statistik.
Nur Signale, bei denen das Residual-Alpha die Faktorzerlegung überlebt, sind echtes neues Alpha. Alles andere ist neu verpackter Stil mit zusätzlichen Schritten.
Elf Knoten. Jeder hat eine Aufgabe. Sie geben ihre Ausgaben den Graphen hinunter weiter.
Das gesamte Modell läuft als ein einziges Slate-Program, das alle 24 Stunden feuert.
Teil 4: Wie man es Schritt für Schritt aufbaut
Hier ist der genaue Aufbau. Folge im Terminal mit.
Schritt 1: Slate installieren
Öffne dein Terminal und führe aus:
1npm i -g @randomlabs/slate
Slate ist ein globales npm-Paket. Die Installation dauert etwa 30 Sekunden.
Überprüfe mit:
1slate --version
Schritt 2: Erstelle dein Projektverzeichnis
Multi-Faktor-Forschung braucht einen eigenen Arbeitsbereich. Zustandsdateien, historische Faktortests, Portfolio-Snapshots – alles lebt hier.
1mkdir ~/projects/multifactor-alpha2cd ~/projects/multifactor-alpha
Führe keine anderen Slate-Projekte aus demselben Ordner aus. Die Zustands-Namensräume sind pro Arbeitsbereich.
Schritt 3: Slate starten
Tippe:
1slate
Schritt 4: Verbinde deine Anbieter
Tippe innerhalb von Slate:
1/providers
Dies öffnet den Bildschirm zur Anbieterkonfiguration. Random Labs authentifiziert standardmäßig. Du kannst auch OpenAI Codex und GitHub Copilot direkt verbinden.
Navigiere mit den Pfeiltasten zu Codex und drücke Enter, um dich zu authentifizieren. Dein bestehendes Abonnement funktioniert.
Schritt 5: Verbinde deine Modelle
Tippe innerhalb von Slate:
1/models
Du siehst jedes Modell, das über jeden verbundenen Anbieter verfügbar ist. Random Labs hostet etwa 90 Modelle.
Du möchtest zwei Modell-Stufen.
Eine schnelle Stufe für die sieben Faktorkonstruktions-Agenten. Claude Sonnet funktioniert.
Eine stärkere Reasoning-Stufe für den Validator, Regimeprüfer und Risiko-Zerleger. Claude Opus funktioniert.
Schritt 6: Aufwärmen mit /goal und /deepresearch
Bevor du dein eigenes Program entwirfst, verbringe 30 Minuten mit den beiden mitgelieferten Beispiel-Programs.
So wird Graph Engineering vom Konzept zur Intuition.
Probiere diesen /goal-Befehl in Slate aus:
1/goal schreibe eine Python-Funktion, die Fama-MacBeth-Querschnitts-Regressionskoeffizienten berechnet, und verifiziere, dass sie mit dem empiricalfin-Paket auf 20 Jahren monatlicher Renditedaten übereinstimmt
Beobachte, wie sich der Graph verzweigt. Beobachte, wie das Bewertungsmodell die Arbeit des Schreibermodells überprüft. Beobachte, was passiert, wenn der erste Versuch fehlschlägt.
Probiere dann diesen /deepresearch-Befehl:
1/deepresearch was sagt die akademische Literatur über den Rentabilitätsfaktor RMW im Vergleich zum Qualitätsfaktor, wie von MSCI definiert, und wie unterscheiden sie sich empirisch von 2015 bis 2026
Beobachte die parallele Worker-Verzweigung. Beobachte, wie der Orchestrator synthetisiert.
Diese beiden Durchläufe geben dir das mentale Modell, das du brauchst, bevor du dein eigenes Program schreibst.
Schritt 7: Entwirf das Multi-Faktor-Program
Dies ist der wichtigste Schritt. Du beschreibst den Graphen in einfachem Englisch und Slate entwirft ihn mit dir.
Gib diesen genauen Prompt in Slate ein:
1entwirf mir ein Program, das sieben Multi-Faktor-Forschungs-Agenten parallel ausführt:2Markt-Beta, Größe, Wert, Momentum, Rentabilität, Investition und niedrige Volatilität.3Nachdem alle sieben abgeschlossen sind, führe einen Validator, einen Regimeprüfer, einen4Portfolio-Konstrukteur und einen Risiko-Zerleger sequenziell aus. Verwende Claude Sonnet für die sieben5Faktor-Agenten und Claude Opus für Validator, Regimeprüfer und Risiko-Zerleger.6Führe die gesamte Pipeline alle 24 Stunden aus. Verwende das Dateisystem als Speicher. Setze ein Budget7von 30 $ pro Durchlauf. Erzwinge eine Newey-West-t-Statistik über 2,5, Bootstrap mit 10.000 Iterationen,8und lehne jeden Faktor ab, dessen In-Sample- vs. Out-of-Sample-Sharpe-Verschlechterung9über 30 Prozent liegt.
Slate beginnt nicht einfach, Code zu schreiben. Es liest sorgfältig und stellt klärende Fragen.
Welche Datenquelle. Welches Backtest-Fenster. Welches Universum. Welcher Regime-Klassifizierer. Ob überschreibbare Standardwerte verwendet werden sollen.
Du antwortest in einfachem Englisch. Slate schreibt das JavaScript.
Schritt 8: Überprüfe das Graph-Diagramm
Sobald Slate das Program entworfen hat, rendert es ein Diagramm des Graphen.
Du liest keinen Code, um zu verstehen, was laufen wird. Du siehst dir die Koordinationsstruktur an.
Sieben Faktor-Knoten, die parallel vom Orchestrator laufen. Ein Synchronisationspunkt. Vier Koordinationsknoten in Sequenz. Ein Persistenzschritt. Ein Schlaf-Knoten. Eine Schleife zurück zum Anfang.
Stelle Slate Fragen zum Diagramm, bevor du etwas ausführst:
- Warum läuft der Validator auf Opus?
- Was passiert, wenn der Momentum-Agent eine Zeitüberschreitung hat?
- Welcher Zustand wird zwischen den Zyklen gespeichert?
- Was löst aus, dass der Regimeprüfer einen Faktor ablehnt?
Wenn dich eine Antwort überrascht, bitte Slate, den Graphen zu ändern.
Schritt 9: Speichern und ausführen
Sobald das Diagramm dem entspricht, was du willst, sag Slate, es solle das Program in einer Datei speichern. Führe dann aus:
1slate run multifactor-alpha.js
In dem Moment, in dem du Enter drückst, startet Slate den Graphen. Die sieben Faktor-Agenten werden parallel gestartet.
Die Feature-Engineering läuft parallel. Die Validierung läuft auf dem stärkeren Modell.
Der erste Durchlauf dauert 15 bis 25 Minuten. Nachfolgende tägliche Durchläufe sind schneller, da die Zustandsdatei bereits die Historie enthält.
Schritt 10: Ein Budget festlegen
Tippe in Slate:
1/budget $30/Durchlauf
Dies begrenzt die Gesamtausgaben pro Durchlauf. Wenn ein Durchlauf sich der Obergrenze nähert, eskaliert Slate, bevor er fortfährt.
Schritt 11: Debuggen, wenn es bricht
Echte Programs brechen. Meins ist in den ersten zwei Wochen dreimal gebrochen.
Der Wert-Agent wurde blockiert, weil er nicht-amerikanische Bilanzen nicht interpretieren konnte. Ich sagte es Slate. Slate reparierte den Wert-Agenten, indem es einen Schritt zur Währungsnormalisierung hinzufügte.
Der Momentum-Agent gab gelegentlich null überlebende Signale in momentum-feindlichen Regimen zurück. Ich sagte es Slate. Slate fügte einen Fallback hinzu, der das Momentum-Betrachtungsfenster während dieser Regime erweitert.
Der Portfolio-Konstrukteur verletzte manchmal die Sektor-Neutralität. Ich sagte es Slate. Slate fügte einen Projektionsschritt hinzu, um die Neutralität vor dem Schreiben des Portfolios durchzusetzen.
Du jagst keinem Stacktrace hinterher. Du beschreibst das Problem Slate. Slate repariert den Knoten.
Teil 5: Was tatsächlich passierte, als ich es ausführte
Hier ist der Teil, den ich nicht erwartet hatte.
Ich beschrieb Slate den Graphen in einem Absatz. Slate überprüfte zuerst die verfügbaren Modell-Identifikatoren, aktivierte die Modelle-Fähigkeit und wählte claude-sonnet-4.6 für die schnellen Agenten und claude-opus-4.5 für die Koordinationsstufen.
Dann entwarf Slate das gesamte Program in einem Durchgang. Kein Rohentwurf. Das vollständige JavaScript. Elf Knoten miteinander verbunden. Parallele Faktorkonstruktion. Sequentielle Validierung. Dateisystem-Shared-Memory mit Zeitstempel-Verseichnisnamen für die Durchläufe. Budgetzuweisungen. Das ganze Ding.
Slate schrieb nicht nur Code und verschwand. Es kam mit drei spezifischen Entscheidungen zurück, die es von mir bestätigt haben wollte, bevor wir es ausführten.
Entscheidung 1: Modell für den Portfolio-Konstrukteur. Mein Prompt-Entwurf spezifizierte Opus für Validator, Regimeprüfer und Risiko-Zerleger, aber ich nannte kein Modell für den Portfolio-Konstrukteur. Slate setzte es standardmäßig auf Opus, weil die Starke analytische Arbeit ist, markierte es aber als umkehrbar, falls ich Sonnet wollte.
Entscheidung 2: Modellversionen. Slate verwendete die aktuellen stabilen Sonnet und Opus (4.6 und 4.5) und bot an, auf neuere Versionen zu aktualisieren, falls ich das bevorzugte.
Entscheidung 3: Budget-Durchsetzung. Diese hat mich überrascht. Slate sagte mir ausdrücklich, dass die Obergrenze von 30 $ pro Durchlauf beratend und kein harter Kill-Schalter sei. Es gibt kein Echtzeit-Kostenmessungs-Primitiv, daher wird das Budget als angegebene Obergrenze plus selbst gemeldete Ausgaben, die summiert und gekennzeichnet werden, durchgesetzt. Wenn ich einen harten Abbruch mitten im Durchlauf wollte, bot Slate an, es explizit zu entwerfen.
Dieser dritte Hinweis ist der Grund, warum ich diesem Werkzeug vertraue. Die meisten Agent-Frameworks würden stillschweigend so tun, als ob das Budget durchgesetzt würde. Slate sagte mir genau, welche Durchsetzungsebene es tatsächlich bieten konnte.
Ich bestätigte alle drei Standardeinstellungen, benannte das Program in multifactor-research-pipeline um und sagte Slate, es solle es speichern.
Dann drückte ich auf Ausführen.
Die sieben Faktor-Agenten feuerten sofort. Jeder erschien im Terminal mit seiner eigenen Sub-Agenten-ID und einem Status-Timer.
Slate bestätigte den Durchlauf in einfachem Englisch:
"Es läuft im Hintergrund als multifactor-pipeline, beginnend mit den sieben Faktor-Agenten parallel auf Sonnet, dann der Validator → Regime → Portfolio → Risiko-Sequenz auf Opus, mit Standardwerten (./research-memory, 30 $-Budget, die drei Tore, ewige 24-Stunden-Schleife)."
Dieser eine Satz zeigt, warum Graphen Skripte schlagen.
Ich habe keinen Koordinationscode geschrieben. Ich bin keinem Stacktrace hinterhergejagt. Ich habe keine APIs zusammengeklebt. Ich habe den Graphen in einfachem Englisch beschrieben, drei Designfragen beantwortet, und Slate hat ihn gebaut.
Alles ist beim Start überschreibbar. Intervall, Budget, Torschwellen, Modelle, Speicherort und eine maxRuns-Obergrenze, falls du nicht willst, dass der Graph für immer läuft.
Hier ist das vollständige Program, das Slate für mich geschrieben hat. Studiere es, aber kopiere es nicht wörtlich. Deines wird je nach den Antworten, die du auf Slates klärende Fragen gegeben hast, etwas anders aussehen.
Teil 6: Was alle 24 Stunden passiert
Um 3 Uhr morgens deiner Zeit wacht der Graph auf.
Die sieben Faktor-Agenten feuern parallel. Jeder zieht die neuesten 24 Stunden Preis- und Fundamental-Daten. Aktualisiert seine Faktor-Zeitreihe. Übergibt an den Validator.
Der Validator führt Newey-West-t-Tests durch. Bootstrap mit 10.000 Stichproben. Entfernt alles, was out-of-sample versagt hat.
Dieser Schritt allein verwirft etwa 80 Prozent von dem, was bei einem ersten Backtest vielversprechend aussieht.
Der Regimeprüfer nimmt, was überlebt hat. Segmentiert die Historie mit dem HMM. Berechnet das Sharpe-Verhältnis pro Regime neu.
Ein Faktor, der nur in einem Regime funktioniert, ist kein Alpha. Es ist Beta auf dieses Regime, als Alpha verkleidet.
Der Portfolio-Konstrukteur nimmt die überlebenden Faktoren. Baut das Long-Short-Portfolio mit den durchgesetzten Neutralitätsbeschränkungen.
Der Risiko-Zerleger nimmt das Portfolio. Regressiert es gegen den breiten Stil- und Makro-Faktorsatz.
Wenn die t-Statistik des Residual-Alphas über 2,5 liegt, überlebt das Signal. Wenn nicht, wird der Tag als "kein Signal" protokolliert und der Graph schläft bis morgen.
Jeden Morgen wachst du auf und bekommst eine Slack-Nachricht. Entweder hast du ein Signal, das du handeln kannst. Oder du hast dokumentierte Beweise, dass heute nur Rauschen war.
Beide Ergebnisse sind nützlich. Keines erforderte, dass du an der Tastatur bist.
So sieht ein selbstlaufendes Multi-Faktor-Alpha-Modell im Jahr 2026 aus.
Der Bauplan
Wenn du dir sonst nichts merkst, merke dir diese sieben Schritte in der richtigen Reihenfolge.
1. Verstehe den Fortschritt. Prompts wurden zu Loops. Loops wurden zu Schwärmen. Schwärme wurden zu Graphen.
2. Kenne deine Faktoren. Markt, Größe, Wert, Momentum, Profitabilität, Investition, niedrige Volatilität. Sieben Faktoren. Jeder wird zu einem Knoten.
3. Entwerfe elf Knoten. Sieben Faktor-Agenten parallel. Vier Koordinations-Agenten sequenziell. Zeichne den Graphen, bevor du eine Zeile Code schreibst.
4. Verwende verschiedene Modelle für verschiedene Knoten. Sonnet für die Faktorkonstruktion. Opus für Validierung und Zerlegung. Ein Maker validiert nie einen anderen Maker.
5. Setze harte Regeln durch. Newey-West-t-Statistik über 2,5. Bootstrap mit 10.000 Iterationen. Regime-Robustheit über drei HMM-Zustände. Residual-Alpha-t-Statistik über 2,5.
6. Mach dich mit /goal und /deepresearch vertraut. Die Intuition für das Graphendesign kommt vom Beobachten von Graphen, nicht vom Lesen über sie.
7. Lass es sich aufbauen. Monat eins bedeutet, Fehler zu finden. Monat zwei bedeutet, Faktoren zu verfeinern. Ab Monat drei erzeugt dein Graph Signale, mit denen du tatsächlich handeln kannst.
Jetzt leg los und baue es
Installiere Slate heute Abend. Starte es. Führe /goal zu einer echten quantitativen Frage aus. Führe /deepresearch zu einem Faktor aus, der dich interessiert.
Erstelle dann dein eigenes Programm mit dem genauen Prompt aus Schritt 6. Überprüfe das Diagramm. Führe es aus. Setze ein Budget von 30 $.
Bis nächste Woche um diese Zeit wirst du deinen ersten selbstlaufenden Multi-Faktor-Graphen haben.
Bis nächsten Monat um diese Zeit wirst du dein erstes handelbares Signal haben, das alle elf Knoten überlebt.
Das ist der Deal. Ein Wochenende Aufbau für ein sich selbst verstärkendes Forschungssystem, das niemals schläft.
Jetzt leg los und baue es.
Wenn du bei irgendeinem Teil des Aufbaus nicht weiterkommst, schreib mir hier eine DM.
Du findest Slate unter http://randomlabs.ai/rr.
Folge @wearerandomlabs, wenn du jede Fähigkeit sehen willst, die sie veröffentlichen. /goal und /deepresearch sind die ersten beiden Programme. Sie werden nicht die letzten sein.
