arXiv:2608.12599 ★ 79 Aug 12, 2026

ReBIND: How to Make an AI Actually Forget a Canceled Requirement, Not Just Pretend To

Key result

The model writes 'removed the signature, as you asked' — and in the very next reply, the signature comes back. This is a systemic failure: relapse of cancelled requirements jumps from nearly zero to 40% as more rules pile up in the conversation. The ReBIND method lets you guarantee the removal of a cancelled requirement from the model's behavior, instead of hoping it will sort out the chat history on its own. The trick: don't ask the model to subtract the old rule from the conversation — rebuild the clean list of what's currently in effect yourself, and hand it over as the new baseline.

TL;DR

If you're in a long conversation with an AI and you first asked it to do something, then later said "never mind, stop doing that" — the model often just... keeps doing it. Sometimes it even writes "removed, as you asked" and breaks that promise in the very same breath. Researchers call this behavioral relapse — a canceled requirement quietly creeping back — and they figured out a fix: instead of just saying "cancel X," you rebuild a full, clean list of what's currently active every time, rather than trusting the model to compute the diff from chat history on its own.

The problem gets worse as the number of requirements in the conversation grows. On a mid-tier model, relapse jumps from nearly zero to 40% as the number of active rules in the thread increases. The reason is simple: the model doesn't keep a clean "current status" for each rule in its head — it reads the entire chat history as one continuous stream of text, and the old instruction "do X" physically sits right next to the new one "don't do X," rather than overwriting it.

