Soft-bound traditions as sources for context engineering strategies

Type: note · Status: seedling · Tags: learning-theory, foundations

Because agent context is soft-bounded rather than hard-limited, strategies from traditions that face similar bounds are candidate sources for context engineering. This note catalogs twelve such traditions and assesses what actually transfers.

The traditions

Each tradition addresses the same general problem: a bounded processor that cannot consume all available knowledge must select, compress, and structure what it loads.

Tradition Bounded processor The bound Adaptation mechanism
Attention economics (Simon) Decision-maker Attention (soft) Satisficing, filtering
Working memory (Miller, Cowan) Human mind ~4 chunks (soft) Chunking, rehearsal
Gradual typing (Siek & Taha) Type checker / programmer Interface surface Progressive annotation
Formal specification (Z, VDM) System builder Specification language Progressive formalization
Modular design (Parnas) Developer / compiler Module interface Information hiding
Faceted classification (Ranganathan) Librarian / searcher Query dimensions Independent facets
Pedagogy (Vygotsky, Bloom) Learner Zone of proximal development (soft) Scaffolding, sequencing
Technical writing Reader Task context (soft) Audience analysis, progressive disclosure
Knowledge creation (Nonaka & Takeuchi) Organization Communication bandwidth (soft) Externalization, combination
Organizational learning (Argyris & Schön) Organization Mental models (soft) Double-loop revision
Hypertext / Semantic Web (Engelbart, Berners-Lee) Navigator / machine Link-following budget Typed relationships
Zettelkasten (Luhmann) Thinker Attention, memory (soft) Atomic notes, judgment-based linking

Five structural elements recur across these traditions:

  1. A bound on what the processor can attend to at once — hard, soft, or both
  2. Selection pressure — not everything fits, so what loads must earn its place
  3. Compression that preserves value — the loaded subset must be more useful per unit than the unloaded whole
  4. Progressive formalization — start loose, tighten as patterns emerge
  5. Modularity as a response to the bound — small independent units compose better under limits

Shared structure doesn't guarantee transfer. The question is which traditions yield strategies that work in agent context engineering, and which only share the abstract form.

Transfer assessment

Already transferred and working

These strategies are already standard practice in prompt and context engineering — the transfer happened naturally, often without explicit attribution:

  • Front-load important information (from journalism, technical writing) — system prompts go first; critical instructions lead
  • Chunk related information (from working memory) — group related context; don't interleave unrelated material
  • Decompose into independent contexts (from modular design / Parnas) — multi-agent architectures, tool-call isolation
  • Progressive disclosure (from pedagogy, technical writing) — load detail on demand rather than upfront
  • Atomic composable units (from Zettelkasten, modular design) — short notes, composable instructions

Plausible but untested

These have structural analogs in agent context but haven't been rigorously validated:

  • Faceted classification (Ranganathan) — multi-dimensional tagging for retrieval. Agents use tags and metadata for retrieval, but whether Ranganathan's specific design principles (facet independence, hospitality) improve agent retrieval is unstudied.
  • Progressive formalization (gradual typing, formal specification) — the constraining methodology is explicitly modeled on this, but whether it produces measurably better agent behavior than alternatives is an open question.
  • Typed relationships (hypertext/semantic web) — typed links could help agents navigate knowledge graphs more efficiently, but the evidence is anecdotal.

Aspirational — transfer conditions unclear

These traditions address bounded processors, but the specific mechanisms may not survive transfer:

  • Scaffolding and ZPD (Vygotsky) — depends on the learner signaling confusion and the instructor adjusting. Agents don't signal confusion; they produce confident output regardless. The feedback loop that scaffolding relies on is absent.
  • Double-loop learning (Argyris & Schön) — revising governing assumptions, not just strategies, requires a processor that can reflect on its own history. Single-context agents lack this; multi-turn agents might approximate it, but the mechanism differs substantially from organizational learning.
  • Externalization/combination (Nonaka & Takeuchi) — the SECI cycle assumes tacit-to-explicit conversion between humans. Agents don't have tacit knowledge in the same sense. The "combination" phase (explicit-to-explicit) might transfer, but the full cycle doesn't.
  • Mastery learning (Bloom) — requires iterative assessment and remediation. Could apply to multi-turn agent interactions, but the assessment mechanism would need to be externally provided.

What blocks transfer

Three structural differences between agents and prior traditions limit what transfers:

  1. Optimization target mismatch. Human working memory optimizes for understanding. Pedagogy optimizes for durable learning. Agent context optimizes for task completion on this turn. Strategies tuned for understanding or learning may underperform on single-turn task completion.

  2. Feedback absence. Many pedagogical and organizational strategies depend on the processor signaling when it's struggling. Agents don't signal degradation — the high control, low observability tension means you can engineer inputs precisely but can't observe whether they're working.

  3. Different failure modes. Human working memory loses chunks (forgetting). Agent context degrades by dilution (lost-in-the-middle), compositional collapse, and instruction-following decay. A strategy that addresses forgetting may not address dilution.

What this means for the KB

The KB's framework draws directly on several of these traditions — constraining, distillation, context efficiency, composable notes, and typed links among them. The transfer assessment indicates where that grounding is solid and where it's aspirational:

  • Literature search becomes targeted. Search for the bounded-processor pattern in each tradition — but focus on the "already transferred" and "plausible" tiers first.
  • Design decisions can be grounded in prior results — but verify the transfer conditions hold (same optimization target, feedback not required, matching failure mode).
  • Heuristic responses are expected, not a failure. When the soft bound can't be precisely measured, heuristic architectural responses (front-load, decompose, isolate, compress) are the rational design strategy. The prior traditions have been productive for decades under similar measurement constraints.

Open questions

  • Which tradition has the most untapped potential for transfer? Working memory and technical writing have already transferred well. Gradual typing seems structurally closest (progressive formalization of a text-based medium), but the transfer is untested.
  • Can transfer conditions be formalized? Something like: "a strategy transfers if it doesn't depend on feedback from the processor, targets task completion rather than durable learning, and addresses dilution/complexity rather than forgetting."
  • For aspirational traditions (pedagogy, organizational learning), is transfer truly blocked or just harder? Multi-turn agents with external evaluation might satisfy the feedback requirement that single-turn agents lack.
  • Is the five-element family resemblance genuinely predictive (traditions with these elements will yield transferable strategies) or merely descriptive?

Relevant Notes: