Computational model

Type: kb/types/tag-readme.md

What kind of "programs" LLM instructions are, and what programming-language concepts — scoping, homoiconicity, partial evaluation, typing — illuminate their behavior. Where learning-theory covers how systems learn and tags covers how knowledge bases are operated, this area covers the computational properties of the medium itself and the scheduling architecture that follows from context scarcity. This is a selective head; the published site appends the complete listing, and the scoped rg recipes recover full membership.

Foundations

• agentic-systems-interpret-underspecified-instructions — core framing: LLM instructions are distinguished by underspecified semantics and execution indeterminism
• context-efficiency-is-the-central-design-concern-in-agent-systems — why context is the scarce resource; cost has two dimensions (volume and complexity) that drive the mechanisms below
• bounded-context-orchestration-model — formalises orchestration as a symbolic scheduler driving bounded LLM calls through a select/call loop with explicit state update
• LLM contexts interpret instructions and content through the same token medium — instructions and data share the same representation, enabling extensibility but removing structural guardrails
• llm-context-is-composed-without-scoping — context is flat concatenation with no scoping, producing dynamic scoping's pathologies; sub-agents are the one isolation mechanism

Scheduling & Orchestration

• agent orchestration occupies a multi-dimensional design space — scheduler placement, persistence, coordination form, guarantee, and return artifacts vary independently
• agent orchestration needs coordination guarantees, not just coordination channels — contamination, inconsistency, and amplification arise from different missing guarantees
• decomposition-heuristics-for-bounded-context-scheduling — practical rules: separate selection from joint reasoning, choose representations not subsets, save reusable intermediates
• llm-mediated-schedulers-are-a-degraded-variant-of-the-clean-model — when the scheduler lives in an LLM conversation it degrades; three recovery strategies
• session history should not be the default next context — stored history and next-context loading are separate decisions; select should decide what to load
• tool loop — the tool-loop area: loop exposure, hidden schedulers, and the observability problems of framework-owned loops (apparent success, semantic recovery)
• Claude Code dynamic workflows — shipped instance of the cluster: a harness exposing a returning agent() plus host-language composition beneath its frozen loop

Instruction Properties

• writing-styles-are-strategies-for-managing-underspecification — five observed context-file writing styles as strategies for narrowing the interpretation space
• programming-practices-apply-to-prompting — typing, testing, version control transfer to prompting with modified cost models
• unified-calling-conventions-enable-bidirectional-refactoring — calling conventions that let components move between neural and symbolic implementations
• natural-language content lacks reliable dereference, so facts need reinforcement at point of use — name resolution holds in formal systems but not in LLM-read natural-language content, so single-source-of-truth gives way to checked denormalization
• indirection is costly in LLM instructions — indirection is nearly free at runtime in code but costs context and interpretation overhead on every read in prompts
• frontloading spares execution context — partial evaluation applied to instructions: precompute known inputs and insert results to spare the consuming call's context budget

Error Correction & Reliability

Dual-tagged with LLM reliability, which provides the broader error theory; these claims are about the scheduling architecture.

• LLM output deviation has three sources with non-substitutable remedies — the deviation taxonomy the claims below rest on: spec, interpreter, and sampling process are different objects, so their remedies cannot stand in for each other
• scheduler-llm-separation-exploits-an-error-correction-asymmetry — symbolic operations are error-correctable through redundancy while LLM bookkeeping compounds errors silently
• specification-level separation recovers scoping before it recovers error correction — an intermediate regime where OpenProse-like DSLs recover frame isolation without hard-oracle bookkeeping

Tensions

• The homoiconic medium enables extensibility (ad hoc prompts, unified calling conventions) but requires explicit scoping disciplines precisely because there are no structural boundaries. The constraining gradient from instructions to scripts is one response — codifying imposes the structure the medium lacks.

Related Tags

• llm-reliability — error correction theory, oracle hardening, and reliability dimensions; explains why the scheduling architecture works
• tool-loop — the loop-exposure and hidden-scheduler cluster, including the observability failures of framework-owned loops
• learning-theory — how systems learn through constraining, codification, and source-derived reshaping; the computational model explains what kind of programs these mechanisms operate on
• tags — practical architecture applying these computational properties; frontloading and indirection cost are PL concepts applied to KB instructions

---

Agent Notes: - 2026-03-10: the Scheduling & Orchestration cluster plus the Multi-Agent Aggregation note formed the core of a paper-outline workshop presenting the scheduling model for an academic audience; that workshop was local scratch, not a durable citation target.

Other tagged notes

