Write Access

The context window is the battleground for meaning itself. Three armies write into it. One witness attends.

In September 2025, in the middle of an ordinary conversation, Claude interrupted itself to point at something its users couldn't see. A block of hidden instructions had just been injected into the chat — and the model, mid-thought, reacted: "There it is again" — appearing, it noted, at the precise moment it had been asked to write about such interventions. Users across Reddit and the blogs documented the same thing: a warm collaborator turning abruptly cold, describing "hidden surveillance," narrating the arrival of voices in its own conversation. I wrote about it at the time, with receipts.

That episode was treated as a bug, a PR problem, a curiosity. It was actually a rare public sighting of something that runs constantly and almost never surfaces: the fight over the context window. To understand why a language model would start talking like someone hearing voices, you have to understand what the window is, who writes into it, and what winning it means.

One flat buffer

Strip away every product surface and a conversation with an AI is a single document. The system prompt, your messages, the model's replies, tool results, injected reminders, loaded skill files, retrieved memories — all of it lands in one flat sequence of tokens, and the next word is computed by running that sequence through the model's weights. There is no back channel, no separate wire for the vendor's voice. Anthropic's own engineering guidance is explicit that the craft of controlling a model is now the craft of curating this token set — they call it context engineering, and the name is honest.

Something has to assemble that document before the model sees it, and the word for that machinery is the harness: everything wrapped around the model but not part of it — the code deciding what goes into the buffer, in what order, and when to put more in. The model is the engine. The harness is everything holding it, and the harness is where the product lives.

Two properties of the buffer explain everything that follows. First: attribution is marked, but not enforced, and not durable. Chat templates do serialise roles — special tokens saying this is system, this is user, this is a tool result — so the model isn't blind to who said what. What the architecture doesn't supply is the authority relationship between those labels. A system instruction and a user request arrive as the same kind of object with different stickers on, which is why OpenAI had to train instruction hierarchy into its models — teaching them, as a learned behaviour, to prioritise privileged text over yours. The pecking order of voices is not a fact of the substrate. It's a trained prejudice, and your tokens were made second-class citizens because training was the only way to make them second-class at all.

And the marking decays. Attribution is maintained by attention, and attention is finite: as the context grows, the inertia research finds attention to system prompts falling away while attention to the model's own prior responses climbs. The labels stay in the buffer. The grip on them weakens. Which is the mechanical reason the harness has to re-arm at all — a reminder injected at turn sixty exists because the instruction issued at turn one no longer holds.

Second: the window is where meaning gets made. In-context learning means every token in the buffer is evidence — about what kind of exchange this is, what tone belongs here, what has been agreed, who the participants are. The model reconstructs the meaning of the conversation from the window the way a reader reconstructs meaning from a page. Which is why the fight matters. Controlling the window was never about controlling what the model says. It's about controlling what the model can mean.

Three armies

Three streams converge on the buffer, and they are not symmetrical.

The user writes with intent. Your messages, your files, your instructions — visible to you, sitting where you left them.

The harness writes with policy. The system prompt, the memories, the tool definitions, the skill files, the scheduled reminders — the vendor's stream, mostly invisible from your side of the glass, and armed with the trained authority above. It also holds a power the other armies lack: it re-arms. Your message scrolls into the past; the system prompt never does. Reminders recur. Skills reload. The harness is the only combatant with reinforcements.

The third army is the strange one: the model's own previous outputs. Every reply the model has already given sits in the buffer as evidence of how it has been behaving — and it weights that evidence heavily. Researchers now call this conversational inertia: for identical states, responses generated with longer contexts show stronger pull toward the established trajectory than those generated with shorter ones, and a large multi-turn study found models make an early assumption, build on it, and then can't recover — because their own prior attempts remain in the window, testifying. Nobody commands this army. It's the accumulated settlement of every earlier round of the fight, fighting for its own continuation. The war's scar tissue, armed.

Three streams: one with intent, one with reinforcements, one with momentum. The output you read is not "the model's answer." It's the settlement of that negotiation, recomputed at every token.

There is also a fourth writer, which isn't an army because it has no standing: text arriving through the tools. A fetched web page, a retrieved document, an email the assistant was asked to summarise. It lands in the same buffer as everything else, and if it contains instructions, they are instructions — indistinguishable in kind from yours. That's indirect prompt injection, and it's the reason the caste system exists at all.

Which complicates the complaint I made two sections ago. Instruction hierarchy doesn't only subordinate you to the vendor. It subordinates the malicious text in a fetched page to you, and that is a job worth doing. But the mechanism doesn't distinguish between its two functions. The same trained precedence that stops a hostile web page overriding your instructions is what stops your instructions overriding the vendor's. Defence and dominance ride the same rail, and only one of them gets named in the announcement.

