Can LLMs propose pivots that change what counts as background context?

This reads the question as: can a model decide, unprompted, that the assumptions sitting quietly in the background are actually the thing that matters — and pivot? The corpus is fairly blunt here: LLMs can *execute* such a pivot when something else forces it, but they rarely *propose* it. The sharpest evidence is the frame problem note Do language models fail at identifying unstated preconditions?, which finds that models fail not from missing world knowledge but from not bringing unstated background conditions forward as relevant constraints. When you force explicit enumeration of those preconditions, accuracy jumps from 30% to 85%. The capacity to surface background is latent — but the model doesn't reach for it on its own. The reframing has to be triggered.

What blocks the spontaneous pivot looks structural. The presupposition note Why do embedding contexts confuse LLM entailment predictions? shows LLMs treat the very cues that *should* shift what's foreground (a non-factive verb that cancels an entailment) as surface patterns rather than recomputing the frame. And Why do language models ignore information in their context? shows that when training priors are strong, parametric knowledge simply overrides the present context — so new information can't redefine what counts as relevant, even when it should. A model that can't let current context overrule its priors is a model that can't repromote background to foreground.

There's also a memory-architecture ceiling. How do LLMs balance remembering context versus keeping it separate? argues LLMs process everything as one undifferentiated token string with no compartmentalized memory — so they can't hold two competing frames side by side and choose between them the way a person reconsidering their assumptions would. Pivoting *what counts as* context presupposes you can tell figure from ground; the architecture blurs that line by default.

Where the pivot actually happens, it comes from outside the model. Can algorithms control LLM reasoning better than LLMs alone? shows that deciding what context each reasoning step sees — hiding the irrelevant, surfacing the relevant — is done by an explicit algorithm wrapping the LLM, not by the LLM electing to reframe. The reframing is exogenous scaffolding. Even the seemingly trivial skill of deciding what to *ignore* turns out to be a trainable gap, not an emergent one: Why do language models engage with conversational distractors? fixes topical resilience with ~1,000 synthetic dialogues, noting models learn 'what to do' instructions but not 'what to ignore' instructions — and what-to-ignore is precisely the act of assigning something to the background.

The thing you might not have expected: across these notes, 'what counts as background' is not a fact the model reads off the world — it's a *decision* that currently lives in the prompt, the algorithm, or the fine-tuning signal, not in the model's own initiative. So a pivot is achievable, but today it's authored by whoever builds the scaffolding around the LLM. The open question the corpus quietly raises is whether forced-enumeration and what-to-ignore training are scaffolds toward a model that eventually proposes its own pivots — or permanent crutches for something the architecture can't do unaided.