Computational model

Type: types/tag-readme.md

How LLM-based programs execute: instruction interpretation, scoping, state, tool-call loops, and the scheduling and orchestration of bounded calls. Assign this tag when an artifact explains or compares those execution mechanisms or their computational limits, including through programming-language concepts such as homoiconicity, partial evaluation, and typing. Merely running on an LLM or using tools is insufficient. Context-engineering asks what knowledge reaches a call; this tag asks how calls and their surrounding control execute. An artifact that explains both may carry both tags. Learning-theory covers how systems learn and improve.

The formal computational model with the LLM inside is Bounded-context orchestration model: closed-world orchestration with explicit state and barriered batches of independent LLM calls, in a conditional select/call normal form; its generality lemma is any symbolic program with LLM calls is a select/call program.

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 — gives closed-world orchestration with explicit state and barriered independent call batches a conditional select/call normal form
• 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
• A context-operation interface bounds the projections its policy can realize — models context assembly as legal interface traces whose reachable projections remain distinct from policy quality
• 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
• Local materialization should outperform distant natural-language declarations — untested comparison of declaration-only context with generated point-of-use views, under a single canonical maintenance authority
• Model-resolved indirection adds interpretation work to LLM execution — distinguishes references resolved by the model from aliases expanded by a deterministic executor and makes literalization conditional on token and lifecycle costs
• 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 requires three-way diagnosis — the deviation taxonomy the claims below rest on: spec, interpreter, and sampling raise three distinct diagnostic questions whose repairs have different primary targets, so no one remedy is a complete substitute for another
• 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
• learning-theory — how systems learn through constraining, codification, and source-derived reshaping; the computational model explains what kind of programs these mechanisms operate on
• context-engineering — the practical side: frontloading and indirection cost applied to what reaches the context

