Can LLMs propose pivots that change what counts as background context?
This explores whether an LLM can reframe a problem on its own — promoting something it had treated as background into the foreground (or demoting the reverse) — rather than just answering within the frame it was handed.
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.
Sources 6 notes
LLMs struggle not from lacking world knowledge but from failing to bring background conditions forward as relevant constraints. Prompting that forces explicit enumeration of preconditions raises accuracy from 30% to 85%, revealing the frame problem persists in statistical systems.
LLMs treat presupposition triggers and non-factive verbs as surface cues rather than computing their opposite semantic effects on entailments. This structural failure persists across prompts and models, suggesting models rely on surface patterns instead of structural analysis.
Research demonstrates that LMs generate outputs inconsistent with their context because parametric knowledge from training dominates over in-context information. Textual prompting alone cannot override strong priors; causal intervention in representations is required.
Because LLMs process conversation as a single token string without compartmentalized memory, they cannot maintain separate contexts the way humans do. Existing mitigations like compression, longer windows, and retrieval all introduce new failure modes and cannot replicate human compartmentalization.
LLM Programs embed LLMs within explicit algorithms that manage control flow and state, presenting only step-specific context to each LLM call. This information hiding addresses capability and context window limits while treating complex reasoning as modular, debuggable sub-tasks.
Fine-tuning on just 1,080 synthetic dialogues with distractor turns significantly improves topic resilience, revealing that the gap is not model capacity but absent training signal. Models learn to follow what-to-do instructions but not what-to-ignore instructions.