TradingAgents - A Multi-Agent LLM Framework That Mirrors a Real Trading Firm

Recent posts on this site have covered the AI tooling layers — personal-assistant runtimes (OpenClaw / NanoClaw / Hermes), coding agent harnesses (Pi / Claude Code), orchestration (Paperclip / Symphony), workflow augmenters (Agent OS / OpenSpec).

TradingAgents is something different: a worked example of what those building blocks compose into when you apply them to a specific domain.

It’s an open-source, Apache-2.0 multi-agent framework that models a real trading firm — analysts debating with researchers, a trader making proposals, a risk team approving or rejecting — to produce a market analysis decision.

It’s not a trading bot. The README is unusually clear about that and it’s worth repeating up front.

“TradingAgents framework is designed for research purposes. Trading performance may vary based on many factors, including the chosen backbone language models, model temperature, trading periods, the quality of data, and other non-deterministic factors. It is not intended as financial, investment, or trading advice.”

What is TradingAgents?

TradingAgents is a research-grade multi-agent LLM framework from Tauric Research (Yijia Xiao, Edward Sun, Di Luo, Wei Wang at UCLA). The architecture mirrors a trading firm: a team of specialized LLM agents — fundamentals, sentiment, news, and technical analysts — feed reports into a structured bullish vs bearish debate, which feeds the trader, which feeds the risk team and ultimately the portfolio manager. Built on LangGraph, supports 15+ LLM providers including dual-region China endpoints and local Ollama.

TradingAgents on GitHub arXiv paper (2412.20138) Tauric Research

What makes it different

• 🏢 Trading-firm architecture — analysts → researchers (debate) → trader → risk team → portfolio manager. Each role is a separate agent with a specialized prompt
• 🥊 Bullish vs bearish debate — bullish and bearish researchers argue the analysts’ reports in configurable rounds before the trader sees a synthesis
• 🌐 15+ LLM providers — OpenAI, Anthropic, Google, xAI, DeepSeek, Qwen (international + China), GLM (international + China), MiniMax (global + China), OpenRouter, Ollama (local + remote), Azure OpenAI for enterprise
• 🇨🇳 Dual-region China LLM endpoints — qwen vs qwen-cn, glm vs glm-cn, minimax vs minimax-cn — unusual but necessary for users inside China or against China-region accounts
• 💸 Two-tier model config — deep_think_llm (frontier model for reasoning) vs quick_think_llm (cheap model for data fetch / summarization). The split is intentional; running everything on a frontier model is expensive
• 📈 Closed feedback loop — every completed decision is appended to ~/.tradingagents/memory/trading_memory.md; next run fetches the realised return (raw + alpha vs SPY), generates a reflection, injects recent decisions + cross-ticker lessons into the Portfolio Manager prompt
• 🔁 LangGraph checkpoint resume — opt-in via --checkpoint; crashed runs resume from the last successful step rather than restarting
• 📊 Backtrader integration — backtesting against historical data
• ⚖️ Apache 2.0 — fully open source, citable research

Where TradingAgents fits in the AI stack

Across recent posts we’ve mapped a five-layer stack of AI infrastructure. TradingAgents doesn’t sit in any of those layers — it’s the layer above them:

This is what the infrastructure is for. The personal assistants and coding agents we’ve covered are general-purpose tooling; TradingAgents is what happens when you pick one domain (financial analysis) and apply LangGraph + multi-agent debate + LLM model selection + persistent memory to that single use case at depth.

For self-hosters reading this site: TradingAgents is the kind of vertical application you can imagine running yourself, on your hardware, calling out to either commercial LLMs (OpenAI / Anthropic) or local models (Ollama). The framework architecture is also genuinely useful as a template for building your own multi-agent system in another domain — research, legal analysis, code review, anything that benefits from the analyst-debate-decider pattern.

How the Agents Compose

The team-of-agents pipeline:

                ┌─────────────────────────────────────────────────┐
                │                  Analyst Team                    │
                │  Fundamentals · Sentiment · News · Technical    │
                └────────────────────┬────────────────────────────┘
                                     │  reports
                                     ▼
                ┌─────────────────────────────────────────────────┐
                │       Researcher Team (configurable debate)      │
                │      Bullish researcher  ⟷  Bearish researcher  │
                └────────────────────┬────────────────────────────┘
                                     │
                                     ▼
                ┌─────────────────────────────────────────────────┐
                │                 Trader Agent                     │
                │  Composes analyst + research → trade proposal   │
                └────────────────────┬────────────────────────────┘
                                     │
                                     ▼
                ┌─────────────────────────────────────────────────┐
                │           Risk Management Team                   │
                │  Volatility, liquidity, exposure assessment     │
                └────────────────────┬────────────────────────────┘
                                     │
                                     ▼
                ┌─────────────────────────────────────────────────┐
                │              Portfolio Manager                   │
                │  Final approve / reject → simulated exchange     │
                └─────────────────────────────────────────────────┘

