Why Does AI Ignore an Instruction That Is Still Sitting Right There?

You tell it to stop using bullet points. Write in full sentences, you say. It does.

Fifteen messages later, there they are again.

Most people read that as the model losing track, or getting sloppy the way anyone gets sloppy late in a long afternoon. That isn't what happened. Your instruction is still sitting in that conversation, word for word, exactly where you typed it. It gets sent to the model again on every single turn, including the turn that just ignored it. Nothing expired and nothing was deleted.

It didn't forget. It stopped looking.

That gap is worth understanding, because it changes what you do about it. If you think the model forgot, you repeat yourself louder or you go looking for a tool with a bigger memory. If you know it stopped looking, you know exactly where to put the sentence so it gets read.

This post is the mechanism, end to end: why nothing is stored between messages, what attention actually is and why it runs out, what happens to your instruction as the conversation grows, and the one-line fix that falls out of it. Most of the numbers here are other people's published work and every paper is named where its result appears. One measurement is mine, and I'll flag it clearly when we get there.

I made a video version of this one too, if you'd rather watch the mechanism than read it. It's on my channel at https://www.youtube.com/@swift-pal.

It never had a memory to lose

Start with the thing almost nobody is told: the model does not keep your conversation.

When you send a message, your app takes the whole conversation, every message you wrote and every reply that came back, all the way to the first line, packages that up and sends the entire thing. The model reads it top to bottom, writes the next reply, and throws all of it away. Anthropic's API documentation puts it in one line: the API is stateless, so you send the full conversation history each time.

Stateless is the word for a system that keeps nothing between one request and the next. Each call arrives with no idea that any previous call happened. It matters here because it removes the obvious explanation before we start: a thing that stores nothing cannot lose what it stored.

Count it on a short conversation and the shape is obvious.

turn 1   sends 1 message
turn 2   sends 3
turn 3   sends 5

Turn two sends what you wrote, what came back, and the new thing you just typed. Turn three sends all five. The same conversation, from the top, a little longer on each pass. In between those calls the model holds nothing at all. Not your name, not the reply it finished writing four seconds ago.

So "it forgot" is wrong twice over. Nothing was ever stored, so there was nothing to lose, and your instruction about bullet points is right there in the block of text, resent, every single turn.

At this point some of you are thinking this is plainly wrong, because these tools clearly do remember your name between separate conversations. They do, and it works the way you'd now expect. When something looks worth keeping, the app writes it into a file. Later conversations get that file pasted back in at the top along with everything else. Anthropic's memory tool is documented as a directory of files that the model reads and writes through ordinary tool calls, and the developer building the app has to supply the storage themselves.

Which makes it a filing cabinet standing next to the model rather than a memory inside it. That somebody had to build one at all is the strongest evidence for everything above.

What attention actually is

If the instruction never left, why is it being ignored? The answer is in how these models read, and this is the part worth going slowly on.

Take a sentence. The cat sat on the mat because it was warm.

What is "it"? The mat. You knew that instantly, but notice there is nothing inside the word "it" that tells you so. Three letters, no content. To work it out you had to hold the whole sentence in your head at once and weigh that one small word against every other word in the line, and "mat" won.

That weighing has a name. It's called attention, and it is the mechanism that makes these models work at all. For every word the model produces, it computes how much each earlier word matters to this one, assigns each of them a share, and builds its answer out of the weighted result. That's how "it" reaches back down the sentence and finds "mat" rather than "cat". Without attention a model would be reading each word in isolation, with no way to connect a pronoun to the thing it refers to, or your instruction to the reply it's supposed to govern. Attention is the connecting.

Here is the part people miss, and it is the whole article.

The amount of attention is fixed. For each word it generates, the model has one budget of consideration to hand out, and that budget gets divided across everything sitting in front of it. Not a share each, but a share of one fixed quantity. It's a pie, and the pie doesn't get bigger when more people show up.

On turn one, your instruction competes with maybe a dozen words. By turn forty it's competing with four thousand. The instruction hasn't moved. It hasn't changed. There is just less and less of anything falling on it.

Three separate things push it further into the dark, and none of them is the model deciding anything.

Distance. The gap between your instruction and the word currently being written keeps growing.

Competition. Everything typed in between is also asking for a share of that same fixed budget.

Position decay. This one needs a sentence of setup. A model has no built-in sense of word order, because attention on its own only sees a bag of words with no sequence to them. So the position of each word gets encoded into it deliberately, by a mechanism called a position encoding. The dominant one in current models is rotary position encoding, and the thing to know about it is that the signal it produces weakens as two words get further apart. That's not a bug. It's how the model is told that nearby words are more likely to be relevant than distant ones, which is usually true and is exactly wrong for a standing instruction you gave forty messages ago.

