Episodic Memory

"The agent remembers" is always code choosing what to reload. Here you write that code.

Your win for this lesson: an agent that recalls a prior run's outcome and changes its plan because of it — the rubric's third Level 2 exercise — followed by the Level 2 readiness check. Prerequisites: Lesson 0002 (memory types), Lesson 0010 (your multi-tool agent).

1 · The setup: a run worth remembering

Give your agent a task that can fail informatively and be retried later. Example: a "deploy checker" that runs a (simulated) check tool which fails the first time with a specific reason ("port 8080 already in use"), and a task the agent should approach differently next session if it recalls that failure.

2 · Write the episodic store

The whole lesson in one idea: memory is retrieval-and-injection, not remembering. Between runs the model retains nothing (Lesson 0001). So:

Write: at the end of a run, append a record to episodes.jsonl — the task, what happened, the outcome, one lesson learned. Give the agent a tool (record_episode(summary, outcome, lesson)) or write it from your loop.
Retrieve & inject: at the start of the next run, read the relevant past episodes and place them into the context (a "prior runs" section in the system prompt or first message) before the model plans.

This is the same move as your MISSION/NOTES files in this very teaching workspace — they're the teacher's episodic memory, re-injected each session because the teacher is stateless too.

3 · Prove the plan changed

Run twice. Run 1: the agent hits the failure, records the episode. Run 2 (fresh process): the agent loads the episode and should open differently — checking the port first, or choosing an alternative — rather than repeating run 1's blind approach.

Pass: run 2's trace shows the agent referencing the recalled lesson and altering its first action. Control test: delete episodes.jsonl and run again — it reverts to the naive approach, proving the behavior came from the injected memory, not the model.

The three memory types, now concrete: in-context (this run's window), external (the episodes.jsonl on disk), episodic (past-run records you chose to reload). You never made the model "remember" — you engineered what re-entered the window. That is the whole of memory in agentic systems.

4 · The Level 2 readiness check

You've now built every Level 2 exercise: structured prompt + injection defense (0009), ReAct multi-hop (0010), RAG build-and-break (0011), episodic memory (0012). Bring to your teaching agent a design justification for one grounded multi-step agent of your choosing — the Level 2 gate skill from Lesson 0002 — now backed by things you've actually built.

The gate is justifying choices, not reciting them. Expect:

Pattern: "Why ReAct here and not CoT or ToT?" — answer by problem shape and token cost, with numbers from your builds
Memory: "Where does state live, and what gets reloaded when?" — answer as retrieval-and-injection, not "it remembers"
Grounding: "What caps this agent's answer quality?" — retrieval; and how you'd measure it
Injection: "Where does untrusted data enter, and what must it never reach?" — least privilege as the structural answer

Pass this and Level 2 is closed — the Level 3 hands-on arc (orchestrator bake-off, tracing + planted regression, critic/verifier) is next.

Lesson 0013 — the orchestrator-vs-single bake-off: prove multi-agent earns its cost, with traces — or admit it doesn't.

Episodic Memory

1 · The setup: a run worth remembering

2 · Write the episodic store

3 · Prove the plan changed

4 · The Level 2 readiness check

Next