The four analysts each consume different data:

The researcher debate forces both bullish and bearish researchers to confront the strongest version of the opposite case before the trader takes over. This is the core design choice — you don’t just average analyst views, you make them argue.

The trader, risk team, and portfolio manager form the decision chain. The trader proposes, risk evaluates, the portfolio manager has final approve/reject authority. A successful run can land at “buy 200 NVDA” or at “no trade — risk team rejected.”

Self-Hosting TradingAgents

Native install (with conda)

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

conda create -n tradingagents python=3.13
conda activate tradingagents
pip install .

Then set your LLM provider’s API key:

export OPENAI_API_KEY=...        # or ANTHROPIC_API_KEY, GOOGLE_API_KEY, etc.
export ALPHA_VANTAGE_API_KEY=... # for market data

Launch the interactive CLI:

tradingagents          # interactive CLI

You’ll be prompted for ticker(s), analysis date, LLM provider, model selections, and research depth.

Docker

The simplest path — copy the env template, fill in your keys, run:

cp .env.example .env       # add your API keys here
docker compose run --rm tradingagents

For local-only execution with Ollama (no external API calls):

docker compose --profile ollama run --rm tradingagents-ollama

The Compose file uses Compose profiles so the Ollama service only spins up when you explicitly request the ollama profile — this prevents the (~5 GB) Ollama image being pulled by default.

Compose

services:
  tradingagents:
    build: .
    env_file:
      - .env
    volumes:
      - tradingagents_data:/home/appuser/.tradingagents
    tty: true
    stdin_open: true

  ollama:
    image: ollama/ollama:latest
    volumes:
      - ollama_data:/root/.ollama
    profiles:
      - ollama

  tradingagents-ollama:
    build: .
    env_file:
      - .env
    environment:
      - LLM_PROVIDER=ollama
    volumes:
      - tradingagents_data:/home/appuser/.tradingagents
    depends_on:
      - ollama
    tty: true
    stdin_open: true
    profiles:
      - ollama

volumes:
  tradingagents_data:
  ollama_data:

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-7"      # reasoning-heavy steps
config["quick_think_llm"]   = "claude-haiku-4-5"     # quick-pass nodes
config["max_debate_rounds"] = 2                       # bullish vs bearish

ta = TradingAgentsGraph(debug=True, config=config)
_, decision = ta.propagate("NVDA", "2026-01-15")
print(decision)

export OLLAMA_BASE_URL=http://gpu-box.local:11434/v1

tradingagents analyze --checkpoint           # enable for this run
tradingagents analyze --clear-checkpoints    # reset all before running

TradingAgents vs the Alternatives

This is a research framework, not a trading platform. Honest landscape:

The honest read:

• Pick TradingAgents if you want to research multi-agent LLM approaches to market analysis or want a template for building your own multi-agent vertical app
• Pick FinRL if you want reinforcement learning rather than LLM agents
• Pick Qlib if you want a production-grade quant platform (no LLMs, just classical ML)
• Don’t pick any of these for live trading without independent validation — the disclaimers are not boilerplate

Conclusion

TradingAgents is genuinely interesting in two ways: as a research artifact (the multi-agent debate architecture, the persistent decision-log feedback loop, the dual-region China LLM support, the structured analyst→researcher→trader→risk pipeline) and as a template for vertical multi-agent applications in domains other than finance. The fact that you can run the whole thing against local Ollama models means the architecture is studyable end-to-end without a cent of API spend.

For self-hosters interested in where multi-agent LLM systems are headed, this is one of the few open-source frameworks where you can read the prompts, see the LangGraph state machine, modify the analysts’ roles, and observe how the debate structure shapes the output. The Apache 2.0 license + arXiv paper + active monthly releases combine to make this the most accessible research-grade multi-agent framework currently shipping.

Related tools worth knowing:

• Anthropic Claude for Financial Services — the vendor-backed counterpart to TradingAgents: Anthropic’s official reference agents + skills + MCP connectors for FSI workflows. Opposite design philosophy (drafts work product for human review vs. makes trading decisions); same Apache 2.0 license. The two illustrate the open-research-vs-vendor-content pattern that’ll repeat across every vertical
• Trading-R1 — the same group’s successor work; terminal expected soon
• FinRL — RL-based, different paradigm
• Microsoft Qlib — production-grade quant platform, no LLMs
• LangGraph — the orchestration framework TradingAgents builds on
• Backtrader — the backtesting library TradingAgents uses