> ## Documentation Index
> Fetch the complete documentation index at: https://autonomy.computer/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Memory

> How agents remember their history of steps.

**Memory** enables agents to maintain coherance over multiple-turns.
Agents store a history of messages that include:

* System messages.
* User messages.
* Model responses.
* Tool calls and their results.

Memory works automatically. Behind the scenes, it uses a two-tier architecture
with recent messages in fast in-memory storage and optional database persistence
for durability.

***

```python theme={null}
from autonomy import Agent, Model, Node

async def main(node):
  agent = await Agent.start(
    node=node,
    name="henry",
    instructions="You are Henry, a legal research assistant",
    model=Model("claude-sonnet-4-v1")
  )

Node.start(main)
```

```bash theme={null}
# First message - agent stores case details
curl --request POST \
  --header "Content-Type: application/json" \
  --data '{
    "message":"I am working on Smith v. Johnson, a contract dispute",
    "conversation": "case-123"
  }' \
  "https://19f13800-myapp.cluster.autonomy.computer/agents/henry"

# Second message - agent recalls the case details
curl --request POST \
  --header "Content-Type: application/json" \
  --data '{
    "message":"What case am I working on?",
    "conversation": "case-123"
  }' \
  "https://19f13800-myapp.cluster.autonomy.computer/agents/henry"

# Agent responds: "You are working on Smith v. Johnson, a contract dispute"
```

The agent automatically:

1. Stores each user message in memory.
2. Stores its own responses in memory.
3. Stores tool calls and results in memory.
4. Retrieves relevant history when building context.

***

## Isolation

### Isolated Conversations

Each conversation has its own isolated memory. Use different conversation
identifiers to maintain separate conversation histories:

```python theme={null}
# Research on contract case
await agent.send("Research breach of contract defenses", conversation="contract-case")

# Research on tort case (completely separate memory)
await agent.send("Research negligence elements", conversation="tort-case")

# These conversations don't see each other's history
await agent.send("What was I researching?", conversation="contract-case")
# Agent only recalls the contract case research
```

```bash theme={null}
curl --request POST \
  --header "Content-Type: application/json" \
  --data '{"message":"What have we discussed?", "conversation": "tort-case"}' \
  "https://19f13800-myapp.cluster.autonomy.computer/agents/henry"
```

### Isolated Users (Scope)

For multi-tenant applications, add a `scope` parameter to isolate memory
across users:

```python theme={null}
# Attorney Smith's case research
await agent.send(
  "I'm working on Smith v. Johnson, a contract dispute",
  scope="attorney-smith",
  conversation="case-research"
)

# Attorney Jones's case research (same conversation ID, different scope)
await agent.send(
  "I'm working on Davis v. Brown, a negligence case",
  scope="attorney-jones",
  conversation="case-research"
)

# Each attorney's memory is completely isolated
await agent.send(
  "What case am I working on?",
  scope="attorney-smith",
  conversation="case-research"
)
# Agent responds: "You're working on Smith v. Johnson, a contract dispute"
```

```bash theme={null}
curl --request POST \
  --header "Content-Type: application/json" \
  --data '{
    "message":"What case details did I provide?",
    "scope": "attorney-smith",
    "conversation": "case-research"
  }' \
  "https://19f13800-myapp.cluster.autonomy.computer/agents/henry"
```

### Isolated Agents

Different agents have separate memory, even when serving the same user:

```python theme={null}
# Two different legal assistants
researcher = await Agent.start(node=node, name="henry", ...)
drafter = await Agent.start(node=node, name="sarah", ...)

# Same attorney and conversation ID, but separate memory
await researcher.send("Research contracts", scope="attorney-123", conversation="work")
await drafter.send("Draft a motion", scope="attorney-123", conversation="work")

# Each agent only sees its own conversation history
```

***

## Memory Limits

By default, agents keep the last 100 messages or \~8,000 tokens in active
memory (whichever limit is reached first). Older messages are automatically
removed to stay within these limits. Messages are removed using
FIFO (first in, first out) order - the oldest messages are removed first.

***

## Memory and Context

Memory stores all conversation messages, but agents don't always send all
messages to the model. The [Context](/agents/context) template determines
which messages to included in calls to the model.