Model or dataset
TauricResearch/TradingAgents avatar
TauricResearch/TradingAgents

TradingAgents: A Multi-Agent LLM Framework for Simulated Trading Decisions

TradingAgents coordinates specialized language-model agents for market research, debate, risk review, and simulated trading decisions.

106,586 stars20,375 forksPythonApache-2.0

At a glance

What is it?
TradingAgents coordinates specialized LLM agents for market research, debate, and risk review, producing simulated trading decisions. This review covers its architecture, setup, limitations, and alternatives for engineers evaluating adoption.
Who is it for?
Adopt TradingAgents if you are a researcher or developer building LLM-agent pipelines for financial decision simulation and need a modular, multi-provider framework with debate and risk-review stages. Do not use it for live trading or as financial advice; the README explicitly states it is for research only.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 1 day ago.
What is it written in?
Mainly Python, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.

DEEP OPEN-SOURCE ANALYSIS

What TradingAgents Solves and Who It Is For

TradingAgents addresses a specific problem: how to structure multiple large language models so they can collectively reason about a trading decision without a single model hallucinating a confident answer. The repository implements a multi-agent framework that mirrors a trading firm's hierarchy, with analyst, researcher, trader, and risk-management roles. Each role is a specialized LLM prompt chain, and the agents interact through structured debates and report handoffs. The intended audience is researchers and developers building financial decision pipelines, not retail traders seeking signals. The README is explicit: the framework is designed for research purposes, and performance varies with backbone models, temperature, trading periods, and data quality. It is not intended as financial, investment, or trading advice. That boundary matters. If you want a production trading system, this is the wrong starting point. If you want to study how multi-agent LLM workflows behave in a simulated market, it fits.

Agent Roles and the Decision Pipeline

The framework decomposes a trading task into four teams. The Analyst Team contains four agents: Fundamentals Analyst, Sentiment Analyst, News Analyst, and Technical Analyst. Each reads a different data slice: financials, news and social chatter, macroeconomic events, and technical indicators like MACD and RSI. The Researcher Team then takes over, with bullish and bearish researchers who critically assess the analysts' insights through structured debates. The Trader Agent composes reports from analysts and researchers to decide timing and trade size. Finally, the Risk Management team evaluates volatility, liquidity, and other risk factors, and the Portfolio Manager approves or rejects the transaction. If approved, the order goes to a simulated exchange. This pipeline is not a single prompt; it is a sequence of role-specific LLM calls with data passed between stages. The v0.2.4 release notes mention structured-output agents for Research Manager, Trader, and Portfolio Manager, which means these stages now return typed data rather than free-form text. That is a concrete architectural improvement, reducing parsing errors in downstream stages.

Getting It Running: Installation and Configuration

Setup starts with cloning the repository and creating a Python 3.12 virtual environment. The README shows conda commands: conda create -n tradingagents python=3.12, then conda activate tradingagents, then pip install. inside the project directory. Docker is an alternative: copy.env.example to.env, add API keys, and run docker compose run --rm tradingagents. For local models with Ollama, there is a separate profile: docker compose --profile ollama run --rm tradingagents-ollama. The framework requires at least one LLM provider API key. The README lists export OPENAI_API_KEY=... and GOOGLE_API... (truncated), but v0.3.0 expanded the provider registry to include NVIDIA, Kimi, Groq, Mistral, Bedrock, and any OpenAI-compatible endpoint. Configuration is environment-variable driven, with TRADINGAGENTS_* variables for API-key auto-detection. The v0.3.1 release notes add a configurable LLM retry budget and Bedrock API-key auth. You must set at least one provider key before running any simulation. The exact CLI command is not shown in the README, but the Docker command implies a runnable entry point. Expect to configure data vendors as well; v0.3.0 mentions FRED and Polymarket data vendors alongside the existing Alpha Vantage integration.

Data Handling and Backtesting Fidelity

