How does OpenClaw manage context across multiple conversations and tasks?

OpenClaw separates context from memory, and that distinction is what lets it handle multiple conversations and long-running tasks effectively.  

At a high level, it has three layers:

• Current session context
• Persistent memory
• Project/workspace context

1. Current session context (working memory)

Every time the model is invoked, OpenClaw builds a fresh context that includes:

• The system prompt
• Conversation history for that session
• Tool calls and their results
• Attached files or images
• Any injected project files

This is everything the LLM "sees" for that particular response, and it's limited by the model's context window.

For example:

Project A chat

You: Build a React dashboard.
Agent: ...
Tool: Reads dashboard files.
Tool: Runs tests.

All of that becomes the current context.

A different conversation starts with a different context.

2. Separate sessions prevent context mixing

OpenClaw doesn't dump every conversation into one giant prompt.

Instead, each session has its own conversation history.

For example:

Session 1
--------------
Client Alpha
React dashboard

Session 2
--------------
Personal finances

Session 3
--------------
Blog writing

When you're working in Session 2, Session 1 isn't automatically included in the prompt. This keeps unrelated work isolated. 

3. Long-term memory spans sessions

Conversation history is temporary.

Memory is persistent.

When you explicitly save something—or a configured memory system stores it—it can survive across conversations and even restarts.

Examples:

• Your preferred programming language
• Project conventions
• API endpoints
• Important decisions
• User preferences

Later, OpenClaw retrieves only the memories that are relevant to the current task instead of loading everything. 

Conceptually:

Conversation
        │
        ▼
Relevant memory search
        │
        ▼
Inject matching memories
        │
        ▼
LLM

4. Workspace files provide project context

OpenClaw can automatically inject project-specific files into the context, such as:

• AGENTS.md
• USER.md
• TOOLS.md
• IDENTITY.md
• SOUL.md
• HEARTBEAT.md

These files act as persistent project instructions and are rebuilt into the system prompt for each run if present. 

For example:

Workspace
│
├── AGENTS.md
├── USER.md
├── TOOLS.md
└── src/

Whenever you're working in that workspace, those files help define the agent's behavior and project-specific knowledge.

5. Managing very long conversations

Since every LLM has a token limit, OpenClaw can't keep an entire conversation forever in raw form.

As the conversation grows, it automatically:

• Summarizes older sections
• Prunes low-value details
• Preserves recent messages
• Keeps important instructions and memories

So instead of forgetting everything, it retains the essential information while reducing token usage.

6. Multiple simultaneous tasks

If you're handling several projects, a common pattern is:

Agent
│
├── Session A → Website redesign
├── Session B → Marketing
├── Session C → Customer support
└── Session D → Personal notes

Each session has its own conversation history, while shared long-term memory can provide reusable facts (if configured that way). Users often organize this with separate channels, threads, or conversations to keep contexts clean.

In summary

OpenClaw manages context using a layered approach:

• Each conversation has its own isolated session context.
• Long-term memory stores persistent facts that can be recalled across sessions.
• Project/workspace files provide consistent instructions and knowledge.
• Older conversation history is summarized and compacted as needed to stay within the model's context window.

This design allows it to work on multiple ongoing tasks without having to resend all prior conversations on every request, while still preserving continuity where it matters.