Skip to Content
View all events

Build Self-Improving Agents with Memory, Traces, and Skills

Published by O'Reilly Media, Inc.

Intermediate content levelIntermediate

Continual learning in token and representation space

What you’ll learn and how you can apply it

  • Differentiate token-space, representation-space, and weight-space continual learning and identify which lever applies to a given production problem
  • Implement trace capture that isolates high-signal workflow trajectories from agent runs using agent memory
  • Build a dual-track promotion loop that distills repeated successful procedures, heavily used tools, and MCP servers into reusable skill files, and repeated failures into guardrails, with review gates, threat-aware shadow review, monitoring, and demotion paths
  • Design continual-learning update loops for persona, entity, and associative memory that keep agents current

Course description

Every deployed language model is frozen the moment training ends. Yet the agents built on them are expected to get better with use: to stop repeating mistakes, remember who they are working with, and turn hard-won successes into repeatable behavior. In production today, almost all of that improvement happens without touching a single weight. It happens in token and representation space through what the agent reads, remembers, and reuses.

Richmond Alake shows you how self-improving agents actually work and why they improve your tokenomics. An agent that re-derives the same procedure on every run pays for it in tokens, cost, and latency. An agent that remembers pays once, and those savings compound across the wider AI infrastructure the agent sits on: fewer model calls, fewer tool invocations, and less compute per task. You’ll learn the vocabulary that makes the field legible (token space, representation space, in-context learning, traces, skills) and why agent memory is the substrate that makes improvement possible.

This live event is for you because...

  • You’re a software engineer, ML engineer, or AI engineer with agents in production (or close to it) and you want them to improve with use rather than stay static.
  • You’re a technical lead or architect deciding how your team’s agents should learn from accumulated interaction data
  • You’ve taken Harness Engineering for AI Agents or the AI Agent Memory Management Bootcamp and want to add the next layer: agents that use their memory to get better
  • You want to understand self-improving agents beyond the hype, with concrete mechanisms and safeguards

Prerequisites

  • Working knowledge of Python, including async patterns and basic API development
  • Familiarity with LLM APIs and prompt-level agent behaviour (tool calling, system prompts, structured outputs)
  • Familiarity with agent memory types (working, episodic, semantic, procedural) is helpful; taking Harness Engineering for AI Agents or equivalent is recommended but not required

Recommended preparation:

  • A Python 3.11+ environment with a recent agent framework installed (LangChain, LangGraph, or the Claude Agent SDK)
  • An API key for at least one frontier model provider (Anthropic, OpenAI, or equivalent)
  • A local database available for memory persistence (Oracle AI Database or bring your own database)
  • A code editor with notebook support, and Git installed for cloning the course repository (shared before the session)

Recommended follow-up:

Schedule

The time frames are only estimates and may vary according to how the class is progressing.

Foundations of continual learning for agents (35 minutes)

  • Presentation: What continual learning means for agentic systems; why frozen model weights make it an architecture problem rather than a training problem; key terms (token space, representation space, in-context learning, traces, skills, self-improving agents); where continual learning sits inside the agent harness; why token-space learning is real learning—the “learning without training” result showing in-context learning acts as an implicit low-rank weight update; a brief look at the weight-space frontier (SEAL, sparse memory fine-tuning, nested learning); where the token/weight boundary is dissolving; the taxonomy of token-space versus weight-space improvement and how to decide which lever fits which problem
  • Q&A
  • Break

High-signal traces and the workflows-to-skills pipeline (45 minutes)

  • Presentation: Capturing workflow trajectories with agent memory; canonical trajectory signatures; separating high-signal traces from noise on both the success and failure side; the dual-track promotion pipeline—eligibility gates (frequency, success rate, recency, query diversity); LLM distillation of successful procedures into skill files and repeated failures into guardrail entries; turning heavily used tools and MCP servers into skills; trust-aware skill injection; the threat model for self-improvement (memory poisoning, skill hijacking, adversarial traces laundered into skills); shadow review before activation; drift monitoring and demotion
  • Hands-on exercise: Capture traces from live agent runs, inspect trajectory classes including a failure class, run a promotion cycle, review the distilled skill and its paired guardrail, and activate both into the agent’s context

Continual learning across the memory system (40 minutes)

  • Presentation: Feedback and update loops for persona, entity, and associative memory, plus handling staleness and conflict as memories evolve; measuring whether learned behavior improves outcomes using five axes (adaptivity, retention, generalization, efficiency, safety); retention framed as skill interference; context failure modes to monitor (brevity bias, context collapse)
  • Hands-on exercise: Implement update loops for persona and entity memory, resolve a staleness conflict between an old and a new memory, and wire the full self-improvement loop end to end
  • Q&A

Your Instructor

Richmond Alake

Richmond Alake is director of AI developer experience at Oracle, where he leads developer relations for the Oracle AI Database and pioneers the discipline of memory engineering, a term he coined to describe the structured design of agent memory systems. He runs the #100DaysOfAgentMemory LinkedIn series, which has reached tens of thousands of AI practitioners.

Richmond has published over 200 technical articles with more than one million views across Medium, NVIDIA’s technical blog, and other industry publications, covering topics from agent memory systems to production LLM application development. He has spoken at the AI Engineer World’s Fair, DeveloperWeek, Confluence, and Monki Gras. Previously, he served as an AI/ML developer advocate at MongoDB, where he built MemoRizz, an open source Python agent memory library, and codeveloped a DeepLearning.AI course on prompt compression and query optimization. Richmond holds a master’s degree in computer vision, machine learning, and robotics from the University of Surrey.

linkedinXlinksearch

Skill covered

Refactoring