Design multi-agent systems for finance you can defend in an architecture review

A fast repass of the ground an architect stands on: what LLMs can and cannot do, the four core limitations, the four ways out, and what separates a chatbot from an agent. If you took Level 1 this is a brisk warm-up; if you didn't, it's your on-ramp.

Key concepts: LLM foundations, the four core LLM limitations, in-context learning vs fine-tuning vs RAG vs agents, the autonomy spectrum, the augmented LLM building block.

2 labs: a ten-minute environment check, then a grounded document Q&A pushed to the exact question where plain retrieval fails. That failure stays open until week 5.

The agent stack rebuilt from zero: the raw loop hand-built, then the same agent on the OpenAI Agents SDK. Around it, the full design-pattern map and a planning deep dive that pays off in the final week.

Key concepts: the agent loop, the design-pattern taxonomy (capability, reasoning, quality, orchestration), planning styles and their hybrids, tool calling.

1 lab: build the loop raw, then rebuild it on the SDK as a company-research agent that produces a rapid due-diligence brief.

The mental shift the course is named for: from a loop you can't inspect to a graph with explicit state that branches, persists, and resumes. This is the substrate everything after runs on.

Key concepts: why graphs beat loops, typed state, conditional branching, checkpointing, resuming a run mid-flight, streaming events.

1 lab: a stock-analysis graph with a conditional risk branch on a sector-ETF pipeline; stop it mid-run, then resume it.

The reasoning landscape on one map, then depth only where you build: how to make an agent check its own work, and what each extra call costs. The advanced search-based patterns are mapped and deferred to Level 3.

Key concepts: chain-of-thought, ReAct, reflection and self-refinement, Reflexion, self-consistency and majority voting, the cost/quality trade-off of each pattern.

3 labs, all built as graphs: a ReAct valuation agent, a reflection loop that critiques a trading strategy, and a self-consistency vote that produces an investment recommendation.

An agent that forgets every session is useless for recurring work. The memory taxonomy first, then the discipline on top of it: treating the context window as a budget and deciding what belongs where.

Key concepts: working vs long-term memory (episodic, semantic, procedural), learning from past sessions, the context window as a budget, prompt vs memory vs retrieval, the four context strategies (write, select, compress, isolate).

1 lab: a portfolio-rebalancing advisor whose past sessions are distilled into retrievable experience that grounds its next recommendation.

The workflow patterns behind reliable agent systems, read through a finance lens: when a fixed, inspectable pipeline beats an autonomous agent, and how to wire specialists in parallel.

Key concepts: the augmented LLM building block, prompt chaining with gates, parallelization (sectioning and voting), routing, orchestrator-workers, workflows vs agents in finance.

1 lab: a sector-ETF call decided two ways: by a panel of specialist analysts synthesized into one view, then by a persona vote.

The architecture chapter: the ways to wire agents together, what state they share, and where a human signs off. It ends on the question architects get paid to answer: when is one agent the right answer?

Key concepts: supervisor/workers, orchestrator-worker, evaluator-optimizer, handoffs, agents-as-tools, shared state design, context isolation, human-in-the-loop approval gates.

3 labs: an evaluator-optimizer loop refining a trading strategy, a side-by-side comparison of handoffs vs agents-as-tools, and a research-note production line where a human approves, edits, or rejects before release.

You just built a system where several agents hand work to each other. This chapter is how you see what it actually did: every call, every tool, every handoff, with latency and token counts attached.

Key concepts: traces and spans, instrumenting an agent, reading a multi-agent trace, built-in tracing vs an external tracing tool, where tracing ends and evaluation (Level 3) begins.

1 lab, two parts: instrument a single tool-using agent and read its full trace, then point the same instrumentation at the previous chapter's agent team and read the handoffs.

The answer to week 1's open failure: retrieval that behaves like an analyst instead of a lookup. You hand-build the control flow, so every decision the system makes is a node you wrote.

Key concepts: naive-RAG failure modes, query rewriting, routing across multiple indexes, sub-question decomposition, retrieval grading, corrective retries, supported/unsupported verdicts with citations.

1 lab: an agentic RAG graph that routes, decomposes, grades its own retrieval, and refuses when the evidence isn't there.

The same architectural ideas, delivered by a framework built for retrieval. The chapter closes on the architecture decision itself: when do you hand-roll the graph, and when do you take the framework's abstractions?

Key concepts: LlamaIndex RAG components, semantic routing across indexes, sub-question decomposition, an agent over query engines, framework vs hand-rolled trade-offs.

1 lab: the agentic retrieval patterns rebuilt on framework abstractions, over a different corpus, ending with the side-by-side comparison.

Week 6 assembles everything into three end-to-end systems, each on a deliberately different architecture: an Autonomous Rates Analyst (Reflex), an FX Strategy Desk (Bullfight), and an ETF Portfolio Construction Team (Sous-Chef). Full details below.