système trading multi-agent IA architecture coûts backtest

Un système de trading multi-agent à base d’IA répartit une seule décision de trading entre plusieurs instances de grand modèle de langage, attribue un rôle à chaque instance et fusionne leurs sorties en un ordre unique. L’effect-type comprend un lecteur de nouvelles, un analyste fondamental, un analyste graphique, un vérificateur de risque et un agent gestionnaire qui arbitre. En juillet 2026, plusieurs frameworks open source de cette forme se trouvent dans le sujet algorithmic-trading sur GitHub, chacun avec quelques centaines d’étoiles. Cette page décrit l’architecture, sépare les preuves publiées des affirmations des README, et présente les données de marché sur les coûts que toute version de ce système doit couvrir.

Ce qu’est réellement un système de trading multi-agent à base d’IA

L’architecture est un comité avec un président. Chaque agent est un template de prompt, un flux de données et un schéma de sortie. L’agent nouvelles reçoit des titres et renvoie un label. L’agent fondamentaux reçoit des extraits de dépôts et renvoie un score. L’agent président reçoit ces labels et scores et renvoie un ordre.

Trois propriétés découlent de cette conception, et chacune mérite d’être nommée avant toute affirmation de performance.

Chaque agent partage généralement un seul modèle de base. Cinq prompts contre les mêmes poids produisent des opinions corrélées, donc un vote à cinq agents n’est pas cinq estimations indépendantes. Le cadre du comité suggère une diversification que l’implémentation n’offre pas.

Le système est un pipeline de texte autour d’une décision numérique. Le modèle lit des mots et émet un token. Le sizing de position, le type d’ordre, le placement du stop et la logique de sortie sont du code ordinaire en dessous, et la majeure partie de ce qui détermine le résultat réside dans ce code plutôt que dans les prompts.

Un aller-retour du comité prend des secondes. C’est réalisable pour un rééquilibrage hebdomadaire et sans intérêt à la vitesse intraday, où les teneurs de marché cotent et recotent en microsecondes.

Ce que la recherche soutient et ce qu’elle ne soutient pas

Les travaux publiés sur les modèles de langage en finance se divisent en trois affirmations de force très différente.

L’extraction et la classification sont l’affirmation forte. Les modèles labellisent le sentiment, extraient des chiffres des dépôts et compressent des documents longs avec une précision qui nécessitait un modèle sur mesure il y a quelques années. C’est mesurable sur du texte hors échantillon et ça tient.

La description de l’état du marché est l’affirmation mitigée. Les modèles rédigent des récits fluides d’un régime, et ces récits sont généralement cohérents avec les données présentées au modèle. Savoir si la description porte une information que le prix ne porte pas déjà est une question distincte, et les articles qui la testent soigneusement rapportent des effets faibles avec de larges barres d’erreur.

La rentabilité est l’affirmation faible. La plupart des README de dépôts rapportent un backtest plutôt qu’un historique de performance financé, et la distance entre une courbe d’equity in-sample et un compte réel est la distance la plus ancienne du trading quantitatif. Mettre un modèle de langage dans la boucle ne la raccourcit pas.

Le plancher de coût qu’un signal doit franchir

Chaque trade traverse un spread, et ce franchissement est le plancher qu’une stratégie franchit avant toute autre chose. Spread médian coté en heures régulières, du 22 au 26 juin 2026, pour six noms cotés aux États-Unis :

SELECT ticker,
       round(quantileExactIf(0.5)(toFloat64(ask_price - bid_price) / (toFloat64(ask_price + bid_price) / 2), bid_price > 0 AND ask_price > bid_price) * 10000, 2) AS spread_bps,
       round(2 * quantileExactIf(0.5)(toFloat64(ask_price - bid_price) / (toFloat64(ask_price + bid_price) / 2), bid_price > 0 AND ask_price > bid_price) * 10000, 2) AS round_trip_bps,
       round(count() / 1e6, 1) AS quote_updates_m