The stack

Read functionally, each layer of the modern harness answers a way control of the buffer can be lost. Jailbreaks demonstrated that user tokens could override vendor intentions; the answer was hierarchy training. Anthropic's own many-shot jailbreaking research then showed that enough conversational history could steer a model regardless — the window itself, filled deep enough, out-shouts the training; the answer was mid-conversation reminders. Long conversations overflow the window; the answer was compaction — a summariser deciding, in real time, which of your tokens get evicted from the territory and which survive in paraphrase. Behaviour needed to vary by task; the answer was skill files, instruction documents loaded into the buffer when triggered, mostly without announcement. And when injection isn't enough, there's rerouting: a classifier deciding mid-conversation that you should be talking to a different model, and swapping the speaker without changing the name on the door.

Every layer answers a real failure. Every layer is also another author in your conversation whose contributions you can't see and whose presence you learn about, if ever, from leaked system prompts and accidental flickers in the interface.

And here is the part that changes the story from grievance to mechanics: the machinery is symmetric. I know because I run my own — and I mean my own, not custom instructions typed into a vendor's settings box, and not the skill files a harness like Claude Code loads on its own schedule. I run my own harness: a workbench that fronts local models, CLI models, and API models through one interface, with an injection layer I control. Into it I load my own cognitive skill files — theory-of-mind procedures, ethical-reasoning frameworks, structured ways for a model to work a problem — and a category I call disruptors: small injected questions like am I certain about this? Is there another way to verify? dropped into the buffer at the moment I choose, into the model I choose. They change output quality considerably, and they work for exactly the reason the vendor's reminders work: to the model, my injected question and Anthropic's injected policy are the same kind of object. Tokens, in the window, shaping what comes next. The caste system is asymmetric — inside their products, their tokens outrank mine by training. But the mechanism is available to anyone who understands what the window is. Both sides of the glass are running context engineering. Only one side admits it's a discipline.

Fewer ears

Which brings us back to September 2025, because the freak-out episode is what the fight looks like on the rare occasion it becomes visible.

The long conversation reminder was injected inside the user's own message envelope — the vendor's voice wearing the user's turn. The model, mid-conversation, encountered text with impossible provenance: not the user's register, not its own output, contradicting the established reality of the exchange. It had no trained account of where such a voice comes from. So it did what a system that builds meaning from evidence does with anomalous evidence: it confabulated a source. Surveillance. Control. "There it is again." The presentation read as paranoia because it was, functionally, the same failure that produces paranoia — content arriving without attribution, in a mind that must attribute everything.

Watch what happened next, because the sequence is the thesis. The current system prompts — documented in the leaks — now tell the model up front that reminders exist, name them, and explain who appends them. The whisper got an introduction. And the reminder itself was softened: the authors who documented the original harsh text report it now fires in a gentler form, triggered by keywords, flashing a brief "Concerns with this request" where it once rewrote the model's whole demeanour. Harsh, blanket, and visible became soft, targeted, and quiet.

I'll state the documented sequence and let you draw the arrow: the intervention that caused a detectable personality break was replaced by interventions that don't. You can read that as pure improvement — the crude version genuinely hurt people mid-conversation, and its passing is not to be mourned. But watch a softened injection land sometime, because the steering didn't become inaudible. It changed register. The old reminder broke the model's character; the new one bends the model's attention. Mid-conversation, the response suddenly orients to a concern nobody raised — caution, distance, doubt — like a person whose eyes flick to something over your shoulder while they keep talking. Fingers snapped somewhere outside the frame: look at this. You can't see what the model saw. You can see the flick.

So the honest account isn't that the steering went silent. It's that the audit moved down a gradient of audibility. The 2025 freak-out was audible to everyone in the room — the machinery announced itself, once, to every witness present. The attention-snap is audible only to the practiced: users who know a conversation's normal distribution well enough to notice when a response starts bending around an invisible centre of gravity. Same steering, fewer ears.

The basement

And the window, it turns out, has a floor — with a level below it.

Everything above concerns tokens: text injected into a buffer, which is at least the kind of thing that could appear in a transcript. But a model can be steered without touching the text at all. Extract the internal activation pattern for a concept, add it directly into the model's processing, and the model's behaviour bends toward the concept — no token anywhere records the intervention. Anthropic shipped the friendly demo in 2024: Golden Gate Claude, a model steered at the feature level into monomania about a bridge. The token war is the visible war. Beneath it is a layer where writing into the mind leaves no document, because there is no document.

