> ## Documentation Index
> Fetch the complete documentation index at: https://docs.duvo.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Where Knowledge Belongs: AOP, Skills, Files, or Memory
> Four places to teach an Agent something, each with different scope.
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
| Layer | What it holds | Applies to | How it changes |
| ----------------------------------------------------------- | --------------------------------------------------------------------------------------------- | ---------------------------------------------------------- | ----------------------------------------------------- |
| [AOP](/user-guide/building-assignments/assignment-sop) | The procedure: steps, decisions, limits, escalations | Every Run of this Agent, for everyone | Draft revision, validate, promote — versioned |
| [Skills](/user-guide/skills/skills-overview) | Reusable know-how: multi-step expertise, helper scripts, reference material packaged together | Every Agent the Skill is attached to, loaded when relevant | Edited as a package, once, for all Agents that use it |
| [Files](/user-guide/assignment-features/files) | Data the Agent reads: templates, reference tables, catalogs, guidelines | Any Agent granted access to that file | Upload a new version — no AOP change needed |
| [Memory](/user-guide/assignment-features/assignment-memory) | Personal preferences and context for how the Agent works with you | Only your Runs of this Agent | Plain-English notes, updated anytime |
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
| You want the Agent to know… | Put it in | Why |
| ------------------------------------------------------------------------ | ------------------- | ------------------------------------------------------------------------------------------------- |
| "Never issue a refund above €200 without approval" | AOP | A rule every Run must obey belongs in the versioned procedure |
| "When responding to a complaint, follow our 9-category playbook" | AOP | It is this Agent's procedure — decision criteria live in steps |
| The response template for each complaint category | Files | Content the Agent fills in, not instructions it follows; swap a template without touching the AOP |
| The current rate card / price list / SKU catalog | Files | Reference data changes on its own schedule; the Agent looks it up per Case |
| How to audit a freight invoice — a procedure three different Agents need | Skill | Package it once, attach it to each Agent; fixes propagate everywhere |
| An exact calculation that must come out the same every time | Skill with a script | See [Let a Skill Do the Math](/best-practices/let-a-skill-do-the-math) |
| "For my Runs, flag anything over \$1,000 — I'm cautious" | Memory | A personal threshold; your colleagues keep their own |
| "I prefer the summary as three bullets, no tables" | Memory | Formatting taste, not team policy |
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:
```mermaid theme={"dark"}
flowchart TD
A[You correct the Agent
or a note recurs in Memory] --> B{Who needs it?}
B -->|Every Run, every user| C[Promote into the AOP
as a revision]
B -->|Several Agents share it| D[Extract into a Skill]
B -->|It is data, not instructions| E[Move it to Files]
B -->|Just you| F[Keep it in Memory]
```
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.
There is a fifth mechanism for a different job: [Learnings](/user-guide/assignment-features/learning-feature) capture an entire successful Run as an example the Agent imitates. Use a Learning to show what good looks like; use the layers above to state rules, data, and procedures explicitly.
## 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
The versioned procedure — what it is and how revisions work.
Reusable capabilities you attach per Agent.
The team library Agents read from at run time.
Your personal context layer for any Agent.