The trader, in brief

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.”

What you’ll learn

Lesson 3 ended with the judge’s verdict, a committed stance written down as a plan. But a verdict is not yet an action. This lesson is about the small, often-overlooked role that turns the decision into something concrete: the trader.

Reading the real code, you will see how cleanly the system separates deciding from doing. The trader reads the judge’s plan straight from shared state, and its instruction tells it to anchor on that plan rather than reopen the debate. It writes its concrete proposal back into shared state as its own field, the handoff to the next stage. And the quiet, revealing detail: the trader runs on the cheaper, quicker model, while the judge that preceded it ran on the deep one. The model tier follows the difficulty of the thinking, not the importance of the agent. The throughline is transferable: when you chain AI steps, let one step decide and a separate step operationalize, feed the decision in as settled, and spend your best model where the hard judgment actually happens.

Everything is anchored to one snapshot of the framework (a frozen version marked 7e9e7b8), and every code claim is checked against that source.

Where this fits

This is the fourth lesson of the track. Lesson 3 staged the debate and the judgment; this lesson follows that judgment one step downstream, to the agent that makes it concrete. Next, lesson 5 hands the proposal to the risk layer, where several voices stress-test it and a final manager can temper or override, and the track continues through orchestration and shared state, memory, and the hands-on capstone.

Before you start

Prerequisites: lesson 3 of this track (the bull and bear debate and the judge), which builds on lessons 1 and 2. You do not need to install or run anything; the project can be read in your browser, and every excerpt is quoted in the lesson.

By the end, you’ll be able to

Explain why deciding and operationalizing are better handled as two separate agent steps
Describe how the trader reads the judge’s plan from shared state and is told to build on it rather than reopen it
Identify the trader’s output, a structured proposal saved to shared state, and the model tier it runs on
Analyze why the trader runs on the cheaper model even though its output is what gets used
Apply the decide-then-operationalize pattern, with model tier matched to difficulty, in your own agent system

Time and difficulty

Read time: about 7 minutes
Practice time: about 15 minutes (a self-check, a design exercise, and flashcards)
Difficulty: deep (this track is the advanced end of the catalog; the foundational agent tracks are the on-ramp)