Capstone: run the agent team yourself

For seven lessons you have read a real multi-agent system one part at a time: the analysts that gather their own data, the bull and the bear that argue, the judge that rules, the trader that plans, the risk seats and the gate, the orchestration that wires them together, and the memory that lets them learn. This last lesson is where it all runs at once. You can watch the whole team work end to end, and if you want, run it yourself, on your own machine, in a safe simulation.

This track teaches how a multi-agent AI system is built and coordinated. It uses stock analysis as the worked example. It is for education only. It is not investment, financial, or trading advice, and nothing here is a recommendation to buy or sell anything.

What you have built up to

Everything you studied is one connected pipeline. When the system runs, control flows through the exact path you read about: the four analysts gather, the bull and the bear debate, the research manager rules, the trader turns that ruling into a proposal, the three risk seats stress-test it, and the portfolio manager makes the final call. The two managers are the deep-model judges; every other role runs on the faster model. That is the whole architecture of this track, in one sentence, and now you get to see it move.

What a run looks like

When the system runs from the command line, it shows a live status board. Each agent flips from waiting to working to done, grouped by team. Here is what it looks like when a run completes (an illustrative company, not a suggestion of any kind):

Selected analysts: market, social, news, fundamentals

  Analyst Team          Market Analyst          completed
                        Social Analyst          completed
                        News Analyst            completed
                        Fundamentals Analyst    completed
  Research Team         Bull Researcher         completed
                        Bear Researcher         completed
                        Research Manager        completed
  Trading Team          Trader                  completed
  Risk Management       Aggressive Analyst      completed
                        Conservative Analyst    completed
                        Neutral Analyst         completed
  Portfolio Management  Portfolio Manager       completed

Analysis Complete!

The board reads top to bottom as the table of contents of this whole track. Each team is a lesson you already finished.

When it ends, the system writes seven plain reports to a folder on your machine, one per stage. Each file is the output of an agent you studied:

the four analyst reports (market, social, news, fundamentals): lesson 2, the tool-using analysts gathering their own data
the investment plan: lesson 3’s judge, the research manager, writing its ruling
the trader’s plan: lesson 4, the verdict turned into a concrete proposal
the final trade decision: lesson 5’s gate, the portfolio manager, making the calibrated final call

The two judgment points stand out in the output, exactly as the track described them. The trader takes the research manager’s ruling and turns it into a specific written proposal. Then the three risk seats argue over it, and the portfolio manager (the deep-model gate) writes the final recommendation, one of the system’s five stances (Buy, Overweight, Hold, Underweight, Sell). The final write-up does not average the three risk voices; it reconciles them and commits. That is the deep-model judge doing the job you read about in lesson 5. (Those stances are the system’s own labels for its written research opinion, not advice to you, and the run places no orders.)

Run it yourself (optional, a safe simulation)

You do not have to run anything to finish this track; the walkthrough above is the lesson. But the whole point of an open-source system is that you can run it, so here is how. It is a simulation: it produces a written research opinion and a set of reports, and it places no trades.

I understand this is a simulation that places no real trades. Show me how to run it.

You will need a computer with Python and your own AI provider key. The project is the same open-source code you have been reading, pinned to the snapshot 7e9e7b8, so what you run matches what you studied.

The short version: create a clean Python environment, install the project, set your own provider key, then start it with a single command.

python3.12 -m venv .venv
source .venv/bin/activate
pip install -e .
export ANTHROPIC_API_KEY=your-own-key-here
tradingagents

That last command starts a short interactive questionnaire: pick a company to analyze, a date, which analysts to include, how deep to go, and which AI provider and model to use. Answer those, and the status board above starts filling in. When it finishes, it writes the seven reports to a folder under your home directory.

A few things that trip people up the first time:

Python version. The project needs Python 3.10 or newer. The Python already on your machine may be older, so build the environment with an explicit modern version (3.11 or 3.12).
Pick a provider and model that match your key. The example above sets an Anthropic key, so at the provider prompt choose Anthropic (Claude). At this snapshot the tool asks for an effort level and applies it to both model slots, and not every Claude model accepts that setting: Claude Sonnet 4.6 works, while some others make the run fail on the very first agent. If that happens, switch to a model that accepts the effort setting. (The framework also ships with a default for a different provider; if you would rather use that one, set that provider’s key instead of the Anthropic one.)
Set a spending cap. A single run makes many model calls and costs real money on your own provider account (a modest amount for one shallow run, more for deeper settings). Set a spend limit on your provider dashboard before you start, and check your usage there for the real figure.
It takes a few minutes. A single shallow run is roughly ten to fifteen minutes. Deeper settings take longer.

Never paste your provider key into a file you commit or share. Keep it in your environment, as shown above.

A note on what this is, and is not

This capstone teaches and runs the open-source library at the heart of Trading Agents Lab: the actual multi-agent LangGraph system you studied across this track, pinned to one commit so the code never shifts under you. It is the real architecture, not a mock-up. The Trading Agents Lab desktop application is a separate, polished product built on a deliberately simplified engine, a choice made for cost and user experience, not the teaching artifact you run here. Both are for education and research only. Everything in this lesson is a simulation that produces a written research opinion. It is not investment, financial, or trading advice, it places no orders, and it connects to no brokerage. You supply your own AI provider key, you never commit your secrets, and nothing you run here touches real money.

About this track: Clawdemy uses the open-source TradingAgents framework (by TauricResearch; Yijia Xiao, Edward Sun, Di Luo, and Wei Wang; arXiv:2412.20138; Apache-2.0) as a real-world example of how an agentic AI system is structured. Our goal is to teach the architecture: how specialist agents, a research debate, a trader role, and a risk layer are coordinated by an orchestrator. We are not teaching you how to invest, trade, or pick stocks, and we make no claim that this or any AI system is profitable or predicts markets. This content is for education only and is not investment, financial, or trading advice. Rules vary by country, and this is not advice anywhere. The Trading Agents Lab capstone is a simulation you explore yourself with your own AI provider key; it does not place real trades. The framework’s own authors state it plainly: “It is not intended as financial, investment, or trading advice.”

If you would rather not run code at all, the free desktop application at tradingagentslab.ai lets you watch a multi-agent run in a polished interface, with the honest caveat above that it uses a simplified engine.

Why this matters when you use AI

Step back from stocks for a moment, because the architecture is the lesson, and it travels.

You have now seen, in working code, a complete pattern for building something real with AI: break a job into focused specialists, let some of them gather their own information with tools, force disagreement where a single voice would get lazy, separate deciding from doing, put a well-resourced gate with veto power at the end, wire it all together with one shared source of truth, and let it learn from how its calls actually turn out. Spend your most capable model only at the points where the system commits.

That pattern is not about trading. It is how thoughtful people are building AI systems for research, operations, support, drafting, and review. The next time you reach for AI on something that matters, you have a real, studied example of what good structure looks like, and the confidence to ask where the specialists are, where the disagreement is, and where the gate is.

What you should remember

A real multi-agent system is a pipeline of focused roles. You watched the same path you studied run end to end: gather, argue, judge, plan, stress-test, decide, with memory closing the loop.
The structure is the lesson, not the domain. Stock analysis was the worked example; the transferable design (specialists, disagreement, a gate, shared state, learning from outcomes, capability spent at the judgment points) is yours to reuse.
You can run the real thing, safely. The capstone is the open-source library you studied, in a simulation that writes a research opinion and places no trades, on your own machine with your own key.

That is the whole track. You came in to learn how a team of AI agents is built, and you leave having read every part of a real one and watched it run. From zero to autonomous, one lesson at a time.