You are deep in a thread with Grok and something is off. It just answered a question from earlier in the conversation instead of the one you actually asked.

That is not random. It is the exact behavior documented in xAI's own issue tracker for long-running conversations, and the reason it catches people out is that Grok never warns you it is coming.

Quick answer: Grok gives you no token counter and no warning, so behavior is your only gauge. If Grok answers an earlier message instead of your latest one, contradicts a decision you both made, or mixes in another project, treat the thread as full. Ask for a handoff summary and move to a fresh thread.

First, work out which failure you hit

Three separate things get reported as "Grok forgot," and they have different fixes. Spend five seconds identifying yours.

	The thread outgrew its context	Memory is not what you think	You planned around an API number
What you see	Grok answers an earlier message, or contradicts something you settled	A new chat does not know the details of a previous chat	Grok drifts far sooner than you expected
What is happening	Older turns stopped reaching the model, because the thread filled its context window	Memory stores facts about you, not the contents of a specific thread	Published figures describe the API, not the app
Does a new thread help?	Yes	No, the new thread still starts blank on that project	Not the issue
What to do	Re-anchor, then hand off before it gets worse	Paste the details you need, memory will not fetch them	Ignore the API number and watch behavior instead

If your problem is the first column, the rest of this guide is for you.

The tells, because there is no counter

This is what makes Grok different from the other assistants in this category. ChatGPT gives you an explicit error message when a thread is done. Grok gives you nothing, so the failure is invisible until it has already happened.

There is no token counter, no percentage, and no warning as a chat approaches its limit, on either x.com/i/grok or grok.com. Worth noting where that description comes from: a vendor selling a Chrome extension that adds exactly such a meter, so it is not neutral documentation. You can confirm it yourself in seconds, though, because there is simply no counter anywhere in the interface to check.

So watch for behavior instead. The clearest tell is documented on xAI's own GitHub repository, in an issue titled "Grok gets confused with long conversations." It reports that when you respond to Grok's last message in a long-running conversation, it will often pick something at random from earlier in the conversation and respond to that instead. A commenter on the same issue adds that it mixes context between different projects, confusing one project for another and offering deprecated commands.

In practice, the signals to watch for are:

• It answers the wrong message. Your last message gets skipped in favor of an older one.
• It reintroduces a rejected option. Something you explicitly ruled out comes back as a fresh suggestion.
• It bleeds in another project. Names, commands, or constraints appear that belong to different work.
• It asks for something you already gave it. A file, a value, a decision from earlier in the same thread.

None of these is proof on its own. Together they are the only signal Grok gives you, and the practical reading is the same either way: stop adding to the thread and start extracting from it. It will not get better on its own.

Fix it: re-anchor, then hand off

1. Run a recall check before you trust the thread. Ask: "Without scrolling up, list the constraints we agreed on and where we are now." If it misses something you both settled, the context has already thinned and everything after this point is guesswork dressed as confidence.

2. Re-anchor rather than correcting. Do not reply "no, I meant the other thing." Paste a short recap of the decisions that still apply, and put your hard constraints at the end of the message, closest to the question, where they carry the most weight.

3. Ask for a handoff summary while Grok can still write one. Do this early. At the ceiling the model has the least room to think, which is exactly when it writes the worst summaries.

   Create a handoff summary I can paste into a new chat. Include: what we're trying to accomplish, key decisions we've made, anything important you'd get wrong by guessing, and the very next step. Then add a separate list of anything you are uncertain about or can no longer see clearly from earlier in this conversation. Keep it short enough to read in under a minute.

   The first half is the standard handoff prompt. The second half is specific to Grok, and it matters more here than anywhere else: since the interface never tells you what has been truncated, asking the model to declare its own blind spots is the closest thing to a context meter you get natively. Treat anything it flags as already lost and supply it yourself.

4. Save it to a file, not your clipboard. Clipboards get overwritten, and this is the only copy of your context that exists.

5. Paste critical values verbatim. Summaries paraphrase, and paraphrasing corrupts exact numbers, names, and code. Copy those in literally.

6. Open a new thread, paste the summary first, then add: "Continue from here. Confirm you understand before proceeding."

7. Keep unrelated projects in separate threads. The cross-project confusion in that GitHub issue is much likelier when one thread is carrying two jobs.

Why nobody can tell you the number

Here is the honest state of the information, which most articles on this query paper over.

xAI does not publish a context window figure for the consumer Grok app. Not a large one, not a small one. There is no official number to plan around.

What is published is the API, and it is a different thing. Developer documentation reported by DataStudios lists Grok 4 (grok-4-0709) with a 256,000 token context window, and Grok 3 and Grok 3 Mini with 131,072 tokens. Those figures describe what a developer gets when calling those models directly. The app wraps the model in its own system prompt, tools, and handling, none of which xAI documents, so the API ceiling does not tell you when your chat will start dropping messages. A separate analysis of the consumer app makes the same point, noting that xAI's technical details for it are not publicly disclosed and offering only an unconfirmed estimate that real-world capacity is roughly comparable to other high-end models.

The mechanism underneath is the same one every assistant deals with. On each turn the entire thread is re-sent to the model, every earlier message competing for one fixed budget measured in tokens. This is why a very short follow-up can be the message that breaks things, and why quality degrades before any wall is reached, as attention spreads thin across a long thread. That gradual decay is context rot. xAI also does not document whether the app quietly drops old turns or compacts them into a summary, which is precisely why the behavioral tells above are the practical answer.

Memory is a different feature, and it does not help here

People conflate these constantly, and the conflation is expensive.

Grok's memory feature launched in beta in April 2025 on the Grok website and the iOS and Android apps, excluding the EU and UK at launch. It lets Grok reference older conversations in future inquiries, so it can recall your details and personalize how it talks to you.

What it does not do is increase the number of tokens the model can handle in one thread. Memory is about you across sessions. The context window is about how much of this conversation the model can see right now. Turning memory on will not stop a long thread from dropping its own middle.

Stop having this problem

Notice the shape of every fix above. You watch for tells, you remember to ask for a summary, you store it, you re-paste it into a new thread. You are doing Grok's filing, on a system that will not even tell you when the filing is due.

The root cause is structural. Your context lives inside one thread, inside one web app, on one device. The thread is the unit of memory, so when it fills up the memory goes with it. Even the workaround for Grok's opacity is a browser extension, which tells you something: it exists at a desk, in one browser tab, and does nothing for you on your phone.

folk is built the other way around. Its memory is not scoped to a thread at all, and it reaches you in iMessage and Telegram, so there is no conversation to reach the end of and nothing to re-paste when one does. What you told it last month is still there.

If you already have context worth keeping elsewhere, you do not need to retype it. You can import your ChatGPT and Claude memory in a single paste.

Hitting this on a different assistant? See the guides for ChatGPT and Perplexity, or the overview of why every AI assistant forgets.