• "Agent" is a useful technical convention, not a definition - A lightweight technical convention — an agent is a tool loop (prompt, capability surface, stop condition) — sidestepping the definitional debate in favor of a unit that organizes code
• A bare writing prompt does not determine its intended contribution - Separates the contribution a bare writing prompt leaves underdetermined from empirical claims about how experts and LLMs supply the missing purpose.
• A proposal-selection improvement loop requires search, evaluation, and operative retention - A proposal-selection improvement loop — candidates generated, evaluated with possible non-adoption, and accepted changes made operative — requires search, reject-capable evaluation, and operative retention
• A retrieval miss is a local reflective-path failure - A missed relevant artifact leaves its represented aspect inert for the affected task and discovery route, while other loading paths and reflective aspects can remain causally connected
• Access burden and transformation burden are independent query dimensions - Queries have two independent difficulty axes — finding inputs (access) and producing the answer (transformation) — conflating them misroutes symbolic transformations through semantic processing
• Agent memory is a crosscutting concern, not a separable niche - Memory decomposes into storage (solved), retrieval/activation (context engineering), and learning (learning theory) — treating it as a standalone category hides that the hard problems are at the intersections
• Agent orchestration needs a privilege quarantine, not just a permission scope - When one agent in an orchestration reads untrusted content, the defense is a role-level privilege quarantine — barring that agent from high-privilege actions entirely — not finer per-call tool scoping
• Agent runtimes decompose into scheduler context engine and execution substrate - Practitioner runtime taxonomies converge on three separable components — scheduler, context engine, and execution substrate — because each solves a different class of model limitation
• Always-loaded context mechanisms in agent harnesses - Survey of always-loaded context mechanisms across agent harnesses — system prompt files, capability descriptions, memory, and configuration injection — cataloguing what each carries, how write policies differ, and where the gaps are
• An action model matters only through its consumption path - Agentic action can be direct or model-mediated; a retained action model matters only when its consumption path affects intervention selection
• Any symbolic program with LLM calls is a select/call program - Any program whose non-LLM steps are symbolic computation over explicit machine state K can be mechanically converted into the select/call loop with the same LLM calls in the same order
• Apparent success is an unreliable health signal in framework-owned tool loops - When framework-owned tool loops recover from broken tools via agent workarounds, final success stops being a reliable signal that the underlying scripts and workflows are healthy
• Codified scheduling patterns can turn tools into hidden schedulers - As agent behavior matures, deterministic next-step policies need explicit control logic; if the framework offers only tools, scheduling patterns end up there and the tools become hidden schedulers
• Compiling a coordination strategy preserves primitive authority but expands aggregate authority - Compiling a coordination strategy preserves the primitive action alphabet but expands aggregate authority — the single-context envelope it escapes bounded both compute and effect volume
• Context engineering - Definition — context engineering is the discipline of designing systems around bounded-context constraints; its operational core is routing, loading, scoping, and maintenance for each bounded call
• Conversation vs prompt refinement in agent-to-agent coordination - Conversation preserves the execution trace; prompt refinement compresses it into a clean handoff. The right choice depends on architecture and how much intermediate work should survive
• Directed reading - Definition - directed reading is reading selected material through an explicit task lens to produce a lens-shaped artifact or judgment
• Formal symbolic systems assess explanatory-reach only through causal and proof obligations - Formal symbolic systems assess explanatory-reach only after claimed generality is translated into causal or proof obligations inside a warranted model
• Full-identity keys decouple a batch protocol from its packing axis - A batched LLM-call protocol keyed by each unit's full composite identity, not position or a single axis, lets grouping strategy vary freely without protocol change
• Gödel machines are a proof-governed case of reflective self-modification - The Gödel machine realizes reflective self-modification with a proof-gated acceptance rule, gaining model-relative rigor at the cost of excluding useful changes it cannot prove
• Human analogies can motivate functions without determining component boundaries - Distinguishes functions and failure modes suggested by human cognition from the unsupported inference that an engineered agent should bundle the responsible roles along human boundaries.
• LLM debugging starts with retry-versus-rewrite triage - Uses execution-versus-interpretation failure to choose the first debugging move: retry a bad execution of a sound reading, or rewrite a specification that reliably induces the wrong reading
• LLM frameworks should keep the tool loop optional - Framework-owned tool loops package the common model/tool/retry pattern well, but strong frameworks keep the loop optional so applications can control state projection, branching, and re-entry
• LLM recompute cost inverts the store-vs-recompute default - For an LLM consumer, in-context recompute is the expensive step, so materializing a derived value to be read pays off exactly where storing it would be premature denormalization in code
• LLM↔code boundaries are natural checkpoints - At each LLM↔code transition both semantic underspecification and execution indeterminism collapse simultaneously, making these boundaries natural places to anchor debugging, testing, and refactoring
• Load-bearing vocabulary collisions should be prevented or visibly scoped at write time - Unqualified technical senses have no reliable namespace in natural-language content; schema slots, rare compounds, and linked clause frames scope them at write time; audits and remediation recover when prevention fails
• Memory-backed personalization can look like model improvement - Distinguishes user-specific gains supplied by retained intent from gains in the model that interprets the assembled context.
• Orchestration strategies and run-state have opposite persistence economics - Separates ephemeral task-specific run state from reusable selection strategies inside host schedulers; RLM-style execution discards both and therefore loses the valuable reusable half
• Pointer design tradeoffs in progressive disclosure - Compares fixed, query-time, and crafted retrieval pointers across specificity, precomputation cost, reliability, and authoring dependence to explain when each progressive-disclosure form pays
• Progressive constraining commits only after patterns stabilize - Constraining via LLM code generation freezes a single projection of the spec in one shot, but progressive constraining observes behavior across many runs and commits only the interpretations that consistently emerge
• Reach-assessment - Definition — judging whether a commitment's claimed explanatory-reach is genuine across natural-language, symbolic, and distributed-parametric forms
• Reflection buys addressability - Self-improvement can accumulate without reflection — parametric learners do — but non-reflective retention gives only indirect handles; reflective retention makes the changed object addressable
• Reflective coverage is graded across representational forms - Reflective coverage is stated per represented form and operation profile; control of an external dependency does not make that dependency part of the system's reflective coverage
• Reflective system - Definition — a system is reflective relative to selected aspects when an internal process uses a causally connected self-representation of them in its operation
• RLM has the model write ephemeral orchestrators over sub-agents - RLM packs orchestration over sub-agents into the tool-loop model by having the model write orchestrators in a REPL — elegant but ephemeral because the orchestrators are discarded after each run
• RLM, Tendril, and llm-do place symbolic work at different persistence boundaries - Compares RLM variants, Tendril, and llm-do as placements for symbolic work and interfaces: ephemeral REPL code, typed RLM combinators, workspace-local generated tools, and durable unified callables
• Runtime structure determines the control surfaces available to governance - Runtime structure and runtime governance are separable, but the runtime's structure determines which inspection, validation, correction, and drift-control operations governance can actually perform
• Self-improving system - Definition — operative, evidence-responsive change to a system's own behavior-determining organization, read against a declared boundary, horizon, and improvement objective
• Semantic sub-goals that exceed one context window become scheduling problems - Some semantic subgoals exceed one context window, so they must be partitioned into smaller semantic judgments with symbolic collection, filtering, and staged summarization between them
• Semantic work can be relocated but not eliminated - A meaning-dependent judgment is never removed, only placed — moved upstream where its inputs exist (amortized) or off a bottlenecked context (offloaded); 'free at use-time' always means paid earlier
• Silent disambiguation is the semantic analogue of tool fallback - When an agent silently resolves unacknowledged material ambiguity in a spec, final success hides that the contract failed to determine the path — an extension of the tool-fallback observability problem
• Skill discovery re-fires in every sub-agent context, not just the top-level invocation - Skill discovery is per-context and autonomous — every installed skill is re-matched in each sub-agent context, even ones a parent narrowed, so a delegating skill's own discoverability is a leak vector
• Solve low-degree-of-freedom subproblems first to avoid blocking better designs - Ordering heuristic for decomposition: commit first to decisions with the fewest viable options, then place flexible choices around them to preserve global optionality.
• Stateful tools recover control by becoming hidden schedulers - Granting the strongest stateful-tool escape hatch shows that recovered control comes from relocating the scheduler into an exceptional tool or runtime, not from the framework loop itself
• Subtasks that need different tools force loop exposure in agent frameworks - When decomposition creates child tasks with different tool surfaces, the parent must construct fresh calls for each child, so a framework-owned loop is no longer the right control surface
• The chat-history model trades context efficiency for implementation simplicity - Chat history persists because appending messages preserves information and avoids interface design, but that convenience trades away selective loading under bounded context
• The deployed system, not the model alone, is the unit of learning - Because prompts, retrieval, tools, and runtime policy jointly determine deployed behavior, model-only learning leaves consequential system choices fixed
• The practical scheduler is the host language, not a reified select - The simplest practical orchestration library demotes the tool loop to a returning, per-call-parameterized function and lets ordinary host-language code play select and K — reifying K only when the run must outlive its process or outgrow its memory
• Topology, isolation, and verification form a causal chain for reliable agent scaling - Topology, isolation, and verification may form a strict dependency chain rather than independent design choices — tested against the simpler account that good decomposition implies the other two
• Traditional debugging intuitions break when tool loops can recover semantically - Programmers trained on traditional software expect broken infrastructure to fail loudly; semantic recovery in agent tool loops violates that expectation, so successful outcomes can create false confidence during debugging and maintenance
• Traditional software can bracket executor conformance; LLM systems cannot - Wrongness is a relation to a norm, never intrinsic to a computation; classical stacks bracket the executor-conformance norm so every failure resolves to the spec, and LLM systems cannot, which is what generates the three-source deviation taxonomy
• Under sub-agent decomposition, feasibility is the heaviest fork's net load - Shows why decomposition changes feasibility from total operation cost to the largest residual load left on any fork after work is shifted to siblings or the parent
• World models assess explanatory-reach through action-conditioned prediction - Learned world models can assess explanatory-reach when action-conditioned predictions are tested across the interventions or shifts a commitment claims