I should be honest about the picture I've handed you. Attention isn't one beam of light. It's many, running in parallel, at every layer of the model, and paying attention is really a weighted sum rather than a spotlight sweeping a room. The shape of the explanation is right. The picture is simpler than the thing, and if you go on to read the actual literature you should expect it to be messier than this.

Somebody measured exactly this

All of that would be a nice story if nobody had checked it. Somebody checked it.

A 2026 paper called When Attention Closes: How LLMs Lose the Thread in Multi-Turn Interaction (Dongre et al., arXiv:2605.12922) measured how much of the model's attention was still reaching the original instruction, turn after turn, and gave it a name: the goal accessibility ratio. It's the share of attention that the words being generated now are paying to the words that set the goal in the first place.

It falls. In every architecture they tested, without exception, and it only ever goes down. The steepest part is inside the first ten turns, and by the end of their conversations it sits between 27 and 48 percent below where it started.

They also found where it bottoms out. Put a fixed limit on how far back the model is allowed to look, and the attention still reaching your instruction hits its floor somewhere between turn nineteen and turn twenty-three, depending on the model. That number being so consistent is the tell that this is geometry rather than mood. Nothing is deciding to stop caring. The arithmetic runs out.

Then they went further, and this is the result that makes the whole thing worth reading.

They forced that attention channel shut on purpose and asked the model to recall twenty facts it had been given. Recall collapsed from nearly perfect to 11.2 percent. At the same moment they read the model's internal state directly, using a linear probe, which is a small classifier trained to answer the question "is this fact present in here?" from the model's raw internal numbers rather than from anything it said out loud. The probe recovered the same facts with an accuracy score reaching 0.99, where 1.0 is perfect and 0.5 is a coin flip.

Sit with that one for a second. The model still held the information. It could not get to it.

That is a very different failure from forgetting, and it's why the distinction at the top isn't pedantry. Forgetting means the information is gone and you have to supply it again from outside. This means the information is present and unreachable, which is a routing problem, and routing problems have cheaper fixes.

Three messages is all it takes

You might be picturing this as something that only shows up deep into a marathon conversation. It doesn't.

Meta ran a benchmark called Multi-IF (arXiv:2410.15553) across 4,501 conversations, fourteen models and eight languages, with three turns each. Between the first turn and the third, average instruction-following accuracy fell from 0.877 to 0.707. Every model they tested got worse with each additional turn. Their own name for the effect, in the paper, is instruction forgetting.

Three turns means you have typed three messages and had two replies back. That is a normal Tuesday morning, not a marathon.

A separate group simulated over 200,000 conversations and measured an average drop of 39 percent the moment a conversation went past a single turn, showing up in exchanges as short as two (LLMs Get Lost In Multi-Turn Conversation, Laban et al., arXiv:2505.06120).

That same paper split the damage into two parts, and the split explains why this feels so random when it happens to you. A small piece of it is the model becoming less capable. The large piece is the model becoming less reliable. It is not quietly turning stupid as you talk to it. It's turning inconsistent, so the same request lands one time and slides straight off the next, and you're left unable to tell whether you phrased it badly or the tool is broken.

And before anyone blames the length of their conversations, Chroma's Context Rot report tested eighteen of the largest current models and found quality falling well before the available space is anywhere near full. A model advertising a very large capacity can be measurably worse a long way inside it.

The same thing happens inside one message

Everything so far has been about turns piling up. The same effect happens inside a single long message, and there's a well-known experiment that isolates it cleanly.

Take a question, and one document that answers it. Bury that document in a stack of twenty where the other nineteen are irrelevant, hand the whole stack over, and ask. Then run it again with the answer moved to a different position in the stack. Nothing changes except where the answer sits.

answer at the top       75.8%
answer at the bottom    63.2%
answer in the middle    53.8%
no documents at all     56.1%

Those are from Lost in the Middle (Liu et al., arXiv:2307.03172, TACL 2024), measured on GPT-3.5-Turbo.

Read the last line again. When the researchers asked the same model the same questions with no documents at all, purely from what it already knew, it scored 56.1. Burying the answer in the middle of the stack left it doing worse than handing it nothing. The correct answer was in the prompt, and supplying it made performance go down.

