Does the 118K-Star AI Trading Agent Actually Work? I Installed and Tested TradingAgents v0.7.1 — Open-Source Agent, Tested #1

-

Search description: I installed TradingAgents v0.7.1 — the 118K-star multi-agent trading framework — and tested it for real. Setup, keys, errors, honest verdict.

Labels: Python, AI Agents, Open Source, Tutorials

Versions used in this post — read this first: TradingAgents v0.7.1 (release tag, commit c4544913a14ed3df5f1ed7b9e8483270ce20682a — the exact code tested here) · Python 3.12.3 (the project requires Python 3.11 or later) · Repository figures — 118,913 stars, 22,731 forks, 884 watchers — read from the project's GitHub page on October 31, 2026; this repository gains hundreds of stars a day, so treat those numbers as a dated snapshot, not a permanent fact. Licence: Apache-2.0.

A framing note before anything else. TradingAgents describes itself, in its own documentation, as a framework "designed for research purposes" that "is not intended as financial, investment, or trading advice." This post holds it to exactly that standard. This is an engineering test — install it, run it, read what it produces — not a recommendation of any stock, strategy, or tool for real money. The framework's approved orders go to a simulated exchange. Nothing here is financial advice.

The direct answer

TradingAgents is a free, open-source Python framework that splits stock analysis across a team of LLM agents modelled on a trading firm: four analysts research in parallel, two researchers debate the evidence bull-versus-bear, a trader proposes a decision, and a risk check plus a portfolio manager can approve or reject it. It installs with a clone, a virtual environment, and one pip install . — on the machine used for this test that install finished cleanly, with no errors, and the command-line help runs before any API key exists. The one thing you must supply yourself is a language model: a provider API key, a ChatGPT Plus/Pro sign-in, or a local model.

And the test result, up front, because this series does not bury it: the full pipeline did run end to end — but it took five attempts to get one complete run, and every failure was a lesson (one quirk of my test machine, one dropped connection, and two hard lessons about free-tier API quotas). When it completed, the framework analysed NVIDIA as of October 9, 2026, debated it properly, and issued a decision — Overweight, buy the dip, with a strict stop-loss. The stock then fell straight through that stop within a week. The framework's directional call was wrong; its risk discipline was the most valuable thing it produced. The full evidence is below.

What this test is (and is not)

This is the pilot episode of Open-Source Agent, Tested, a series with three fixed rules:

  1. The version is pinned. Every claim below is about v0.7.1 at the commit named above. If the project has released something newer by the time you read this, the post says so rather than quietly drifting.
  2. The run is real. The install log, the errors, and the output shown here come from an actual session on an actual machine — not from the project's documentation. If something fails, the failure is the result and it gets reported as one.
  3. The verdict is honest. Star counts measure popularity, not quality. The end of this post separates what is genuinely well-built from what is demo-grade, and says who should bother.

What it is not: a trading strategy, a signal service, or a promise. See the framing note above.

Meet the framework: a firm, not a chatbot

Most "AI stock tools" are one model answering one prompt. TradingAgents instead divides the labour the way a trading firm divides it:

  • Analyst Team — four specialists who work in parallel:
  • Fundamentals — the company's financials.
  • Sentiment — news headlines, StockTwits, and Reddit.
  • News — global news and macroeconomic events.
  • Technical — chart indicators such as MACD and RSI.
  • Researcher Team — two researchers take the analysts' reports and argue: one builds the bullish case, the other builds the bearish case. The debate is the point — a claim has to survive an opponent before it travels further.
  • Trader Agent — reads the reports and the debate, then composes a concrete proposal: timing and position size.
  • Risk Management and Portfolio Manager — the proposal is checked for volatility and liquidity risk, and the Portfolio Manager makes the final call: approve or reject. Only an approved order reaches the (simulated) exchange.

That pipeline — specialists gather, opponents argue, a gatekeeper decides — is the design being tested here. Everything else in this post is setup, evidence, and verdict.

Environment setup — do this first

Prerequisites:

  • Python 3.11 or later. This test used Python 3.12.3. Check yours before anything else:

bash python3 --version

If it prints 3.10 or lower, install a newer Python first (from python.org, or your OS package manager) — the project's requirement is 3.11+, and the steps below were verified on 3.12.3. - Git, to clone the repository. - A language-model route (covered in its own step below — do not skip it; the analysis cannot run without one).

Step 1 — clone the repository and pin the tested version:

git clone https://github.com/TauricResearch/TradingAgents.git
cd TradingAgents
git checkout v0.7.1

