Smorster

Someone open-sourced a hedge fund (53k stars on GitHub)

Indie Hacker News · 8m 27s · Watch on YouTube · 16 sources

Decision Card

Effort: Weekend project — clone TauricResearch/TradingAgents, pip install, set one LLM provider API key, and run the interactive CLI against a single ticker (~1–2 hours to first run, plus a few dollars of LLM tokens per analysis).

Honest take: The video’s stats were accurate when recorded (~April 2026) but are stale now — the repo is at ~93.6k stars and v0.3.1, and the post-video changelog undercuts the “fully auditable, clean reference implementation” framing: v0.3.1 fixed a look-ahead-bias bug in the fundamentals data filter and mid-run router crashes, exactly the silent failure modes that make LLM backtest results untrustworthy. Also note the simulated exchange is a backtest only; the video mentions this but still frames the project as a near-turnkey trading system.

Concrete next steps:

  • Skim the arXiv paper (2412.20138) for the architecture and reported results before touching code (~30 min)
  • Clone the repo and run one ticker with a cheap model (e.g. via Ollama or DeepSeek) to inspect the debate transcripts and decision log (~2 hours)
  • Read the releases page — v0.3.x notes reveal the data-integrity and stability issues that existed in the version the video reviewed (~15 min)
  • Skip if you want a production trading system — there is no live broker integration, the authors label it research-only, and per-run token costs make continuous operation expensive

TL;DR

TradingAgents is an Apache-2.0 Python framework (from a UCLA/MIT-affiliated research paper, maintained by Tauric Research) that simulates a hedge fund as a LangGraph pipeline of LLM agents: four parallel analysts, debating bull/bear researchers, a trader, a risk team, and a portfolio manager with final approval. The video argues its value is traceability — every decision comes with readable reports and debate transcripts — while cautioning that it burns real token money, only trades against a simulated exchange, and is explicitly not financial advice.

Key Points

  • TradingAgents is a trending Python project (53k+ stars at recording) that simulates an entire trading firm with LLM agents from a single stock ticker input 00:09
  • The firm structure: fundamentals, sentiment, news, and technical analysts; bull and bear researchers who debate; a trader; a risk management team; and a portfolio manager who approves or rejects every transaction 00:28
  • It started as a research paper out of UCLA in late 2024, was quietly open-sourced, and has been doubling stars every couple of months 00:57
  • The four analysts run in parallel and their reports are deliberately not collapsed into a single signal — disagreement is treated as information 03:52
  • Bull and bear researchers argue for a configurable number of rounds, citing specific numbers from the analyst reports, before the trader reads the full debate transcript and makes a call 04:07
  • Orchestration runs on LangGraph: every agent is a node, transitions are checkpointed, and an opt-in resume feature preserves analyst work after a crash 04:46
  • An always-on decision log records each run’s reasoning; on the next run for the same ticker it fetches realized returns, computes alpha vs SPY, and injects a reflection into the portfolio manager prompt 05:04
  • Version 0.2.4 (April 25) added structured-output decision agents via Pydantic schemas, new providers (DeepSeek, Qwen, GLM, Azure OpenAI), Docker multi-stage builds, and a five-tier buy/overweight/hold/underweight/sell rating scale 06:05 (note: the transcript’s “TLM” is a mis-hearing of GLM)
  • Main tradeoffs: each analysis burns four parallel analyst calls plus debate rounds in LLM tokens, and the “exchange” is a backtest — live trading requires wiring your own broker integration 07:29
  • The pitch to builders: one of the cleanest reference implementations of a multi-agent LLM decision graph, regardless of whether you care about trading 07:17

Notable Quotes

“The disagreement between them is signal, not noise.” 03:56

“So, the system literally learns from past trades.” 05:28

“…you should not yolo your retirement into whatever the portfolio manager spits out.” 07:44

Verified Claims

  • Claim: A project called TradingAgents is an open-source multi-agent LLM trading framework under Apache 2.0, written in Python, built on LangGraph. 00:09 — Sources: TauricResearch/TradingAgents on GitHub. Verdict: Confirmed (Apache-2.0, 99.9% Python, LangGraph-based).

  • Claim: The repo has 53,678 stars and 9,768 forks. 00:45 — Sources: GitHub repo. Verdict: Confirmed for the recording date, now outdated — as of July 2026 the repo shows ~93.6k stars and ~18.1k forks, which incidentally supports the “doubling every couple months” claim.

  • Claim: The underlying paper is published on arXiv as 2412.20138, from late 2024. 03:11 — Sources: arXiv:2412.20138. Verdict: Confirmed (submitted December 28, 2024; authors Yijia Xiao, Edward Sun, Di Luo, Wei Wang).

  • Claim: It “started as a research paper out of UCLA.” 00:57 — Sources: arXiv:2412.20138, TradingAgents project page. Verdict: Mostly confirmed — arXiv lists the affiliation as Tauric Research, but the authors are UCLA/MIT-affiliated researchers, so “out of UCLA” is a reasonable shorthand rather than the formal affiliation.

  • Claim: v0.2.4 shipped April 25 with structured-output (Pydantic) decision agents, DeepSeek/Qwen/GLM/Azure OpenAI providers, Docker multi-stage builds, and a five-tier rating scale. 06:05 — Sources: GitHub releases. Verdict: Confirmed — the v0.2.4 release notes (April 25, 2026) match every listed feature.

  • Claim: It supports every major LLM provider, including OpenAI, Gemini, Anthropic, xAI/Grok, DeepSeek, Qwen, OpenRouter, and Ollama for local models. 05:43 — Sources: GitHub repo. Verdict: Confirmed — the repo lists all of these plus GLM, MiniMax, and Azure OpenAI (and v0.3.0 later added Bedrock, Groq, Mistral, NVIDIA NIM, and Kimi).

  • Claim: A persistent decision log learns from past trades by reflecting on realized outcomes. 05:04 — Sources: GitHub releases (v0.2.4: “persistent decision log with outcome-grounded reflections”). Verdict: Confirmed for the mechanism; the specific SPY-benchmark alpha detail was not independently verifiable from the sources fetched.

  • Claim: The authors say it’s a research framework, not financial advice, and the exchange is simulated (no live broker). 07:40 — Sources: GitHub repo (disclaimer: “designed for research purposes… not intended as financial, investment, or trading advice”). Verdict: Confirmed.

Tools, Papers & Standards Mentioned

Follow-up Questions

  1. Does the adversarial bull/bear debate measurably improve decision quality over a single-agent baseline at equal token budget, or is the paper’s reported outperformance (up to ~30.5% annualized in backtests) mostly attributable to data selection and backtest period?
  2. How robust is the backtest to look-ahead bias given that v0.3.1 patched exactly such a bug in the Alpha Vantage fundamentals filter — and how would one audit the remaining data vendors for the same class of leak?
  3. Could the analyst → debate → trader → risk-gate pattern transfer to non-financial decision domains (e.g., the “researchLater” pipeline’s own summarization: multiple analyst lenses plus an adversarial reviewer before a final verdict)?

Sources