LaunchedEditorial Listing

TradingAgents

Tauric Research · TradingAgents: Open-Source Multi-Agent LLM Framework for Trading Research

Open TradingAgents

TradingAgents is an open-source (Apache-2.0) Python framework from Tauric Research in which LLM agents play the roles of a trading firm, from analysts and bull and bear researchers to a trader, risk managers, and a portfolio manager, and debate their way to a trading decision on a ticker. It is built for researchers and technically minded investors studying multi-agent market analysis, not for live automated trading.

PricingFree
Setupmedium
Runs onSelf-hosted
Open sourceYes
Multi-AgentTrading ResearchOpen SourceLangGraphBacktestingPythonMarket Analysis

Best for

Researchers, students, and technically minded investors who want an open-source, extensible multi-agent framework for studying LLM-driven market analysis and backtesting it

Not ideal for

Anyone looking for investment advice or a hands-off trading bot, traders who need live brokerage execution, and non-technical users who do not want to manage Python environments and API keys

Who it's for

Quantitative researchers, students, and developers studying multi-agent LLM systems for financial market analysis

Capabilities

  • Role-based agent team: fundamentals, sentiment, news, and technical analysts, bull and bear researchers, a trader, a risk management team, and a portfolio manager
  • Structured bull-versus-bear debate with a configurable number of debate rounds
  • Interactive CLI for choosing tickers, analysis date, LLM provider, and research depth, plus a Python API (`TradingAgentsGraph.propagate`)
  • Works with any market Yahoo Finance covers using exchange-suffixed tickers, including crypto pairs such as BTC-USD
  • SEC EDGAR fundamentals served as filed for point-in-time historical runs, alongside Alpha Vantage, FRED, Polymarket, StockTwits, and Reddit data
  • Portfolio-aware runs that pass your cash and positions to the trader, risk analysts, and portfolio manager
  • Persistent decision log that reflects on realized returns and feeds lessons into later runs
  • Grid backtesting over tickers and dates, scored on realized alpha against each market's benchmark
  • Broad LLM provider support, including OpenAI, Anthropic, Google, xAI, DeepSeek, Qwen, GLM, Kimi, Groq, Bedrock, Azure, Ollama, and OpenAI-compatible servers
  • Docker Compose setup, including a profile for local models through Ollama, and opt-in LangGraph checkpoint resume

Limitations

  • The project states it is designed for research and is not financial, investment, or trading advice
  • No live brokerage integration is documented; approved orders go to a simulated exchange
  • Outputs are non-deterministic: the same ticker and date can produce different decisions, and backtest results are not guaranteed to match published figures
  • News, StockTwits, and Reddit inputs reflect the present even when you pin a historical analysis date
  • SEC EDGAR fundamentals cover only SEC filers, start in 2009, and report fourth quarters as unavailable rather than derived
  • Self-managed setup: you clone the repository, install it into a Python environment or run it with Docker, supply API keys for your LLM provider and some data vendors, and pay those providers directly. The `tradingagents` package on PyPI is a separate third-party fork, not the official release
  • Minor releases can break code that imports the package; v0.5.1 moved several module paths

Use cases

  • Running a multi-agent analysis of a stock or crypto pair on a specific date and reading each agent's report
  • Backtesting the agent pipeline over a grid of tickers and dates to study decision quality
  • Comparing how different LLM providers or debate settings change trading decisions
  • Passing a portfolio file so the agents reason about an existing position rather than a flat book
  • Using the codebase as a starting point for custom multi-agent financial research

Our take

TradingAgents applies role-based multi-agent reasoning to a concrete domain. The analyst, debate, trader, and risk structure is easy to inspect, and recent releases added point-in-time SEC fundamentals and grid backtesting, which reduce look-ahead bias when you evaluate it on past dates. It is still a research scaffold. Decisions vary from run to run, social and news data are not point-in-time, and there is no live execution. Treat it as a tool for studying and extending multi-agent financial analysis, not as a strategy to trade on.

Who should use it

Researchers and students studying multi-agent LLM systems in finance, developers who want a working reference architecture to extend, and technically minded investors who want to see structured, multi-perspective analysis of a ticker and backtest it.

Who should skip it

People who want investment advice or a turnkey trading bot, traders who need live order execution, and non-technical users unwilling to manage Python environments and API keys.

Strengths

  • Free and open source under Apache-2.0
  • Clear, inspectable role structure with bull-versus-bear debate and risk review
  • Works with many LLM providers, including local models through Ollama
  • Point-in-time SEC EDGAR fundamentals and grid backtesting for more honest historical evaluation
  • Active release cadence with detailed changelogs

Weaknesses

  • Research tool only, with no live brokerage execution documented
  • Non-deterministic outputs make results hard to reproduce exactly
  • Requires Python or Docker setup and paid LLM API usage
  • Import paths changed between minor releases

TradingAgents pricing

Open source

Free

  • Apache-2.0 license
  • CLI, Python package, and Docker setup
  • Bring your own LLM provider or local model

Note: The framework is free. Costs come from the LLM provider you connect and any paid data APIs, such as Alpha Vantage. SEC EDGAR and FRED data are free (FRED requires a free key).

Technical specs

Available models

GPT-6 Sol (default deep model)GPT-6 Luna (default quick model)ClaudeGeminiGrokDeepSeekQwenGLMKimiLocal models via Ollama