---

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
• Academic Research Skills - Academic Research Skills as a prompt-defined Claude Code research pipeline with narrow executable checks, host-dependent orchestration, protocol-only resume, and conflicting terminal gate rules
• Access burden and transformation burden are distinct query dimensions - Separates the system-relative cost of finding required inputs from producing an answer, so query systems can diagnose which work remains as retrieval and reasoning interact
• 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-runtime analysis should separate scheduling, context assembly, and external state - For runtimes composed of bounded model calls, separating control progression, per-call context, and external state or action services localizes failures even when one implementation owns all three
• Agno AgentOS - Whole-system analysis of Agno AgentOS as an open-source execution and control plane, distinguishing its runtime loops from the companion coding-agent and Studio builder loops
• AI Agents in Depth - Whole-book comparison of AI Agents in Depth with Commonplace, separating broad architectural convergence from differences in memory admission, epistemic warrant, governance, and orchestration
• 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
• An agentic substrate becomes a software factory through family-specific production machinery - Maps the bounded-call agentic substrate to Greenfield's software-factory ontology without calling every generic harness or generated program a factory
• Autogenesis - Autogenesis as a code-grounded self-evolving agent framework: protocol resources, orchestration, versioned mutation, rollback, and the gaps between its paper artifact and current rewrite
• Backtracking keeps lightweight search control provisional - Backtracking preserves the provisional status of a heuristic branch choice by restoring an earlier usable state and redirecting search after contrary evidence
• beads_rust - beads_rust as a local active-work and coordination substrate: transactional CLI claims and workflow gates, explicit external execution and Git boundaries, and weaker parity across MCP, inherited-context, and shipped instruction paths
• Broad software demands create pressure for agentic factory development - Broad software demands make exhaustive predefinition of useful family-specific production machinery practically implausible, motivating agentic factory development without ruling out a fixed universal substrate in principle
• Causal and proof obligations are two formal routes to assessing explanatory-reach - Causal and proof obligations demonstrate two ways formal symbolic systems can assess explanatory-reach inside a warranted model
• Code complements the weight–prompt pair with independently executed symbolic operations - A model-mediated operation is instantiated by weights plus prompt; code complements that pair by defining operations whose consequences a symbolic runtime executes without reinterpreting the prompt
• Commonplace as a reflective self-improving system - Commonplace witnesses that a human-inclusive KB can be reflectively self-improving on one pathway despite uneven coverage and human-gated design judgment
• 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
• Compound Engineering plugin - Compound Engineering's compounding claim separated into product change, project-knowledge retention, and the narrower reflective pathway that can revise project operating instructions but not the installed harness itself
• 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
• Cost-sensitive formalisms for tentative theory search - Exploratory map of backtracking, learning, and complexity models that expose budgets relevant to search guided by tentative theories
• Cross-task transition policy remains scheduling behind a tool interface - Classifies code by authority over interceptable transitions among independently steerable goals, separating scheduler role from its tool-shaped interface and audience-relative concealment
• Exo - Exo as a running reflective self-improvement harness: a protected Rust substrate under a fully rewritable executor, allowlisted host control, and a rewind that preserves the record of what was tried
• Final task success does not establish intended-path health - When intended-path success and fallback success produce the same final task outcome, the outcome cannot establish whether the intended path and its supporting infrastructure were healthy
• Fractal - Fractal as a code-grounded RLM harness: PredictRLM workspace turns, SBX sandbox mounts, headless delegation, and session continuity outside the repo.
• 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 - A Gödel machine admits self-rewrites through proof under its current formalization; this restricts admission without establishing how many useful changes are reachable or how reliably they are found
• 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.
• Instantiation alone cannot model agent learning across sessions - The class/instance analogy captures session startup but omits the retained update relation that can revise later agent definitions and reusable-content placement
• Lightweight search control allocates further search without licensing adoption - A search judgment is lightweight when its authority stops at allocating further investigation, probing, continuation, suspension, or abandonment rather than licensing an operative change
• LLM debugging separates specification gaps, instruction violations, and run-to-run variation - Choose a debugging move by checking intent against the specification, output against the specification, and variation across repeated runs; failure frequency alone cannot identify the defect
• 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 shifts the store-vs-recompute balance - For model-facing derived values, costly model-side recomputation shifts cache economics toward checked materialization, but persistence pays only when its total expected cost beats the alternatives and the copy substitutes for work
• LLM↔code boundaries are natural checkpoints - LLM↔code boundaries expose concrete inputs and outputs for inspection and replay; deterministic execution preserves rather than corrects a wrongly interpreted argument
• 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.
• Open-ended improvement must allocate search before decisive evaluation is available - Open-ended improvement must choose which questions, candidates, experiments, or proof paths to develop before decisive evidence about them is available; even a Gödel machine's proof gate retains this prior search problem
• 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, cost, availability, accuracy, and authoring dependence
• Preferential codification concentrates less predictable work at the agent boundary - Explains the negative-selection mechanism by which preferential codification changes the composition of work retained at an agent boundary
• 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, λ-RLM, Tendril, and llm-do separate restriction from persistence - RLM variants, Tendril, and llm-do show that control-language restriction and artifact persistence are separate questions, including where cited RLM sources leave post-return lifecycle unspecified
• 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
• Swamp - Swamp as an agent-facing automation control plane: typed resource models, declarative DAGs, remote workers, policy gates, and extension distribution.
• Task families and product families classify different things - Task families group obligations or evaluations; software product families group products through declared commonality, variability, and reusable production scope
• 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 declared Commonplace frame - The declared boundary under which Commonplace's self-improvement, reflectivity, and allocation attributions are assessed — what is inside, what is outside, and how to cite or depart from it
• 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 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
• Universal software factory needs a declared universality axis - Universal software factory is ambiguous unless the universality axis, covered class, supplied inputs, adequacy relation, and resource bounds are declared
• Where change candidates come from in Commonplace - Surveys how problem-noticing and candidate-drafting happen in Commonplace beyond a maintainer's own judgment — skills, ephemeral reports, mechanical checks, freshness tracking, agent initiative
• 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