Practice: The trader

For education only. This practice is about agent architecture; it is not investment, financial, or trading advice, and nothing here is a recommendation to buy or sell anything.

Self-check

Six short questions. Answer each in your head before opening the collapsible. Active retrieval is where the learning sticks.

1. The judge already committed to a stance last lesson. Why does the system need a trader at all?

Show answer

Because a decision is not yet an action. The judge’s plan says what to lean toward (“the case favors growing the position”), not what to actually do. The trader’s job is to turn that verdict into a concrete, specific proposal. Deciding and working out the plan are two different jobs.

2. What does the trader read as its starting point, and what does it pointedly not do?

Show answer

It reads the judge’s plan straight from shared state (the investment plan). It pointedly does not re-read the raw debate transcript to form its own opinion or reopen the question. It takes the finished judgment as settled and builds on it. Its instruction even tells it to anchor its reasoning in the analysts’ reports and the research plan.

3. What happens if you ask a single agent to both decide and lay out the plan in one shot?

Show answer

It tends to re-argue the decision while it is supposed to be executing it, because deciding and operationalizing pull in different directions. The result is a wobbly answer that does neither job cleanly. Splitting them into two agents keeps each one clean and lets you inspect the decision before building on it.

4. The trader runs on the cheaper model, but the judge before it ran on the more capable one. Why is that the right way around?

Show answer

Because the model tier follows the difficulty of the thinking, not the importance of the agent. The hard part, weighing both sides and committing, already happened at the judge, so that is where the expensive model was spent. Turning a settled decision into a concrete plan is real work but not the hard judgment, so it can run on the cheaper, faster model.

5. The trader’s output “matters a great deal,” yet it still runs on the cheap model. Is that a contradiction?

Show answer

No. Importance of the output and difficulty of the thinking are different things. The trader’s proposal is what the next stage acts on, so it matters, but producing it from an already-settled decision is comparatively routine. You spend capability on hard judgment, not on important-looking outputs.

6. Where does the trader’s proposal go, and why does that matter for the next stage?

Show answer

It is written back into shared state as its own field (the trader’s investment plan). That is the handoff: the next stage, the risk layer, reads the proposal from shared state, exactly as the trader read the judge’s plan from it. Each agent leaves one durable output behind for the next to pick up.

Try it yourself: add a synthesis step to your own agents

No tooling, no cost; this is design judgment. Pick a decision-then-plan task you understand (for example: a hiring committee that decides “extend an offer,” then someone drafts the actual offer; or a team that decides “we will rebrand,” then someone writes the rollout plan). Then design the split:

1. Name the DECISION step and the SYNTHESIS step as two separate agents.
2. Decide what the synthesis agent READS: the finished decision (yes) or the
   raw inputs that produced it (no). How will you feed it the decision?
3. Write the synthesis agent's INSTRUCTION so it builds on the decision instead
   of reopening it. Then pick its MODEL tier and justify it.

Show answer (worked example: rebrand rollout)

Two steps: a “decide” agent that weighs whether to rebrand and commits; a separate “plan” agent that writes the rollout.
What it reads: the finished decision plus the supporting notes, not a blank slate. You hand it the committed call (“we are rebranding, here is the rationale”) so it does not relitigate whether to rebrand at all.
Instruction and model: “Assume the rebrand decision is final; produce a phased rollout plan that anchors on the stated rationale.” A capable-but-cheaper model is fine here, because the hard call (should we rebrand?) was already made by the decide step on your best model.

Notice the shape matches the lesson: the decision is made once, upstream, on the strong model; the synthesis step builds on it, on a cheaper model. The domain changed; the pattern did not.

Flashcards

Eight cards. Click any card to reveal the answer. Use the Print flashcards button to lay out the full set as one card per page for offline review.

Q. Why does the system need a trader after the judge already decided?

Because a decision is not yet an action. The judge’s plan says what to lean toward; the trader turns that verdict into a concrete, specific proposal. Deciding and operationalizing are two different jobs.

Q. What does the trader read, and what does it not do?

It reads the judge’s plan from shared state and builds on it. It does not reopen the debate or form a fresh opinion from the raw transcript; it takes the finished judgment as settled.

Q. What goes wrong if one agent both decides and plans in one shot?

It re-argues the decision while it should be executing it, because the two tasks pull in different directions. The output does neither job cleanly. Splitting them keeps each clean.

Q. Which model does the trader run on, versus the judge?

The trader runs on the quick (cheaper) model; the judge ran on the deep (more capable) one. The model tier follows the difficulty of the thinking, not the importance of the agent.

Q. The trader's output matters a lot but runs on the cheap model. Contradiction?

No. Importance of the output and difficulty of the thinking are different. Producing a plan from an already-settled decision is comparatively routine, so it does not need the expensive model.

Q. Where does the trader's proposal go?

Back into shared state as its own field (the trader’s investment plan). The next stage, the risk layer, reads it from there, the same handoff pattern every agent uses.

Q. What is the decide-then-operationalize pattern?

One step makes the decision; a separate step turns that decision into the concrete artifact, building on it rather than reopening it. Feed the decision in as settled.

Q. How should you choose a model tier for a synthesis step?

By the difficulty of the thinking, not the importance of the output. The hard judgment already happened upstream on the strong model, so a synthesis step that operationalizes it can run on a cheaper one.