Where TradingAgents excels

Studying how LLM agents reason about a stock

Each run produces separate analyst, researcher, trader, and risk reports, so you can see how the final decision was built and where the agents disagreed.

Evaluating an agent pipeline on historical dates

Grid backtesting and SEC EDGAR fundamentals served as filed let you score decisions on realized alpha without leaking restated figures into past runs.

Comparing model providers on the same financial task

Provider and model settings are configuration options, so the same pipeline can run on OpenAI, Anthropic, open-weight, or local models for side-by-side comparison.

TradingAgents vs. competitors

TradingAgents vs. LangGraph

LangGraph is a general framework for building stateful agent graphs, and TradingAgents is built on it. Choose TradingAgents for a ready-made trading-firm pipeline with market data vendors and backtesting; choose LangGraph to design your own agent workflow from scratch.

TradingAgents vs. CrewAI

CrewAI is a general multi-agent framework for defining role-based crews for any task. TradingAgents is narrower: it ships a finance-specific team of analysts, researchers, trader, and risk managers with market data tools already wired in.

Frequently asked questions

What is TradingAgents?

TradingAgents is an open-source multi-agent LLM framework from Tauric Research that mirrors a trading firm. Analyst agents gather fundamentals, sentiment, news, and technical data, bull and bear researchers debate the findings, a trader proposes a decision, and a risk team and portfolio manager review it.

Is TradingAgents free?

Yes. The code is free and licensed under Apache-2.0. You pay for the LLM provider you connect (or run local models through Ollama) and for any paid data APIs you choose to use.

Can TradingAgents trade with real money?

No live brokerage integration is documented. Approved orders go to a simulated exchange, and the project states that it is designed for research and is not financial, investment, or trading advice.

Which LLMs does TradingAgents support?

It supports OpenAI, Anthropic, Google, xAI, DeepSeek, Qwen, GLM, MiniMax, Kimi, Mistral, Groq, NVIDIA NIM, OpenRouter, Azure OpenAI, AWS Bedrock, Ollama, and any OpenAI-compatible server such as vLLM or LM Studio. As of v0.5.1 the defaults are GPT-6 Sol for deep reasoning and GPT-6 Luna for quick tasks.

Can I backtest TradingAgents?

Yes. `run_backtest` (or `tradingagents backtest` in the CLI) runs the pipeline over a grid of tickers and dates and scores decisions on realized alpha against each market's benchmark. Results vary between runs because the agents are LLM-driven.

Integrations & fit

LangGraphYahoo FinanceSEC EDGARAlpha VantageFREDPolymarketStockTwitsRedditOllamaAWS BedrockAzure OpenAIOpenRouter
Good fit forSolo / individual, Startup / small team
Pricing modelFree· No cost to start
See pricing on TradingAgents →

Alternatives to consider

About TradingAgents

TradingAgents runs a LangGraph pipeline modeled on a trading firm. Four analysts gather information in parallel: fundamentals, sentiment (news headlines, StockTwits, and Reddit), news and macro, and technical indicators such as MACD and RSI. Bullish and bearish researchers then debate the findings. A trader agent proposes a decision, a risk management team assesses it, and a portfolio manager approves or rejects it, with approved orders sent to a simulated exchange. You run it from an interactive CLI (`tradingagents`), through Docker, or in Python by creating a `TradingAgentsGraph` and calling `propagate(ticker, date)`. It works with any market Yahoo Finance covers, including US, Hong Kong, Tokyo, London, India, and China A-share tickers and crypto pairs. Other data vendors include Alpha Vantage, FRED macro data, Polymarket, and, since v0.5.0, SEC EDGAR fundamentals served as filed, so a historical run sees statements as they stood on that date. The framework supports many LLM providers, including OpenAI, Anthropic, Google, xAI, DeepSeek, Qwen, GLM, MiniMax, Kimi, Mistral, Groq, NVIDIA NIM, OpenRouter, Azure OpenAI, AWS Bedrock, Ollama, and any OpenAI-compatible server, and it uses separate deep-thinking and quick-thinking models (GPT-6 Sol and GPT-6 Luna by default). Recent releases added portfolio-aware runs that reason against your actual holdings, a decision log that reflects on realized returns in later runs, checkpoint resume, and grid backtesting scored on realized alpha against each market's benchmark. The project says plainly that it is designed for research and is not financial, investment, or trading advice. Runs are non-deterministic, news and social inputs reflect the present even for historical dates, and backtest results are not guaranteed to match published figures. It is most useful to people who want to study or extend multi-agent financial reasoning and are comfortable managing Python environments and API keys.

Updates from TradingAgents

New FeatureTradingAgents v0.5.1 reorganizes the package and switches default models

v0.5.1 reorganized the package layout (old import paths are gone), added optional TypeSafe Jev screening of StockTwits and Reddit posts, made GPT-6 Sol and GPT-6 Luna the default deep and quick models, and fixed run isolation and SEC EDGAR statements.

New FeatureTradingAgents v0.5.0 adds backtesting and point-in-time fundamentals

v0.5.0 added point-in-time integrity across dated data paths, SEC EDGAR fundamentals served as filed, backtesting over a grid of tickers and dates, and portfolio-aware runs.

Are you the founder? Claim this listing →