By Matt Connor · Multi-Agent AI Trading Systems: What Is Real
Multi-agent AI trading systems run LLM committees on a trade. See the architecture, the market costs a signal clears, and the backtest traps involved.
A multi-agent AI trading system splits one trading decision across several large language model instances, gives each instance a role, and merges their outputs into a single order. The usual roster is a news reader, a fundamentals analyst, a chart analyst, a risk checker, and a manager agent that arbitrates. As of July 2026, several open source frameworks of this shape sit in the algorithmic-trading topic on GitHub with a few hundred stars each. This page walks the architecture, separates the published evidence from the README claims, and puts market data on the costs any version of it has to clear.
What a multi-agent AI trading system actually is
The architecture is a committee with a chair. Each agent is a prompt template, a data feed, and an output schema. The news agent receives headlines and returns a label. The fundamentals agent receives filing extracts and returns a score. The chair agent receives those labels and scores and returns an order.
Three properties follow from that design, and each one is worth naming before any performance claim.
Every agent usually shares one base model. Five prompts against the same weights produce correlated opinions, so a five-agent vote is not five independent estimates. The committee framing suggests a diversification that the implementation does not provide.
The system is a text pipeline wrapped around a numeric decision. The model reads words and emits a token. Position sizing, order type, stop placement, and exit logic are ordinary code sitting underneath, and most of what determines the outcome lives in that code rather than in the prompts.
A committee round trip takes seconds. That is workable for a weekly rebalance and irrelevant at intraday speed, where market makers quote and requote in microseconds.
What the research supports and what it does not
Published work on language models in finance splits into three claims of very different strength.
Extraction and classification is the strong claim. Models label sentiment, pull figures out of filings, and compress long documents at an accuracy that needed a bespoke model a few years ago. It is measurable on held-out text and it holds up.
Description of market state is the mixed claim. Models write fluent accounts of a regime, and those accounts are usually consistent with the data the model was shown. Whether the description carries information the price does not already carry is a separate question, and the papers that test it carefully report small effects with wide error bars.
Profitability is the weak claim. Most repository READMEs report a backtest rather than a funded track record, and the distance between an in-sample equity curve and a live account is the oldest distance in quantitative trading. Putting a language model in the loop does not shorten it.
The cost floor a signal has to clear
Every trade crosses a spread, and that crossing is the floor a strategy clears before anything else. Median quoted spread over regular hours, June 22 to June 26, 2026, for six US-listed names:
The exact SQL behind every number
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_bpsA basis point is one hundredth of a percentage point. The tightest name in the panel, SPY, quoted a median spread of 0.27 basis points over that week. The widest, RIOT, quoted 7.09. A round trip pays the spread twice, so an entry and exit in the first name starts 0.55 basis points behind and the same pair in the last name starts 14.19 behind. An agent that turns its book over twice a week pays that toll about a hundred times a year, and the toll is charged whether the call was right or wrong. What it costs to trade a stock itemizes the rest of the bill.
The noise a directional call has to beat
Direction calls are graded against a distribution that is mostly small numbers. Every SPY session in calendar 2025, sorted by the size of its close-to-close move:
The exact SQL behind every number
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))Half the year sat inside half a percent. The under 0.25% band held 24.9% of sessions and the 0.25 to 0.5% band another 24.1%. At the other end, 13 sessions moved 2% and up, 5.2% of the year.
Hold that beside the spread panel. One basis point is 0.01%. A typical session move of 0.3% is thirty times a tight spread and roughly four times the wide one. The arithmetic leaves room for a patient, correct call and very little for a fast, marginal one.
Where the tradable universe actually sits
Agent frameworks advertise coverage, often hundreds of tickers scanned every morning. Dollar volume shows how much of that list can absorb size. Every US-listed name that traded during regular hours on June 30, 2026, grouped by its rank in that session's dollar volume:
The exact SQL behind every number
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)Ten names carried 22.5% of the session's dollar volume, about $205.04 billion. The next 40 carried 20.5%. At the other end, 10966 names ranked beyond 1000 shared 12.9% between them, roughly $117.83 billion spread across the whole tail.
Breadth is cheap to advertise and expensive to trade. A committee that ranks three thousand names spends most of its ranking effort in that tail, where the spread panel above is a real cost rather than a rounding error.
Why these backtests flatter the system
The largest single source of a flattering backtest is the choice of window. SPY by calendar year, 2016 through 2025, with the gap between the year's highest and lowest closing price alongside:
The exact SQL behind every number
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 yearA system tested only on 2021, a year that closed 28.7% higher, inherits a rising tape. The same system tested only on 2022, which closed -20%, inherits a falling one. The within-year gap between the highest and lowest close reached 68% in 2020 and stayed above 25.3% even in the calmer years.
Four traps sit on top of the window problem, and one of them belongs to language models alone.
- Lookahead through training data. A model trained on text through 2025 has already read how a 2023 trade turned out. A backtest over 2023 asks a question the model knows the answer to, and no shuffling of the price series removes that knowledge.
- Survivorship in the ticker list. A universe assembled from today's listings omits the names that delisted along the way.
- Fill assumptions. A backtest that fills every order at the midpoint erases the entire cost panel above.
- Selection over prompt variants. Twenty prompt phrasings tried and the best one reported is the same overfitting that plagued parameter sweeps long before language models existed.
Where language model agents plausibly help
The honest version of the pitch is narrower than the README version and still useful.
Reading volume is the clearest win. An agent that works through every filing and headline on a watchlist overnight and returns a structured summary saves hours of human attention, and the output is checkable against the source.
Describing a regime in plain language is the second. A daily paragraph on dispersion, breadth, and volatility, generated from the same numbers a human would read, is a useful briefing document even when it carries no forecast.
Process hygiene is the third. An agent that refuses an order breaching a stated position limit, or that flags a strategy about to trade an earnings date, enforces rules a distracted human skips.
None of those three is an edge in the market. All three are research and operations work, which is where the measurable gains sit today. A documented effect such as the low volatility anomaly took large samples and repeated out-of-sample replication before anyone treated it as real, and a new agent framework meets the same bar or it does not clear it. Missing the best days shows what frequent switching costs a long-horizon holder.
The discipline practitioners describe
Teams running these systems in public tend to describe the same sequence. Forward test on simulated fills for months rather than days, since a paper record accumulates only at the speed of real time. Keep an out-of-sample stretch the prompts never saw. Log every prompt, every response, and every order, since a committee that cannot be replayed cannot be debugged. Size positions with fixed rules that sit outside the model. Count every cost from the panels above before calling any stretch profitable.
FAQ
Do multi-agent AI trading systems actually make money?
The public evidence is thin. Most open source projects publish a backtest rather than an audited live record, and backtests of language model strategies carry a specific flaw: the model was trained on text that describes the test period. An unaudited equity curve demonstrates the software, not an edge.
Is a committee of LLM agents better than a single model?
A committee reduces some formatting and parsing errors and adds structure to the output. It does not add independent information when every agent queries the same base model over the same underlying data. Five correlated opinions vote as roughly one opinion, with extra latency and extra token cost attached.
Can an AI agent trade faster than a market maker?
No. A language model round trip runs in seconds while professional quoting systems operate in microseconds over co-located hardware. Any strategy whose profit depends on speed sits outside what these systems can do, which leaves horizons of days and weeks as the plausible ground.
What is the biggest backtest trap specific to LLM trading agents?
Training-data lookahead. Conventional backtests guard against future prices leaking into a decision, but a model's weights already encode published commentary about the test window. Walk-forward windows and out-of-sample splits do not remove knowledge baked into the weights, and the only clean test is a period after the training cutoff.
How long does a paper-trading period need to run?
The useful framing is sample size rather than calendar length. A strategy that trades weekly produces about fifty observations a year, a small sample for any claim about an edge. Practitioners generally want enough trades to have seen a drawdown, not just a good stretch.
Every panel on this page is a stored, versioned query over real US market data. Open any panel to read the SQL behind it, or run your own against the same tables on the Strasmore terminal.