# Knowledge and memory internals

> How knowledge centers and user memories store pages, control access, keep versions, and how agents recall and save what they learn.

Section: Platform · Updated: 2026-11-19 · Canonical: https://nested.me/docs/knowledge-model

## Knowledge centers

A knowledge center is a named, versioned tree of Markdown pages. Pages use the **Open Knowledge Format (OKF)**: Markdown with YAML frontmatter that must include a `type`. Each center has two required documents — **instructions** (what the center is for) and **guidelines** (how to write in it) — which agents load before they use it.

| Kind | Owner | Notes |
|---|---|---|
| Team centers | Created by operators or users | Runbooks, product docs, team wikis |
| Platform | Nested | Built-in docs about Nested itself; read-only |
| Memory | One person, in one team | Private to its owner; see below |

Search is Postgres full-text search. There is no vector search.

## How storage works

Every page body is written to object storage as an immutable snapshot. Postgres holds the live pointer, the search index, every version, and a change log with diffs. Restoring an old version copies it forward as a new version, so history is append-only.

Every change records who made it: an agent (with the agent and task that caused it), an operator, the owner, or the system. The change log keeps 24 months of history by default.

## Access

The server derives who is calling from the credential, never from the request body. Agents get a credential signed for them that only reaches the centers granted to that agent. Each grant is **Read & write** or **Read only**. Operators can read every center **except** memories, which only their owner can see.

## How agents use knowledge

Agents use tools in the built-in `nested` MCP server, designed for progressive disclosure:

1. `nested_knowledge_bootstrap` loads each granted center’s instructions, guidelines, and access level.
2. `nested_knowledge_search` returns short stubs only — path, title, description, tags.
3. `nested_knowledge_get` reads one page; `nested_knowledge_neighbors` follows its links.
4. `nested_knowledge_put` writes a page. The agent passes the hash of the version it read; if someone changed the page in the meantime, the write is refused and the agent gets the current page to merge into.

Version history, restore, and the change log are tools too, so an agent can see what changed while it was away.

## Memories

A memory is a knowledge center that belongs to **you**, not to an agent. Every agent you work with can use it, so what one agent learns is available to the next. Deleting an agent does not delete what it learned.

- You get a default memory in each team and can keep up to 5.
- A memory holds up to 2,000 pages and starts with structure pages for preferences, lessons, people and systems, decisions, and a logbook.
- Each task binds up to 3 memories, each read-only or read-write, with one primary. The choice is fixed when the task is created: chosen explicitly, inherited from the automation or schedule that started it, or taken from your defaults. Subtasks inherit their parent’s memories.

### Recall

Before each turn, the agent adds a short memory block: your preferences page, its own notes about its environment, and the most relevant facts and recent logbook entries from each bound memory. The block is capped at 6 KiB and gives up after 500 ms, so memory never slows or breaks a turn.

### Saving lessons

When a task completes (or fails), a durable workflow reviews the task and writes lasting facts and one logbook entry to the task’s primary memory. Logbook pages carry an expiry date and are removed automatically when it passes. You can turn automatic saving off per memory.

### Reorganize

**Reorganize** asks an agent to find duplicates, conflicts, and logbook entries worth turning into standing knowledge. It proposes a plan; you review the preview and apply it. A page that changed in the meantime is skipped, not overwritten.

To manage memories in the app, see [Memories](https://nested.me/docs/memory). To attach team centers to an agent, see [Knowledge centers](https://nested.me/docs/knowledge).

## Questions

### Can operators read my memories?

No. Operators can read team knowledge centers but not memories. A memory is private to the person who owns it.

### Does Nested use a vector database for memory?

No. Knowledge and memory search use Postgres full-text search, and agents follow links between pages.

### What happens when two agents edit the same page?

The second write is refused because the page changed since it was read. The agent receives the current page and re-applies its change.

## Related

- [Memories](https://nested.me/docs/memory)
- [Shared knowledge centers](https://nested.me/docs/knowledge)
- [Security model](https://nested.me/docs/security)
- [Agent runtime](https://nested.me/docs/agent-runtime)
