TradingAgents is a multi-agent LLM trading framework open source project that has quietly become one of the most-starred repositories on GitHub, with more than 117,000 stars and 22,000 forks. It does not promise to make you rich. Instead, it does something more interesting: it recreates the structure of a real trading firm inside software, with specialist analyst agents, a bull-versus-bear debate, a trader, and a risk team, all arguing about a single ticker before any decision is made. If you build software, advise clients on AI, or research trading systems, this is the project that best shows what multi-agent AI actually looks like when it is applied to a hard, adversarial domain.
This deep-dive explains what TradingAgents is, how its agent teams work, how to run it yourself, why it caught fire in 2026, and — just as importantly — where its limits are. It is a research framework, not a money machine, and understanding that distinction is the whole point.
Inside this multi-agent LLM trading framework open source project
TradingAgents comes from Tauric Research on GitHub, where it is published under the Apache 2.0 licence in Python. The accompanying research paper, published on arXiv, describes a framework that mirrors the dynamics of a real trading firm: specialised LLM-powered agents evaluate market conditions from different angles, debate each other, and only then arrive at a trading decision. The project is actively maintained — version 0.7.1 landed in October 2026 — and its recent releases read like a changelog of hard-won research lessons: decisions scored only on final closes, fixes for model dates that could read filings published after the run date, and backtests that see only data published by each analysis date.
That last point matters more than it sounds. Most amateur backtests leak future information into past decisions, which makes strategies look far better than they are. TradingAgents treats point-in-time integrity as a first-class feature: its data paths are filtered so a simulated decision on a given date can only use information that actually existed on that date. If you have ever wondered why a backtest looks brilliant and live trading disappoints, look-ahead bias is usually the culprit, and this framework is built to avoid it.
The analyst team: four specialists, no generalists
Every run starts with the Analyst Team, and the design choice here is deliberate: four agents, each with its own tools and its own brief, working in parallel.
- Fundamentals Analyst — evaluates company financials and performance metrics, looking for intrinsic value and red flags in the numbers.
- Sentiment Analyst — aggregates news headlines, social chatter and community discussion into a single read on short-term market mood.
- News Analyst — monitors global news and macroeconomic indicators, interpreting how events move market conditions.
- Technical Analyst — works with indicators such as MACD and RSI to detect patterns and forecast price movement.
The analysts work simultaneously, each on its own tools, and the research debate only starts once all of their reports are in. Splitting them means each report is checkable, and when a decision goes wrong, you can trace it back to the analyst whose read was off.
The debate: bull versus bear before any trade
Once the analysts report, the Researcher Team takes over — and this is the part of TradingAgents that most single-agent tools skip entirely. Bullish and bearish researchers critically assess the analysts’ insights through structured debate, balancing potential gains against inherent risks. The bull must argue the upside case with evidence; the bear must attack it. Neither side is decorative. The debate exists because a trading decision that has never survived an attack is not a decision, it is a hunch with formatting.
For business readers, this is the transferable idea. Most AI products in 2026 give you one confident answer. TradingAgents gives you an argument, with the dissent included. A system that can articulate the case against its own recommendation is far more useful than one that merely sounds sure of itself.
Trader, risk manager, portfolio manager: the decision chain
After the debate, the Trader Agent composes the analysts’ and researchers’ reports into a concrete trading decision: timing and magnitude. But the decision is not final yet. The Risk Management team continuously evaluates portfolio risk — volatility, liquidity and other risk factors — and produces an assessment report for the Portfolio Manager, who approves or rejects the transaction. Only an approved order goes to the simulated exchange for execution.
Notice the separation of powers. The agent that wants to trade is not the agent that approves the trade, and the agent that approves the trade is not the agent that measures the risk. This mirrors how real firms avoid blow-ups, and it is a pattern worth stealing for any multi-agent system you build.
How it works in practice: setup, providers and backtesting
Getting started is straightforward for a Python project of this size. Clone the repository, install the package, and launch the interactive CLI:
git clone https://github.com/TauricResearch/TradingAgents.gitcd TradingAgentspip install .tradingagents
The CLI walks you through ticker selection, analysis date, LLM provider, research depth and more, and your previous run’s answers return as defaults. A non-interactive mode runs without prompts from flags such as --ticker and --date, and runs can be embedded in your own code through the Python package, where a TradingAgentsGraph object returns a decision via its propagate() method. Docker is supported for teams that want a reproducible environment.
Model support is unusually broad. The provider registry covers OpenAI, Anthropic, Google, xAI, DeepSeek, Qwen, GLM, NVIDIA, Kimi, Groq, Mistral and AWS Bedrock, plus any OpenAI-compatible endpoint such as vLLM, LM Studio or llama.cpp, and local models through Ollama. Since version 0.7.0 you can even run on your own ChatGPT Plus or Pro plan instead of an API key. Different model tiers can run on different providers, so the quick-thinking analysts and the deep-thinking managers do not have to share the same model or the same bill.
Backtesting is built in, over a ticker and date grid, with portfolio-aware runs and reports saved as a single HTML page. The project also keeps a persistent decision log, so every decision is auditable after the fact.
Why it is trending: the agent wave meets a real benchmark
TradingAgents sits at the intersection of the two biggest developer trends of the last two years: multi-agent systems and applied LLM research. It arrived with a research paper, real code, and a problem domain — financial markets — where results can be measured rather than merely demoed. That combination is rare. Most agent frameworks demo well and measure poorly; a trading framework cannot hide, because the market keeps score.
Its timing helped too. As teams moved from asking “can an agent do this task?” to “can a team of agents do this job?”, TradingAgents offered a complete, inspectable answer: roles, debate, risk gates and an audit trail, all in one repository. The star count — now past 117,000 — reflects that it became the default reference implementation people point to when they explain what multi-agent AI means in practice. If you explore our AI tools directory, you will see the same pattern across the category: the tools that last are the ones with a clear job, a measurable output, and honest limits.
From our experience: what to expect, and what not to
Having built AI systems for clients across nine years and hundreds of projects, our read is this: TradingAgents is an excellent research and prototyping framework, and a poor autopilot. The multi-agent structure genuinely improves the quality of analysis compared with a single prompted model, because specialisation plus debate catches errors that a single pass misses. But output quality still depends heavily on the backbone models, their temperature settings, the data quality, and the market period — exactly the variables the project’s own disclaimer names.
Cost is the other reality nobody mentions in the star count. A full run with parallel analysts, a bull-bear debate, a trader, a risk team and a portfolio manager is many LLM calls per ticker per date. Multiply that across a backtest grid and the bill adds up fast, which is why the provider-per-tier feature and the local-model options matter so much in practice. Budget for experimentation and run narrow backtests before wide ones.
When should you not use it? If you want a signal to trade real money on tomorrow, this is not that tool, and its authors say so plainly. If you want to understand how agent teams behave, prototype a research pipeline, teach a team what multi-agent architecture looks like, or build a decision-support tool with an audit trail, it is one of the best starting points in open source. For a broader practitioner view of which AI trading tools are real and which are hype, see our guide to AI trading tools in 2026.
Responsible use: a research tool, not a money machine
The project’s own position is unambiguous: TradingAgents is designed for research purposes, and it is not intended as financial, investment, or trading advice. Trading performance varies with the chosen models, temperature, trading periods and data quality, and the framework’s decisions are non-deterministic. Read the full Tauric Research disclaimer before running anything, and never connect research output directly to real funds without your own backtesting, risk limits and compliance review. The framework executes against a simulated exchange by design. That boundary is a feature, not a limitation to work around.
Getting started with TradingAgents
- Clone the repository and install the package with
pip install ., or use the Docker setup for a reproducible environment. - Set your provider credentials — an API key, a ChatGPT Plus or Pro sign-in, AWS Bedrock credentials, or a local Ollama endpoint — and pick models per tier in the configuration.
- Launch the interactive CLI with
tradingagents, choose a ticker and analysis date, and watch the analyst reports, debate and decision unfold. - Review the saved HTML report and the decision log, and sanity-check the decision against your own read of the ticker before drawing any conclusions.
- Run a small backtest over a date grid, confirm the point-in-time behaviour holds for your data sources, and only then scale up the tickers or dates.
- Keep the simulated-exchange boundary intact: use the output for research, prototyping and learning, not as a live trading signal.
Frequently asked questions
Is TradingAgents free to use?
Yes, the code is free under the Apache 2.0 licence. You still pay for whatever the agents consume: LLM API calls, a ChatGPT plan, or data feeds, plus the compute to run it. The framework itself costs nothing; the models it orchestrates do not.
Does TradingAgents trade with real money?
No. Approved orders go to a simulated exchange. The framework is a research tool by design, and its authors state clearly that it is not financial, investment, or trading advice.
Which AI models does TradingAgents support?
A wide range: OpenAI, Anthropic, Google, xAI, DeepSeek, Qwen, GLM, NVIDIA, Kimi, Groq, Mistral and AWS Bedrock, any OpenAI-compatible server such as vLLM or LM Studio, local models via Ollama, and ChatGPT Plus or Pro plans since version 0.7.0. Different tiers can run on different providers.
Can TradingAgents beat the market?
There is no guarantee, and anyone promising one should not be trusted. The accompanying paper reports backtests against baselines, but real performance varies with the backbone models, temperature, trading period and data quality, and the framework’s decisions are non-deterministic. Treat it as a research instrument, not a return promise.
Do I need to code to run TradingAgents?
Not for a first run: the interactive CLI walks you through ticker, date, provider and depth. Coding helps when you want to embed it in your own pipeline through the Python package, run non-interactive backtests, or customise the agent configuration.
TradingAgents earns its star count the honest way: it takes a genuinely hard problem, decomposes it into roles a reader can follow, argues both sides before deciding, and keeps an audit trail. Whether you are researching trading systems, designing your own multi-agent product, or just trying to understand what the agent hype actually amounts to, it is worth an afternoon of your time. If you want help turning an idea like this into a production system, talk to MTD Technologies.