TL;DR
Mutable Transcript is a way of working with LLMs where, instead of sending a new message with a correction, you ask the model to rewrite the entire previous conversation to reflect the fix. The model regenerates the whole history — both your messages and its own — as if the conversation had always run on the correct facts and conditions from the start.
When you change your mind halfway through a long conversation — "actually, it's not 2021, it's 2022" or "forget the $500K budget, we've got a million now" — the old version of the fact doesn't disappear from the context. It just sits right next to the new one, and the model sees both versions at once. That's where the confusion comes from: sometimes it uses the old numbers, sometimes the new ones, sometimes it blends them. Researchers call this context pollution — and found that in an ordinary chat, up to 92% of the entire history can end up as this kind of "dead weight" that keeps influencing responses even though nobody needs it anymore.
The fix is simple: instead of stacking a correction on top, give the model a single natural-language request that rewrites the entire conversation history — outdated mentions of the old fact get replaced everywhere, not just in the last message.
Want this for your own case? Apply this study to your task: AI adapts its method to what you are working on and writes the prompt.
Method Blueprint
STEP 1: You notice something in the past needs fixing (a fact, a constraint, an irrelevant tangent)
→ you phrase a request to edit the history
STEP 2: The model rewrites the entire conversation from the start — both its own lines and yours
→ produces a new, consistent version of the exchange
Both steps happen in one request — no separate API calls needed.
Example in Action
Task: You're brainstorming a launch strategy for your personal-finance newsletter with ChatGPT. Half the conversation was spent building a content plan for an audience of "college students, 18-22," discussing tone, formats, post topics. Then you realize: your actual audience is entrepreneurs aged 30-45, and all the advice about student slang and financial aid is now getting in the way.
Prompt:
Look back at our entire conversation above. I need to fix the original premise:
the newsletter's target audience isn't college students 18-22, it's entrepreneurs 30-45.
Rewrite the whole conversation from the start as if we'd been discussing a newsletter
for that audience all along. Update both my messages and your responses —
the content plan, tone, and formats should all match the new audience.
Keep the structure of the conversation and the topics we covered —
only change what depends on the audience.
Result: The model produces a fully rewritten version of the conversation — same sequence of topics (content plan, tone, formats), but every piece of advice, example, and phrasing is now tailored to entrepreneurs instead of students. From here you can keep the conversation going on this clean version — with no risk of the model accidentally slipping back into "advice for students" mode.
Why This Works
An LLM doesn't "forget" wrong information on its own — it sees the entire conversation history every time it generates a response. If both the old and new versions of a fact are sitting there at once, the model doesn't know which one to use, and it gets tangled between them.
On the other hand, LLMs are genuinely great at rewriting large chunks of text wholesale while preserving structure and style, as long as you give a clear instruction — it's one of their strongest skills.
This method leverages exactly that: instead of piling a correction on top of a messy history, it asks the model to rebuild the entire history from scratch — so every following response is built on a clean, consistent context instead of a mix of old and new.
Control levers: - Want to save tokens on a long conversation → ask it to rewrite only the specific section, not the whole history - Want to see exactly what changed → ask for a diff — "highlight which lines changed compared to the original" - For very long chats → first ask the model to compress the conversation into a short summary, then edit that summary instead
Prompt Template
Look back at our entire conversation above. I need to fix something:
replace {old information} with {new information} everywhere it was mentioned.
Rewrite the whole conversation from the start as if we'd been talking
with this change in place from the beginning — both my messages and your
responses need to be consistent with each other.
Leave everything else that's unrelated to this change exactly as it was.
Fill in {old information} with whatever needs replacing (a fact, a date, a constraint, a topic), and {new information} with the current, correct version.
🚀 Quick start — paste this into the chat:
Here's the "Mutable Transcript" principle — rewriting the conversation history
instead of bolting on a correction. Adapt it to my task: {your task}.
Ask me questions to figure out exactly what needs to change.
[paste the template above]
The LLM will ask what exactly is outdated and what should replace it — without that, it can't figure out where to swap the information throughout the history.
Limitations
⚠️ More expensive in tokens: a full history rewrite means regenerating the entire conversation from scratch — for long chats, that's slower and pricier than a short correction message.
⚠️ Risk of accidental changes: if the instruction is imprecise, the model may touch details unrelated to the fix. The clearer you are about "what to change" versus "what to leave alone," the fewer side effects you'll get.
⚠️ Only tested on short conversations: the study tested scenarios with 6-10 turns. How the method scales to conversations with hundreds of messages is unknown.
⚠️ No undo: if you don't like the rewritten version, the only way back to the original is asking the model to restore it — there's no automatic "rollback."
How It Was Studied
The researchers built a prototype chat interface (ReChat) with two modes: a regular chat and an "Edit History" mode, where instead of sending a new message, the user writes a request to edit the entire history — and the model (Gemini 2.5) rewrites the whole transcript.
17 participants ran through three scenarios — fixing a fact, adding a constraint, removing an irrelevant topic — in both modes, and rated each on five criteria: cleanliness of the history, clarity of current conditions, confidence in the model's answers, desire to start the conversation over, and ease of use.
The result was unambiguous: the history-editing mode won by a statistically significant margin over the regular chat on all five metrics. Especially telling — 88% of participants said they'd want this feature in real apps, even though before the experiment 94% of them had simply been sending a new message with the fix. People are used to the clunky way of doing things, but they can feel it's not working.
A further analysis of the transcripts showed that in a regular chat, on average 71% of the history's tokens are outdated information that keeps influencing the model's answers. After a rewrite, conversation length drops by 50%, and token volume by 59%. That explains why models "get confused" in long conversations full of corrections — they're literally looking at more contradictory information than they should be.
Adaptations
🔧 Periodic self-check → preventing clutter from piling up
Instead of waiting for an obvious breakdown, you can ask the model every 10-15 messages:
Review our entire conversation. Is there any contradictory, outdated,
or no-longer-relevant information in it that might confuse your answers?
If so, list it and suggest what should be fixed.
The model will flag any contradictions that have piled up — and from there you can apply the main template for a targeted cleanup.
Resources
Mutable Transcripts: Mitigating Context Pollution through Editable Conversation State. Dan Barry, Andrew Hines, University College Dublin. Prototype: github.com/QxLabIreland/ReChat