Run a multi-agent trading desk on your own machine: hands-on with TradingAgents and Ollama

TradingAgents does not try to build a smarter stock picker. It hires a whole firm: four analysts read the data, a bull and a bear argue about it, a trader writes a plan, three risk analysts attack the plan, and a portfolio manager signs or kills it. Version 0.7.1 runs that firm against any model you choose — including one on your own machine, with no API key and no broker. This guide proves it: a full NVIDIA run on a local Ollama model, every command shown, every output quoted from the run, and an honest account of where the tiny model earned trust and where it did not.

• Who: TradingAgents (TauricResearch/TradingAgents on GitHub).
• What: a multi-agent trading research firm: four analysts, a bull-versus-bear debate, a trader, a risk team, and a portfolio manager — reports only, no broker connection.
• When: version 0.7.1, verified in this guide; 117,304 stars at the 2026-10-28 snapshot, up 4,296 stars in five days.
• Requirements: Python 3.11+, Ollama, about 522 MB for qwen3:0.6b. No API key, no account, and no GPU for the small model used here.
• Licence: Apache-2.0.
• Verified: a full NVDA run for 2026-10-26 completed in about 46 minutes on a 2-core VM; the saved bundle holds a 21,044-byte Markdown report plus HTML; the final rating was Hold; the small model’s failures (unit slip, invented news figures, three structured-output fallbacks) are documented in Step 6.

Why this project is blowing up now

TradingAgents (TauricResearch/TradingAgents, Apache-2.0) is a multi-agent LLM financial-trading framework built on LangGraph. You give it a ticker and a date; it returns a decision and a report. It does not place trades and it is not connected to a broker — approved orders go to a simulated exchange — and its authors describe it as research, not financial advice. That framing matters, and this tutorial keeps it: nothing here is a recommendation to buy, sell, or hold anything.

The numbers behind the surge are measured, not vibes. Whatstrending.ai's daily snapshots put the repo at 117,304 stars on 2026-10-28, up 4,296 stars in the five days from October 23 to October 28, with its growth rate accelerating from 254 stars a day to 859 stars a day — the biggest acceleration of any tracked AI repo that week. The timing lines up with the 0.7.1 release line, which added per-tier model providers (so the managers can run on a different model from the analysts) and one-page HTML reports. This guide uses 0.7.1, verified with pip show tradingagents.

What you'll need

• Python 3.11 or later (verified here on Python 3.12) and pip.
• Ollama (verified here: 0.40.11) and about 522 MB of disk for the qwen3:0.6b model on first pull.
• Git, and an internet connection for Yahoo Finance prices and SEC EDGAR filings. Neither needs an account or an API key.
• No LLM API key, no market-data subscription, no broker account. The whole run below costs $0 in API usage.
• Patience on a small machine: the full run took about 46 minutes on a 2-core VM, because the local model generates at roughly 5 tokens a second. A stronger local model or a cloud model finishes much faster, at the price of API usage.

A warning before you start: the model in this guide is tiny — 0.6 billion parameters. It is here to prove the pipeline end to end for free. Its analysis is weak, and Step 6 shows exactly how. If you want research you can rely on, run the same steps with a capable model (Step 7 explains how) and still verify every figure yourself.

Step 1 — Install Ollama and pull a local model

Ollama serves local models behind an OpenAI-compatible API on http://localhost:11434/v1, which is exactly what TradingAgents talks to in its Ollama mode. Install it from Ollama's own installer, then start the server:

curl -fsSL https://ollama.com/install.sh | sh
ollama serve

Then pull the small model this guide uses. The first pull downloads about 522 MB:

ollama pull qwen3:0.6b
ollama list

Expected output (verified):

NAME                    ID              SIZE      MODIFIED
qwen3:0.6b              7df6b6e09427    522 MB    4 weeks ago

One honest note: in this sandbox the pull's manifest fetch timed out behind the network proxy, so the run below used a previously cached copy of the model. The cached model itself was verified three ways — ollama list shows it, the server answers /api/tags, and a chat-completions call returned a correct answer. If your pull stalls, check your proxy before blaming the model.

Confirm the API the framework will use, with a one-word smoke test:

curl -s -X POST http://127.0.0.1:11434/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{"model":"qwen3:0.6b","messages":[{"role":"user","content":"Reply with the single word OK."}],"temperature":0}'

Verified response: a completion whose message content is OK. If this fails, stop here — TradingAgents will fail the same way, and the fix is in your Ollama server, not in TradingAgents.

Step 2 — Install TradingAgents 0.7.1

Clone the repo and install it into a virtual environment:

git clone https://github.com/TauricResearch/TradingAgents.git
cd TradingAgents
python3 -m venv venv
./venv/bin/pip install .

The clone is small (9 MB). The install pulls LangGraph and its dependencies; on a flaky proxy you may see pip retry a few wheels before succeeding — that is retry noise, not failure. Verify the install:

