Tools, Memory, and Multi-Agent Systems
Most agent demos fall apart the same way: they work in the happy path and break the moment a tool call fails, a context window fills up, or a memory store gets fed something it shouldn't trust. This course teaches the two disciplines that decide whether an agent survives that: designing tools it can call safely, and giving it memory that actually holds up past one session. You will build a reasoning agent and a memory subsystem yourself, not just read about ones that exist, and by the end you can look at any agent framework, including one you build, and say specifically which bug classes its architecture removes and which ones it just papers over. Five weeks, migrated from a live Nebius Academy cohort, with a real framework (sovereign-agent) built and debugged on camera as the running case study. Every claim in it is backed by a measured number, a named paper, or a production incident, not a general sense that agents are hard.
MethodThis course teaches a discipline. The examples use today's tools; the method is meant to outlast them.
Rod Rivera
Professor
Desk
First lesson is free to preview.
What You'll Learn
- Tell whether a system is a real agent or a model with a longer conversation loop, and why lost-in-the-middle is a property of attention, not a bug you can prompt away
- Split a task between a Planner role and an Executor role tiered to difficulty, and trace exactly what happens between a model deciding to call a tool and that tool actually running
- Design a tool with all five required parts, and choose correctly among CLI wrappers, in-process functions, external APIs, MCP, and A2A for a given job
- Defend against prompt injection and the lethal trifecta with structural controls, not persuasive instructions — and size every model in a multi-model pipeline for what's upstream of it
- Place any reasoning technique — a paper, a product feature, a framework flag — correctly on the spectrum from reactive to strategic, and build a Planner-Executor loop that replans instead of crashing
- Pick the right memory type for a piece of information, choose a memory structure by operational fit rather than benchmark score, and name all nine CRUD++ operations a real memory system needs
- Place any memory framework into one of three production archetypes, and defend a memory store against a poisoning attack at the write path, not the read path
- Distinguish a framework's structural guarantees from an agent's semantic correctness, and write a dataflow integrity check that verifies what ticket-and-manifest checks structurally cannot
Prerequisites
- Comfort reading Python; every lesson from Week 2 onward works through real code, not pseudocode
- No prior agent-building experience required — Week 1 builds the vocabulary this course uses from first principles
- Helpful but not required: some exposure to calling an LLM API directly (a raw chat completion call, not a framework)
Syllabus
Ready to keep going?
The lessons in Tools, Memory, and Multi-Agent Systems are open. The Prof Rod weekly lesson is the next thing, not a door.
