Computational model

Type: types/tag-readme.md

Instruction interpretation, scoping, state and orchestration of bounded LLM calls. Assign this tag to explanations or comparisons of those execution mechanisms and their limits. Merely using an LLM or tools is insufficient. Context-engineering asks what knowledge reaches a call; this tag asks how execution works. Learning-theory covers learning and improvement.

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

• Prompting changes failure diagnosis with the semantic reference — model-defined programming and English instruction execution share a prediction problem but judge conformance against different references
• Context efficiency — why context is the scarce resource; cost has two dimensions (volume and complexity) that drive the mechanisms below
• Bounded-context orchestration — 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
• Context scoping — selected frame inputs limit direct access; scope among supplied instructions remains a separate question

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
• Statecharts and programs differ in what they show, not in what they can compute — control visibility: recursion and data-dependent fan-out read as code; fixed reactive control reads as a chart
• Decomposition heuristics — practical rules: separate selection from joint reasoning, choose representations not subsets, save reusable intermediates
• LLM-mediated schedulers — 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

• English can approximate a model-defined prompt language — coarse clause meanings support local reasoning where their predictions hold; residual behavior bounds fidelity

• Clear instructions can compose into an unsettled contract — scope, precedence and exceptions can leave combined English requirements unsettled

• Instruction writing styles — five observed context-file writing styles as strategies for narrowing the interpretation space

• Checks for prompt programming — checks matched to requirements, conformance, prediction and variation
• Unified calling conventions — 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 — specification, interpreter and execution variation require different diagnostic questions
• Scheduler–LLM 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

• Shared text supports extension but does not itself enforce scope. Explicit runtime boundaries can supply specific guarantees; adopting a model reference alone does not.

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 goal-holding interpreter fails soft, and its workarounds tax a bounded budget - A procedure compiles its goal away, so a blocked step fails loud and hard; an interpreter holds the goal and re-routes, so failures are absorbed as a per-encounter tax on bounded capacity — silent, accumulating, and softly saturating
• 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
• Acceptance authority does not require a separate repair session - Separates exact checking, acceptance authority, and repair-session placement; explains when worker-local feedback avoids a handoff and when a fresh context is justified.
• 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
• Ad hoc prompts extend the system without schema changes - Any system with an LLM agent layer can absorb new requirements through natural language prompts without changing the deterministic base
• 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
• 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
• Code complements the weight–prompt pair with independently executed symbolic operations - Distinguishes model interpretation from runtime-assigned execution, including model-generated code and the same code artifact used as prompt context or as an executable operation
• Codify-versus-LLM decision heuristics - Specification, checking, permitted interpretations, repeated-use cost, and the stake set against a pattern's stated odds and exposure inform which operations to codify; none alone makes code or model interpretation universally preferable
• 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
• Generate KB skills at build time, don't parameterise them - Template generation resolves installation-known values before model execution, trading model-side binding work for setup, regeneration, and derived-copy maintenance
• 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
• 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-executed methodologies are metacircular interpreters, not compilers - Self-hosting LLM methodologies are closer to metacircular interpreters than compilers: agents re-interpret natural-language rules each session, while stable paths codify into validators and commands
• 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
• 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
• 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 - Progressive extraction uses repeated behavior to identify stable candidates, then checks the extracted rule against the applicable requirement before committing it.
• 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.
• Synthesis is not error correction - Synthesis propagates errors by merging all agent outputs; voting corrects errors by discarding minorities — Kim et al.'s 17.2× amplification is a synthesis failure, not evidence against multi-agent coordination
• 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
• 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