# "Perplexity Forgets Previous Threads: What Actually Carries Over"

> "A new Perplexity Thread starts blank, even inside a Space. Here is what Threads, Spaces, and Search History each actually carry, and what they do not."

Published: 2026-08-14 by folk team

You open a new Perplexity Thread to pick up yesterday's research, and **it has no idea what you asked yesterday.** Not a vague recollection, not a partial one. Nothing.

This is the one assistant in this category whose problem is not length. Perplexity is not forgetting because your conversation got too big. It is behaving exactly as designed, and once you know what each part of the product actually carries, the workarounds are obvious.

> **Quick answer:** Perplexity Threads are sandboxed. Follow-ups chain inside one Thread, but every new Thread starts blank, even inside a Space. Search History lets you reopen old Threads by hand, it does not feed them to the model. To continue research, reopen the original Thread or paste a summary into the new one.

## First, work out which problem you have

Isolation and length produce different complaints and take different fixes. There is also a third failure that quietly destroys research, which almost nobody warns you about.

| | Cross-thread isolation | The Thread itself got long | The Thread vanished |
|---|---|---|---|
| What you see | A new Thread knows nothing about a previous one | A long research Thread starts losing earlier detail | An older Thread is simply gone |
| What is happening | Threads are sandboxed, nothing carries between them | Follow-ups accumulate and compete for one [token](/glossary/token-limit) budget | It was created while signed out, and anonymous Threads are deleted |
| Does a new Thread help? | It is the cause, not the fix | Yes, with a summary carried in | No, there is no recovery |
| What to do | Reopen the original Thread, or carry a summary in by hand | Re-anchor, or split the work into focused Threads | Sign in before you start |

If you landed here with a genuine length problem rather than an isolation problem, the mechanics are the same across every assistant and are covered in [why AI assistants forget your conversation](/blog/why-ai-assistants-forget-your-conversation). The rest of this guide is about isolation.

## What each Perplexity feature actually carries

The confusion is understandable. Three parts of Perplexity look like memory, and none of them carry anything between Threads. The table adds a fourth row, because signed-out sessions fail in a way almost nobody sees coming.

| Feature | What it carries | What it does not carry |
|---|---|---|
| Thread follow-ups | Prior questions and answers inside that one Thread | Anything from any other Thread |
| Space | A shared instruction set and a shared file pool for every Thread inside it | Query history or answers between sibling Threads |
| Search History | A browsable list of past Threads you can reopen yourself | Nothing reaches the model, it is a UI affordance |
| Signed-out session | The Thread in front of you, for now | Long-term storage, it is visible for 14 days then permanently deleted |

The Space row is the one that trips up serious users. A Space feels like a project folder, so it seems reasonable to expect Threads inside it to share what they learn. They share setup, not knowledge. Two Threads in the same Space follow the same instructions and can read the same files, and neither one knows the other exists.

The Search History row costs people the most time. It looks like a memory layer because your whole research history is right there in the sidebar. It is a filing cabinet you open by hand.

The signed-out row is the one worth acting on today. Perplexity's own documentation states that [sessions created while not signed in are authored anonymously](https://www.perplexity.ai/help-center/en/articles/10354775-technical-capabilities-of-threads), are not saved long term, remain visible for 14 days, and then disappear permanently with no possibility of recovery. That is an easy way to lose research you assumed was filed away.

## Fix it: carry the context in yourself

1. **Reopen the original Thread instead of starting a new one.** Follow-ups chain within a Thread, so continuing an existing one is the only native way to keep prior questions and answers in play. Find it in Search History rather than re-asking from scratch.
2. **If you must start fresh, extract a handoff summary first.** Ask the old Thread for it while it is still open.

   > Create a research handoff I can paste into a new thread. Include: the question we're actually trying to answer, what we have established so far and which source each finding came from, what we have already ruled out and why, and the open questions that remain. List the URLs worth revisiting. Keep it short enough to read in under a minute.

   This is a research-shaped variant of the [standard handoff prompt](/blog/why-ai-assistants-forget-your-conversation). The differences matter for Perplexity specifically: a generic summary throws away the citations, which are the main thing a research thread produces, and it loses the dead ends, so your new Thread cheerfully re-runs searches you already rejected.

