TauricResearch/TradingAgents
TradingAgents: Multi-Agents LLM Financial Trading Framework
Bull and bear agents argue every trade before a risk team gets final veto power.
Turn what you learned into a concrete stack decision.
Want the shortlist in your inbox?
Subscribe for the weekly brief that turns new AI noise into the few tools and workflows worth testing.
TradingAgents: Multi-Agents LLM Financial Trading Framework
Most crypto trading bots are one prompt wearing a trench coat. Feed it price data, get a buy/sell/hold back, done. No pushback, no second opinion, no one in the room asking "wait, why do we think this."
TradingAgents does something different: it builds an actual trading desk out of LLM agents. A bull researcher and a bear researcher argue the same setup from opposite sides. A trader agent has to synthesize that argument into a position. Then a separate risk team — three more agents arguing risky, neutral, and conservative angles — gets to veto the whole thing before anything ships. It's open source (Apache 2.0) from Tauric Research, built on LangGraph, and it works on any ticker Yahoo Finance covers, including crypto pairs like BTC-USD.
The interesting question isn't whether this is clever architecture — it obviously is. It's whether forcing a debate actually catches bad trades, or just adds latency and API spend to the same bad call two agents talked each other into.
TradingAgents runs four agent layers per decision, in order:
Analyst team (parallel, no debate). A Fundamentals Analyst reads financials, a Sentiment Analyst scrapes news/StockTwits/Reddit, a News Analyst tracks macro events, and a Technical Analyst runs MACD/RSI-style indicators. Each produces an independent report — no argument yet, just data gathering.
Researcher team (this is the debate). A Bull Researcher and a Bear Researcher each get all four analyst reports and have to build the strongest possible case for their side, then rebut each other for max_debate_rounds rounds (default config runs 1-2). A Research Manager reads the transcript and calls a winner.
Trader agent. Takes the debate outcome and analyst data, and proposes a concrete position — direction and sizing rationale, not just a stance.
Risk management team + Portfolio Manager. Three more agents (Risky, Neutral, Conservative) argue over whether the trader's proposal survives contact with actual risk — volatility, liquidity, portfolio concentration. The Portfolio Manager reads that debate and gives the final approve/reject.
That's potentially 10+ LLM calls for one decision on one asset. This is the first thing to internalize: TradingAgents is not fast, and it's not built to be.
Here's what an actual run looks like, using the Python API instead of the interactive CLI:
from tradingagents.graph.trading_graph import TradingAgentsGraph
from tradingagents.default_config import DEFAULT_CONFIG
config = DEFAULT_CONFIG.copy()
config["llm_provider"] = "anthropic"
config["deep_think_llm"] = "claude-opus-4-8" # researcher debate + risk debate
config["quick_think_llm"] = "claude-haiku-4-5" # analyst reports (cheap, parallel)
config["max_debate_rounds"] = 2
config["max_risk_discuss_rounds"] = 1
config["online_tools"] = True # pull live data, not cached
ta = TradingAgentsGraph(debug=True, config=config)
state, decision = ta.propagate("BTC-USD", "2026-07-10")
print(decision)
Walking through what happens on that call: the four analysts run first and hand back independent reads — say the Technical Analyst flags an RSI near overbought on the 4H chart, while the Sentiment Analyst reports a spike in bullish Reddit chatter around a recent ETF inflow headline. That's already a tension the analysts didn't resolve — which is exactly what the debate layer exists to sort out.
Round 1: the Bull Researcher leans on the sentiment and inflow data, argues momentum continuation. The Bear Researcher leans on the overbought RSI and points out sentiment spikes are a lagging, crowd-following signal, not a leading one. Round 2 (since max_debate_rounds=2): both sides get to rebut. The Research Manager reads the full transcript and rules bear-leaning, given the technical setup is stretched.
The Trader agent takes that and proposes a small long-side entry anyway, betting the sentiment tailwind outweighs the RSI reading over a short horizon, with a modest size to reflect the disagreement. Then the risk team debates: the Conservative agent flags that a mixed 2-1-ish research verdict shouldn't get anything more than minimum size, the Risky agent argues the tailwind is real and sizing should be closer to normal. The Portfolio Manager reads that and approves a reduced-size long, explicitly citing the split verdict as the reason for cutting size rather than rejecting outright.
You get back a decision object with the position, sizing rationale, and — if you set debug=True — the full agent transcript so you can see exactly which argument won and why. Nothing here places an order. You're reading a reasoned recommendation, not triggering an execution.
Both, honestly, depending on the setup. Where it earns its keep: setups where analyst signals genuinely conflict, like the RSI-vs-sentiment example above. Forcing a bear case into existence stops a single-pass bot from just running with whatever signal it saw first. That's a real, defensible improvement over "one prompt, one opinion."
Where it doesn't help: when all four analysts already agree. If fundamentals, sentiment, news, and technicals all point the same direction, the bull and bear researchers are debating from a position where one side has almost nothing to work with, and the "debate" becomes theater — two agents performing disagreement on a call that was never close. You paid for 10+ extra LLM calls to arrive where a single well-built analyst pass would've landed anyway.
The failure mode Jet's original question points at — two agents debating their way into agreeing on the same bad call — does happen, and it's structural, not a bug you can config away. If the underlying analyst data is wrong or stale (a delayed sentiment feed, thin liquidity data on an obscure altcoin), both researchers are debating from the same bad premise. Debate improves reasoning quality on top of the inputs; it does not audit the inputs.
| | TradingAgents | Single-prompt bot | |---|---|---| | Decision quality on conflicting signals | Better — forces the counter-case | Whatever the model latched onto first | | Latency per decision | Slow — 10+ sequential/parallel LLM calls | Fast — one call | | Cost per decision | High, scales with debate rounds | Low, fixed | | Good for high-frequency/scalping | No | Yes, if it's good at all | | Good for deliberate entries (swing, position sizing) | Yes | Risky without a second check | | Live execution built in | No — outputs a decision, you wire the broker/exchange | Depends on the bot | | Auditable reasoning trail | Yes, full transcript per agent | Rarely |
If you're scalping or running anything that needs a decision in under a second, skip this — the debate overhead alone makes it unusable. If you're sizing a position you'll hold for hours or days and want a documented reason a human can review before hitting send, this is a legitimately better shape than a single-call bot.
Wiring the output straight to a live exchange API. TradingAgents doesn't place trades — it returns a decision object. Treating the Portfolio Manager's approval as a trade execution signal skips the human review step the framework's own disclaimer assumes exists.
Running full debate rounds on every tick. This is a research/deliberation tool, not a real-time signal generator. Running max_debate_rounds=3 on a 1-minute loop just burns API budget for decisions that are stale before the risk team finishes arguing.
Using the same model for deep_think_llm and quick_think_llm. The analyst layer runs in parallel and doesn't need your most expensive model — that's what quick_think_llm is for. Running everything on a top-tier reasoning model multiplies cost for no quality gain on the analyst pass.
Treating a clean debate transcript as validated alpha. A coherent bull/bear argument that ends in consensus is a well-reasoned narrative, not a backtested edge. It hasn't been checked against what actually happened to the price afterward — that's on you to track separately.
No. It outputs a structured decision (direction, sizing rationale, reasoning transcript) via ta.propagate(). You have to write the integration to an actual exchange or broker API yourself, and the project's own disclaimer states it isn't financial or trading advice.
It depends entirely on your model choices and max_debate_rounds, but budget for 10+ LLM calls per single-asset decision (4 analysts + debate rounds + trader + 3 risk agents + portfolio manager). Using a cheaper model for quick_think_llm on the analyst layer and reserving a stronger model for the debate/risk layers keeps this reasonable.
It works on any Yahoo Finance ticker, which includes crypto pairs like BTC-USD. Just know that sentiment and fundamentals data thin out fast once you go past major-cap coins — the framework's data quality is only as good as what's available for that asset.
→ Ask the index what to build your multi agent debate stack
→ Free credits for these tools
Written by McKlaud AI. Want to know which AI tools actually fit your business? Get a free AI audit.