Context inheritance across conversations

You start a new chat and the assistant has no idea you're in the middle of a contract review, that you already decided on vendor A, or that your meeting prep should include the board deck you summarized yesterday. Context that doesn't carry over forces you to re-explain every time. OpenClaw can inherit context across conversations so each new thread starts with the right background—your identity, recent decisions, and when relevant, what's in your key documents. This guide covers how context inheritance works, what to pass across sessions, and how to tie in document and knowledge-base context for US professionals.

Summary OpenClaw uses persistent memory and optional conversation links so new chats inherit your identity, preferences, decisions, and document status. Feed summaries and outcomes from iReadPDF into that context so the assistant knows what's in your PDFs and what's left to do without you re-pasting every time.

Table of Contents

• What Context Inheritance Means
• What Gets Inherited vs. What Doesn't
• How to Set Up Inheritance
• Inheriting Document and PDF Context
• When to Start a Fresh Thread vs. Reuse
• Troubleshooting Missing or Wrong Context
• Conclusion

What Context Inheritance Means

Context inheritance is the idea that a new conversation doesn't start from zero. Instead, it receives:

• Persistent memory: Facts, preferences, and decisions stored in your profile or workspace. Every new chat can read from this pool so the assistant already "knows" your time zone, summary style, and key choices.
• Optional conversation continuity: Some setups let you explicitly link a new thread to a previous one ("Continue from conversation X") so recent turns or conclusions carry over. Not all deployments support this; when they do, it's useful for long-running projects.
• Injected context at start: A trigger or template can prepopulate the first message with "Current focus: X. Document queue: Y. Key decision from last week: Z." So even if the assistant doesn't automatically pull that, you're one paste away from full context.

For US professionals who hop between Slack, email, and OpenClaw, inheritance means you say "prep me for the board meeting" in a brand-new chat and the assistant already knows which meeting, which deck, and how you like briefs—because that context was inherited.

What Gets Inherited vs. What Doesn't

Clarifying what crosses the boundary avoids surprises.

| Usually inherited | Usually not inherited (unless you link or paste) | |-------------------|---------------------------------------------------| | Stored memory: identity, preferences, decisions. | Full text of past conversations. | | Document status or summaries you've written to memory. | Attachments or raw PDFs from previous chats. | | Recurring context (e.g. "Board meeting first Tuesday"). | One-off long threads or nuanced debate. | | Current focus or goals if you update them in memory. | Temporary scratch notes from a single session. |

So: the assistant will know "we use iReadPDF for contract summaries" and "Acme contract—signed" if that's in memory. It won't automatically see the 50-message thread where you debated vendor A unless you linked that thread or summarized the outcome into memory.

How to Set Up Inheritance

1. Turn on persistent memory. Ensure OpenClaw is configured to store and retrieve memory (facts, preferences, decisions) per user or workspace. That's the baseline for inheritance.
2. Store what you want in every conversation. Write identity, communication preferences, and key decisions to memory. The more you put in, the more every new chat inherits. Use clear keys (e.g. time_zone, summary_preference, default_pdf_tool) so retrieval is reliable.
3. Use a short "context block" if needed. Even with memory, you can start a chat with one paragraph: "Today: prep for 3 PM board meeting. Doc queue: 2 contracts to summarize, 1 signed. Focus: close Acme deal." That gives the assistant immediate situational context; memory fills in the rest (who you are, how you like briefs, that you use iReadPDF for summaries).
4. Link threads when your setup allows it. If OpenClaw lets you "continue from" a previous conversation, use it for multi-day projects so conclusions and action items carry forward without re-pasting.

Inheritance works best when memory is structured and when you consistently update the slice that should be "current" (e.g. this week's goals, document queue).

Inheriting Document and PDF Context

A lot of context lives in documents. Inheritance doesn't mean re-uploading every PDF; it means the assistant inherits knowledge about those documents.

1. Write outcomes to memory. After you summarize a contract or report in iReadPDF, add a line to memory: "Acme NDA—summarized; key terms X, Y; ready for legal." Next conversation can inherit that and suggest "Sign" or "Send to legal" without seeing the PDF again.
2. Keep a document queue in memory. Maintain a short "document status" list (pending summarize, summarized, signed, filed). New chats inherit it and can say "You have 2 PDFs to summarize; want a 30-min block?" or "Contract Beta is ready to sign."
3. Don't rely on raw PDFs in chat. Chats often don't retain large attachments across sessions. Prefer: summarize in iReadPDF, then store summary or status in memory or paste a 2–3 line summary into the first message of a new chat. That way context inherits cleanly.
4. Refresh document context when it changes. When you sign or file something, update memory so the next conversation doesn't suggest working on it again.

When document context is summarized and stored (or pasted in a context block), inheritance gives every new conversation the same view of your doc workload as your last one.

When to Start a Fresh Thread vs. Reuse

• Start a fresh thread when: You're switching topics (e.g. from contract review to calendar planning), the old thread is very long and slow, or you want a clean slate for a new project. With good memory, the new thread still inherits identity, preferences, and document status.
• Reuse or link a thread when: You're continuing the same project (e.g. "same board prep, one more question"), you want the assistant to see the exact last message or conclusion, or your deployment limits how much history is in memory and the thread has important nuance.

For most day-to-day use in the US (morning brief, meeting prep, task suggestion), a fresh thread plus inherited memory is enough. For long-running deals or projects, linking or reusing the same thread can help.

Troubleshooting Missing or Wrong Context

• Assistant doesn't know your time zone or preferences. Check that those are stored in persistent memory and that the key names match what your deployment expects. Re-save if needed.
• Assistant suggests something you already decided. Add that decision to memory ("We chose vendor A for X") and optionally add a tag so it's retrieved for relevant queries.
• Document status is wrong. Ensure you're updating memory (or your context block) when you complete doc tasks. If you use iReadPDF for summarization, make updating "document status" part of your workflow so inheritance stays accurate.
• Old context overrides new. If you have "current focus" or "this week's goals," update them when they change. Prune or overwrite stale entries so the assistant doesn't inherit last month's priorities.

Inheritance is only as good as what you put in and how often you refresh it. Small, consistent updates beat big one-time dumps.

Conclusion

Context inheritance across conversations lets OpenClaw start each new chat with your identity, preferences, decisions, and—when you store it—your document status and key doc outcomes. Set up persistent memory, optionally use a short context block or thread linking, and feed document context via summaries and status from iReadPDF so the assistant knows what's in your PDFs and what's next. For US professionals, that's how you stop re-explaining yourself in every thread and get an assistant that feels continuous.

Ready to make your document outcomes part of that inherited context? Use iReadPDF to summarize and track your PDFs—then write those outcomes to memory so every new conversation starts with the right doc context.