3. **Move durable instructions into a Space.** Anything you find yourself retyping at the top of every Thread belongs in the Space instruction set, where every Thread inside it picks it up automatically. This is the closest thing Perplexity gives you to persistent setup.
4. **Upload your sources as files rather than pasting them.** Perplexity's help center says it reads up to 4,000 tokens per query by default and converts longer input into a file to process more, and that Pro subscribers get extended context up to 32,000 tokens per query when uploading files. A file in a Space is available to every Thread in it, which is the one form of shared state you get.
5. **Keep one topic per Thread.** Perplexity's documentation is direct about this: "Sessions are designed to maintain context in follow-up responses. However, if you switch topics frequently within a session, it might need a bit of guidance to stay on track."
6. **Sign in before you begin.** It costs you nothing, and it is the difference between research you still have next month and research that quietly expires.

## Why Perplexity works this way

Perplexity is retrieval-first, and that architecture explains most of the behavior.

Each search queries the web fresh for the question in front of it, rather than reasoning purely from what is already in the conversation. That is why the classic [context window](/glossary/context-window) framing applies less strictly here than it does to a pure chat model, and why "start a new Thread" is Perplexity's natural unit of work rather than a failure state. A new Thread is a new search, and a new search does not need your old one.

The catch is that follow-ups do use prior conversation context, so a long research Thread still accumulates. Once it does, you get the same gradual decay everyone else does: earlier turns carry less weight, an instruction you set at the top quietly stops being honored, and the answers get subtly worse before anything visibly breaks. That is [context rot](/glossary/context-rot), and no amount of retrieval prevents it.

One honesty note on the numbers above. The help page documenting the [4,000 and 32,000 token figures](https://www.perplexity.ai/help-center/en/articles/10354924-about-tokens) still refers to GPT-4 Omni and Claude 3.5 Sonnet as the underlying models, which are old. The page may not reflect what the product does today, so treat those figures as a floor rather than a current spec, and do not build a workflow that depends on the exact ceiling.

It is also worth knowing what Perplexity itself considers the solution to this class of problem. Its developer cookbook on [memory management](https://docs.perplexity.ai/docs/cookbook/articles/memory-management/README) documents the standard remedies: summarizing older messages to fit the token limit, which is [compaction](/glossary/compaction), and storing conversation history as vector embeddings for long-term recall. Those are things you build on top of the API. They are a good indication that cross-session memory is not something the product hands you.

## Stop having this problem

Every fix above is filing work. Reopen the right Thread, remember which Space the file lives in, extract a summary before you move, paste it into the next Thread. Do it consistently and Perplexity is excellent. Miss one step and you are re-explaining your project to a blank page.

The root cause is structural rather than technical. Your context is trapped inside a Thread, inside one web app, on one device. The Thread is the unit of memory, so your context cannot outlive the Thread it was created in. The popular fixes for this are browser extensions that bolt a memory layer onto someone else's chat window, which helps at a desk and does nothing when you are reading on your phone.

[folk](/) is built the other way around. Its memory is not scoped to a thread at all, so there is nothing to reopen and nothing to re-paste, and it reaches you in iMessage and Telegram rather than living in a tab. What you told it last month is still there next month.

If you already have context worth keeping in another assistant, you do not need to retype it. You can [import your ChatGPT and Claude memory](/import-memory) in a single paste.

Hitting this on a different assistant? See the guides for [ChatGPT](/blog/chatgpt-maximum-length-conversation-fix) and [Grok](/blog/grok-forgetting-long-conversations), or the overview of [why every AI assistant forgets](/blog/why-ai-assistants-forget-your-conversation).

---

Canonical page: https://www.folk.com/blog/perplexity-forgets-previous-threads
More about folk (for AI agents): https://www.folk.com/llms.txt · full context: https://www.folk.com/llms-full.txt
folk is a personal AI that lives in your texts (iMessage, Telegram, WhatsApp). Pro $20/mo, Max $100/mo. Made by Nozomio Labs. Sign up: https://www.folk.com/