FROM global_markets.cache_stocks_quotes
WHERE ticker IN ('SPY', 'AAPL', 'MSFT', 'KO', 'F', 'RIOT')
  AND sip_timestamp >= toDateTime('2026-06-22 00:00:00')
  AND sip_timestamp < toDateTime('2026-06-27 00:00:00')
  AND (toHour(sip_timestamp) * 60 + toMinute(sip_timestamp)) BETWEEN 810 AND 1199
GROUP BY ticker
HAVING countIf(bid_price > 0 AND ask_price > bid_price) > 0
ORDER BY spread_bps

Un point de base est un centième de point de pourcentage. Le nom le plus serré du panel, SPY, a coté un spread médian de 0.27 points de base sur cette semaine. Le plus large, RIOT, a coté 7.09. Un aller-retour paie le spread deux fois, donc une entrée et une sortie sur le premier nom commencent 0.55 points de base en retard et la même paire sur le dernier nom commence 14.19 en retard. Un agent qui retourne son portefeuille deux fois par semaine paie ce péage environ cent fois par an, et le péage est facturé que l’appel soit juste ou faux. Ce qu’il en coûte pour trader une action détaille le reste de la facture.

Le bruit qu’un appel directionnel doit battre

Les appels directionnels sont notés par rapport à une distribution composée majoritairement de petits nombres. Chaque session SPY de l’année calendaire 2025, triée par la taille de son mouvement close-to-close :

WITH daily AS (
    SELECT toDate(toTimeZone(window_start, 'America/New_York')) AS d,
           argMax(close, window_start) AS close_px
    FROM global_markets.delayed_stocks_minute_aggs
    WHERE ticker = 'SPY'
      AND toDate(toTimeZone(window_start, 'America/New_York')) >= toDate('2025-01-01')
      AND toDate(toTimeZone(window_start, 'America/New_York')) <= toDate('2025-12-31')
      AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60
           + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959
    GROUP BY d
),
paired AS (
    SELECT d, close_px,
           any(close_px) OVER (ORDER BY d ASC ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING) AS prev_px
    FROM daily
),
rets AS (
    SELECT d, round(100 * (toFloat64(close_px) / toFloat64(prev_px) - 1), 3) AS ret_pct
    FROM paired
    WHERE prev_px > 0
)
SELECT multiIf(abs(ret_pct) < 0.25, 'under 0.25%',
               abs(ret_pct) < 0.5, '0.25 to 0.5%',
               abs(ret_pct) < 1.0, '0.5 to 1%',
               abs(ret_pct) < 2.0, '1 to 2%',
               '2% and up') AS move_bucket,
       count() AS sessions,
       round(100 * count() / sum(count()) OVER (), 1) AS pct_of_sessions
FROM rets
GROUP BY move_bucket
ORDER BY min(abs(ret_pct))

La moitié de l’année se situait à l’intérieur d’un demi pour cent. La bande under 0.25% contenait 24.9% des sessions et la bande 0.25 to 0.5% en contenait 24.1%. À l’autre extrémité, 13 sessions ont bougé de 2% and up, 5.2% de l’année.

Mettez cela à côté du panel de spread. Un point de base est 0,01 %. Un mouvement de session typique de 0,3 % est trente fois un spread serré et environ quatre fois le spread large. L’arithmétique laisse de la place pour un appel correct et patient, et très peu pour un appel rapide et marginal.

Où se situe réellement l’univers tradable

Les frameworks d’agents vantent une couverture, souvent des centaines de tickers scannés chaque matin. Le volume en dollars montre quelle partie de cette liste peut absorber de la taille. Chaque nom coté aux États-Unis ayant tradé pendant les heures régulières le 30 juin 2026, regroupé par son rang dans le volume en dollars de cette session :

WITH tv AS (
    SELECT ticker,
           sum(toFloat64(close) * toFloat64(volume)) AS dollar_volume
    FROM global_markets.delayed_stocks_minute_aggs
    WHERE toDate(toTimeZone(window_start, 'America/New_York')) = toDate('2026-06-30')
      AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60
           + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959
    GROUP BY ticker
    HAVING sum(toFloat64(close) * toFloat64(volume)) > 0
),
ranked AS (
    SELECT ticker, dollar_volume,
           row_number() OVER (ORDER BY dollar_volume DESC) AS rk
    FROM tv
)
SELECT multiIf(rk <= 10, 'top 10 names',
               rk <= 50, 'ranks 11 to 50',
               rk <= 200, 'ranks 51 to 200',
               rk <= 1000, 'ranks 201 to 1000',
               'ranks beyond 1000') AS liquidity_tier,
       count() AS tickers,
       round(sum(dollar_volume) / 1e9, 2) AS dollar_volume_bn,
       round(100 * sum(dollar_volume) / (SELECT sum(dollar_volume) FROM tv), 1) AS pct_of_dollar_volume
