Case packet

Neutral case identifier: case-792c56f9b2a2f7

The possible directed relationship from Artifact A to Artifact B is under review.

Artifact A

First principles are inherited constraints, not design choices

A companion note shows which rules a universal framework cannot keep as universals: first-order content taxonomies [demote to guarded defaults] because they are not universal — the next kind of KB breaks them. This note is the other half: the rules that genuinely constrain the design space and therefore cannot demote.

The membership test: a rule is a first principle iff it arrives in the constraint packet of one of the framework's boundary commitments — the consumer it serves, the substrate it is built on, the domain it commits to (knowledge), or the machinery it has built. The commitments themselves are chosen, sometimes for features unrelated to the constraints they bring — files picked for ubiquity and tooling, not for how placement behaves. But every such choice is a packet deal: whichever substrate is chosen, its limitations come along whole, and the framework cannot cherry-pick the features it likes out of the bundle. What is unchoosable is not the boundary but the unbundling — and that is the sense in which a first principle is inherited: it comes with a commitment, never on its own terms.

Nor does composition escape a packet: a framework can combine parts built on different substrates, but each part still answers to its own substrate's limitations — artifacts held in files obey the file packet even when acceptance state lives in a database next door. Machinery coherence fits the same shape, just later: building machinery of a given kind is the choice, and its coherence rules are the packet. These four are the boundary commitments currently visible; the list is open, like the list of principles itself.

The two halves are therefore not symmetric. Design choices are positions within the design space: a rival can be swapped in while every boundary commitment stays, so a framework aiming at universality can offer several and let a collection pick — they demote to guarded defaults. First principles are boundaries of the design space: there is no rival position to demote to, and dropping one means re-choosing a boundary commitment and taking a different packet whole — not reconfiguration but a different framework.

The principles that currently pass the test

