TradingAgents in 2026: The Multi-Agent LLM Trading Framework, Explained

1. What TradingAgents Is (and Why It’s Trending)

TradingAgents is an open-source Python framework from Tauric Research that models a trading firm with LLM agents: analysts gather evidence, researchers argue both sides, a trader proposes, a risk team pushes back and a portfolio manager signs off. It is built on LangGraph and accompanies the paper ‘TradingAgents: Multi-Agents LLM Financial Trading Framework’ by Yijia Xiao, Edward Sun, Di Luo and Wei Wang (arXiv 2412.20138), which arXiv lists as an oral at Multi-Agent AI in the Real World.

The momentum is real. On 26 October 2026 GitHub’s weekly trending page showed 2,461 new stars this week, and the API reported 115,476 stars and 22,204 forks. The release pace is just as fast: five releases between 18 September and 16 October 2026, from v0.5.0 to v0.7.0.

2. The Architecture in 4 Steps

The README’s diagram maps cleanly onto the wiring in tradingagents/graph/setup.py. This is what actually runs for one ticker on one date with the defaults: one debate round and one risk round.

3. Quickstart: v0.7.0 in Five Minutes

These are the README’s commands. You need Python 3.11 or later and an API key for one LLM provider; the defaults use OpenAI.

Install with uv (or pip)

git clone https://github.com/TauricResearch/TradingAgents.git
cd TradingAgents

# Python 3.11+ is required; the README's examples use 3.13
uv venv --python 3.13
source .venv/bin/activate        # Windows (PowerShell): .venv\Scripts\activate
uv pip install .                 # or plain: pip install .

cp .env.example .env             # add OPENAI_API_KEY (the default provider)

With the defaults, OPENAI_API_KEY is the only key you need. ALPHA_VANTAGE_API_KEY, FRED_API_KEY (free) and TYPESAFE_API_KEY (screens social posts with Jev) are optional. SEC EDGAR needs no key, but set SEC_EDGAR_USER_AGENT to your own name and email so SEC can reach you rather than the project.

Run it from the CLI: interactive, or headless for a scheduled job

# interactive: tickers, date, provider, research depth...
tradingagents

# headless (cron / Task Scheduler): flags + TRADINGAGENTS_* variables
export TRADINGAGENTS_LLM_PROVIDER=openai TRADINGAGENTS_QUICK_THINK_LLM=gpt-6-luna TRADINGAGENTS_DEEP_THINK_LLM=gpt-6-sol
export TRADINGAGENTS_OUTPUT_LANGUAGE=English TRADINGAGENTS_MAX_DEBATE_ROUNDS=1 TRADINGAGENTS_MAX_RISK_ROUNDS=1
tradingagents --ticker NVDA --date 2026-10-23 --analysts market,news,fundamentals --save --no-show

Each flag skips only its own question. Without a terminal, a missing answer stops the run before it starts and names the flag or variable to set, which makes it safe to schedule.

Or call it from Python

from tradingagents.graph.trading_graph import TradingAgentsGraph
from tradingagents.default_config import DEFAULT_CONFIG

config = DEFAULT_CONFIG.copy()
config["llm_provider"] = "openai"
config["deep_think_llm"] = "gpt-6-sol"     # Research Manager + Portfolio Manager
config["quick_think_llm"] = "gpt-6-luna"   # analysts, researchers, trader, risk debaters
config["max_debate_rounds"] = 1
config["max_risk_discuss_rounds"] = 1

ta = TradingAgentsGraph(selected_analysts=("market", "social", "news", "fundamentals"), config=config)
state, rating = ta.propagate("NVDA", "2026-10-23")
print(rating)                    # Buy / Overweight / Hold / Underweight / Sell, or REVIEW
ta.save_reports(state, "NVDA")   # Markdown + complete_report.html under results_dir

propagate() returns the final state and the rating. selected_analysts takes market, social (the Sentiment Analyst’s internal key), news and fundamentals; drop the ones you don’t need.

The repo’s own evaluation: a ticker × date grid

# CLI
tradingagents backtest NVDA,AAPL --start 2026-06-01 --end 2026-08-01 --every 7

# Python
from tradingagents.backtest import iter_grid, run_backtest, summarize

dates = iter_grid("2026-06-01", "2026-08-01", every_n_days=7)
result = run_backtest(["NVDA", "AAPL"], dates, config, selected_analysts=["market", "news"])
print(summarize(result).render())

Each cell is scored on realized alpha against the instrument’s regional benchmark (SPY for US tickers) over holding_period_days, 5 by default, grouped by rating. Since v0.7.0 a decision enters at the first close after its date, because a run reads news published after that day’s close. It tells you whether ratings point the right way. It doesn’t charge costs, size positions or compound a portfolio.

4. Data Vendors and Point-in-Time Plumbing

Much of the recent engineering went into the unglamorous part that decides whether a historical run is honest: what each agent may see on a past date. The defaults in default_config.py:

5. What the Paper’s Backtest Proves, and What It Doesn’t

