Why does Perplexity forget my previous queries?

Perplexity forgets your previous queries because each Thread is sandboxed: follow-ups only chain inside the Thread that started them, and a new Thread, even inside the same Space, begins blank. Search History stores titles for you to browse, but the model does not load earlier Threads as context for new ones. The fix is an external memory layer that captures query history and feeds it back into every new Thread.

Perplexity's product is built for fast, citation-grounded answers, one question at a time. The architecture that makes that fast also makes query carry-over weak.

1. Threads are isolated conversations. Follow-up questions chain inside one Thread, but Perplexity treats every new Thread as a fresh session. The model does not auto-load yesterday's Thread into today's context, even when both Threads sit inside the same Space.

2. Search History is for you, not for the model. Your past queries appear in History so you can revisit them, but they are not fed back into new queries as context. The history is a UI affordance, not a memory layer.

3. Spaces add instructions, not query memory. A Space gives every Thread inside it a shared instruction set and a shared file pool. It does not give every Thread inside it access to the actual questions and answers from sibling Threads.

The result: Perplexity is excellent at answering today's question well. It loses the chain of reasoning that took you from yesterday's question to today's.

Every new Thread costs you 5-15 minutes of re-grounding, and the cost compounds over a real research project:

• Reasoning chains break. "We narrowed the candidate suppliers from 12 to 3 last Thread based on the certification filter" becomes a fact Perplexity no longer holds, so it reopens the full 12-candidate list.
• Source preference resets. The handful of sources you rejected yesterday for being out of date show up again today as top citations.
• Refined questions go blunt. Yesterday's tight question, sharpened across six follow-ups, becomes today's loose question, sharpened from scratch.

The fix is not "keep one Thread open forever." Long Threads slow down, hit limits, and follow-up quality drops. The fix is to detach query memory from Thread memory.

Perplexity has shipped a few features that touch this problem. None of them close the gap.

Threads chain follow-ups inside one conversation and preserve in-Thread context well. They do not share context with sibling Threads, so the boundary of memory is the Thread itself.

Spaces scope a project to a workspace with shared instructions and sources, raising the floor of every Thread inside that workspace. They do not pass query history between Threads, so reasoning state still resets when you open a new Thread.

Search History keeps a browsable list of your prior queries. It is helpful when you want to reopen a Thread by hand, but it is not fed into the model as context, so it does not stop the forgetting.

You can read Perplexity's own description of these features in the Perplexity Help Center.

For one-off questions, the natives are fine. For ongoing inquiry, they leak.

The deeper issue is that your inquiry rarely stays inside one product. You ask in Perplexity, validate in Claude, draft in ChatGPT, and check the numbers in a sheet. Each tool has its own query log, none of them talk, and the chain of reasoning fragments. Spaces solve a slice of the problem inside Perplexity. They solve none of it the second you switch tabs.

That is the gap a cross-tool memory layer fills: one query memory, written by Perplexity, read by every other AI you use.

MemoryLake is a cross-model memory layer that sits between you and every AI you use. Instead of relying on Perplexity's per-Thread sandbox, you give the line of inquiry its own MemoryLake Project, and Perplexity reads from that Project at the start of every new Thread.

• Per-project query memory. Past questions, answers, and refinement steps are stored against the project, not the Thread. Open a new Thread and the prior reasoning is already loaded.
• 10,000x more context than raw prompting. MemoryLake's retrieval engine reads from billions of tokens of query history and feeds Perplexity only the slices relevant to the current question. You stop pasting recaps.
• Portable to every other AI. The same query memory works in Claude, ChatGPT, Grok, Gemini, and Cursor. When you leave Perplexity to draft or analyze, the chain of reasoning follows.

MemoryLake scored 94.03% on the LoCoMo long-context benchmark, the top published result as of 2026, with millisecond retrieval and AES-256 end-to-end encryption.

1. Create a project and load your prior queries. Sign in to MemoryLake, open Project Management, click Create Project, and name it after the line of inquiry (for example, "Perplexity - supplier vetting Q2"). Paste the key questions and answers from past Threads into the Memories tab so they travel with the project, and drop any reference documents into the Document Drive.
2. Generate an MCP Server endpoint. Open the MCP Servers tab inside your project, click Add MCP Server, name it "Perplexity integration", and click Generate. MemoryLake returns an API key ID, secret, and endpoint URL. Copy the secret right away, since it is shown only once.
3. Connect Perplexity. Perplexity does not yet support MCP natively in the consumer apps, so use the REST API with your Bearer token to fetch the project's query history before each new Thread, or paste a short prompt at the top of a new Thread that references your MemoryLake project. Developers using the Perplexity Sonar API can call the Python SDK to inject prior queries per turn.