B3: Personal Agents Structured to Learn

Most AI agents have amnesia. Every conversation starts fresh. You teach them something useful, and by tomorrow it's gone.

I wanted agents that actually get better over time. Not through fine-tuning or retraining—through structured learning from use. Here's how I built it.

The Two-File System

Every agent in my system has two files that make learning work:

AGENT.md is the agent's durable knowledge. It defines the role, workflow, integrations, and—critically—an "Accumulated Learnings" section at the bottom. This is where permanent knowledge lives. Things like:

• Workflow rules ("always prioritize shipping over planning")
• Technical knowledge ("use UTC timestamps for scheduling")
• Strategy guidance ("filter out cold outreach before showing priority emails")

This file is committed to Git and versioned. When I teach an agent something that should change how it works forever, it goes here.

memory.md is the agent's private scratchpad. Personal preferences, temporary context, notes that don't need to be shared. This file is gitignored—local only.

The split matters. Some knowledge is universal (put it in AGENT.md, share it). Some knowledge is personal (put it in memory.md, keep it private).

How Learning Actually Happens

When I give feedback—"that's not a priority," "do it this way instead," "never show me those emails"—the agent figures out which file to update.

Workflow changes go to AGENT.md:

### Accumulated Learnings

**Email Filtering (2026-01-15)**
Filter out cold sales outreach before showing priority emails.
Check sender domains and subject line patterns.

**Priority Logic (2026-01-20)**
When surfacing tasks, always put "Complete" items first,
then "Advance" items, then "Consider" items.

Personal context goes to memory.md:

### Notes

- Prefers morning standups before 9am
- Currently focused on Q1 launch
- Skip calendar items tagged "optional"

The key: every learning is dated and specific. Not vague principles—concrete rules the agent can apply.

Why Structure Beats Intelligence

The smartest model in the world is useless if it forgets what you told it yesterday. Structure creates persistence.

Here's what I've learned building this system:

1. Narrow beats broad. An agent with a single job and deep memory outperforms a generalist with no context. My Calendar agent only does calendar. But it remembers every preference I've ever expressed about scheduling.

2. Examples beat instructions. Instead of telling an agent "write good emails," I show it examples of emails I liked. Those examples live in AGENT.md, and the agent references them every time.

3. Corrections compound. Every time I say "not like that," the agent gets better. After a few weeks, the corrections are rare because the agent has learned what I actually want.

The Feedback Loop

The system creates a tight feedback loop:

1. Agent does something
2. I react (good, bad, or "do it differently")
3. Agent updates the right file
4. Next time, agent does it better

This is how humans learn too. We try, get feedback, adjust. The difference is my agents write down every lesson so they never forget.

What's Next

Right now, each agent learns independently. My Calendar agent doesn't know what my Email agent has learned. The next step: shared learning across agents.

Some knowledge should propagate. If I tell my Email agent "this person is high priority," my Calendar agent should know that too. That's the architecture I'm building toward—agents that learn individually but share knowledge where it makes sense.

More on that in a future post.