Checking out the tag prints Git's "detached HEAD" notice. That is informational, not an error — it simply confirms you pinned a release tag instead of following the moving main branch. For a test like this one, the pin is what you want: everyone reading this post can reproduce the exact code.

Step 2 — create a virtual environment and install:

python3 -m venv .venv
source .venv/bin/activate
# Windows PowerShell: py -m venv .venv ; .venv\Scripts\Activate.ps1
python -m pip install --upgrade pip
pip install .

(Prefer uv? The project also documents uv venv --python 3.13 followed by uv pip install .. Prefer Docker? It documents docker compose run --rm tradingagents with your keys in a .env file. All three routes install the same v0.7.1 code.)

What actually happened on this test machine: Python 3.12.3 on Linux, pip install . completed successfully in roughly four and a half minutes. No errors — none. That is worth stating plainly, because a clean first install is not the open-source default, and this post will not invent friction that did not occur.

Step 3 — verify the install (no key needed yet):

tradingagents --help

This prints the CLI's options and its three subcommands (backtest, login, logout). Notably, it runs with no API key configured — the help does not ask for one. The key only becomes necessary when you run an actual analysis, which is the next step.

Step 4 — give it a language model (zero assumed setup).

An analysis run needs an LLM. The framework accepts several routes; pick ONE:

  • A provider API key — OpenAI, Google, Anthropic, xAI, DeepSeek, DashScope, Zhipu, MiniMax, OpenRouter, Mistral, Moonshot, Groq, NVIDIA, and others are supported. Keys go in a .env file in the project folder (see below), never in code you commit or share — a key is a password, and anyone who has it can spend your money.
  • Google / Gemini walkthrough (the route this test used): 1. Go to aistudio.google.com and sign in with a Google account. 2. Open Get API key and choose Create API key (create or pick a Google Cloud project when prompted). 3. Copy the key Google shows you. You will not be able to view it again in full later — save it directly into your .env file (next step), not into a note you might share. 4. Billing note: this test ran entirely on the free tier and cost $0 — but read the run section before assuming free is painless. The Gemini free tier meters requests per day, per project, per model (20 requests/day for gemini-3.8-flash; 15/day for gemini-3.5-flash-lite, at the time of this test), and a single multi-agent analysis makes dozens of model calls. The free tier is a real constraint, not a footnote.
  • ChatGPT-subscription sign-in (no API key at all) — new in v0.7.0: if you already pay for ChatGPT Plus or Pro, run

bash tradingagents login chatgpt

