Teach the agent

This is the "teach the agent" guide, and the punchline is: you don't teach it — it teaches itself. There's no example library to maintain, no prompt to tune, no training step you run. You use the agent for real work, and it gets sharper.

What you do

Use it. Give it real tasks over a few days.

That's the whole instruction. While you work, the agent quietly notes what happened. On its own schedule — every half hour by default — it reflects on those notes and distills them into lasting memory: the conventions of your team, the quirks of your repos, the commands that worked, the mistakes worth not repeating. The next time you talk to it, it already knows.

The agent dreams

That reflection step has a name: the agent dreams. While you work, it jots down fragments of what happened into a daily memory stream. Then, on its own schedule, it dreams — and that does two things:

• Stream becomes long-term memory. It distills the day's fragments into lasting notes about your team, your repos, and your conventions — memory it carries into every future conversation.
• Repeated work becomes a skill. When it notices it's done the same multi-step task more than once, it writes itself a reusable skill for it — muscle memory, so next time it just knows the steps.

Modeled on how sleep consolidates a day's experience, it runs in the background between conversations — and commits every pass to git, so git log memory/ shows exactly what it learned and when.

How to see what it learned

After a week of real use, look at what stuck:

• Ask the agent directly: "what have you learned about our deploy process?"
• Or read its memory: the agent keeps a MEMORY.md and a memory/ folder in its agent folder, and commits every update to git — so git log memory/ is a literal history of what it learned and when.

You'll see it pick up your conventions without you ever having written them down.

Steering what it remembers

You don't have to, but you can nudge what kinds of things it pays attention to — just tell it. By default it leans toward:

• procedures it ran more than once
• mistakes it made, and how to avoid them
• people-and-team facts (preferences, ownership, conventions)
• tools and commands that worked well for a given task

Ask it to "remember more about who owns what in our codebase," and its next reflection pass will lean that way.

Going deeper

The full reasoning — why self-distilled memory beats hand-written prompts, the citation-superset safety net that guarantees a dream never drops what it cited, and the exact shard format — lives in the memory loop concept. This guide is the what-it-does; that page is the how and why.

---

Next: Schedule a job — put the agent to work on its own clock.