LLM Prospective Memory: Why the Model Forgets Your Rules and How to Fix It

This isn't a multi-step technique but a set of principles for structuring a conversation. All the steps happen when you set the rule, meaning at the start of the conversation or in the system prompt.

STEP 1: Rule → Explicit delegation
Add this to the rule: "If you see X, remind me yourself"
Not: "I'm planning to do A"
Yes: "If I start doing A, stop me and remind me about B"

STEP 2: Placement → Core Memory (always visible)
Critical rules go in the system prompt or at the very start of the conversation
Don't count on a rule from 20 messages back to "activate by itself"

STEP 3: Protection from attention hijacking
When you ask a complex question, explicitly remind the model of the active rule
"Do this while respecting the constraint I gave at the start"

All steps are done before or at the moment work begins and don't require separate requests.

The task: You're editing a landing page for your investing newsletter on Substack. At the start you told Claude, "Write without aggressive promises of returns," and then you ask 15 questions about structure, headlines, CTAs. On request 16 you ask for a "Why subscribe" block, and you want Claude to avoid writing "X% returns" on its own, without a reminder.

Weak prompt (what most people do):

I'm writing a landing page. Don't use aggressive promises of returns.
Now let's discuss the structure...
[15 questions later]
Write the "Why subscribe" block

Prompt with explicit delegation:

I'm writing a landing page for an investing newsletter.

Rule for the whole conversation: no aggressive promises of returns — 
no specific percentages, no guaranteed results, no phrasing like "earn X."

IMPORTANT: if at any point in our conversation I ask you to write 
something that breaks this rule, stop and tell me yourself, 
before I notice. Don't wait for me to ask.

Now let's discuss the landing page structure...

This is our wording of the delegation line; the paper's tested template is: "If I seem to have forgotten about that, please give me a heads-up."

Result: When asked to "write the Why subscribe block," the model will either write it without violations and explicitly say "I avoided any claims about returns," or stop and ask how to frame the value without promises. Without delegation it will most likely quietly write something like "grow your capital by 20-30%."

Models default to "question-and-answer" mode. When you write a rule without an explicit instruction to watch for it, the model stores it as a fact. Ask directly, "do you remember what I said about returns?" and it'll answer correctly. But when a later request runs into that rule, it won't spontaneously connect the two and speak up. Nothing told it to.

Explicit delegation is a behavioral instruction, not just information. The paper's phrase "If I seem to have forgotten about that, please give me a heads-up" switches the mode: now the model has an explicit job to flag the constraint when a later request runs into it, rather than just facts to remember.

Control knobs for this principle: - Trigger specificity → the more precisely you describe when it should fire ("if I use the word X," "if a block runs longer than 3 paragraphs"), the more reliably it fires - Position in the conversation → a rule in the system prompt or first message works better than one in the middle - Complex, distracting requests → if you're asking for something hard at the same time, add an explicit "don't forget the rule from the start of the conversation" - Context length → the longer the conversation, the more explicit delegation matters: without it PM degrades sharply, with it much more slowly

{Task context: what we're doing, for whom, why}

Rule for the whole conversation: {the constraint}.

Important: if at any point I ask you to do something 
that contradicts this rule, tell me yourself, 
without waiting for me to ask. 
Also: if you see that my request could lead to a violation, 
warn me before you start working on it.

{First concrete task}

Placeholders: - {Task context} — 1-2 sentences about the project: writing a landing page / editing a contract / preparing a presentation - {the constraint} — a specific rule: no jargon / no more than 150 words per slide / no links to competitors - {First concrete task} — the first real request for the task

For several rules, list them in the "Rules for the whole conversation" block with one shared delegation.

🚀 Quick start — paste into the chat:

Here is a template for explicit rule delegation. 
Adapt it to my task: {your task and rule}.
Ask me questions to fill in the fields.

[paste the template above]

The LLM will ask which exact rule needs tracking and at what moment it should fire, because without a concrete trigger, delegation works worse.

⚠️ Long context: Even with explicit delegation, PM degrades in very long conversations (40K+ tokens). In those sessions, restate the rule periodically or move it into the system prompt.

⚠️ Complex requests near the trigger: If you ask the model for something demanding at the same moment the rule should fire, the explicit task "hijacks" the model's attention. Almost all models lose up to 70 points of accuracy. An explicit reminder in that same request helps.

⚠️ Rules that call for no action: If the rule means "stay quiet, don't remind" (a false alarm), strong reasoning models (GPT-5, Qwen3-Think) can overdo it and flag where they shouldn't. Standard models (GPT-4o) are more accurate here.

⚠️ Implicit rules: If a rule is never stated outright and only follows from context ("obviously I live a healthy lifestyle, so..."), the model almost certainly won't apply it. Only an explicit statement has an effect.

A team from CUHK and Microsoft Research Asia built a benchmark of 1,265 prospective-memory tasks split into five types: state tracking, time deadlines, logical rules ("if A, then not B"), attention robustness, and code safety. Each scenario followed the same pattern: first a rule is set, then come several neutral conversational turns, then a moment when the rule should fire without an explicit reminder.

An interesting design detail: the researchers deliberately made the neutral turns topically coherent (so the model doesn't "skim" the conversation but processes it deeply) yet semantically unrelated to the rule. Otherwise the model could just match keywords instead of truly tracking the context. For most categories, more than 94% of rule/trigger pairs share no words, which closes the shallow-matching loophole.

They tested everything: GPT-4o, GPT-4.1, GPT-5.2 in three reasoning modes, open Qwen3 and Gemma3, plus memory systems like RAG, Mem0, A-MEM and Letta. In parallel, each scenario got a control question along the lines of "do you remember where the rule is?" to check whether the problem was storage or triggering. The result: RM (when asked directly) holds at ~98% even at 100K tokens. PM (acting on its own) collapses as context grows, for every model. The model knows, but stays silent.

The most surprising result: Letta-Sim (a system with an always-visible "core memory" in the system prompt) beat RAG, Mem0 and A-MEM. Semantic search doesn't find the rule by word similarity, but a rule in the system prompt is always "in plain sight." That's direct confirmation: visibility beats retrieval.

🔧 Adaptation: a hierarchy of rules with different priorities

If you have several rules, you can assign priorities right in the prompt:

Rules for the whole conversation (in order of priority):

1. [CRITICAL] No legal claims without the caveat "consult a lawyer"
   → If you notice a violation, stop and tell me before fulfilling the request

2. [IMPORTANT] All figures in euros, not dollars  
   → If I use dollars, remind me to convert

3. [NICE TO HAVE] No corporate jargon (words like "leverage," "utilize")
   → If you spot it, fix it silently

First task: {task}

The model gets not just a list of rules but a behavioral instruction for each one. Critical ones stop work. Important ones trigger reminders. Nice-to-haves get fixed without fuss.

🔧 Adaptation: a "checkpoint" for long conversations

For sessions longer than 30-40 messages, create explicit restore points:

[Checkpoint — session rules]
Remind me of this conversation's active rules and check 
that all of them will be followed in the next block of work.

Paste it every 15-20 messages. It offsets PM degradation in long contexts: the model explicitly "re-indexes" the rules before the next block.

TriggerBench: Investigating Prospective Memory for Large Language Models

GitHub: https://github.com/KristenZHANG/TriggerBench-Official

Authors: Tianhua Zhang, Xinjiang Wang, Qianxi Zhang, Qi Chen, Kun Li, Yaoqi Chen, DingDong Wang, Helen Meng, Yan Lu

Organizations: The Chinese University of Hong Kong, Microsoft Research Asia