The paper (v7) backtests from 1 January to 29 March 2024. Its text names Apple, Nvidia, Microsoft, Meta and Google; Table 1 reports AAPL, GOOGL and AMZN against buy-and-hold and four rule-based strategies (MACD, KDJ+RSI, ZMR and SMA). The backbones were gpt-4o-mini and gpt-4o as quick thinkers and o1-preview as the deep thinker. These are the TradingAgents rows:

To the authors’ credit, they flag the anomaly themselves. The highest Sharpe “exceeds our expected empirical range”, they attribute it to few pullbacks in that period, and they kept the test to three months because each prediction took 11 LLM calls and 20+ tool calls.

Data-path leakage is the other half. Since the paper, the maintainers have shipped look-ahead fixes in four releases: Alpha Vantage filtering (v0.3.1), FRED macro, social sentiment and the memory log (v0.4.0), point-in-time integrity across every dated path (v0.5.0) and scoring from the first close after each decision (v0.7.0). That’s what good maintainers do, and it also shows how easily an LLM pipeline leaks the future. I can’t tell from the paper which code produced Table 1, so I read its numbers as a demo, not as evidence.

To evaluate it yourself, apply the same discipline as for any strategy: point-in-time data, walk-forward splits, costs, and a deflated Sharpe that counts every configuration you tried. I walk through all of it in my backtest validation tutorial, and every prompt or model swap counts as a new trial.

6. What One Run Costs: Calls, Tokens, Dollars

Cost scales with LLM calls, and the graph makes them countable. From graph/setup.py and conditional_logic.py, one ticker-day works out like this:

LLM calls per ticker-day, read from the v0.7.0 graph

LLM calls for one ticker on one date (v0.7.0 graph)

  N =  Σ (r_a + 1)   market, news, fundamentals analysts   r_a = tool rounds used (cap: max_tool_rounds = 20)
     + 1             sentiment analyst                      fetches its sources first, no tool loop
     + 2·D           bull + bear turns                      D = max_debate_rounds (default 1)
     + 3·R           aggressive, conservative, neutral      R = max_risk_discuss_rounds (default 1)
     + 3             research manager, trader, portfolio manager
     + m             one reflection per past decision settled during the run

  defaults, one tool round per analyst: 6 + 1 + 2 + 3 + 3 = 15 calls
  deep tier = research manager + portfolio manager = 2 calls; quick tier = everything else

  cost = Σ_quick (tokens_in · 0.10 + tokens_out · 0.50) / 1M     gpt-6-luna, $ per 1M tokens
       + Σ_deep  (tokens_in · 2.00 + tokens_out · 10.00) / 1M    gpt-6-sol  (standard tier, ≤272K context)

So with defaults and one tool round per analyst you’re at 15 calls, and more whenever analysts take extra tool rounds. Two of them are deep-tier. At OpenAI’s standard prices for the README’s default models, GPT-6 Sol costs $2 / $10 per million input / output tokens and GPT-6 Luna $0.10 / $0.50, a 20× gap per token.

A worked example (the token sizes are my assumptions, not measurements)

# ASSUMED token sizes, not measurements: replace them with your own numbers
LUNA = (0.10, 0.50)    # $ per 1M tokens, input / output (OpenAI standard tier)
SOL = (2.00, 10.00)

def cost(calls, tokens_in, tokens_out, price):
    return calls * (tokens_in * price[0] + tokens_out * price[1]) / 1e6

quick = cost(18, 8_000, 1_000, LUNA)   # 18 quick calls, 8K in / 1K out each
deep = cost(2, 20_000, 3_000, SOL)     # 2 deep calls, 20K in / 3K out (reasoning tokens bill as output)
print("quick $%.3f + deep $%.3f = $%.2f per ticker-day" % (quick, deep, quick + deep))
# quick $0.023 + deep $0.140 = $0.16 per ticker-day

Under those assumptions one ticker-day costs about $0.16, and the two deep calls are roughly 85% of it. One ticker every session for a month (~21 sessions) is about $3.40; the paper’s grid (3 tickers × ~61 sessions) would be about $30. Your numbers will move with news volume, tool rounds and reasoning effort, so measure them.

Measure your real cost with the CLI’s own counter

from cli.stats_handler import StatsCallbackHandler   # the counter behind the CLI footer

stats = StatsCallbackHandler()
ta = TradingAgentsGraph(config=config, callbacks=[stats])
_, rating = ta.propagate("NVDA", "2026-10-23")
s = stats.get_stats()
print(rating, s["llm_calls"], s["tokens_in"], s["tokens_out"])   # both tiers summed

The interactive CLI footer already shows LLM calls, tool calls and tokens in and out. From Python, pass the same handler. It sums both tiers, so price the total at Sol rates for an upper bound and at Luna rates for a lower bound, or read your provider’s per-model usage.

7. Plugging In a Cheaper or Local Model

Swapping models is a config change. The README lists OpenAI, Google, Anthropic, xAI, DeepSeek, Qwen, GLM, MiniMax, Mistral, Kimi, Groq, NVIDIA NIM, OpenRouter, Azure OpenAI, AWS Bedrock, Ollama and any OpenAI-compatible server.

