Five AI Agents, One Trading Decision: The Architecture Behind the 95K Stars

I keep a tab open on GitHub trending. Every morning, before the market opens, I scroll through what caught the developer world’s attention overnight. Most of it is noise: another scaffold tool, another wrapper, another repo that will be abandoned in six weeks.

Last Tuesday, a number stopped me.

Ninety-five thousand stars. For a trading framework. On a repo that did not exist eighteen months ago.

I have been watching AI + finance tooling for three years. Nothing in that space not the quant libraries, not the BloombergGPT wrappers, not the retail-trading bots has ever pulled numbers like that. I read the name twice: TradingAgents. I closed the browser. I opened it again.

This is what it actually is.

The creator roster

TradingAgents is not one AI that gives you buy and sell signals. It is five separate AI agents, each with a defined role, working through a decision chain that mirrors how a real fund makes a call.

The Analyst Team starts it. A Fundamentals Analyst pulls financial statements, earnings reports, and balance sheet ratios the stuff that tells you whether a company is structurally sound. A Technical Analyst looks at price history, MACD, RSI, volume patterns the chart geometry that retail traders live and die by. A Sentiment Analyst scrapes news headlines, StockTwits posts, Reddit discussions and spits out a single read: bullish, bearish, or mixed. A News Analyst monitors macro events rate decisions, CPI prints, geopolitical flashpoints and maps them to affected sectors.

None of these agents talk directly to the trader. They report upward.

The Researcher Team is next. This is where the framework gets interesting. Two agents, one assigned bull case, one assigned bear case, take everything the Analyst Team produced and argue it out. Not in the way a single AI might hedge (“there are arguments on both sides”). They are forced into opposing positions. The bull researcher finds the strongest case for buying. The bear researcher finds the strongest case against. What comes out of that debate is not a compromise. It is a tension map.

The Trader Agent sits above that tension. It reads the analyst reports and the researcher debate, then decides: buy, sell, hold, and how much.

Then the Risk Management team gets a turn. They do not generate ideas. They shoot them down. Volatility checks, liquidity screens, tail-risk flags, position-size limits. If the Trader’s proposed order fails any of these screens, it goes back for revision.

The Portfolio Manager is the final gate. They see everything the analyst reports, researcher debate, trader proposal, risk flags, and decide whether the order executes in the simulated exchange.

Five agents. No single point of failure where one model’s bad day becomes your bad trade.

Inside the decision chain

What makes this architecture work, technically, is LangGraph. Each agent is a node in a directed graph. The edges between nodes carry state: the analyst reports, the researcher debates, the risk flags so that information moves forward through the chain without being re-queried at every step. When a trader revises a proposal after a risk rejection, the revision carries the full context of the previous attempt.

That matters more than it sounds. Most single-model trading bots re-run the same query on every tick. TradingAgents preserves the decision trail. If you look at the decision log a week later, you can trace exactly which analyst signal triggered the trader’s initial proposal, which risk flag caused the revision, and what the portfolio manager’s final rationale was.

The data layer is equally deliberate. Alpha Vantage handles US equity fundamentals and technicals. FRED pulls macroeconomic indicators the stuff that tells you whether the macro environment is conducive to a long book. Polymarket provides real-time crowd-sentiment data, which is noisy but directionally useful in the short term. Crypto sentiment sources cover the altcoin exposure some of these strategies carry.

In v0.3.1, released this month, the team added look-ahead filtering for Alpha Vantage data (prevents accidentally training on future information in backtests), crash-safe graph routing, a configurable retry budget for LLM API calls, and support for Claude Sonnet 5 and Fable 5 alongside the existing GPT-5.x, Gemini 3.x, and Grok 4.x coverage.

The project crossed 95,000 stars on GitHub. That number is not decoration; it is a proxy for how many developers looked at this architecture and decided it was worth saving.

The part nobody has named yet

Here is what I keep turning over after reading through the code, the changelog, and the seven months of commit history.

The architecture is defensible. Five agents with defined roles, forcing functions that require explicit disagreement, a risk layer that can block a trade this is closer to how a real institutional shop operates than anything else I have seen in the open-source AI trading space.

But the architecture is not the output. The output is the trading signal. And the framework’s own disclaimer, backed by the license and a link to tauric.ai/disclaimer, is unambiguous: this is a research project. Trading performance may vary based on backbone model, temperature settings, data quality, and market regime. It is not financial advice.

That disclaimer exists because the honest answer to “does this actually make money” is: nobody has published audited performance data. The changelog tracks new agents, new data sources, and new provider support, not Sharpe ratios or backtest results. Which is not a criticism. It is an honest boundary.

The gap I keep circling: a multi-agent architecture that looks more rigorous than a single model does not automatically produce better signals. The forcing functions (bull vs. bear researchers, risk layer veto) reduce certain failure modes groupthink, unchecked overconfidence but they introduce others. A bear researcher assigned to argue against a trade might argue against it for the wrong reasons. A risk model calibrated on historical volatility may miss regime changes.

What the framework demonstrates is a better process. Whether that process produces better outcomes is a different question that the project has not answered and, to its credit, has not claimed to answer.

Who should actually be looking

Three profiles get the most out of this.

Quant enthusiasts who want to see what a multi-agent decision chain looks like in production code, not a diagram in a blog post, not a LangChain demo, but a working system with data feeds, model routing, and a persistent decision log. The architecture is dense but well-documented. Clone it, read the graph structure, trace one full decision cycle.

AI engineers working on multi-agent systems who want a concrete, non-trivial use case. Most multi-agent demos are toy problems. TradingAgents is not simply the researcher bull/bear debate alone requires careful prompt design, structured output parsing, and state management across graph nodes. The v0.3.1 changelog shows the team is still solving hard coordination problems. That is a useful signal if you are building something similar.

Finance professionals evaluating where LLM-based tools fit in their workflow. Not to replace analysts; the framework is explicit that it is not that, but to understand what the technology can and cannot do today. Running through a few simulated decisions with different model backends gives you a feel for where the process holds and where it breaks.

One non-obvious thing worth naming: the Apache 2.0 license covers commercial use. If you are building a product that needs a research-grade decision architecture as a component of a wealth management advisory layer, an internal quant research tool, this is one of the few open-source options with a license that does not box you into open-sourcing your own work.

I did not run a live trade with TradingAgents. Running it properly requires API keys for Alpha Vantage, FRED, and Polymarket, plus a simulated exchange configuration that is a setup session, not a quick test. What I can say is that ninety-five thousand developers decided the architecture was worth bookmarking. Seven months of active commits suggest the team is still in the problem. And the problem itself building a trading process that forces explicit disagreement instead of confident noise is the right one to be working on.

The signal quality question is still open. That is not a flaw in the project. It is an honest state of the field.

Source: GitHub repo TauricResearch/TradingAgents (95,521 stars, Apache 2.0, v0.3.1, July 2026);