A Trading Firm Made of LLM Agents Has 117,000 Stars. Read the Disclaimer.

TradingAgents has about 117,700 stars on GitHub and picked up roughly 4,900 of them this week, which makes it one of the more popular repositories in the "agents that do real work" category. It's a multi-agent framework from Tauric Research that simulates a trading firm: analysts, researchers, a trader, a risk team, and a portfolio manager, all driven by language models, arguing with each other until something gets approved.

The repo is careful about what it claims. Its own description says it's designed for research purposes, and adds that performance will vary with the chosen backbone model, the temperature, the trading period, data quality, and plain nondeterminism. That sentence is doing a lot of work, and it's the most important thing in the README.

The org chart is the architecture

What's interesting here isn't that an LLM can pick stocks. Plenty of prompts do that badly. It's that the pipeline is structured like an actual firm, with separation of duties and a debate stage.

Four analysts work in parallel and independently: fundamentals (financials, intrinsic value, risk signals), sentiment (news headlines, StockTwits, Reddit), news (global and macro events), and technical (MACD, RSI, pattern recognition). None of them see the others' output. All four reports have to land before anything else starts.

Then a research team of two — a bull and a bear — debates those reports in structured rounds. Then a trader synthesizes the analyst and researcher material into a decision with timing and size. Then a risk team evaluates volatility, liquidity, and exposure, and hands an assessment to a portfolio manager who approves or rejects. Approved trades go to a simulated exchange.

If you've worked at a fund, the shape will look familiar, including the part where the risk team has veto power and the portfolio manager has the final call. That's not decoration. The reason trading firms are organized this way is that a single decision-maker with one view of the world makes correlated mistakes. The structure is an error-correction mechanism, and the framework is copying the mechanism rather than the job titles.

Getting it running

Python 3.11 or higher. The README suggests conda or uv:

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

Then copy the env file and add keys:

cp .env.example .env

And run the interactive CLI:

tradingagents

There's a Docker path too, which is the one I'd use if you want results you can reproduce:

docker compose run --rm tradingagents

For scheduled runs there's a non-interactive mode with explicit model selection:

export TRADINGAGENTS_LLM_PROVIDER=openai \
  TRADINGAGENTS_QUICK_THINK_LLM=gpt-6-luna \
  TRADINGAGENTS_DEEP_THINK_LLM=gpt-6-sol
tradingagents --ticker NVDA --date 2026-09-23 \
  --analysts market,news,fundamentals --save --no-show

That two-model split is worth noticing. "Quick think" handles the mechanical turns; "deep think" handles the analysis. It's a cost-control decision dressed as a config option, and it implies the authors know that a full multi-agent run on a big model is expensive per ticker.

The numbers problem

Here's where I'd push back on how this repo is usually discussed.

A multi-agent trading system that produces a decision per ticker per day generates very few data points per year. If you run it on 30 tickers over 12 months, you have 7,560 decisions — which sounds like a lot until you remember they're all drawn from the same 12 months of market conditions. The effective sample size is closer to one regime than to 7,560 independent observations.

Add the nondeterminism the README warns about. Temperature, model version, tool latency, and the order in which retrieved news arrives all shift the output. Two runs on the same date and ticker can diverge at the researcher debate stage and end up with different positions. That makes a conventional backtest nearly impossible to replicate, and replication is the only thing that turns a result into evidence.

None of this is a knock on the framework. It's a knock on the genre of "my agent beat the S&P" posts that follow every release like this one. The authors themselves publish it as an arXiv paper (2412.20138) with a research framing, and the repo says research purposes in the first sentence. The gap between that and the way it gets shared is where people lose money.

What the debate layer actually buys you

I've read a fair number of agent debate transcripts, and there's a consistent pattern: the debate doesn't change the conclusion as often as it changes the confidence.

That's still useful. A bull and a bear arguing over the same analyst reports surfaces the specific assumption the trade depends on — "this works if margin expansion continues" — and that's the sentence a human analyst should be reading anyway. The output isn't a signal. It's a structured statement of what has to be true.

There's also a real risk in the opposite direction: debate transcripts are persuasive. A well-written bear case reads like insight even when it's built on a hallucinated earnings figure. The framework mitigates this by isolating analysts from each other and giving the risk team veto power, but nothing in the pipeline verifies that a cited number exists. If you deploy this, the verification layer is yours to build, and it should be a hard gate rather than another agent's opinion.

What a result from this thing would have to look like

If someone wants to convince me a multi-agent setup like this has edge, here's the minimum bar, and it's higher than any demo I've seen.

Freeze everything. Model versions, temperature, prompt templates, data snapshot date, and the retrieval corpus. A result produced against live data on a specific Tuesday is an anecdote, not a measurement.

Compare against the right baseline. Not "did it make money" — did it beat a naive strategy with the same exposure? A long-only system in a rising market beats cash by definition, and a surprising amount of agent trading content is that, with extra steps.

Report the cost. A full four-analyst, multi-round debate run costs real tokens per ticker per day. If the strategy returns 12 percent a year and the model bill is 3 percent of the portfolio, the debate layer has to be worth a quarter of the alpha before it earns its place.

And publish the losing runs. The reason the Cloudflare security repo is credible is that it says out loud that one pass finds half of what repeated passes find. The equivalent here would be publishing the tickers where the bear researcher was right and the portfolio manager overrode it. Nobody does that yet, in any repo.

Who should actually clone it

Three legitimate uses, and none of them is "trade my money."

As a scaffold for research on multi-agent coordination, it's genuinely good: clean role separation, a debate protocol, a veto mechanism, and a paper describing the design. If you're studying whether structured disagreement improves LLM reasoning, this is a working testbed with an interface you don't have to build.

As an education tool for someone learning how a trading desk decomposes a decision, it's better than a textbook diagram, because you can watch the reports flow and see where a bad input propagates.

As a personal pre-mortem, with strict limits: run it on a position you already hold, read the bear case, and treat the output as a checklist of things to verify. The value is in the questions, not the BUY/SELL field. And keep it in the simulated exchange, which is where it ships by default and where it should stay.

The 117,000 stars are a signal about demand, not about performance. People want a system that reads the news for them and tells them what to do. This framework gives them something more honest and less satisfying: a room full of colleagues who disagree, and a decision that still depends on whether the data was right.