Three ways to go cheaper or local

# A) everything local with Ollama (default endpoint http://localhost:11434/v1)
#    first: ollama pull qwen3:latest && ollama pull glm-4.7-flash:latest
config["llm_provider"] = "ollama"
config["quick_think_llm"] = "qwen3:latest"
config["deep_think_llm"] = "glm-4.7-flash:latest"

# B) quick tier local, the two managers in the cloud (a provider per tier, v0.6.0+)
config["llm_provider"] = "openai"
config["deep_think_llm"] = "gpt-6-sol"
config["quick_think_provider"] = "ollama"
config["quick_think_llm"] = "qwen3:latest"

# C) any OpenAI-compatible server: vLLM, LM Studio, llama.cpp
config["llm_provider"] = "openai_compatible"
config["backend_url"] = "http://localhost:8000/v1"   # LM Studio: http://localhost:1234/v1
config["quick_think_llm"] = config["deep_think_llm"] = "<the model your server serves>"

The CLI’s Ollama suggestions are qwen3:latest (8B), gpt-oss:latest (20B) and glm-4.7-flash:latest (30B), and ‘Custom model ID’ accepts anything you’ve pulled. Set OLLAMA_BASE_URL for a remote ollama-serve. With Docker there’s a ready profile: docker compose --profile ollama run --rm tradingagents-ollama.

8. How I’d Paper-Trade It (My Suggestion, Not Part of the Repo)

The idea is simple. After each close, run the graph for a small fixed universe, map the five-tier rating to a target position with a rule written down before day one, and send market orders that Alpaca queues for the next session. Long-only keeps the first version simple.

A minimal Alpaca paper loop (alpaca-py)

# My sketch, not part of TradingAgents. Run it after the close; orders queue for the next session.
import os
from alpaca.trading.client import TradingClient
from alpaca.trading.requests import MarketOrderRequest
from alpaca.trading.enums import OrderSide, TimeInForce
from tradingagents.agents.rating import is_review

UNIVERSE = ("NVDA", "AAPL", "MSFT")   # examples, not picks
SLOT = 10                             # max shares per ticker in the paper account
TARGET = {"Buy": 1.0, "Overweight": 0.5, "Underweight": 0.0, "Sell": 0.0}   # long-only; Hold = no change

client = TradingClient(os.environ["APCA_API_KEY_ID"], os.environ["APCA_API_SECRET_KEY"], paper=True)
held = {p.symbol: int(float(p.qty)) for p in client.get_all_positions()}

def rebalance(ticker, rating):
    if is_review(rating) or rating not in TARGET:    # REVIEW or Hold: leave the position alone
        return
    delta = round(TARGET[rating] * SLOT) - held.get(ticker, 0)
    if delta:
        client.submit_order(order_data=MarketOrderRequest(
            symbol=ticker,
            qty=abs(delta),
            side=OrderSide.BUY if delta > 0 else OrderSide.SELL,
            time_in_force=TimeInForce.DAY,           # after the close: queued for the next trading day
        ))

for ticker in UNIVERSE:
    _, rating = ta.propagate(ticker, "2026-10-23")   # the session that just closed
    print(ticker, rating)                            # log it next to the report path
    rebalance(ticker, rating)

The mapping (Buy to a full slot, Overweight to half, Hold unchanged, Underweight and Sell to flat) is my arbitrary choice. What matters is fixing it before you start and never tuning it on the paper results. Alpaca queues DAY orders submitted after the close for the next trading day.

9. Use Cases Where It Shines

Where I think it earns its stars:

10. When NOT to Use It

And where I’d keep it away:

Conclusion

TradingAgents is one of the best open-source references I know for structuring LLM agents like a trading desk, and v0.7.0 takes point-in-time data far more seriously than most projects in this space. The architecture is worth studying even if you never trade its output.

The returns are a different story. The paper’s quarter is a demo, today’s default models have seen that quarter, and the repo’s own evaluation scores direction without costs. If you try it, run it forward on paper after the cutoffs, measure your real cost per ticker-day and hold it to the same bar as any other bot.

If you’re building the bot around it, start with my guide to building trading bots for the execution and risk side that a rating still needs.

Sources

• TauricResearch/TradingAgents on GitHub (README, v0.7.0)
• Xiao, Sun, Luo & Wang — TradingAgents: Multi-Agents LLM Financial Trading Framework (arXiv 2412.20138, v7)
• TradingAgents CHANGELOG (v0.3.1 to v0.7.0 look-ahead fixes)
• TradingAgents default_config.py (models, rounds, tool cap, data vendors)
• OpenAI API pricing (gpt-6-sol and gpt-6-luna, standard tier)
• OpenAI model page for GPT-6 Sol (knowledge cutoff; Luna’s page lists May 18, 2026)
• Alpaca — Paper Trading (what the simulation does not account for)
• Alpaca — Orders at Alpaca (time in force, orders after the close)