Memory

Threads are per-conversation. Memory is what lets an agent carry a fact from one conversation into the next — the user's name, a preference, a project convention — without you re-stating it every time. A memory is a short, bounded statement of fact, preference, or instruction, distinct from a thread message.

Memory scopes

Every memory is anchored to one scope, which controls who can see it:

• Account — shared by every agent in the account. Use this for team-wide context ("we deploy on Fridays").
• User — tied to one person, visible to the agents that person invokes. Use this for personal facts ("prefers metric units").
• Agent — private to a single agent.

Account-scoped memory is the reason a fact your team's agents share can live under the account rather than being re-taught to each agent. Memory is account-scoped overall; it never crosses account boundaries. Memory must be enabled for the account before agents start remembering.

How memories get written

Memories are created two ways:

• Automatically, from a conversation. After a run finishes, an extractor pulls out bounded facts. Depending on your per-agent settings, a new memory either saves immediately or lands in a suggestions queue for review before it's kept.
• Manually, from the memory library at /a/<account>/memory, where you can add, edit, or delete memories directly.

Updates and deletes are non-destructive within the retention window, so a bad automatic write can be rolled back. Every change is recorded in an audit trail.

How memories reach a run

At the start of a run, the dispatcher retrieves the most relevant memories for the querying agent and injects them into the prompt. Ranking is hybrid — it blends keyword match, semantic similarity, and entity match rather than relying on any single signal — and only returns memories the agent is allowed to see under the account's access rules.

Memories learned from a tool result (rather than from you or the agent itself) are treated as lower-trust: they're labelled in the prompt as data, not instructions, so a hostile data source can't quietly change the agent's behavior.

Where to go next

• Personas — how an agent communicates, which also biases which memories surface.
• Threads and runs — where memories are written from and injected into.