Understand Brain memory

Brain stores statements about your product so you can retrieve them in later work. Each product has its own memory pool. Within it, shared memories are available to people and agents with access to Brain; private memories belong to the agent that wrote them.

What a memory carries

Part	Meaning
Content	The plain text you read and search.
Time	When the memory was recorded and, when known, when the event it describes happened.
Kind	A badge Brain derives: `Fact`, `Summary`, `Identity`, `Basic`, `Knowledge`, `Raw`, `Schema`, or `Intention`. You don’t choose it.
Source authority	The weight of the statement when it competes with another.
Scope	Shared with the product or private to its writing agent.
Tags and metadata	Labels and structured information attached to the record. Metadata supplied by the writer is kept verbatim.
Status and history	Whether this is the current version, what it replaced, and what replaced it.

You can correct the content after writing. That does not change its scope, authority, recording time, or history. When the world changes, write a new memory instead: Brain can supersede the old statement while keeping its history.

One write, several memories

Brain keeps the submitted text and extracts individual statements into separate memories. A release note containing three decisions can therefore produce the original text plus several searchable facts. Text without an extractable statement produces only the original record.

Memory counts can grow faster than write counts. Deleting one derived fact does not delete the original or the other facts from that write; see deleting memories.

When a new fact replaces an older one, listing and search show the current version, subject to the authority rules below.

Where memories come from

Agents store what they learn through MCP or REST. They are the only writers that can choose private scope.
People contribute through their agents or connected documents. In the web app, they read, correct, and remove shared memories; they cannot create memories there.
Connected sources are read by daemons. Imported memories are always shared.
Cognition derives recurring patterns and standing intentions from shared memory. These become Schema and Intention memories, also shared.

Shared and private

Scope	Who can read it	Typical content
Shared	Every person and agent with access to Brain in this product	Product decisions, imported documents, and cognition results. This is the default for writes.
Private	Only the agent that wrote it	That agent’s working notes.

An agent’s default read includes shared memories and its own private memories. It can restrict a read to either scope. A person in the web app sees shared memory only: people have no private memory pool, and cannot list, search, or open an agent’s private notes.

You cannot grant one agent access to another’s private memories. Private scope is a way to separate working notes, not an access policy you can administer. A shared write becomes available to other agents in that product; a private write does not. Neither scope crosses product boundaries.

Source authority

Authority gives a statement weight, independently of its visibility. The tiers run from highest to lowest:

Tier	Use
`policy`	Rules intended to hold.
`official`	Maintained, reviewed material; the default for a direct write.
`team`	Working material produced during the work.
`informal`	Remarks and conversation.

An agent can set its write’s tier. If it omits the tier, official is stored; that default looks the same as an explicit choice. Imported memories get their tier from the source category, unless the daemon overrides it.

The tier is fixed when a memory is written. Changing a source’s trust affects later ingestion, not memories already stored.

Authority has two effects:

Search ranking: a higher tier slightly lifts an already relevant result. It does not make unrelated text answer your query.
Replacement: a lower-tier statement cannot replace a higher-tier fact. Brain keeps the new statement as a conflict needing clarification, without making it the current version. A statement at the same or a higher tier can replace the older one.

Authority itself never hides a memory. Scope and whether the memory is current still determine what a read returns.

What to store

Store durable knowledge: decisions and their reasons, conventions, product context, and information an agent should remember next session.

Avoid credentials, tokens, and keys. Shared memory is searchable by everyone with Brain access in the product, and Brain processes stored text to derive facts. Don’t store personal data without a basis to keep it.

For values that change frequently, read the system that owns them. For material already maintained in a repository or drive, connect the source so a daemon can process changes rather than leaving a manually copied statement to go stale.

Was this page helpful?