OpenCode Persistent Memory Across Sessions, 10x Token Savings

You are helping me turn one specific YouTube video into real, durable learning.

Source video:
- Title: OpenCode Persistent Memory Across Sessions, 10x Token Savings
- URL: https://www.youtube.com/watch?v=QIwLqXJkX08
- Topic: Agentic Engineering
- My current learning frame: On a project OpenCode has already worked on, run the same prompt twice (once on a fresh session with empty memory, once with Claude Mem active) and compare how closely each first answer matches your patterns to feel the continuity difference.
- Why this matters: New playlist item from AI Stack Engineer; queued for transcript-backed review, topic mapping, and a practical learning artifact.

Transcript anchors from this exact video:
- 1:00 / Evidence 1: "reach for it every month, and the numbers keep climbing. A lot of that growth got a strange boost back in January of 2026 when Anthropic blocked third-party tools from using Claude through consumer subscriptions. Instead of slowing..."
- 2:38 / Evidence 2: "if you describe it totally differently than how it got recorded the first time. There's also a search system the agent itself can reach for. So, mid-task, it can glance back through your project history and pull up..."
- 4:12 / Evidence 3: "flag, it actually scans your machine for coding agents you already have. So, it'll pop up a list with options like Claude Code, Gemini CLI, Open Code, and a few others, and let you multi-select which ones to..."
- 6:32 / Evidence 4: "twice. Once on a fresh Open Code session with no memory and once with Claude Mem active on a project it's already seen. The cold one gives you something generic, missing your patterns, repeating default choices, needing a..."
- 8:25 / Evidence 5: "that persistent memory is quietly becoming the line between an agent that's handy for a one-off task and one you can actually build with over weeks. Open code already gave you the freedom to run any model you..."

Your task:
1. Use the transcript anchors above as the primary source packet. If you add outside context, label it clearly as outside context and keep it secondary.
2. Create a source-check table with columns: timestamp, claim, what the demo proves, confidence, and what still needs verification.
3. Extract the actual teachable claims from the video. Do not invent claims that are not supported by the title, lesson frame, or transcript anchors.
4. Build a reusable learning artifact: A task packet that a coding agent could execute without wandering.
5. Include:
   - a plain-English definition of the core idea
   - a diagram or structured model using this sequence: Intent -> Task Packet -> Agent Run -> Evidence -> Review -> Standard
   - 3 concrete examples that apply the video idea to real agentic work
   - 2 failure modes the video helps prevent
   - a checklist I can use the next time I run Codex or Claude
   - one practical exercise with a clear done signal
6. Add a "learning transfer" section: what changes in my workflow tomorrow if I actually learned this?
7. Add a "source check" section that cites which transcript anchor supports each major takeaway.

Quality bar:
- Make this specific to "OpenCode Persistent Memory Across Sessions, 10x Token Savings", not a generic Agentic Engineering essay.
- Prefer operational examples, failure modes, and reusable artifacts over broad definitions.
- Call out uncertainty instead of smoothing over weak evidence.
- If evidence is weak, say what transcript segment or timestamp needs review instead of guessing.
- Finish with a concise artifact I could paste into my learning app.