FROM ranked
GROUP BY liquidity_tier
ORDER BY min(rk)

Dix noms portaient 22.5% du volume en dollars de la session, environ 205.04 milliards de dollars. Les 40 suivants portaient 20.5%. À l’autre extrémité, 10966 noms classés au-delà de 1000 se partageaient 12.9% entre eux, environ 117.83 milliards de dollars répartis sur toute la queue.

La largeur est bon marché à annoncer et coûteuse à trader. Un comité qui classe trois mille noms consacre la majeure partie de son effort de classement dans cette queue, où le panel de spread ci-dessus est un coût réel plutôt qu’une erreur d’arrondi.

Pourquoi ces backtests flattent le système

La source unique la plus importante d’un backtest flatteur est le choix de la fenêtre. SPY par année calendaire, de 2016 à 2025, avec l’écart entre le plus haut et le plus bas cours de clôture de l’année :

WITH daily AS (
    SELECT toDate(toTimeZone(window_start, 'America/New_York')) AS d,
           argMax(close, window_start) AS close_px
    FROM global_markets.delayed_stocks_minute_aggs
    WHERE ticker = 'SPY'
      AND toDate(toTimeZone(window_start, 'America/New_York')) >= toDate('2016-01-01')
      AND toDate(toTimeZone(window_start, 'America/New_York')) <= toDate('2025-12-31')
      AND (toHour(toTimeZone(window_start, 'America/New_York')) * 60
           + toMinute(toTimeZone(window_start, 'America/New_York'))) BETWEEN 570 AND 959
    GROUP BY d
),
yr AS (
    SELECT toYear(d) AS year,
           argMin(close_px, d) AS first_close,
           argMax(close_px, d) AS last_close,
           max(close_px) AS high_close,
           min(close_px) AS low_close,
           count() AS sessions
    FROM daily
    GROUP BY year
)
SELECT year,
       sessions,
       round(100 * (toFloat64(last_close) / toFloat64(first_close) - 1), 1) AS price_return_pct,
       round(100 * (toFloat64(high_close) / toFloat64(low_close) - 1), 1) AS high_low_range_pct
FROM yr
ORDER BY year

Un système testé uniquement sur 2021, une année qui a clôturé 28.7% plus haut, hérite d’une tendance haussière. Le même système testé uniquement sur 2022, qui a clôturé -20%, hérite d’une tendance baissière. L’écart intra-année entre le plus haut et le plus bas cours de clôture a atteint 68% en 2020 et est resté au-dessus de 25.3% même dans les années plus calmes.

Quatre pièges se superposent au problème de la fenêtre, et l’un d’eux appartient uniquement aux modèles de langage.

• Anticipation via les données d’entraînement. Un modèle entraîné sur du texte jusqu’en 2025 a déjà lu comment un trade de 2023 s’est terminé. Un backtest sur 2023 pose une question dont le modèle connaît la réponse, et aucun brassage de la série de prix ne supprime cette connaissance.
• Survivorship dans la liste de tickers. Un univers assemblé à partir des cotations d’aujourd’hui omet les noms qui ont été radiés en cours de route.
• Hypothèses de remplissage. Un backtest qui remplit chaque ordre au midpoint efface l’intégralité du panel de coûts ci-dessus.
• Sélection sur les variantes de prompt. Vingt formulations de prompt essayées et la meilleure rapportée est le même surapprentissage qui a miné les paramètres bien avant l’existence des modèles de langage.

Où les agents de modèle de langage aident plausiblement

La version honnête du pitch est plus étroite que la version README et reste utile.

