The trader: cheatsheet

For education only. Multi-agent architecture taught via stock analysis; not investment, financial, or trading advice.

The one idea

A verdict is not an action. After the judge decides, a separate, cheaper agent (the trader) turns that decision into a concrete plan, building on it instead of reopening it. (Anchored to the TradingAgents framework, frozen snapshot 7e9e7b8; trader in agents/trader/trader.py.)

Decide vs operationalize

• Deciding weighs competing arguments and commits. That was the judge’s job last lesson.
• Operationalizing takes the decision as settled and spells out the concrete steps. That is the trader’s job.
• Mashing them into one agent makes it re-argue while it should be executing; you get a wobbly answer that does neither job well. Split them.

What the trader does

Step	What happens	In the code
Read the decision	Pull the judge’s plan from shared state	investment_plan = state["investment_plan"]
Build on it	Anchor on the plan and reports; do not relitigate	”Anchor your reasoning in the analysts’ reports and the research plan.”
Write the proposal	Save a concrete proposal as its own field	return {"trader_investment_plan": trader_plan, ...}

The proposal is a structured object (machine-readable), with a plain-text fallback if that fails. The “buy, sell, or hold” recommendation is the agent’s own output inside the system, an architectural step, not advice to you.

The quiet tell: model tier

tradingagents/graph/setup.py

trader_node = create_trader(self.quick_thinking_llm)

The trader runs on the quick (cheaper) model; the judge before it ran on the deep one. The model tier follows the difficulty of the thinking, not the importance of the agent. The hard judgment already happened at the judge, so that is where the expensive model was spent.

How to follow along

Read it free in your browser at github.com/TauricResearch/TradingAgents (pinned snapshot). No account, no Git, no programming knowledge needed. The short code 7e9e7b8 marks one frozen version, so the lessons match what you see.

Build your own (the transferable pattern)

1. Pass the decision in as given; the synthesis agent reads the finished decision, not the raw inputs that produced it.
2. Tell it to build on the decision, not relitigate; anchor it to the prior judgment.
3. Use a cheaper model here; the hard call is already made, so save your best model for the decision step.

Pitfalls to dodge

• One agent that decides and delivers in a single shot (it re-argues while executing).
• A synthesis step fed the raw evidence instead of the decision (it forms its own view and may contradict the judgment).
• Spending your most capable model on the write-up instead of on the actual judgment.

Words to use precisely

• Synthesis / operationalize: turning a settled decision into a concrete, actionable artifact.
• Build on, not reopen: anchor on the prior decision rather than re-arguing it.
• Model tier by difficulty: the expensive model goes where the hard judgment is, not on every important-looking step.