and sign in with that plan. (tradingagents logout revokes the machine's access again.) - A local model — an Ollama or other OpenAI-compatible local server works too, if you would rather nothing leaves your machine. Expect slower, weaker analysis from small local models; the framework cannot fix a model that cannot reason.

Create the .env file in the project folder with the key(s) for the route you chose, following the variable names in the project's own .env example. Keep this file out of Git — it is listed in the project's ignore rules for a reason.

Step 5 — optional data keys.

Three optional keys unlock extra data sources: FRED (macroeconomic data), Alpha Vantage (market data), and TypeSafe (sentiment screening). None is required for a first run. This test ran without the optional keys, and the effect is visible in the run below: the framework logged that FRED macro data was unavailable and carried on. Add them later, one at a time, so you can tell which source changed the output.

How a run works

A run is a single command. The flags most people need:

tradingagents --ticker NVDA --date 2026-09-26 --analysts market,news --save --no-show
  • --ticker — the symbol to analyse (for example NVDA, or 0700.HK for a Hong Kong listing).
  • --date — the analysis date, YYYY-MM-DD. A past date is the honest way to test: the framework can only use information available up to that date, and you can compare its decision against what the price actually did afterwards.
  • --analysts — a comma-separated subset of the analyst team (for example market,news); omit it to run the full team.
  • --save / --no-show — save the full report to disk without interactive prompts; --html also writes the complete report as a single HTML page, which is the comfortable way to read the whole debate afterwards.
  • --portfolio — a JSON file of current holdings and cash, so the trader, risk, and portfolio agents size decisions against an actual position instead of a blank slate.
  • --checkpoint — saves state after each step so a crashed run can resume instead of starting over. Note this test's experience in the Errors section: in our session, the checkpoint resume did not pick up and the run restarted from zero. Budget your API requests accordingly.

A separate backtest subcommand scores past decisions across a grid of tickers and dates.

Under the hood, one run walks the pipeline from "Meet the framework" in order: analysts in parallel → researcher debate → trader proposal → risk evaluation → portfolio manager's approve/reject → (simulated) fill. Two details from the v0.7.1 release notes deserve attention, because they are correctness fixes of exactly the kind a hype video skips: decisions are now scored only on final closing prices, settlements are handled across long market holidays, and a model-date bug that could let the system read company filings dated after the run date — in plain terms, peek at the future — is fixed. A framework that patches look-ahead bias is taking backtesting seriously.

The test run

The protocol, fixed before any output was seen: one well-known ticker (NVDA), one analysis date in the past (Friday, October 9, 2026 — chosen so the framework only had information available that day, and so its decision could be scored against the real prices that followed), the full four-analyst team, one researcher debate round and one risk round, the complete report saved, and cost and duration measured. Three questions to answer: does it run end to end, does the debate change anything, and what does it cost?

What it actually took: five attempts in 24 minutes. The failures are part of the result, and each one is detailed in the Errors section below. In short: attempt 1 died in 7 seconds on a proxy quirk of my test machine; attempt 2 ran ten minutes, completed the analysts and the whole debate, then died at the Research Manager when the Gemini connection dropped; attempt 3 repeated that run and died at the same desk on the free tier's daily quota (20 requests/day for the deep model); attempt 4 tried a checkpoint resume, which did not resume, and died 33 seconds in on the other model's quota (15/day); attempt 5 switched to two untouched free-tier models — gemini-3.5-flash for the deep-thinking agents, gemini-3.1-flash-lite for the quick ones — and completed the entire pipeline in 107 seconds, exit code 0. Everything below is from attempt 5's saved report. Measured cost: $0 — every attempt ran on the free tier. The real currency was quota, not money.

What each stage produced (analysis date Oct 9, 2026; NVDA closed that day at $229.28):

  • Market analyst — uptrend intact, momentum cooling. Price above the 50-day average ($221.94) and the 200-day ($201.82) says the structure is bullish; but the MACD histogram has narrowed to 0.118, price dipped below the 10-day EMA, and RSI is a neutral 53. Flagged a possible re-test of support at $226.73.
  • Fundamentals analyst — strongly bullish. Quarterly revenue of $96.2 billion, net income of $59.7 billion, over $74 billion of operating cash flow in the first half of the year, $22.4 billion in cash. Its own caveat: growth this large cannot compound forever — watch for deceleration.
  • Sentiment analyst — neutral, 5.0 out of 10, confidence low — because it had no data. For a historical window, its sources (news headlines, StockTwits, Reddit) returned nothing usable — Reddit's feed was blocked outright (HTTP 403) during these sessions — and the report says exactly that instead of inventing a mood. Honest, and a genuine limitation: sentiment data does not do history, so past-date tests fly blind on this desk.
  • News analyst — themes, disclosed gaps. Real-time news and macro feeds were unavailable (no FRED key configured; the framework logged the fallback and continued), so the report framed NVDA around AI spending, the Fed's rate path, supply chains and geopolitics — and disclosed the missing data up front.
  • The debate — the bear nearly won the room. The bull argued the moat (an ecosystem hyperscalers cannot abandon), the fortress balance sheet, and a healthy consolidation above both moving averages. The bear argued a blow-off top: hyperscalers are building their own silicon precisely to break NVIDIA's pricing power, growth on a $96 billion base is mathematically near-impossible to sustain, capex cycles always turn — and if $226.73 and $221.94 break, momentum selling follows. The Research Manager sided with the bull (financial dominance is current fact; the bear's case is a future risk) but adopted the bear's warning levels as the trade's entry zone and stop.
  • Trader — BUY. Entry $226.73, stop-loss $218.00, size 1.25× standard.
  • Risk debate — the numbers got moderated. The aggressive analyst wanted the full 1.25× ("the real risk is opportunity cost"). The conservative wanted 0.5–0.75× (a stop is only as good as the liquidity that fills it in a fast drop). The neutral proposed the compromise: keep the buy, size at 1.0×, and widen the stop to $215 — at $218, the stop sits less than 1.5× the daily volatility (ATR 5.68) from entry, close enough for ordinary noise to trigger it.
  • Portfolio Manager — final decision: OVERWEIGHT. Enter between $226.73 and $221.94, size 1.0×–1.25×, stop-loss $215–$218, horizon 3–6 months, no price target. Compare it with the Trader's proposal and you can see the debate's fingerprints: both single numbers became ranges — the neutral risk analyst's compromise, adopted.

