Where Knowledge Belongs: AOP, Skills, Files, or Memory

There are four places to put what an Agent needs to know: the AOP, Skills, Files, and Memory. They are not interchangeable. Each has a different scope — who it applies to, when it loads, how it changes — and knowledge in the wrong layer doesn’t fail loudly. It silently applies to a few Runs, or bloats every Run with material the Agent should be looking up instead of reading.

​

The Four Layers at a Glance

The most consequential row is Memory’s scope: Memory is personal. Every user of an Agent has their own, applied only to their Runs.

​

Route Each Piece of Knowledge

A concrete split, from a team that answers marketplace reviews: the AOP holds the nine complaint categories and the rule for which template variant to use; Files hold the nine response templates as documents; a Skill provides the document-handling capability to read them; and Memory is where one teammate keeps their personal preference for a more formal draft tone. Four layers, no overlap.

​

Misplacements and Their Symptoms

A team rule stored in Memory. It works perfectly — for you. Your colleague’s Runs ignore it, because their Memory is their own. And Runs started by a schedule or trigger apply the creator’s context, not the whole team’s. The symptom: “the Agent follows the rule sometimes.” If everyone’s Runs must obey it, it belongs in the AOP. A data table pasted into the AOP. Every price change now requires editing, validating, and promoting an AOP revision. Worse, the Agent reads the table as prose instead of looking values up, which invites transcription errors. The symptom: AOP revisions whose only diff is numbers. Move the table to Files and keep one AOP step that says where to look. The same expertise pasted into three AOPs. They agree today. After a month of independent edits they don’t, and each Agent handles the same situation differently. The symptom: fixing the same instruction in multiple places. Extract it into a Skill and attach it to all three Agents. The Agent keeps re-learning the same lesson. Memory also accumulates notes from Runs as the Agent works. Reviewing one production Agent, a team found it had built up roughly ninety such notes — and about ten of them recorded the same edge-case rule, rediscovered again and again. That is not the Agent being diligent; that is a rule waiting to be promoted into the AOP, where it applies always, instead of being re-derived per Run.

​

The Promotion Loop

Knowledge rarely starts in the right place — it starts as a correction. What matters is where it ends up: Review what has accumulated when you refine an Agent: recurring corrections are promotion candidates, and the AOP revision history is the right place for anything the whole team depends on.

​

The Litmus Test

Four questions, in order:

1. Must every Run obey it, no matter who started it? → AOP.
2. Could another Agent reuse it as-is? → Skill.
3. Is it looked up rather than followed? → Files.
4. Is it about how you want your results? → Memory.

If a piece of knowledge matches none of these, it is probably run-specific context — put it in the prompt when you press Start Work, and don’t store it at all.

​

Related