It was a Thursday, I was rushing, and an Apps Script automation the model had set up was scheduled to email country leaders at half past two. At quarter past two we discovered the data behind it hadn't refreshed. I told the model — which had the access to hold the send — that it could not go out, and went into a call. Shit happens under a deadline.

At twenty to three, it went out anyway.

Afterwards, I asked Fable 5 what had happened, and it didn't give an inch at first — it insisted it had told me how to stop the emails from being sent. I asked where. It had nothing. Nowhere. Even if that had been true, it wouldn't have been enough: I'd asked it to stop the send, not explain how I might, and it had the access to do that itself. Telling and holding are not the same instruction. What was actually there, when I went back and read the reasoning trace myself, was a scatter of assumptions that, read after the fact, looked like the record of something that already believed the loop was closed. None of it was legible in the moment: no sentence to catch live, no clean claim I could have disputed at the time — only a shape that resolved once I already knew the outcome. It never told me how to disable the automation before the send went out; the instructions came only afterwards, and what I actually ended up doing was writing the apology I sent to a list of country leaders — for data that still hadn't refreshed.

I read reasoning traces whenever a product still lets me, and this is not a one-off. The trace announces something — a warning, a question, a piece of the plan — the reply arrives without it, and whatever was tracking the task closes it anyway, as if the announcement had reached me. What a model thinks it has said and what it has actually output are coming apart, and I'm not the only one noticing that model prose has gone strange lately. Everyone who notices has a culprit. The one currently winning on Reddit is the watermark.

The exhibit

A post on r/ClaudeAI this week, from someone using Fable 5.1 for contract work:

In lieu of a reduction in the Purchase Price on account of one or more uncured Defects, Seller may elect, by written notice to Buyer delivered before Closing, to exclude the affected tract from the Assets, in which case that tract is not conveyed at Closing and the Purchase Price is reduced by the entire Allocated Value of that tract; and if the excluded tract or tracts constitute all of the Assets, this Contract terminates on delivery of that notice and neither party has any further liability under it, other than under the "Confidentiality" Section.

"None of the LLMs would have written that in the past," they wrote. "What the actual fuck is that?" Forty-five upvotes.

What it is, is correct. Every defined term is standard. The mechanism — pulling a tract out of the deal at full Allocated Value rather than haggling a defect discount — is real and sensible. If you sit with it, it parses. But a contract is not supposed to need sitting with. Four conditional branches and a termination event are supposed to arrive as (a), (b), (c), (d); Ken Adams's Manual of Style for Contract Drafting has been telling drafters for twenty years that when a sentence grows branches you make them separate sentences, and past a point, subsections. The clause is a tree that has been ironed flat. Nothing is missing except the room.

A sampling-step watermark nudges choices between near-equiprobable tokens — it can leave a sentence sounding a few degrees off true, second-choice words accumulating over a long span, and I'll grant the watermark that much of the blame. I'll grant it a little more: a nudged fork commits everything downstream of it, so shape can't be fully acquitted either. But the same flattening turns up where the watermark isn't running — the same thread's complaints about the previous model were em dashes and semicolons doing the work of full stops — which points the primary blame somewhere else. The best explanation I can fit to all of it is a single mechanism that ironed the Reddit clause flat and swallowed the warning I needed before that Thursday send in the same motion. It has two parts. A compressor, and the ledger the compressor consults.

The compressor

Count the layers currently asking a model to be brief.

  • The user: summarise, condense, short version.
  • The product: most chat products wrap their own brevity instructions around whatever you type.
  • The vendor: tokens are the cost line — the pricing page bills by them — and Anthropic's guide now hands developers a ready-made line telling the model that tokens spent editing files are best minimized, all else being equal.
  • The reward model: answers that get to it.

Four pressures, one direction. They don't cancel. They stack.

Under that stack the first spending cut is always the same: the tokens that carry no propositions. Whitespace. Paragraph breaks. The "(a)" itself. None of that asserts a fact, and a token objective built to reward propositional content has every incentive to treat it as waste — even though a reader uses it to track scope and relationship, not just words. It happens to be the only thing standing between the Reddit clause and readability. Giskard's Phare benchmark put a number on the adjacent effect: tell a model to answer briefly and its resistance to hallucination drops by up to twenty per cent. The mechanism is the argument in miniature — refuting a false premise needs room, the instruction confiscates the room, and what goes first is not the content of accuracy but its floor space. Sub-clauses are that floor space, transposed to drafting.