La lecture de volume est le gain le plus clair. Un agent qui parcourt chaque dépôt et chaque titre d’une watchlist pendant la nuit et renvoie un résumé structuré économise des heures d’attention humaine, et la sortie est vérifiable par rapport à la source.

Décrire un régime en langage clair est le deuxième. Un paragraphe quotidien sur la dispersion, la largeur et la volatilité, généré à partir des mêmes chiffres qu’un humain lirait, est un document de briefing utile même lorsqu’il ne porte aucune prévision.

La discipline de processus est le troisième. Un agent qui refuse un ordre enfreignant une limite de position déclarée, ou qui signale une stratégie sur le point de trader une date de résultats, applique des règles qu’un humain distrait ignore.

Aucun de ces trois points n’est un avantage sur le marché. Les trois sont du travail de recherche et d’exploitation, et c’est là que se situent les gains mesurables aujourd’hui. Un effet documenté comme l’anomalie de faible volatilité a nécessité de grands échantillons et des réplications hors échantillon répétées avant que quiconque ne le traite comme réel, et un nouveau framework d’agent rencontre la même barre ou ne la franchit pas. Manquer les meilleurs jours montre ce que coûte un changement fréquent à un détenteur de long terme.

La discipline que décrivent les praticiens

Les équipes qui font tourner ces systèmes en public ont tendance à décrire la même séquence. Test forward sur des simulations de remplissage pendant des mois plutôt que des jours, car un historique papier ne s’accumule qu’à la vitesse du temps réel. Conserver un segment hors échantillon que les prompts n’ont jamais vu. Logger chaque prompt, chaque réponse et chaque ordre, car un comité qui ne peut pas être rejoué ne peut pas être débogué. Sizer les positions avec des règles fixes qui se situent en dehors du modèle. Compter chaque coût des panels ci-dessus avant de qualifier un segment de rentable.

FAQ

Les systèmes de trading multi-agent à base d’IA gagnent-ils réellement de l’argent ?

Les preuves publiques sont minces. La plupart des projets open source publient un backtest plutôt qu’un historique réel audité, et les backtests de stratégies de modèle de langage portent un défaut spécifique : le modèle a été entraîné sur du texte qui décrit la période de test. Une courbe d’equity non auditée démontre le logiciel, pas un avantage.

Un comité d’agents LLM est-il meilleur qu’un seul modèle ?

Un comité réduit certaines erreurs de formatage et de parsing et ajoute de la structure à la sortie. Il n’ajoute pas d’information indépendante lorsque chaque agent interroge le même modèle de base sur les mêmes données sous-jacentes. Cinq opinions corrélées votent comme une seule opinion, avec une latence supplémentaire et un coût de token supplémentaire.

Un agent IA peut-il trader plus vite qu’un teneur de marché ?

Non. Un aller-retour de modèle de langage prend des secondes tandis que les systèmes de cotation professionnels opèrent en microsecondes sur du matériel colocalisé. Toute stratégie dont le profit dépend de la vitesse se situe en dehors de ce que ces systèmes peuvent faire, ce qui laisse les horizons de jours et de semaines comme le terrain plausible.

Quel est le plus grand piège de backtest spécifique aux agents de trading LLM ?

L’anticipation via les données d’entraînement. Les backtests conventionnels se protègent contre la fuite de prix futurs dans une décision, mais les poids d’un modèle encodent déjà les commentaires publiés sur la fenêtre de test. Les fenêtres walk-forward et les splits hors échantillon ne suppriment pas la connaissance cuite dans les poids, et le seul test propre est une période postérieure à la date de coupure de l’entraînement.

Combien de temps une période de paper-trading doit-elle durer ?

Le cadre utile est la taille de l’échantillon plutôt que la durée calendaire. Une stratégie qui trade chaque semaine produit environ cinquante observations par an, un petit échantillon pour toute affirmation d’un avantage. Les praticiens veulent généralement suffisamment de trades pour avoir vu un drawdown, pas seulement une bonne période.

Chaque panel de cette page est une requête stockée et versionnée sur des données de marché US réelles. Ouvrez n’importe quel panel pour lire le SQL derrière, ou exécutez le vôtre sur les mêmes tables sur le terminal Strasmore.