Memory Blocks

What are memory blocks?

Memory blocks are structured sections of the agent’s context window that persist across all interactions. They are always visible - no retrieval needed.

Memory blocks are Letta’s core abstraction. Create a block with a descriptive label and the agent learns how to use it. This simple mechanism enables capabilities impossible with traditional context management.

Key properties:

• Agent-managed - Agents autonomously organize information based on block labels
• Flexible - Use for any purpose: knowledge, guidelines, state tracking, scratchpad space
• Shareable - Multiple agents can access the same block; update once, visible everywhere
• Always visible - Blocks stay in context, never need retrieval

Examples:

• Store tool usage guidelines so agents avoid past mistakes
• Maintain working memory in a scratchpad block
• Mirror external state (user’s current document) for real-time awareness
• Share read-only policies across all agents from a central source
• Coordinate multi-agent systems: parent agents watch subagent result blocks update in real-time
• Enable emergent behavior: add performance_tracking or emotional_state and watch agents start using them

Memory blocks aren’t just storage - they’re a coordination primitive that enables sophisticated agent behavior.

Memory block structure

Memory blocks represent a section of an agent’s context window. An agent may have multiple memory blocks, or none at all. A memory block consists of:

• A label, which is a unique identifier for the block
• A description, which describes the purpose of the block
• A value, which is the contents/data of the block
• A limit, which is the size limit (in characters) of the block

The importance of the description field

When making memory blocks, it’s crucial to provide a good description field that accurately describes what the block should be used for. The description is the main information used by the agent to determine how to read and write to that block. Without a good description, the agent may not understand how to use the block.

Because persona and human are two popular block labels, Letta autogenerates default descriptions for these blocks if you don’t provide them. If you provide a description for a memory block labelled persona or human, the default description will be overridden.

For persona, the default is:

The persona block: Stores details about your current persona, guiding how you behave and respond. This helps you to maintain consistency and personality in your interactions.

For human, the default is:

The human block: Stores key details about the person you are conversing with, allowing for more personalized and friend-like conversation.

Read-only blocks

Memory blocks are read-write by default (so the agent can update the block using memory tools), but can be set to read-only by setting the read_only field to true. When a block is read-only, the agent cannot update the block.

Read-only blocks are useful when you want to give an agent access to information (for example, a shared memory block about an organization), but you don’t want the agent to be able to make potentially destructive changes to the block.

Creating an agent with memory blocks

When you create an agent, you can specify memory blocks to also be created with the agent. For most chat applications, we recommend create a human block (to represent memories about the user) and a persona block (to represent the agent’s persona).

1
// install letta-client with `npm install @letta-ai/letta-client`
2
import { LettaClient } from '@letta-ai/letta-client'
3
4
// create a client to connect to your local Letta server
5
const client = new LettaClient({
6
  baseUrl: "http://localhost:8283"
7
});
8
9
// create an agent with two basic self-editing memory blocks
10
const agentState = await client.agents.create({
11
    memoryBlocks: [
12
        {
13
          label: "human",
14
          value: "The human's name is Bob the Builder.",
15
          limit: 5000
16
        },
17
        {
18
          label: "persona",
19
          value: "My name is Sam, the all-knowing sentient AI.",
20
          limit: 5000
21
        }
22
    ],
23
    model: "openai/gpt-4o-mini",
24
    embedding: "openai/text-embedding-3-small"
25
});

When the agent is created, the corresponding blocks are also created and attached to the agent, so that the block value will be in the context window.

Creating and attaching memory blocks

You can also directly create blocks and attach them to an agent. This can be useful if you want to create blocks that are shared between multiple agents. If multiple agents are attached to a block, they will all have the block data in their context windows (essentially providing shared memory).

Below is an example of creating a block directory, and attaching the block to two agents by specifying the block_ids field.

1
// create a persisted block, which can be attached to agents
2
const block = await client.blocks.create({
3
    label: "organization",
4
    description: "A block to store information about the organization",
5
    value: "Organization: Letta",
6
    limit: 4000,
7
});
8
9
// create an agent with both a shared block and its own blocks
10
const sharedBlockAgent1 = await client.agents.create({
11
    name: "shared_block_agent1",
12
    memoryBlocks: [
13
        {
14
            label: "persona",
15
            value: "I am agent 1"
16
        },
17
    ],
18
    blockIds: [block.id],
19
    model: "openai/gpt-4o-mini",
20
    embedding: "openai/text-embedding-3-small"
21
22
});
23
24
// create another agent sharing the block
25
const sharedBlockAgent2 = await client.agents.create({
26
    name: "shared_block_agent2",
27
    memoryBlocks: [
28
        {
29
            label: "persona",
30
            value: "I am agent 2"
31
        },
32
    ],
33
    blockIds: [block.id],
34
    model: "openai/gpt-4o-mini",
35
    embedding: "openai/text-embedding-3-small"
36
});

You can also attach blocks to existing agents:

1
await client.agents.blocks.attach(agent.id, block.id);

You can see all agents attached to a block by using the block_id field in the blocks retrieve endpoint.