./venv/bin/python -c "import tradingagents; print('tradingagents import OK')"
./venv/bin/pip show tradingagents | head -3

Verified output:

tradingagents import OK
Name: tradingagents
Version: 0.7.1

./venv/bin/tradingagents --help should render the full CLI, including --ticker, --date, --analysts, --save, --no-show, and --html. If help renders, the install is good.

Step 3 — Point TradingAgents at the local model

TradingAgents reads its configuration from TRADINGAGENTS_* environment variables, which also skip the interactive CLI's questions. Set these before running:

export NO_PROXY=localhost,127.0.0.1
export TRADINGAGENTS_NO_UPDATE_CHECK=1
export TRADINGAGENTS_LLM_PROVIDER=ollama
export TRADINGAGENTS_QUICK_THINK_LLM=qwen3:0.6b
export TRADINGAGENTS_DEEP_THINK_LLM=qwen3:0.6b
export TRADINGAGENTS_OUTPUT_LANGUAGE=English
export TRADINGAGENTS_MAX_DEBATE_ROUNDS=1
export TRADINGAGENTS_MAX_RISK_ROUNDS=1

What each line does: NO_PROXY keeps the Ollama loopback address off the network proxy (without it, local calls can be routed out and fail); the provider line selects Ollama, whose default endpoint is http://localhost:11434/v1 with no key; the two model lines put the same small model on both tiers — the quick tier serves analysts, researchers, debaters and trader, the deep tier serves the research and portfolio managers; the rounds lines keep the debate and the risk discussion to one round each, which is the default and the fastest setting.

Storage defaults to ~/.tradingagents. This run pointed storage at a scratch folder with TRADINGAGENTS_RESULTS_DIR, TRADINGAGENTS_CACHE_DIR, and TRADINGAGENTS_MEMORY_LOG_PATH; omit those three lines to use the defaults. Nothing else in the command below depends on them.

Step 4 — Run NVIDIA through the whole firm

One command, no questions asked, because every choice is either a flag or an environment variable:

./venv/bin/tradingagents --ticker NVDA --date 2026-10-26 \
  --analysts market,news,fundamentals --save --no-show

The CLI confirms every choice before it starts. Verified output:

✓ Ticker from --ticker: NVDA
✓ Analysis date from --date: 2026-10-26
✓ Output language from environment: English
Selected analysts: market, news, fundamentals
✓ Research depth from environment: 1 debate / 1 risk rounds
✓ LLM provider from environment: ollama
✓ Backend URL: http://localhost:11434/v1
✓ Thinking agents from environment: quick=qwen3:0.6b, deep=qwen3:0.6b

The analysts run in parallel. The market analyst pulls Yahoo prices, the news analyst pulls current news and macro data, and the fundamentals analyst pulls SEC EDGAR filings — for NVIDIA, the cache shows CIK0001045810.json, NVIDIA's EDGAR company file. The data layer verifies point-in-time integrity: the log records "Rows after the requested analysis date are excluded before verification," and the snapshot it used is real Yahoo data for 2026-10-26:

# Stock data for NVDA from 2026-10-26 to 2026-10-26
Date,Open,High,Low,Close,Volume,Dividends,Stock Splits
2026-10-26,213.11,217.75,212.61,216.00,90829300,0.0,0.0

Analyst wall times from the finished run: Market 754.23s, News 138.74s, Fundamentals 416.36s. The spread is the model, not the data — the market analyst's report is the longest generation. Then the bull and bear researchers debate, the trader writes a plan, three risk analysts (aggressive, conservative, neutral) rebut it, and the portfolio manager decides. Expect roughly three quarters of an hour on a machine like this one; the progress is visible in the reports folder as each stage lands.

Three lines in the log deserve attention, because they are the small model's signature. Each of the three manager roles failed structured output once and fell back to free text:

Research Manager: structured-output invocation failed (structured output returned no parsed result); retrying once as free text
Trader: structured-output invocation failed (structured output returned no parsed result); retrying once as free text
Portfolio Manager: structured-output invocation failed (structured output returned no parsed result); retrying once as free text

The fallbacks worked — the run completed — but they are a warning: this model cannot reliably produce the structured outputs the framework asks for. A capable model does not need the fallback.

Step 5 — Read the report it saved

The run ends with Analysis Complete! and a saved bundle. Verified:

✓ Report saved to: results/reports/NVDA_20261028_021642
  Complete report: complete_report.md
  HTML report: complete_report.html

Inside the bundle: complete_report.md (21,044 bytes) and complete_report.html (52,875 bytes), plus one folder per stage — 1_analysts, 2_research (bull, bear, manager), 3_trading (trader), 4_risk (conservative, neutral, aggressive), 5_portfolio (decision). The decision itself, from 5_portfolio/decision.md:

