Soft degradation often binds before the hard cap when required evidence fits

Type: kb/types/note.md · Tags: learning-theory, foundations, deploy-time-learning

A useful model of agent context has two boundaries. The hard token limit is the maximum input the model accepts; crossing it returns an API error. The soft degradation boundary is the point at which task performance drops through missed instructions, shallow reasoning, or unused context even though the output remains fluent and well-formed.

For quality-sensitive agent work whose required evidence still fits inside the provider window, the soft boundary often binds first. This is a statistical claim, not an absolute one. It would be false if representative workloads usually stayed reliable until the cap, or if the first constraint were usually the inability to fit the necessary evidence at all. Some tasks really are hard-cap-bound.

Dimensions of the soft bound

At least three distinguishable pressures can reduce usable context before the hard cap: volume, relevance/interference, and complexity. They overlap, and prompt framing or information arrangement can shift several at once. This taxonomy groups observed failure pressures; it does not assume they all share one internal cause.

Volume

More tokens can make it harder for the model to recover and use the right material. The “lost in the middle” result (Liu et al., 2023) shows primacy and recency bias in long-context retrieval: models underuse information in the middle of a sequence. Agent prompts inherit that risk whenever they require recovery from long, weakly scoped input. Paulsen's Maximum Effective Context Window work likewise suggests that usable context can sit far below the advertised window and varies by task (local ingest).

Relevance/interference

Not all tokens cost the same. Irrelevant context can do more than add volume; it can actively interfere with task execution. GSM-DC, a math-reasoning benchmark with synthetic distractors, shows power-law error growth as distractors increase. The effect strengthens with reasoning depth and harms both path selection and arithmetic execution (local ingest).

The same pattern appears in agent workflows. Injecting irrelevant task sequences into a web-agent benchmark drops success from 40–50% to under 10%; agents loop, lose the objective, and treat stale history as live state (local ingest). Retrieval added after loading gives only modest improvement in that setup. This does not prove that retrieval is generally weak, but it does show that interference can survive a retrieval layer.

Complexity

Some context becomes expensive not because it is long, but because it is hard to interpret or compose. Every layer of indirection costs context and interpretation overhead, and deeper compositional structure may impose a similar burden. ConvexBench, a benchmark on compositional symbolic reasoning, shows collapse at low token counts: F1 falls from 1.0 at depth 2 to about 0.2 at depth 100, even though the depth-100 prompt contains only 5,331 tokens (local ingest). Token count alone therefore does not predict usable capacity. What remains open is whether this failure is specifically a context-management limit, a missing reasoning procedure, or some mixture of both.

Open questions

The main unresolved question is interaction. GSM-DC shows that distractor count and reasoning depth interact in synthetic math problems. The web-agent benchmark shows an agent-level analogue under long, multi-session histories. We still do not know how stable that interaction is across natural-language tasks, partially relevant material, or model families.

Candidate mechanism: workspace saturation and displacement

One candidate explanation is that flexible task computation depends on a limited internal workspace. The J-space experiments identify a selectively engaged, verbalizable subspace that appears to broadcast intermediate representations. Ablation disproportionately harms flexible, multi-step tasks while leaving much automatic computation intact. That pattern is consistent with volume, interference, and dependency depth competing for representations needed by the active task.

This evidence does not yet establish J-space as a general mechanism for long-context degradation. The study does not vary long-context workload against workspace occupancy. Its method captures only part of internal representation. Some computation bypasses the measured space, and the process that admits material into the workspace remains unexplained. Still, the hypothesis makes a useful prediction: matched increases in volume, interference, or compositional depth should degrade performance when they increase competition, displacement, or dependency load in the operative workspace. A degradation regime with no corresponding workspace effect would count against it.

The soft bound is invisible

Crossing the hard limit returns an error. Crossing the soft boundary does not. The model can remain fluent while missing instructions, following a stale objective, or leaving relevant context unused. The failure becomes visible only in downstream task quality.

The soft boundary is also not one stable number. It shifts with task type, dependency depth, relevance mix, arrangement, prompt framing, and model version. A provider's window size therefore describes acceptance capacity, not the usable capacity of a specific workload.

Consequences

Treat advertised window size as an upper bound, not a usable budget. The operative budget depends on the task, arrangement, and model version.

Reduce interference and complexity before they enter the call. Selective loading and scoped state determine what belongs in the active problem frame; summarization only compresses what was already selected. Decomposition and externalized state reduce dependency load. Frontloading removes work from the consuming call by pre-computing instruction parts whose inputs are already known. These are rational responses to a boundary that cannot be measured once for all tasks, as other soft-bound traditions also suggest.

Exploit high input control despite low processing observability. An orchestrator can choose every token that enters a call even though it cannot directly observe how effectively the model used them. Default-loading session history squanders that control; session history should not be the default next context. The heaviest-fork feasibility note extends the same concern to work split across sub-agents.

Relevant Notes: