Anatomy of an AI Agent Team
Most explanations of AI agents stop at one clever model in a loop. This track goes further: it opens the source code of a real, working system in which many AI agents divide the work, argue with each other, review the result, and commit to a decision together. You read the actual code, in your browser, with no account, no Git, and no programming background needed. 8 lessons, about 2 hours, free.
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 will learn
- Why real systems split one AI into a team of specialists, and when that actually helps rather than adds noise.
- The tool-use loop that turns a plain model into an agent that fetches its own data and knows when to stop.
- How to make agents disagree on purpose, and why a separate judge, not the debaters, should decide.
- The two things that turn separate agents into one system: orchestration (who runs next) and shared state (what they pass along).
- How a careful system reviews its own plan with a gate that can overrule it, and how it learns from how its past calls turned out.
The team, at a glance
The system you read is a small organization. Analysts gather the evidence. A bull and a bear argue it at full strength, and a judge rules. A trader turns that ruling into a concrete plan. Three risk voices with different temperaments stress-test the plan, and a separate manager holds the final gate. Orchestration decides who runs next; a shared workspace carries each agent's work to the one after it; and a memory layer lets the team reflect on how its past decisions turned out. The last lesson runs the whole team end to end, as a safe simulation you run yourself.
The lessons, in order
- Why split one AI into many Meet a real, free multi-agent AI system as a team of specialists, and learn why splitting one AI into many roles makes it work better.
- How an agent fetches its own data Watch a real analyst agent decide what data it needs, fetch it with tools, and stop on its own. The tool-use loop that turns a model into an agent.
- Arguing on purpose: the bull and the bear Two agents argue the same evidence at full strength, one for and one against, then a separate judge decides. The structured-disagreement pattern, in real code.
- From verdict to plan: the trader A decision is not yet an action. Watch a real agent turn the judge's verdict into a concrete plan, on the cheaper model, without reopening the debate.
- What could go wrong: the risk gate Before the plan is final, three risk voices stress-test it and a separate manager makes the last call. The review-and-veto gate, in real code.
- How a team of agents becomes one system The last five lessons met the agents one by one. Now see the two things that turn them into one system: who runs next, and the shared state they all use.
- How the system learns from its past calls A team that never reviews its past calls repeats its mistakes. See how the system records each decision and, once the outcome is known, reflects on it.
- Capstone: run the agent team yourself You have read every part of the team. Now watch them run together end to end, in a safe simulation you run yourself, and see the architecture come alive.
About the system you will read
The worked example is TradingAgents, an open-source multi-agent framework from Tauric Research, released under the Apache 2.0 license and described in the paper TradingAgents: Multi-Agents LLM Financial Trading Framework (arXiv:2412.20138). Every lesson reads from one frozen snapshot of the project (pinned commit 7e9e7b8) so the code you see never shifts under you. You can browse that snapshot here: github.com/TauricResearch/TradingAgents . We teach its architecture as a case study; we are not affiliated with the project, and the code is used here for education, not as a trading tool.