- **Rating**: Hold
- **Executive Summary**: The trader's position is a strategic risk-based move aligned
  with the technical strength of the current upward trend, supported by MACD signals
  (signal -0.9178) and moving average levels (50 SMA $222.216), as well as volume evidence.

The trader's plan behind it:

- **Action**: Hold
- **Entry Price**: $189.5
- **Stop Loss**: ATR $6.11
- **Position Sizing**: 10% of the total investment

The market report's indicator values, as the model reported them: close 216.00, moving averages 222.216 and 203.519, RSI 44.1367, MACD signal −0.9178, ATR 6.11169. The fundamentals table lists quarterly revenue of 81,615 and 96,221 (millions) for the quarters ending 2026-04-26 and 2026-07-26, with net income of 58,321 and 59,688 (millions) for the periods 2026-04-26 and 2026-07-26. Treat those as the model's report of the data, and check them against the filing before you use them — Step 6 is why.

Step 6 — Audit the small model's work before you trust any of it

This is the most important step, and it is the reason the local run is a smoke test rather than research. Four concrete failures from this exact run:

1. It misread the units. The fundamentals table is labeled in millions, and the model's own insights call the same figures "$81.6M in revenue" and "$58.3 million" of net income. 81,615 millions is $81.6 billion, not $81.6 million. Any conclusion built on the model's prose inherits a thousand-fold error.
2. It invented figures in the news report. The news report claims "NVIDIA's recent Q4 revenue growth of $15B" and a stock "expected to reach $18B by 2026." Neither figure appears in the data the run fetched. The data layer is verified; the news prose is not.
3. Its own plan contradicts its own data. The trader's plan sets an entry price of $189.5 while the market report's verified close is 216.00. A plan whose entry is 12% below the close it just reported is not a plan you execute — it is a sign the model lost track of the numbers.
4. It cannot do structured output. All three manager roles failed structured output and needed the free-text retry (Step 4). The framework handled it, but on a longer or stricter run that fallback is where a pipeline silently degrades.

The pattern is consistent: the framework's data fetching, verification, debate structure, and report assembly all worked, and the tiny model's reasoning about the numbers did not. That split is the whole point of running it locally first — you learn which half to trust before you pay for a model that can do the other half.

Step 7 — When to use this, and what to run instead for real research

Use the local path when you want to learn the framework, test a configuration, or verify that your data vendors work — all for $0. Use it to answer "does this pipeline run?" Never use a 0.6-billion-parameter model's Hold rating as an investment input.

For research you intend to rely on, change only the model, not the workflow. Set TRADINGAGENTS_LLM_PROVIDER to a cloud provider you have a key for (OpenAI, Google, Anthropic, DeepSeek, Groq, and others are supported) and set the quick and deep model variables to capable models, then re-run the same command. The per-tier settings exist for exactly this: put a strong model on the deep tier (research and portfolio managers) even if the analysts run on something cheaper. Expect API costs per run, and expect the debate to take minutes rather than three quarters of an hour.

Two more routes the same install gives you, neither run here so neither is claimed as verified: the tradingagents backtest subcommand scores past decisions over a grid of tickers and dates, and the Python API (TradingAgentsGraph(...).propagate(ticker, date)) lets you drive the firm from your own code, including passing a portfolio so the trader sizes against your actual book. Both are documented in the repo's README; start with the CLI run above before you reach for them.

What this does not replace: a single careful read of the filing, a second data source for any figure you act on, and your own judgment. The framework's own docs say the same — it is research tooling, and live data moves, so a run dated today sees different news and social inputs than the same run next week even for the same trade date.

When to use this vs alternatives

The takeaway

TradingAgents earns its surge honestly at the framework level: a real multi-agent pipeline, real free data vendors, point-in-time discipline, and a complete report bundle from one command. The local-model run proves all of that for $0 in about 46 minutes on a small machine. It also proves the limit that matters: a tiny model will misread the very data the framework verified. Run it locally to learn the machine, run it on a capable model to do research, and never let either one skip the audit in Step 6.

Checklist: Ollama serving with qwen3:0.6b listed; TradingAgents 0.7.1 installed and importing; environment variables set; the NVDA command exits 0 with "Analysis Complete!"; the saved bundle contains complete_report.md and complete_report.html; and you have read the trader's plan and the portfolio manager's rating with the Step 6 audit in mind. If any item is missing, the run is not done — re-run it rather than trusting a partial bundle.

Sources

• TauricResearch/TradingAgents — README, installation, Ollama configuration, CLI flags, and Python API (version 0.7.1, read 2026-10-27)
• whatstrending.ai — AI Repo Acceleration Report, updated 2026-10-28 (star snapshots for TradingAgents)

Research only. This tutorial demonstrates open-source software with a simulated exchange; it is not financial, investment, or trading advice, and no trade was placed. Verify every figure against primary sources before acting on any research output.