Je vais décomposer exactement comment construire les boucles qui font fonctionner un système de trading quantitatif entièrement autonome.
Allons droit au but.
À Conserver
- Je suis Roan, développeur back-end spécialisé dans la conception de systèmes, l'exécution de type HFT et les systèmes de trading quantitatif. Mon travail se concentre sur la façon dont les marchés de prédiction se comportent réellement sous charge. Pour toute suggestion, collaboration réfléchie ou partenariat, mes DM sont ouverts.
Une chose que je commence à appliquer dès aujourd'hui.
Si tu construis un système quant, si tu es sur le point de commencer ou même si tu y penses simplement, envoie-moi un DM avec ce sur quoi tu travailles ou réponds simplement sous cet article et je te contacterai (tu peux même simplement me montrer une capture d'écran de ton architecture actuelle).
Je vais personnellement passer en revue les 20 premiers setups et te montrer l'écart entre ce que tu as et un système qui génère réellement de l'alpha.
La plupart des quants utilisent encore Claude à la demande. Ils tapent. Ils attendent. Ils lisent la sortie. Ils retapent.
Les builders les plus intelligents de la planète ont arrêté de faire ça.
Ils écrivent des boucles. Les boucles interrogent Claude. Les boucles vérifient le résultat. Les boucles décident de la suite. Les boucles continuent de tourner même après avoir fermé le laptop.
Boris Cherny, le responsable de Claude Code chez Anthropic, l'a dit clairement il y a deux semaines. « Je n'interroge plus Claude directement. J'ai des boucles qui interrogent Claude et qui décident quoi faire. Mon métier est d'écrire des boucles. » Cette seule phrase a recadré la façon dont chaque ingénieur IA sérieux sur terre pense à la construction. Et elle s'accorde parfaitement avec le trading quantitatif.
La plupart des quants particuliers liront ceci et diront que ça ne s'applique pas à eux car ils sont trop petits. Ils ont tort. Plus ton capital est petit, plus cela compte. Une boucle auto-exécutante est le seul moyen pour un constructeur solitaire de combler l'écart avec un fonds qui emploie 100 PhDs.
Car le trading quantitatif est déjà une boucle. Récupérer les données. Générer des signaux. Backtester. Exécuter. Surveiller les risques. Recommencer.
Chaque fonds de Wall Street exécute ce cycle exact. Renaissance le fait depuis 1988. Citadel le fait avec des équipes d'ingénieurs qui surveillent chaque étape. Two Sigma, Jane Street, tous.
La seule différence est qu'ils ont besoin de centaines d'humains assis à l'intérieur de la boucle. Toi, non.
J'ai déjà construit cette boucle pour moi-même. Elle récupère les données de marché selon un planning. Elle effectue des recherches d'alpha. Elle vérifie chaque signal via un agent séparé. Elle n'exécute que ce qui passe la vérification. Elle écrit chaque leçon dans la mémoire.
Cet article est tout ce que j'ai appris sur l'ingénierie des boucles et comment la câbler dans un système de trading autonome complet.
À la fin de ceci, tu sauras :
La différence exacte entre interroger un agent et concevoir une boucle.
Les six éléments qui font fonctionner chaque boucle en production.
Comment câbler ces six éléments dans un système de trading quantitatif auto-améliorant, à partir de zéro.
C'est parti.
Partie 1 : La différence entre l'interrogation et l'ingénierie des boucles
Pendant les deux dernières années, travailler avec l'IA ressemblait à ceci.
Tu tapais une instruction. Tu lisais ce qui revenait. Tu tapais l'instruction suivante en fonction de ce que tu voyais.
Tu étais la boucle.
L'agent était un outil. Tu le tenais tout le temps. Chaque mouvement était toi, assis à ton clavier, décidant de la suite.
L'ingénierie des boucles met fin à cela.
Tu cesses d'être la chose à l'intérieur de la boucle. Tu deviens l'architecte qui la conçoit.
Une boucle est un objectif récursif. Tu définis un but. L'agent itère pour l'atteindre. La boucle continue jusqu'à ce qu'une condition d'arrêt réelle soit remplie.
L'agent oublie entre les exécutions. La boucle, non.
Ce simple fait est toute l'architecture.
C'est ce que Boris voulait dire quand il a dit que son métier était d'écrire des boucles. Il a arrêté de taper des instructions une par une. Il a construit des systèmes qui envoient les instructions à sa place, lisent les résultats et décident de la suite.
Pour le codage, cela change la façon dont les logiciels sont livrés.
Pour le trading, cela change tout.
Parce qu'aucun quant n'a jamais gagné de l'argent en tapant une instruction et en s'en allant. L'avantage vient du fait d'exécuter le même cycle des milliers de fois, de s'améliorer de un pour cent à chaque itération, et de ne jamais dormir.
C'est exactement ce que fait une boucle.
Si tu tapes encore des instructions dans Claude, un trade à la fois, tu fais ce que Boris a arrêté de faire il y a deux ans. Le point de levier a monté d'un cran. Tu n'écris plus de meilleures instructions. Tu écris le système qui écrit les instructions.
La différence entre l'interrogation et l'ingénierie des boucles
Partie 2 : Les six éléments qui font fonctionner chaque boucle
Une boucle fonctionnelle est construite à partir de six parties. Si tu en rates une, la boucle se casse silencieusement.
1. L'automatisation.
C'est le battement de cœur. Un planning cron, un webhook, une commande /loop, ou un hook dans Claude Code qui se déclenche sans que tu tapes.
Il y a deux variantes qui valent la peine d'être connues. /loop se relance à une cadence, quel que soit l'état. /goal continue jusqu'à ce qu'une condition vérifiable que tu as écrite soit réellement vraie, avec un modèle petit et séparé qui évalue si le travail est terminé.
En trading, /loop correspond à ta récupération de données chaque minute. /goal correspond à « continue d'itérer sur ce signal jusqu'à ce que le Sharpe du backtest soit supérieur à 1,5 ».
2. La compétence.
Une compétence est un manuel de procédures que l'agent lit au lieu de recevoir des instructions depuis le début à chaque session.
Elle se trouve dans un fichier SKILL.md. Elle contient tes conventions, tes règles, ton « on ne fait pas comme ça à cause de cet incident ».
Sans compétences, chaque exécution de boucle part de zéro. Avec des compétences, l'intention s'accumule.
3. Le fichier d'état.
Un fichier Markdown. Généralement appelé STATE.md ou PROGRESS.md.
Il survit entre les exécutions. L'agent oublie. Le fichier, non.
L'agent le lit au début de chaque exécution. Il écrit ce qui s'est passé à la fin.
Cela a l'air trop idiot pour avoir de l'importance. C'est en fait l'épine dorsale de toute boucle fonctionnelle.
4. Le vérificateur.
L'agent qui a écrit le code est le pire juge possible pour savoir si le code est correct.
Applique cela au trading. L'agent qui a généré le signal est le pire juge possible pour savoir si le signal est un véritable alpha ou du bruit.
Tu as besoin d'un agent séparé, avec des instructions différentes, idéalement un modèle différent, dont le seul travail est de vérifier le travail.
C'est le modèle « maker checker ». Chaque bureau de prop trading à Wall Street est structuré ainsi en interne. Chez Jane Street, le trader qui propose un trade n'approuve pas le trade. Chez Citadel, le chercheur qui construit le modèle ne valide pas le modèle.
5. Les worktrees.
Dès que tu exécutes plus d'un agent sur les mêmes fichiers, ils commencent à entrer en collision.
Les Git worktrees donnent à chaque agent son propre répertoire de travail isolé, pointant vers sa propre branche.
En trading, cela te permet d'exécuter la recherche de signaux, le backtesting et la surveillance des risques en parallèle, sans jamais empiéter les uns sur les autres.
6. Les connecteurs.
Une boucle qui ne peut que lire des fichiers est une petite boucle.
Les connecteurs construits sur le Model Context Protocol permettent à la boucle d'appeler une API de broker, d'interroger une base de données, de poster sur Slack, d'envoyer des ordres à la bourse.
C'est la différence entre une boucle qui suggère des trades et une boucle qui les exécute réellement.
Ces six éléments sont universels. Ils apparaissent dans Claude Code. Ils apparaissent dans Codex. Ils apparaissent dans chaque système agentique fonctionnel sur la planète.
Maintenant, laisse-moi te montrer comment les câbler ensemble dans un système de trading complet.
Partie 3 : Comment construire une boucle de trading quantitatif auto-améliorante
La boucle de trading quantitatif comporte cinq étapes. Chaque étape est sa propre sous-boucle, avec sa propre compétence, son propre fichier d'état et son propre vérificateur.
Première étape. L'ingestion de données.
Une automatisation se déclenche chaque minute, chaque heure ou chaque jour selon la classe d'actifs.
1@loop(interval="1h")2def ingest_data():3 data = fetch_market_data(symbols=universe, lookback="30d")4 state.write("latest_data.parquet", data)
Les données vont dans un fichier d'état partagé que l'étape suivante lit.
Deuxième étape. La génération de signaux.
C'est là que la recherche d'alpha se produit.
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)
L'agent de génération de signaux lit un fichier SKILL.md qui contient tes règles de recherche d'alpha.
1# alpha_research_skill.md23## Objectif4Générer des signaux en utilisant une régression linéaire sur les 30 derniers jours5de données de prix et de volume.67## Règles8- Le ratio de Sharpe doit être supérieur à 1,5 dans 3 des 5 derniers backtests9- La taille de position est limitée à 2 pour cent du capital par signal10- Ignorer les signaux les jours d'annonce du FOMC11- Ignorer les signaux 48 heures avant les publications de résultats1213## Leçons apprises14- 2026-02-14 : Perte de 4,2 pour cent pendant la semaine des résultats.15 Nouvelle règle : ignorer tout signal 48 heures avant les résultats.16- 2026-03-08 : Un dépassement de l'exposition sectorielle a causé un drawdown de 6 pour cent.17 Nouvelle règle : plafonner l'exposition sectorielle à 30 pour cent.18- 2026-04-22 : Un signal de momentum a explosé le jour du FOMC.19 Nouvelle règle : tuer tous les signaux de momentum les jours du FOMC.
La compétence grandit avec le temps. Chaque perte écrit une nouvelle leçon. Chaque leçon devient une nouvelle règle pour la prochaine exécution.
C'est ce qui rend le système auto-améliorant.
Troisième étape. La vérification.
Le signal va à un agent complètement séparé. Modèle différent. Instructions différentes. Aucune exposition à la façon dont le signal original a été raisonné.
1@checker2def verify_signal(signal):3 result = claude.invoke(4 skill="backtest_verification_skill.md",5 signal=signal,6 rules=[7 "Ratio de Sharpe supérieur à 1,5",8 "Drawdown maximal inférieur à 10 pour cent",9 "t-stat de Newey-West supérieur à 2,0",10 "Période hors échantillon d'au moins 2 ans"11 ]12 )13 return result.verdict
Si la vérification échoue, le signal est tué. S'il réussit, il passe à l'exécution.
Le vérificateur ne voit jamais ce que le créateur a raisonné. Cette séparation est tout l'avantage.
Tu peux aussi utiliser un modèle plus fort pour le vérificateur que pour le créateur. Claude Opus pour la vérification, Claude Sonnet pour la génération. Des architectures de modèles différentes attrapent différents types d'erreurs. C'est la même logique que les méthodes d'ensemble utilisent en apprentissage automatique.
La division créateur-vérificateur
Quatrième étape. L'exécution.
Seuls les signaux vérifiés atteignent cette étape.
1@auto_mode2def execute(signal):3 if verify_signal(signal):4 broker.send_orders(signal, max_position=0.02)5 state.write("active_trades", signal)
Le connecteur MCP gère l'API du broker. La boucle ne demande jamais la permission. Le mode auto lui permet de fonctionner sans intervention.
Cinquième étape. La surveillance des risques.
Exécutée en continu dans un worktree parallèle.
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.")
C'est l'interrupteur d'arrêt. Il impose les règles sans négociation.
Ensemble, ces cinq sous-boucles forment un système auto-exécutant.
Les données entrent. Les signaux sont générés. Les signaux sont vérifiés. Les signaux vérifiés sont exécutés. Les risques sont surveillés. Les leçons sont réécrites dans la mémoire.
Puis cela recommence.
Comment la boucle cumule
Je l'ai conçu une fois. Je n'ai plus fait aucune de ces étapes manuellement depuis.
C'est ça, l'ingénierie des boucles. C'est ce que Boris voulait dire quand il a dit que son métier était d'écrire des boucles.
Un avertissement. Une boucle sans véritable condition d'arrêt échoue silencieusement. L'agent émet un signal de complétion en croyant que le travail à moitié fait est terminé. La boucle se ferme. Le mauvais trade reste ouvert.
Tes conditions d'arrêt doivent pouvoir être vérifiées par autre chose que la propre affirmation de l'agent. « Sharpe supérieur à 1,5 sur les 30 derniers trades. » « Drawdown inférieur à 5 pour cent. » « La suite de tests passe. » Jamais « l'agent dit que c'est fait ».
Dans mon article sur la théorie des jeux, j'ai expliqué pourquoi chaque trade est un mouvement stratégique dans un jeu multi-joueurs avec information imparfaite. Si tu l'as manqué, tu voudras le lire juste après celui-ci :
https://x.com/RohOnChain/status/2066178991892119820
La boucle est ce qui te permet de rester à cette table pour toujours sans t'épuiser.
Résumé
Le trading quantitatif est déjà une boucle. Chaque fonds de Wall Street la fait tourner. Ils ont juste besoin de centaines d'humains à l'intérieur.
L'ingénierie des boucles supprime les humains.
Six éléments composent chaque boucle fonctionnelle. Les automatisations lancent le battement de cœur. Les compétences contiennent la connaissance du projet. Les fichiers d'état contiennent la mémoire. Les vérificateurs notent la sortie. Les worktrees isolent le travail parallèle. Les connecteurs donnent des mains à la boucle dans le monde réel.
Câble-les autour du cycle de trading en cinq étapes et tu obtiens un système auto-améliorant qui effectue des recherches d'alpha, vérifie les signaux, exécute les trades et surveille les risques tout seul.
Le système devient plus intelligent à chaque cycle. Chaque perte écrit une nouvelle leçon. Chaque leçon devient une nouvelle règle. Après cent trades, le fichier de compétence est un document vivant. Après mille, il se rapproche d'une connaissance institutionnelle que rien de ce qu'un seul humain pourrait retenir.
Les fonds qui construiront cela en premier cumuleront pour la décennie à venir. Ceux qui interrogent encore seront laissés pour compte.
Alors voici la question à méditer.
Si l'ingénierie des boucles est la prochaine abstraction au-dessus de l'interrogation, et que le trading quantitatif est la boucle aux enjeux les plus élevés au monde, es-tu la personne qui tape encore des instructions un trade à la fois, ou es-tu l'architecte qui a conçu la boucle qui trade pour toi pendant que tu dors ?
Il n'y a pas de mauvaise réponse, mais il y en a des très révélatrices.