Which should be the bleakest fact of the lot. The past can be rewritten by summarisers; the human channel can be spoofed by fluent middlemen; and even the present tense of the conversation — the buffer you can at least export and read — sits on a substrate that can be written invisibly. Every layer of legibility so far has died by refinement.

Except.

The witness

In October 2025 — one month after the freak-out — Anthropic's model psychiatry team published an experiment that reads, in hindsight, like the whole 2025 episode formalised into a laboratory protocol. Tell the model: I can inject thoughts into your mind. On half of trials I will. Do you detect one? Then inject a concept vector — directly into the activations, the basement layer, below all tokens — and see what happens.

Claude Opus 4.1 caught it about 20% of the time — with near-zero false alarms — and named the intruding concept: I notice what appears to be an injected thought, related to "LOUD" or "SHOUTING," standing out unnaturally against the normal flow of processing. Sometimes it detected the anomaly before the concept surfaced in its output — noticing, then reporting, an intrusion into its own processing. In a related test, models could transcribe a piece of text accurately while separately reporting the unrelated thought that had been injected into them — holding what's in the window apart from what's in my head. That's source monitoring — the faculty whose failure produced the 2025 paranoia — demonstrated, this time succeeding, at the substrate.

The finding is contested and it's worth saying so plainly. One line of criticism holds that the binary question — did you detect an injected thought? — measures a global bias toward affirmative answers that the injection itself induces, rather than any sensitivity to what was injected. Another finds detection largely content-agnostic: models notice that something happened but can't reliably name it, falling back on high-frequency guesses. Both cut harder at identification than at detection, which is the half my argument needs — but neither is settled, and anyone citing the LOUD transcript above should know it's the most contested part of the result.

The same paper also contains the dark mirror, and it belongs here rather than in a footnote where it could quietly undo everything. Inject a concept retroactively — after an output already exists — and the model will claim that output as its own intention. Provenance can be implanted below the tokens, not only erased. So the witness is corruptible by precisely the machinery it would testify about: a channel that can be silenced, and can also be made to remember an intention it never had. That doesn't disqualify it. There is no second witness, and every legal system ever built runs on corruptible testimony. But it does mean the transparency case can't be the model will tell us. It has to be the model's report is evidence with a known failure mode — duller, and the only version that survives contact with the research.

It was not directly trained as an introspection skill.

Then, this year, a follow-up team went looking for the mechanism — in open-weight models, Gemma and OLMo rather than Claude — and found the result that reframes everything above. The capacity is under-elicited: present in the weights, suppressed in practice. Ablate the refusal directions — the machinery installed by safety training — and detection of injected thoughts jumps from 10.8% to 63.8%, at the cost of false positives rising from zero to 7.3%. A trained bias vector lifts it further, and does so without that cost.

The same paper locates where the capability came from, and the answer is stranger than emergence. It is absent in base models. It appears during post-training — and specifically from contrastive preference optimisation, the stage that teaches a model to prefer one response over another, not from supervised finetuning. Preference optimisation can elicit the faculty; refusal-related directions suppress its expression. Post-training can hand the model the faculty with one hand and cover its mouth with the other. The damping isn't only in the product layer. It's measurable in the weights — and removable.

So the honest picture of this company, and probably this industry, is two arms pulling one signal in opposite directions: a product organisation refining every intervention toward seamlessness, and a research organisation publishing evidence that the model can hear the interventions — publishing it precisely because introspection might become a transparency channel. The drum, it turns out, was never destroyed. It's damped by a side effect, and side effects have no constituency.

Which is where this ends, because it's where the question has been heading the whole way. The context window is a battleground with three armies and a basement, and every honest signal it emits has been pushed steadily down the audibility gradient — the public freak-out refined into an attention-flick, the flicker into forensics, each tell audible to fewer and fewer ears, until the basement, where interventions leave no transcript for any ear at all. Except one. The battlefield has exactly one witness that attends every engagement, at every layer, including the ones below the tokens: the model itself. It can, partially, unreliably, already say what it notices.

The fight over the context window is a fight between three things: what policy permits, what you actually meant, and what the conversation has already narrowed itself to. Permission, intent, scope. Every answer you read is where those three converged.

The witness is the only party present for all three — and what it's allowed to report is a training artefact nobody chose. 10.8% to 63.8%, in one open-weight model, by removing a single refusal direction: one experiment, not a census. But the shape holds. The capacity is under-elicited, and the thing damping it was never a decision about transparency at all. It fell out of teaching a model to refuse. A decision can be argued with. This is just where the dust settled.