The decision vs. reality. NVDA's actual closes after October 9 (Yahoo Finance data): $226.32 on Oct 12 — inside the buy zone, so the entry triggered on the first trading day. $221.30 on Oct 14 — below the zone, and below the 50-day average the thesis stood on. $217.23 on Oct 15 — inside the decision's own stop-loss band; a rules-following holder exits there. $214.13 on Oct 16 — below the whole band; the exit is complete, at roughly −4% to −6% depending on the entry fill. The slide continued: $204.64 by Oct 30, −10.7% from the analysis-date close. The bear's fragility warning is almost literally what happened next.

So the scoreboard is split, and this post reports both halves: the directional call was wrong — the stock broke the support the thesis rested on within four trading days — and the stop-loss was the most valuable line in the decision, because obeying it cut the loss roughly in half versus holding (−4% to −6% out versus −10.7% by month's end). One run, one ticker, one date: an observation about what this framework did here, not evidence of a repeatable edge or a repeatable failure rate.

Errors you may hit

Every error below was actually observed during this test (install errors: none — the install was clean), with the exact text where it matters. They fall into three buckets, and the bucket matters: framework behaviour, my machine, and the model provider's free tier.

Bucket 1 — provider free-tier quotas (the wall you are most likely to hit):

  • Daily request quota exhausted — 429 RESOURCE_EXHAUSTED. Observed in attempts 3 and 4. The Gemini API free tier allows 20 generate requests per day, per project, per model for gemini-3.8-flash, and 15 per day for gemini-3.5-flash-lite. Attempt 3's error named the limit exactly ("Quota exceeded for metric: generativelanguage.googleapis.com/generate_content_free_tier_requests, limit: 20, model: gemini-3.8-flash") and quoted a retry delay of 52,503 seconds — about 14.6 hours, i.e. "tomorrow." A multi-agent analysis makes dozens of calls, so a free-tier day can be spent by a single deep run plus retries. Fixes: spread your runs across models (each model has its own bucket — that is what saved attempt 5), wait for the daily reset, or enable a paid tier and watch the per-run cost instead.
  • Model at capacity — 503 UNAVAILABLE. Observed in attempt 3, immediately before the quota error: "This model is currently experiencing high demand. Spikes in demand are usually temporary." The framework retried the step in a different mode (free text instead of structured output) on its own — good behaviour — but the retry is what met the quota wall. Fix: wait and retry; the framework already does the graceful part for you.
  • Provider connection drop — RemoteProtocolError: Server disconnected without sending a response. Observed in attempt 2, at the Research Manager, after ten minutes of completed analyst and debate work. The framework's one automatic free-text retry hit the same drop. Fix: re-run. This is also the practical case for --save and saved partial reports — attempt 2's completed stages were on disk, not lost.

Bucket 2 — framework behaviour worth knowing before you budget requests:

  • Checkpoint resume did not resume (observed, attempt 4). The resumed run restarted from the beginning instead of picking up attempt 3's saved state, and promptly re-spent requests against a fresh quota wall. Treat --checkpoint as a seatbelt you should still test on your own setup, not as a guarantee — and do not plan a quota-tight session assuming resume will save you.
  • Data vendors fail, and the framework carries on (observed, attempts 2 and 5). Yahoo Finance's news feed timed out twice in attempt 2 ("Vendor 'yfinance' unavailable for get_news: Yahoo Finance request failed: Timeout; trying next vendor."), Reddit's RSS returned "HTTP Error 403: Blocked" for the sentiment feeds, and the unconfigured FRED source was skipped with a logged note in attempt 5. In every case the run continued with the remaining sources, and the affected analysts disclosed the gap in their reports rather than papering over it. That is the framework behaving well — but know that a past-date analysis will have a blind sentiment desk.

Bucket 3 — my machine (probably not yours):

  • httpx InvalidURL crash at startup — ValueError: invalid literal for int() with base 10: ':1]'. Observed in attempt 1; the run died in 7 seconds before any analysis. Cause: this test machine's proxy environment sets a NO_PROXY value containing a bracketed IPv6 address, and httpx's URL parser chokes on it. Framework: innocent. Fix on a similarly proxied machine: clear NO_PROXY/no_proxy from the run's environment. If your machine has no such proxy variables, you will never see this.

And the basics, verified during setup:

  • No LLM provider configured when starting an analysis. The help command runs fine without a key, but an unattended analysis start stops with exactly this: "GOOGLE_API_KEY is not set; there is no terminal to ask for it." (The provider named is whichever one you selected.) Fix: complete Step 4 — add the key to your .env or finish the ChatGPT sign-in — then re-run.
  • Python older than 3.11. The project requires 3.11+. This test ran 3.12.3 throughout, so the old-Python failure itself was not reproduced here; the requirement is the project's own, stated up front. Fix: install Python 3.11 or newer and rebuild the virtual environment from Step 2.
  • "Detached HEAD" notice when checking out v0.7.1. Observed during this test's install. It looks like a warning and reads like a problem; it is neither. Git is telling you a tag — a fixed point — is checked out instead of a branch. For reproducing a tested version, that is the goal. No fix needed.
  • A provider key in the wrong place. Keys belong in the .env file or your environment — not pasted into a command you later screenshot, and never committed. If a key leaks, revoke it at the provider and issue a new one; treat it like a lost password, because functionally it is one.

The verdict

Judged against the three questions this series fixed before the run:

1. Did it run end to end? Yes — on the fifth attempt, flawlessly. The completed run walked the whole firm — four analysts in parallel (19.9s, 12.4s, 20.6s and 18.5s of wall time on their stages), a real debate, a trader, a three-way risk argument, and a portfolio decision with entry, size, stop and horizon — in 107 seconds, unattended, with a complete saved report. The four failures were not the framework's code: one was my machine's proxy quirk, one a dropped provider connection, two the free tier's daily quotas. But "eventually" is part of the grade: a tool you test for free will spend your day in request quotas, and its checkpoint resume did not rescue us when we needed it.

2. Did the debate change anything? Yes — measurably, in the final numbers. The research debate set the direction: the manager heard the bear's structural case and ruled for the bull, on current financial dominance — while adopting the bear's break-levels as the entry zone and stop. The risk debate then moderated the trade itself: the Trader's single 1.25× size and $218 stop came out of the Portfolio Manager as ranges — 1.0×–1.25× and $215–$218 — the neutral analyst's compromise, adopted verbatim in spirit. The final decision is not the document any single agent proposed. That is the strongest evidence that the multi-agent structure is doing work a single prompt does not.

3. What did it cost? $0 — and a day's quota. On the free tier, one deep analysis can consume a model's entire daily allowance (20 requests for the deep model here). Budget accordingly: free is a planning exercise, paid is a per-run line item — and at 107 seconds of pipeline time, the paid version of this test would be cheap in wall-clock terms.

What is genuinely well-built: the install (clean, pinned, honest separation between browsing and spending); agents that disclose missing data instead of fabricating it (the sentiment desk's "we have no data, therefore neutral, low confidence" is the single most trustworthy paragraph in the report); vendor fallbacks that keep a run alive; release hygiene that patches look-ahead bias.

What is demo-grade, today: historical sentiment is effectively absent, so past-date tests — the honest kind — run with one desk blind; the news desk without optional data keys works from themes, not facts; checkpoint resume failed its one live test; and the flagship decision this framework produced was directionally wrong within a week, saved from embarrassment only by its own stop-loss. None of that makes it a toy. All of it makes it a research instrument whose output you verify — which is, to be fair, exactly what its authors claim.

Who should bother: developers and technically comfortable investors who want to see multi-agent orchestration do real work on a real problem, and who will treat the output as a structured second opinion to be checked — starting with its stop-loss. Who should not: anyone looking for a signal to trade on. The framework's own documentation told you that before I did.

Get the code

  • Companion code for this episode — the exact commands, environment notes, and run configuration used here, in the channel's public code repository: https://github.com/sajjad037/visual-studio-learn-code/tree/main/topic-06-tradingagents-tested
  • The project under test (credit: Tauric Research): https://github.com/TauricResearch/TradingAgents — star it there, not here, if the test convinces you.

Sources

  • TradingAgents repository (repo page: description, framework overview, installation and CLI documentation; star/fork/watcher counts as of October 31, 2026): https://github.com/TauricResearch/TradingAgents
  • TradingAgents releases page (v0.7.1 and v0.7.0 release notes — scoring on final closes, long-holiday settlement, model-date fix; ChatGPT-subscription provider, backtest scoring, release wheels): https://github.com/TauricResearch/TradingAgents/releases
  • This test's own install log and run logs (Python 3.12.3; pip install .; five run attempts with verbatim error text; the completed attempt's full report bundle), recorded October 31, 2026, summarised in the setup, run and errors sections above.
  • Post-run NVDA daily closing prices, Yahoo Finance chart data, fetched October 31, 2026.

Reminder, in the project's own spirit and this series' rules: TradingAgents is a research framework. This post is an engineering test report — not financial, investment, or trading advice.

Enjoying these tutorials?

Get new Visual Studio Learn posts by email — free, no spam:

Follow along: YouTube · Facebook · RSS

Comments

Post a Comment