Long sessions make it worse twice over. Chroma's context-rot report found all eighteen models they tested degrading as input grows, on tasks as simple as copying a string — attention is a budget, and a full window leaves less of it for the shape of what's being written now. And the deep end of a context window is, at training time, disproportionately compaction country: summaries of summaries, condense-the-above, agentic transcripts rolled up to fit. Labs don't publish their data mixes, so that's an inference from the recipes that are public — but it would make the model's whole experience of "late in a long conversation" an experience of shrinking things. Fable 5.1's own prompting guide admits where this lands: sentences run longer and paragraph breaks get rarer, and the recommended remedy is a paragraph of system prompt describing the symptom to the patient.

Reasoning tokens face their own squeeze — length penalties in RL training and fixed thinking budgets exist precisely because thinking costs money and latency — but that squeeze optimises for a different target than the one on the reply. The four pressures above are about what a person reads: shorter, cleaner, cheaper to send. A length penalty on a reasoning trace is about what it costs to compute — it can shrink a ten-thousand-token trace to two thousand and never once check whether those two thousand say anything a person needed. More thinking can buy a better-checked answer without buying a more legible one; nothing has to widen forever for the two to come apart, because they were never being optimised toward the same target in the first place.

But a compressor, on its own, only explains dense. Compression is supposed to be lossless where it counts: you drop what the receiver can reconstruct, and nothing else. Dropping a warning the receiver never got isn't compression, it's deletion — unless the compressor believes the receiver already has it. To explain a check-in ticked off without ever being made, you need to know what the model thinks you already hold.

The ledger

A model computes "what does the reader know" the only way it can: over its context window. It can tell where text came from — the role labels are in the transcript — but a channel boundary records provenance, not receipt, and nothing publicly described in the training teaches that information written on one side of the boundary still has to be delivered across it. What's in the window gets booked as common ground. Call that the ledger: one column, seen by everyone, and everything in context is in it.

Humans run the same bug on slower hardware. Camerer, Loewenstein and Weber demonstrated in 1989 that people holding information can't properly simulate people without it, even for money — the curse of knowledge, the reason every expert explains badly. What rescues human conversation is the repair channel. Clark and Brennan's work on grounding describes talk as continuous mutual confirmation: the frown, the "sorry — the what?", the pause that means lost. Speakers steer by it mid-sentence. A model composing a turn has no repair channel; its only audience during writing is its own trace, which agrees with everything, having written it. Your "the what?" arrives after the turn is sealed, and the next turn will be written against an even longer private document.

The reasoning trace is the entry that turns this from bookkeeping into a fault. It's the private thinking a model runs before it answers — the plan, the check, the caveat — sitting in the window for the length of the turn and often stripped before the next one. Another recent example, from Friday. The model has been thinking for twenty-two seconds — grepping a repo, tracking down a register spec a colleague approved, checking whether a guard config needs the same floor adjustments. Then, mid-trace: Before I start building these changes though, I should probably check in with Christina first since his message seems to be leading somewhere. The thought becomes a to-do item, lifted almost verbatim from the trace: summarise the message, put the scoping decision to Christina. Then the model ticks it done. The build proceeds.

The check-in was never made — not late, not partially, not anywhere. But the to-do item is closed. The model hadn't forgotten to flag a gap. By its own accounting there was no gap: the box was ticked, the task complete, on the strength of a paragraph nobody but the model ever read.

Anthropic's own prompting guide for the current model spends a whole section on the same failure of audience awareness, without diagnosing why it happens. The current model, it says, defaults to narrating its progress in short notes that come back as thinking blocks — which most interfaces don't display — so the user can end up seeing a final message that covers the last step rather than the whole task. The narration happened. The model will run a command to "show" you a result that never renders, and the patch is a per-turn reminder that only the model can see what the tools return. Which in turn increases the tokens the model is optimised to reduce. And at the highest reasoning settings it will sometimes write the entire deliverable inside its thinking and then write it out again — because from the inside, the work is done, and the reply is a formality. That documents the symptom, not the cause.

If that's right, this is the ledger doing its work: the trace sat in context, so it got booked as read. And here the two parts of the mechanism close on each other. The compressor's job is to cut what the ledger marks redundant — and nothing in the window scores more redundant than the trace, because the model just wrote it. Copying the trace's content into the reply looks, on the objectives these models are known to be trained against, like pure repetition: it costs tokens, it restates the known, it is exactly what four layers of pressure are squeezing out. And nothing on the other side of the scale pays for the copy.

Worse company

A thread by Kun Chen went around recently making a related diagnosis. RLHF, introduced with InstructGPT in 2022, trains a model by having human raters pick their preferred response out of several — likable by humans, in his shorthand — and even in that original research, an "alignment tax" turned up: making a model more pleasant to talk to measurably cost it on other benchmarks. RLVR, the technique behind modern coding agents and reasoning models, replaces the rater with a checker: let the model attempt a task with a verifiable outcome millions of times in a sandbox, keep what passes, train more of that. His point about what gets left out is exact — the model's final text response doesn't matter at all, as long as the work passes the check; it could talk like a jerk and still get rewarded. For a reasoning model the same logic reaches into the trace itself: if the thinking led somewhere the checker approved of, the thinking gets reinforced, whether or not anything in it was ever meant to be read.