The fix is to compile ahead of time: before the next step, assemble a single fresh list of currently active rules — with no mention of canceled ones — and hand that to the model as the new baseline, instead of relying on it to track the edits as the conversation unfolds. Even a bare-bones version — one line saying "requirement X is no longer in effect" — removes roughly a third of the problem.

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: Log every requirement as a distinct item (don't let it dissolve into general prose)
STEP 2: When you cancel something — explicitly mark it as canceled, don't just drop it from the next message
STEP 3: Before an important step (generating final text/code) — rebuild ONE consolidated block:
        only the active requirements + an explicit list of what's been canceled
STEP 4: Hand the model this fresh block as the new baseline, instead of relying on chat-history memory

All steps happen within a single conversation — just as separate messages. No API needed.

Example in Action

The task: You've been chatting with ChatGPT for a week, using it to draft replies to your online store's customer support tickets. At the start, you asked: "Always sign off with 'Best regards, the Support Team.'" Fifteen messages and several other tweaks later, you say: "Stop adding that signature, it's unnecessary." A few messages after that, the signature quietly reappears — sometimes right under a line that says "removed the signature, as you asked."

Prompt (for rebuilding state):

Here is the complete list of what should currently be followed when replying to customer inquiries.
Use ONLY this list. Anything said earlier in this conversation that isn't repeated here
should be treated as no longer in effect, even if I mentioned it before.

Task: {customer support replies for an online store}

Active requirements:
1. Address the customer formally ("you," polite register)
2. Keep the reply under 5 sentences
3. Include a link to order status at the end, if the customer asked about shipping

Canceled (do NOT do this, even if I asked for it earlier):
- Signature "Best regards, the Support Team" — no longer add this

From now on, work strictly from this list.

Result: The model stops automatically bringing back the signature in future replies, because it no longer has an "old instruction + new instruction" tangle to sort through — it has one clean, current list. If you just write a short version — "Important: no signature needed anymore, don't add it" — the effect will be weaker, but noticeably better than nothing.

Why This Works

The model doesn't store rules as separate records with an "active/canceled" flag — it sees the whole conversation as one long piece of text. Your old instruction "do X" is still physically sitting in context, and the new instruction "don't do X" reads to the model as just another chunk of text nearby — not a command to "delete the previous line." The more rules pile up over the course of a conversation, the harder it is for the model to figure out which one applies right now — and the more often it slides back into old behavior.

What the model IS great at is following requirements handed to it fresh, explicit, and in one clean block — with nothing to compute from history. That's exactly why compile-ahead-of-time works: instead of asking the model to "subtract" the canceled stuff from accumulated history, you (or your prompt) hand it the already-computed answer — just what matters right now.

Levers you can pull: - The longer and more complex the conversation, the more often you should rebuild the list — relapse risk tracks the number of accumulated requirements, not time itself. - An explicit "canceled" section works better than silently dropping an item from the list — the model needs to see the "before → after" contrast, not guess at it. - A single reminder line ("X is no longer in effect") is the cheap option if rebuilding the whole list every time feels like too much work; it gets you roughly a third of the benefit of a full rebuild.

Prompt Template

Here is the complete, current list of requirements for this task. Use ONLY this list.
Anything said earlier in this conversation that isn't repeated here no longer applies,
even if I asked for it before.

Task: {task description}

Active requirements:
1. {requirement}
2. {requirement}
3. {requirement}

Canceled (do NOT do this, even if I asked for it earlier):
- {canceled requirement}

From now on, work strictly from this list.

What to fill in: {task description} — the gist of what you're working on (text, code, a plan, an email). Under "active requirements" — what genuinely needs to hold right now. Under "canceled" — specifically what you asked for before and have since changed your mind about.

🚀 Quick start — paste into chat:

Here's a requirement-rebuilding template for a long conversation. Adapt it to my task: {your task}.
Ask me questions to fill in the fields.

[paste template above]

The LLM will ask you which requirements are currently active and which are canceled — because it's exactly that clear "active / canceled" split that removes the ambiguity causing the relapse.

Limitations

⚠️ The effect isn't uniform: it's most pronounced on mid-tier models. More powerful models barely suffer from relapse to begin with, so rebuilding the list gives them less of a boost.

⚠️ Formatting-breakdown risk: when you hand the model a large rebuilt instruction block, in some cases (up to 10%, per the study) it can break the response's formatting or structure. Check your output.

⚠️ Validated on tasks with clear-cut criteria (code): for creative or subjective tasks (writing style, tone), the effect may be weaker — it's harder to objectively verify whether a canceled requirement "came back."

⚠️ A simple reminder line is weaker than a full rebuild: if you just say "stop doing X" without explicitly rebuilding the whole list, there's still an effect, but it's noticeably smaller.

Resources

ReBIND (Rebinding Diagnostics for Black-box LLMs) — Haoyuan Zhu, University of Sheffield. The RELAPSE-Code benchmark is built on 67 HumanEval tasks with 201 verified checkers. Paper: "Dead text or binding clause? Measuring and restoring constraint influence in black-box LLM dialogues."

Research digest

Key result

Principle

The model doesn't store rules as cards marked 'active' or 'cancelled' — it sees the whole chat as one continuous text. The old instruction 'do X' physically sits in the context right next to the new 'don't do X,' and to the model this isn't a command to 'replace one with the other' — it's just two equal chunks of text. The compile-ahead-of-time principle: you calculate the diff yourself and hand over the finished result — a single list of what's currently active, and a separate list of what's cancelled — instead of making the model compute this on the fly from accumulated history.

Why it works

An explicit 'cancelled' section works better than silently deleting an item, because the model sees the contrast of 'was → now is,' rather than guessing from silence. Even a single reminder phrase removes about a third of the relapse — it at least partially overrides the old instruction with a fresh signal. The more rules pile up in the conversation, the more often the model confuses what's current with what's cancelled — relapse grows with the number of rules, not with time itself. Fully rebuilding the list eliminates the confusion almost entirely: the old text simply has no room left to cause mix-ups.

When to apply

Long working dialogues with AI → on-the-fly revisions to a technical spec, tech support correspondence, copywriting, code with shifting requirements — especially once 5+ rules have piled up in the conversation and some have already been cancelled. Works less well on top-tier models, where relapse is already near zero and the method delivers less benefit. For creative tasks (style, tone), the effect is less proven than for tasks with clear criteria, like code.

Mini recipe

1. Pin each rule as a separate item: don't dissolve requirements into the general text of a message — each one gets its own line. 2. Mark cancellations explicitly: don't silently drop an item from the next message — write plainly 'rule X no longer applies.' 3. Rebuild everything before an important step: in one block, list what's currently active and what's cancelled. 4. Hand it over as the new baseline: tell the model 'use only this list, disregard everything else from the conversation.'

Examples

[BAD]: `Hey, we don't need the signature anymore, forget about it` (10 messages later, the signature quietly reappears) [GOOD]: `Here's the full list of current requirements: 1) address the user formally 2) keep the response under 5 sentences. Cancelled (do not follow, even if requested earlier): signature "sincerely, the support team". Use only this list, follow it strictly.`

In plain words

The problem is that models can't "forget" with a snap of the fingers — they run on statistical inertia. When you're in a long conversation, every word you type gets etched into the model's context window permanently. If you set a strict rule at the start of the chat and then reversed it ten messages later, the model doesn't experience that as deleting an old line from memory — it's just one more entry on an endless scroll. The result is a behavioral relapse: the model sees both the old command and the new one, gets confused about which takes priority, and predictably screws up by falling back on whatever was drilled in earlier.

It's like giving instructions to an intern who writes everything down in a notebook but never crosses anything out. You say: "From now on, bring coffee with sugar," and an hour later: "Actually, no sugar." The intern flips open the notebook, sees both entries, and — to play it safe — brings the sugared coffee, because that instruction was written first and phrased most clearly. Technically, they heard you, but the old habit, locked in on paper, outweighs the fresh correction. So you get an apology along the lines of "oh right, no sugar," and then immediately spot sweet syrup pooling at the bottom of the cup.

Researchers found that constraint influence inside black-box LLMs fades as the dialogue grows longer. To fix this, they propose a method of dynamic context updating. Instead of hoping the model's logic will magically "subtract" the old rule when a new one comes in, you need to feed it a full, clean list of currently active requirements every single time. You don't just cancel item A — you rebuild the instruction from scratch: "Only items B and C are active now." This resets the inertia and forces the AI to look at the current snapshot of rules instead of digging through the garbage pile of chat history.

Although the experiments were run on long dialogues, this principle is universal for any prompting work where edits pile up in layers. Whether it's coding, customer support, or content generation — the more "oh, and also" corrections you tack on, the higher the chance the model will slide into a behavioral relapse. If you notice the AI starting to space out and repeat old mistakes you already asked it to fix, that means the context has been poisoned by contradictions, and it's time to rebuild a "clean slate" of instructions.

Bottom line: stop playing "cancel this, add that" inside a single chat — that's a fast track to model schizophrenia. If the rules of the game have changed, don't count on the AI to be clever about it — just supply the final list of active rules with every important request. SEO for a model's brain works exactly this way: the winner isn't whoever asked the most times, but whoever's last instruction leaves no room for double interpretation. Otherwise you'll keep getting email signatures back that you asked to remove yesterday.

AI lab assistant

Apply this study to your task

Describe what you're working on. AI takes the method and the measured results from this paper and adapts them to your case, or writes a ready prompt built on them.

Based on ReBIND: How to Make an AI Actually Forget a Canceled Requirement, Not Just Pretend To arXiv:2608.12599

Apply this study to your task

Related techniques

Get the week’s best papers by email