Each is named with the boundary it inherits from. The list is what passes today, not a closed set.

  1. Bounded context / context economy — inherited from the consumer's architecture. The reader attends to one finite window in which everything competes (since [context efficiency is the central design concern in agent systems]), and the binding pressure is silent degradation before any hard limit (since [agent context is constrained by soft degradation, not hard token limits]). Specific length norms are local strategies serving this economy; the economy itself cannot be opted out of while the consumer is an LLM.

  2. Composability / co-loading — inherited from how the consumer ingests artifacts: files load as whole units into one shared window, so an artifact's usefulness is decided by what it does when co-present with others (see [short composable notes maximize combinatorial discovery]). The inherited form is weak — every artifact must stay usable when loaded alone, without dragging in unrelated claims. The stronger "citable as a bare premise" rule is a theoretical-register design choice layered on top, not the principle.

  3. Substrate asymmetry — inherited from the file substrate. Directory placement is total (every file has exactly one location, no opt-out) while frontmatter classification is partial and opt-in, so location contracts and type contracts encode different guarantees and cannot substitute for each other (because [directory placement is total, frontmatter classification is partial]). On files this asymmetry is not negotiable.

  4. Answerability — inherited from the domain commitment to knowledge. Every artifact must answer to something outside itself and can therefore be wrong or stale; a collection that cannot state what its artifacts answer to and what makes one stale is not holding knowledge (see [the complement note's scope test], which states the answerability property; the [knowledge-artifact] definition supplies the artifact class this commitment quantifies over). Which relation an artifact bears — to the world, a system, an outcome, a source — is local; having one is not.

  5. Declaration obligation — inherited from machinery coherence. Every writable collection must carry a loadable contract, because the machinery routes and validates by reading that contract; a collection without one is an operational defect regardless of content. The complement note treats this as the surviving second-order universal (its shipped instance is ADR 017's COLLECTION.md).

  6. Admission discipline — inherited from machinery coherence. Once taxonomies are opened into extensible sets, some admission brake is required: without one, the open sets proliferate until no convention is shared — which is the other way to stop being a framework. As with composability, the inherited form is weak — an admission discipline must exist — while the specific worked-case guard (entries admitted only after surviving use in a real collection, never from anticipation) is the discipline this framework chose, layered on top. The complement note identifies that guard as the load-bearing piece that lets closed taxonomies safely open.

  7. Derived-copy rule — inherited from machinery coherence. A copy of information recomputable from a ground-truth source must be machine-checked against that source or not exist; a hand-maintained-and-trusted copy is a trap (because [a derived copy of recomputable truth must be checked or absent]). Any framework that caches recomputable values inherits this, since a silently stale trusted cache corrupts the consumers that trust it.

Contrast: rules that look like principles but demote

The membership test earns its keep by excluding rules that feel foundational but are positions the framework chose and could re-choose. Each of these demotes to a guarded default per the complement note:

  • The three [registers] (theoretical / descriptive / prescriptive) — a proven bundle, but a new kind of KB can need a fourth; they demote to default text-contract profiles.
  • Link-label sets — extends, grounds, contradicts, and the rest are a collection-owned selection from a shared catalogue, not a universal vocabulary.
  • Type sets — open and collection-local; the framework fixes that types exist and are path-valued (machinery), not which types there are (choice).
  • Spending the directory tree on content-area rather than on kind — a routing decision a given KB makes, reversible without touching the framework.
  • Status / lifecycle enums — the existence of a lifecycle is machinery; the specific values, and whether status fuses structural state with first-person endorsement, are a choice sitting one level too high.

The tell in every case: you can name a rival that also works under the same boundary commitments. When no rival exists — because the only alternative is to change the consumer, substrate, or domain, or to break the machinery — the rule is inherited, and the list above collects the ones currently visible.

Caveats

The durable content is the test, not the enumeration: a later principle may be recognized as inherited, or one of these may turn out to be a disguised choice with an unnoticed rival, and neither outcome would touch the test itself. The test defines first-principle status rather than deciding it — the rival-hunt is how the test is applied, and application is fallible in both directions. And "inherited" is always relative to a framework's own boundary commitments: a framework that changed consumer or substrate would inherit a different set. So these are first principles of this framework, not of knowledge bases in general.

Relevant Notes:

Artifact B

Agent context is constrained by soft degradation, not hard token limits

Agent context windows have two bounds: a hard token limit and a soft degradation surface. The hard limit is the maximum tokens the model accepts — exceed it and the API rejects the request. The soft bound is where performance silently degrades: missed instructions, shallow reasoning, ignored context — while output remains well-formed.

The soft bound is the binding constraint — performance degrades well before the hard limit is reached. What constrains work is not running out of tokens but the quality of what those tokens do, driven by at least three dimensions: volume, complexity, and relevance/interference. Other factors — information arrangement and prompt framing — also shift the degradation surface, often by changing one of these dimensions indirectly.

Dimensions of the soft bound

Volume

More tokens dilute attention. The "lost in the middle" finding ([Liu et al., 2023]) established primacy and recency bias — models overweight information near the beginning and end of the context, underweighting the middle. Because agent prompts face the same flat-sequence selection problem, this positional bias applies whenever the model must recover the right items from a long unscoped context. Anthropic (the AI lab) calls this context rot ([2025]). Paulsen's Maximum Effective Context Window (MECW) work confirms that usable context can be far below advertised windows and is task-dependent ([Paulsen, 2025]).

Relevance/interference

Not all tokens are equal. Irrelevant context is not merely extra volume; it can actively interfere with task execution. GSM-DC, a math-reasoning benchmark with synthetic distractors, shows power-law error scaling with distractor count ([Yang et al., 2025]). The interaction with reasoning depth is the key signal: distractors hurt more as the task requires more dependent steps, and they degrade both reasoning path selection and arithmetic execution.

The same pattern appears at the agent-workflow level. Chung et al. find that injecting irrelevant task sequences into web-agent benchmarks collapses success rates from 40-50% to under 10% ([Chung et al., 2025]). The failures are not just slower retrieval from a larger context; agents loop, lose objectives, and treat stale history as live problem state. Bolt-on retrieval (iRAG) provides only modest improvement in that benchmark, which is weak but useful evidence that irrelevant context often needs to be excluded or scoped away rather than compensated for after loading.

This is why the mitigation is architectural. Summarization can shrink irrelevant material, but it does not by itself decide whether the material belongs in the active problem frame. Selective loading, scoped state, and sub-agent boundaries attack relevance/interference directly by preventing non-task state from competing with the task.

Complexity

Some forms of context complexity add interpretation overhead. Every layer of [indirection costs context and interpretation overhead], and deeper compositional structure may impose similar costs. ConvexBench, a benchmark on compositional symbolic reasoning, shows complexity-driven collapse at low token counts: F1 dropped from 1.0 at depth 2 to ~0.2 at depth 100, even though total tokens (5,331 at depth 100) were far below context limits ([Liu et al., 2026]). The shared mechanism is that both agent operations and symbolic reasoning fail when the model must carry many intermediate dependencies without scoped subproblems or externalized state. Compositional depth, not volume, was the bottleneck.

Open questions

Volume, complexity, and relevance/interference are distinguishable but not fully separable — reducing volume often reduces complexity and interference as side effects.

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

The soft bound is invisible

The hard limit is visible — exceed it and the API returns an error. The soft bound is invisible at every level.

To the practitioner. The model doesn't signal when it crosses the soft bound. Output remains well-formed; problems surface downstream. A CPU signals overflow. A human says "I'm confused." An LLM produces fluent output whether it reflects the supplied context or leaves large portions unused.

To the benchmarker. The soft bound is not a single number. It shifts with task type, compositional depth, relevance mix, information arrangement, and prompt framing. Model updates shift the degradation surface without notice.

To the market. Providers advertise hard token limits because those are clean, comparable numbers. They don't publish soft degradation surfaces — those are task-dependent and hard to characterize. The number on the box describes the bound that rarely binds; the bound that actually constrains work has no number.

Consequences

Don't trust the number on the box. Usable context depends on what you're doing, how you arrange it, and which model version you're running.

Silent degradation makes heuristic design rational. Front-loading critical content, decomposing complexity, isolating scopes, compressing aggressively, and excluding irrelevant state are the rational strategy, not a placeholder until better measurement arrives. This is how [surveyed traditions facing soft bounds] have operated.

Programmatic constructability is the genuine advantage. You can programmatically choose every token that enters the context. This creates a distinctive tension: high control over inputs, low observability of effective processing. The engineering opportunity is real, but it must be exercised against a bound you cannot directly observe. Default-loading session history is the most common way this advantage goes unexercised — [session history should not be the default next context]. The [heaviest-fork feasibility note] extends these consequences to work split across sub-agents.

Relevant Notes:

  • [Context efficiency is the central design concern] — extends: ranks this note's soft-bound claim as the binding feasibility face of context scarcity
  • [A goal-holding interpreter fails soft, and its workarounds tax a bounded budget] — extends (KB-internal conjecture, not benchmarked): proposes failure workarounds as a further load source on this soft bound — defects in interpreted artifacts converting into per-encounter re-routing load — argued from mechanism and two worked instances, unlike the measured dimensions above
  • [On the "Induction Bias" in Sequence Models (Ebrahimi et al., 2026)] — candidate mechanism (volume dimension): transformers learn largely length-specific solutions in isolation and show much weaker sharing when lengths are mixed
  • Caveat: training-time evidence on synthetic tasks, not direct measurement of inference-time context degradation
  • [GSM-DC ingest] — exemplifies (relevance/interference dimension): power-law error scaling with distractor count in math reasoning, with reasoning-depth interaction
  • [Web agent benchmark ingest (Chung et al., 2025)] — exemplifies (relevance/interference dimension): agent-level catastrophic degradation from injected irrelevant task sequences; iRAG provides only modest relief
  • [ConvexBench ingest] — exemplifies (complexity dimension): compositional depth collapse at low token counts
  • [Paulsen MECW] — exemplifies (volume dimension): usable context drastically below advertised windows, task-dependent

Under-review context phrase

the binding form of the context bound the economy answers to