From your first LLM API call to your first multi-agent finance system

Start at the foundations: what a large language model actually is, what it can and cannot do, and how you talk to one through an API. You leave able to make your own calls, read what a call costs you, and get clean structured data back instead of loose prose.

Key concepts: what “large”, “language” and “model” each mean, reasoning vs non-reasoning models, tokens and context windows, open-source vs proprietary models, LLM APIs, structured outputs.

2 labs: your first calls to several LLM providers, a finance summarization task, and typed JSON you can pass downstream.

Where a raw model breaks on finance work, and the four ways out: better prompting, fine-tuning, retrieval, or an agent. You watch each failure happen for yourself, so you can recognize it in the wild and know which fix belongs to which problem.

Key concepts: the four core LLM limitations, hallucination, prompt engineering (zero-, one- and few-shot), fine-tuning, RAG, the bridge to agents.

2 labs: make the limitations happen on purpose, then fix them with grounding and typed extraction.

What actually separates a single prompt from an agent, and the parts every agent is built from. This is where tools enter the picture: the moment a model stops guessing at an answer and starts going to fetch it.

Key concepts: prompting vs agentic workflows, the autonomy spectrum, the anatomy of an agent (planning, memory, tools, environment, reflection), tool calling.

1 lab: the same finance question answered without an agent and with one, using tools on live data.

The map of agent design patterns, then the engine sitting under all of them: the loop. You build that loop yourself before you meet the framework that hides it, so nothing the OpenAI Agents SDK does later feels like magic.

Key concepts: the design-pattern taxonomy, tool use and agent memory, deterministic flows (routing, handoffs, guardrails), the agent loop, the OpenAI Agents SDK.

3 labs: build your own agent harness, rebuild the same agent on the SDK, then extend it with a set of tools.

How to make an agent reason before it acts, and why a reasoning trace you can actually read matters in a regulated industry. Built by hand first, then the same agent on the SDK.

Key concepts: Chain-of-Thought prompting, ReAct (thought, action, observation), reasoning traces you can audit.

2 labs: a ReAct agent from scratch, then the same agent on the SDK.

An agent that forgets is useless for anything you do more than once. You learn what kinds of memory an agent can have, and give one a memory that survives from session to session.

Key concepts: working memory, long-term memory (procedural, episodic, semantic), keeping state across runs, not just across turns.

1 lab: a memory-backed assistant for a recurring portfolio task.

How to put your own documents within an agent's reach and answer questions with the sources attached. Then the step that makes it agentic: letting the agent decide which source to open in the first place.

Key concepts: chunking, embeddings and similarity search, RAG pipelines, answers grounded in your documents with sources attached, agentic retrieval.

2 labs: a grounded Q&A over one filing, then an agentic version that routes across two.

When one agent should become several, and the two ways to wire them together. You run the same finance question through each approach and see for yourself where each one fits.

Key concepts: why more than one agent (context isolation, specialization), handoffs vs agents as tools, routing and parallel calls.

1 lab: one finance question run through each orchestration pattern, side by side.

The question that saves the most money is whether you needed an agent at all. A straight look at where simple beats clever, and what every extra layer of autonomy costs you in latency, spend and reliability.

Key concepts: the autonomy vs complexity spectrum, workflows for consistency vs agents for flexibility, cost and latency against reliability and accuracy.

Takeaway: a decision framework you can apply to your own use cases.

Three end-to-end builds that put the whole course together on real finance workflows: a Morning Briefing Desk (Espresso), a Financial News Bot (Hot Take) and an Earnings Season Watchtower (Harvest). Full details below.