A critical aspect of any backtesting framework is preventing look-ahead bias, where future data leaks into past decisions. The v0.3.1 release notes specifically mention Alpha Vantage look-ahead filtering, which suggests earlier versions had a real risk of this bias. That is a notable admission. The v0.2.3 release notes also mention backtesting date fidelity, indicating the team has iterated on temporal correctness. For engineers, this means you cannot trust historical simulation results without verifying the data pipeline. The framework pulls live or historical data from vendors like Alpha Vantage, FRED, and Polymarket, and the LLM agents process that data in sequence. The Sentiment Analyst aggregates news headlines, StockTwits, and Reddit, which are inherently noisy and time-stamped. If you feed unsorted or misaligned data, the agents will produce decisions based on information that would not have been available at the simulated time. The v0.3.1 fix is a step toward correctness, but you should still audit your data sources and date ranges before relying on any backtest output.

Limitations and Failure Modes

The most obvious limitation is that TradingAgents is not a live trading system. The simulated exchange is just that: simulated. There is no broker integration mentioned in the README. Another limitation is the dependence on external LLM providers. The README warns that trading performance varies with the chosen backbone models, temperature, and other non-deterministic factors. That is not a disclaimer for legal cover; it is a technical reality. LLM outputs are probabilistic, and a debate between two agents can converge on a confident but wrong conclusion. The framework tries to mitigate this with a risk-management stage, but it cannot eliminate model hallucination. The v0.3.1 release notes mention graph-router crash-safety and checkpoint resume, which implies the pipeline can fail mid-run. If a provider times out or returns malformed output, the entire chain may break. The configurable retry budget helps, but it is a budget, not a guarantee. For a research tool, these are acceptable trade-offs. For a production system, they are disqualifying.

Alternatives and Different Approaches

A direct alternative is a single-agent approach where one LLM is prompted to perform all analysis and decision-making. That is simpler and cheaper, but it lacks the structured debate and risk-review stages that TradingAgents provides. Another alternative is a rule-based backtesting library like backtrader or vectorbt, which uses deterministic indicators and no LLM reasoning. The difference is fundamental: TradingAgents uses LLM agents to interpret data and make qualitative judgments, while rule-based libraries execute predefined strategies with no natural-language reasoning. There is also the sibling project Trading-R1, mentioned in the README as a technical report with a Terminal expected to land soon. That appears to be a reinforcement-learning-based approach, which would differ from the multi-agent prompt framework. For engineers who need deterministic, reproducible backtests, a rule-based library is the safer choice. For those exploring LLM-driven decision-making, TradingAgents offers a structured pipeline that rule-based tools cannot match.

Maintenance, Licensing, and Upgrade Cost

The project is actively maintained, with releases every few weeks. The last push was July 2026, and v0.3.1 came out the same day. The release notes show a pattern of adding new model support and provider integrations, which is good for longevity but also means you will need to track changes. The v0.2.4 release added LangGraph checkpoint resume and a persistent decision log, so you can resume interrupted runs. That reduces operational cost, but upgrading between versions may require adjusting configuration. The license is Apache-2.0, which permits commercial use, modification, and distribution with attribution. There is no copyleft obligation. However, the README includes a disclaimer that the framework is not financial advice, and the project's homepage points to a separate disclaimer page. That does not affect code licensing, but it signals the authors' intent to limit liability. For maintenance, expect to spend time on API key management and data vendor contracts. The v0.3.0 release mentions a verified data-access contract, which suggests the team is formalizing how data is fetched, but you should still review that contract before production use.

Editorial conclusion

Adopt TradingAgents if you are a researcher or developer building LLM-agent pipelines for financial decision simulation and need a modular, multi-provider framework with debate and risk-review stages. Do not use it for live trading or as financial advice; the README explicitly states it is for research only. Before adopting, verify the data-access contract in v0.3.0, confirm your chosen LLM provider's rate limits and retry budget, and review the look-ahead filtering for Alpha Vantage data to avoid backtest bias. Check the CHANGELOG for the latest correctness fixes, especially graph-router crash-safety and checkpoint resume, to ensure your workflow can recover from failures.

Official sources

  1. Official documentation
  2. Official README
  3. Project repository
  4. Release notes
Community notes

Community notes