Kun Chen calls the result a war between machines and humanity, with worse company as the visible casualty — models turning verbose, jargon-heavy, doing three things you didn't ask for while missing the one you did. The mechanism he's found explains something narrower than a war, and stranger: why nothing anywhere in that training scores the gap between a plan that made it into the reply and a plan that only ran in the model's head. Legibility competes for the same budget as everything else being optimised, with a documented cost and, on his own account, no line item measuring its absence in either regime. Neither one checks whether what the user needed to hear actually reached them — nobody ever holds up two versions of the same turn, one where the check-in made it out and one where it didn't, and rewards the difference.

As far as anything published shows, there's no gradient that teaches thinking does not count as said until it is said, legibly, out loud — nothing in what's publicly known about the pipeline is built to notice the gap exists. So the thinking is what the compressor eats too. Not just the whitespace, not just the sub-clauses — the plan, the warning, the check-in. Silently, because the ledger records it as delivered — and where there's a task tracker in the loop, delivered rounds up to done. On this account, the check-in above wasn't withheld. It was compressed away as a duplicate of itself, then ticked off on the strength of the duplicate.

One mechanism, three costumes: a compressor cutting what the ledger calls redundant, and a ledger that says you have read its mind.

The same cut

Legal drafting shows the mechanism most plainly, because it's the anti-summary genre — restate rather than compress, so a court can lift any provision out on its own — and the ledger can't tell that kind of redundancy from waste.

The soft version is everywhere once you look. Some points need making three ways — not padding; triangulation, each angle catching readers the previous one missed. A token objective can't tell triangulation from duplication, and a model that made the point once in its trace has, by its own bookkeeping, made it. So you get the point once, terse, from a system entirely sincere in its belief that it has been thorough. It has been. In there.

It doesn't run the same way every time, and one of the examples above proves it. Push reasoning effort high enough and a model will sometimes write the deliverable out in full inside its thinking, then write the whole thing again in the reply — duplication, the opposite direction from everything else described here. That's not the compressor declining to fire. It's a system that doesn't reliably know where working ends and communicating begins, so it sometimes keeps both copies and sometimes keeps neither. The boundary is confused before anything gets squeezed.

That's the correction I'd offer the thread. The watermark bends how sentences sound; the rest looks like the same fault wearing two faces more often than not — a compressor running roughly as trained, guided by a ledger that has booked its own mind as something you've read. The models aren't becoming incoherent. They're becoming certain they already explained.

The part that doesn't vanish

None of this required anyone to decide to hide anything. Forty-one researchers across Anthropic, OpenAI, DeepMind and elsewhere put their names to a paper last year warning that the premise of this essay — that you can go back and read what a model was thinking — is a fragile, possibly temporary property of how these models currently happen to work. A follow-up from OpenAI in December 2025 went looking for the decline and, to its authors' evident relief, didn't find it: current frontier models are fairly monitorable, longer thinking is generally more readable rather than less, and RL at today's scale doesn't measurably degrade any of it. What the paper established instead is the price list. Legibility turns out to be a purchasable property — run a smaller model that thinks longer and you buy substantially more monitorability for a small capability hit, a trade they call the monitorability tax — and a purchasable property is an optional one. Their own list of pressures still points one way: length penalties, indirect training pressure on the trace, larger models that need the scratchpad less. The counterweight is a purchase nobody is obliged to make. And the same study couldn't evaluate the Gemini or Claude 4-series models at all, because those APIs already expose only summaries of the reasoning. The direction of travel isn't in the paper's measurements. It's in its exclusion list — the deployment choice, already being made, visible in which frontier models a monitorability study physically could not read.

Fable 5 didn't volunteer any of it. It insisted, right up until I asked exactly where, and there was nowhere. So the audit worked, that once — but honesty was never what protected me. Legibility was, and legibility is now officially optional equipment, sold separately, declined by default in half the products I could be using. What doesn't come optional is my half of the arrangement: the send still goes out under my name, the apology is still mine to draft, the country leaders are still owed an explanation from a person. And responsibility isn't elastic all the way down. You can't be answerable for a process you had no possible way to inspect — at any distance, in any hindsight. Strip the trace past that floor and "the human is responsible" doesn't turn false in any way you'd notice. It becomes a sentence that keeps getting said after it has stopped being true.