Design multi-agent systems for finance. Then make them production-grade.

A fast repass of the ground an architect stands on: what LLMs can and cannot do, what separates a chatbot from an agent, and 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.

Key concepts: the agent loop, the design-pattern taxonomy (capability, reasoning, quality, orchestration), planning styles, tool calling, in-context learning vs fine-tuning vs RAG vs agents.

Labs include: a grounded document Q&A pushed to the exact question where plain retrieval fails (a failure that stays open until the agentic RAG module resolves it), and a company-research agent built raw, then rebuilt on the SDK.

The mental shift the architecture phase is built on: 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.

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

How to make an agent check its own work, and what each extra call costs. Every pattern is built hands-on, on a finance task.

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

Labs include: 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, prompt vs memory vs retrieval, the four context strategies (write, select, compress, isolate).

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

When a fixed, inspectable pipeline beats an autonomous agent, how to wire specialists in parallel, and the ways to connect agents into a team: 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: prompt chaining with gates, parallelization, routing, orchestrator-workers, supervisor/workers, evaluator-optimizer, handoffs, agents-as-tools, human-in-the-loop approval gates, workflows vs agents in finance.

Labs include: a sector-ETF call decided by a panel of specialist analysts, an evaluator-optimizer loop refining a trading strategy, 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 module 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.

Labs include: instrument a single tool-using agent and read its full trace, then point the same instrumentation at an agent team and read the handoffs.

The answer to the opening module's planted failure: retrieval that behaves like an analyst instead of a lookup. First hand-built in LangGraph, so every decision the system makes is a node you wrote, then rebuilt on LlamaIndex's abstractions, closing on the architecture decision itself: when do you hand-roll, and when do you take the framework?

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

Labs include: an agentic RAG graph that routes, decomposes, grades its own retrieval, and refuses when the evidence isn't there, then the same patterns rebuilt framework-native over a different corpus.

The signature module of the production phase, and a discipline no tutorial teaches: the harness is everything the loop must own that the model doesn't. Runaway loops, silent failures, and cost blowouts each get a detection signal and a guard.

Key concepts: turn and token budgets, stop conditions, tool dispatch, retries and timeouts, cost circuit breakers, checkpoint and resume, human interrupts, the loop failure taxonomy.

Labs include: familiar agent loops re-read through production robustness: bounded retries, budget guards, and disagreement as a live escalation signal.

Keeping an agent inside its mandate: guardrails as first-class components, the subtle race condition where a tool fires before the guardrail verdict lands, and red-teaming your own system before someone else does.

Key concepts: input and output guardrails, tripwires, the guardrail-vs-tool race condition, compliance-safe behavior, red-team batteries as living test assets.

Labs include: harden a fundamentals agent against out-of-scope queries and the race condition, then attack an advisory agent with a red-team battery.

Agents that touch real workflows need defense and a paper trail: resisting injected instructions, tiering actions by how reversible they are, and being able to reconstruct for a reviewer exactly why the agent did what it did.

Key concepts: prompt-injection defense, action tiers, least-privilege tools, the trace as an audit file, reconstructing an agent's history from its records.

Labs include: a hardened client-intake agent, and an audit lab that reconstructs an agent's decisions end to end.

From reading traces to running monitoring: instrument a whole agent team persistently and turn a pile of runs into a monitoring view someone can act on.

Key concepts: traces and spans for teams, persistent instrumentation, reading a team's behavior per agent and per run, latency budgets, monitoring vs looking.

Labs include: instrument the team you built in Phase 1 end to end and read what it actually did, agent by agent, run by run.

The module that separates a demo from a system: how do you know the agent is good, and how do you know it's still good after you change it? Judges where judgment is needed, code where code is better, and thresholds you re-check after every change. Then the part most courses skip: measuring your retrieval pipeline, with the metrics that tell you whether the retriever or the generator is failing.

Key concepts: offline evals over traces, synthetic datasets, LLM-as-a-judge vs deterministic code evaluators, tool-selection evals, trajectory convergence, the RAG evaluation triad (faithfulness, answer relevance, context relevancy), hallucination metrics.

Labs include: judged QA at scale, tool-call evaluation, trajectory convergence, code-execution checks, and a routed retrieval pipeline over a real filing evaluated end to end.

The closing stretch assembles everything into complete, inspectable systems drawn from both phases (see the builds below), then you design and ship your own capstone: any finance use case, at least two cooperating agents, plus at minimum guardrails, tracing, and one eval. Scope small and finish: a modest system that runs beats an ambitious diagram.