That's the same shape as before. The beginning gets read and the end gets read, and the long stretch in between is where things quietly go missing. In a long conversation, that stretch is exactly where your instruction about bullet points has been sitting for the last fifteen messages.

Which hands you the fix

The useful thing about a mechanical explanation is that the fix falls out of it without any guessing.

If the problem is distance and competition, move the instruction back to where the attention is. Say it again, in your most recent message rather than your first.

It does not have to be elaborate:

Reminder: no bullet points,
full sentences only.

One line, at the bottom, where the attention actually is. You are not nagging the model. You are relocating a piece of text from the dead middle of a long block to the position that gets the largest share of a fixed budget.

That sounds too simple to be worth doing, so it's worth knowing it was tested. The same 200,000 conversation study ran exactly this intervention, restating the important context before the model answers, and one model went from 50.4 percent to 66.5. It did not fully close the gap with asking in a single turn, which is the honest caveat. It recovered a large part of it for one line of typing.

Starting a fresh conversation works for the same reason, and it isn't superstition. It resets the distance and clears out the competition in one move. If you've been going back and forth for half an hour and the thing has started drifting, a new conversation with a two-line summary of where you got to will usually outperform another ten messages in the old one.

Three things follow from the mechanism, and they're all the same idea:

Put standing instructions at the end of your latest message, not only at the start of the conversation. Keep irrelevant material out of the prompt entirely, because everything you paste is competing for the same budget as the thing you care about. And when a conversation has drifted past recovering, start again rather than arguing with it.

The other kind of forgetting

There is a second cause, and it's the one most people assume is the only one. Conversations do eventually outgrow the space available.

That space has a name and a hard number. The context window is the maximum amount of text a model can have in front of it at once, and it is measured in tokens rather than words. A token is the unit a model actually reads: a chunk of text that's usually a common word, a word fragment, or a piece of punctuation. English runs somewhere around three-quarters of a word per token on average, so a small 4,000-token window holds about six pages, and a large 200,000-token one holds a decent paperback. Everything has to fit inside it at once: the system instructions, your entire conversation history, any documents you pasted, and the reply currently being written. When the total would exceed the window, something has to give.

What gives is the oldest part of the conversation. Providers ship a feature for this. Anthropic documents it as compaction, and it triggers automatically as a conversation approaches the limit: older messages get summarised, and the summary is sent in place of the real thing. This is a shipped feature rather than a malfunction, and it is the reason your conversation doesn't simply stop dead at message forty.

A summary is lossy. That's what a summary is.

I wanted to know how lossy, so I measured it. This is the one number in this post that's mine.

I planted twelve specific facts inside a 9,169-token document, split it into passes small enough to fit the window, had each pass summarised into notes, then combined those notes into a single summary, checking recall at each stage. After the first pass, 56 percent of the planted facts survived. After the combining pass, 25 percent.

Three quarters of the detail gone, with nothing failing anywhere along the way. Every step did exactly what it was asked to do.

Two honest notes on that measurement, because it's mine and it's the one you can't check by reading a paper. It was run against Apple's on-device model rather than a hosted one, so it is not a direct measurement of what ChatGPT or Claude do to your conversation when they compact it. What transfers is the direction and the rough scale of the loss, not the exact figure. And the variance was large: my four best-configuration runs recalled 8, 50, 0 and 42 percent, so one run in four lost effectively everything. The stable part across every configuration I tried was that the combining pass costs 55 to 79 percent of whatever the notes had managed to keep.

A short rule about formatting is exactly the kind of small thing that doesn't survive being made shorter.

The two-sentence version

Your whole conversation is resent on every single turn, so your instruction never actually leaves, but the attention reaching it thins out as the conversation grows until the model is reading past something that's still sitting right there. Go long enough and it gets compressed into a summary, and then most of it genuinely does disappear.

Everything above was measured on benchmarks, or in my case on one model summarising one document. It was not measured on the tool you actually use, in the way you actually use it.

So tell me that part. How many turns before yours starts ignoring something you told it, and which tool was it? Both, in the comments. If enough people answer, the spread across real tools is worth a post on its own, and it's the one number none of these papers can give me.

Next in this series: why GPUs turn out to be the right hardware for any of this in the first place. It has almost nothing to do with them being fast.

🎉 Enjoyed this article? Your support means the world to me!

🎬 Subscribe on YouTube for video versions of these posts: https://www.youtube.com/@swift-pal

💼 Let's connect on LinkedIn for more professional insights: https://www.linkedin.com/in/karan-pal

☕ If this saved you some time, you can buy me a coffee: https://coff.ee/karanpaledx