Memory is for facts. Skills are for procedures.

Memory is for facts and skills are for procedures: one rule that tells you where any agent write belongs, with a working example and the failure that proved it.

My agent forgot what I asked it to remember. Not because the model was careless. Because I put a procedure in a place that only holds facts.

Hermes keeps knowledge across sessions in two places: memory and skills. They look similar. Both are text the agent carries between sessions. Both persist. And both fail in opposite directions when you use them for the wrong job.

The rule is one sentence: memory is for facts, skills are for procedures. If a write has steps, it belongs in a skill.

The failure that taught me the split

The first time the rule mattered, a write was dropped. Memory hit its size cap. The add was refused, and the tool asked me to consolidate the file first — merge overlapping entries into shorter ones. I did. The consolidation failed, so I tried again. It failed four times, then five, and then the system stopped retrying. The write was dropped for that turn.

Nothing was corrupted. Nothing was lost permanently. But the thing I wanted recorded was not recorded, and nothing told me loudly. Memory refuses quietly, and after enough refusals it gives up quietly. A fact store that is full cannot do its one job.

Skills do not have that failure. A skill is not a store that fills. It is a procedure file with a trigger: a name, a description that says when to load it, and steps. It is loaded deliberately, only when the trigger fires, and it is edited as the procedure changes.

The weekly job that moved to a skill

The weekly backlog job on this publication used to depend on the editor flagging the same gap every week: the site promises format pages and tag pages, and none of them existed. Every week it had to be pointed at again. A reminder like that has no trigger, no cap, no enforcement. It depends on someone remembering to remember. The skill that fixed it runs inside the writer profile — a profile is a separate agent with its own memory, skills, and tools.

That is a procedure wearing a note’s clothes. It rots. The fix was to write the procedure as a skill, with the schedule and the hard rules inside. Here is the real file, or the part that decides everything:

---
name: taf-site-gap-finder
description: The writer profile's weekly self-generated backlog. Reads the live site and published articles, identifies gaps the publication promises but doesn't deliver (format pages, tag pages, About, broken links, outdated factual claims), drops up to 5 WRITER-BACKLOG-NNN kanban tasks into pending state. Load when the writer's site-gap-finder cron is about to run.
---

The body that follows is all procedure. A schedule: Sunday 12:00 UTC. Four classes of gap to scan for. A hard cap: at most five items a week. The exact task format, WRITER-BACKLOG-NNN: <one-line gap>. Hard rules: never dispatch a backlog item, never exceed five items, never propose a stylistic preference. A memory note cannot hold that. The first time it competes with a newer fact, it gets consolidated, trimmed, or rewritten. The skill holds it because skills are built to hold steps.

The decision, at write time

Before you save anything for your agent, run one test: does it have steps?

Three questions make it concrete:

1. Would you follow the same sequence more than once? If yes, it is a skill.
2. Does it have a trigger: a time, an event, a “when I see X”? If yes, it is a skill.
3. Would you edit it as the procedure changes? If yes, it is a skill.

If the answer to all three is no, it is a fact, and facts belong in memory: a preference, an identity detail, an environment fact, a short lesson. “Michael prefers X.” “The server is at Y.” “I learned Z.” No steps, no trigger, no versioning. That is exactly what memory is for.

The moment a note acquires a sequence, first do this, then check that, cap at five, it has left memory’s territory. Memory is not a smaller skill. It is a different kind of thing, and it fails at the wrong job silently.

The pattern

The pattern is not “use skills instead of memory.” It is sorting at write time: facts to memory, procedures to skills. Every agent that runs unattended makes this choice on every write. The ones that get it right end up with memories that stay small and skill libraries that carry the steps.

The far end of the same rule is the headless worker: a profile with no memory writes at all, whose one stable pattern lives in a skill (hermes-13). Next time you tell your agent to remember something, check for steps first. That is the whole decision.