PaperlayerView exact revision on arXiv

Source-linked AI summary

A Contract-Centered Architecture for Scalable and Manageable Agentic Runtimes

Yaxiao Liu, Pengbo Liu, Yiwen Liu, Yihua Guan, Zhenghe Hou, Jiaxing Song

arXiv:2608.27086v1cs.AIcs.MAcs.SE

TL;DR

Enterprise AI lacks a unified way to coordinate capability changes, runtime governance, execution capacity, and enterprise data while preserving distinct ownership and evidence obligations. The paper proposes four contract-based responsibility objects and a cluster-period crossover protocol for testing cost-aware capability-capacity separability. It reports no completed implementation, experiment, dataset, or measured result.

  • Problem

    Use-case benchmarks establish task outcomes for particular Skills but do not establish admission, safe composition, capacity binding, isolation, replayability, portability, or enterprise affordability.

  • Method

    The paper defines Skills, a Harness, Scaffolds, and a stack-external source-preserving data substrate, then proposes measured obligations and a cluster-period randomized crossover for P1.

  • Results

    The paper presents a contract-bounded runtime architecture, source-preserving data substrate, and falsifiable measurement protocol, with no completed empirical result.

  • Takeaways & Limitations

    P1 is framed as a bounded decision about whether capability and compatible capacity changes remain separable while required controls fit an enforcement budget.

  • Takeaways & Limitations

    The paper is a reference architecture and proposed-experiment design, not a production system, enterprise adoption study, or empirical result.

Abstract

from arXiv · show

Enterprise AI deployment is a coordination problem across business units, application and AI teams, testing, platform engineering, infrastructure, security, operations, and data governance. Use-case benchmarks show whether one agent completes one task, but not how changing capabilities, models, runtime mechanisms, capacity, and enterprise data should be owned, changed, admitted, or evidenced together. We present four responsibility objects as shared organizational contracts: Skill (reusable, versioned capability and workflow asset), Harness (runtime compiler and governor), Scaffold (execution/control boundary and NFR owner), and a stack-external data substrate under independent CIO-governed semantics and telemetry. The runtime core is A = <S, H, X>, with the data substrate outside that stack. The central contribution is one bounded, falsifiable hypothesis, P1 (cost-aware capability-capacity separability): within a declared operating region, changing activated capability preserves the capacity-response interaction within a preregistered equivalence margin, while changing compatible Scaffold capacity preserves capability semantics up to a non-inferiority margin, and the required controls stay within a declared enforcement budget. Six design conditions become measured obligations whose coverage, violations, uncertainty, cost, and exclusions determine whether P1 is decidable. We propose a cluster-period randomized crossover experiment (balanced order, reset/washout, repeated seeds and failure regimes, cluster-aware uncertainty) with a four-state verdict: supported, falsified, conditional-engineering, or inconclusive. This paper contributes a contract-bounded runtime architecture, a source-preserving data substrate, and a falsifiable measurement protocol. It reports no completed implementation, experiment, dataset, or measured result.

1 Introduction

Enterprise AI deployment spans organizational boundaries that separate business outcomes, runtime governance, execution infrastructure, testing, security, operations, and data stewardship. The paper proposes contract-based architecture and a falsifiable protocol to test whether capability and capacity can remain separable while controls stay affordable.

  • Deployment gap: Use-case benchmarks measure task outcomes for particular Skills but cannot establish policy admission, safe composition, capacity binding, isolation, replayability, portability, or enterprise affordability.Runtime targets likewise cannot establish business value, so business/use-case and system/runtime evidence remain separate.
  • Research question: The paper asks whether independently deployable capabilities can change without materially changing capacity response, while compatible capacity changes preserve capability semantics at acceptable enforcement cost.This is named cost-aware capability-capacity separability and is evaluated within a specified operating region.
  • Architecture: The architecture distinguishes versioned Skills, a Harness that admits and binds activated paths, Scaffolds that execute and control runs, and a stack-external CIO-governed data substrate.The data substrate preserves canonical source authority while derived indexes and summaries remain discovery metadata.
  • Architecture: The Harness resolves the boundary between capability and capacity interventions, making ownership, handoffs, admission, binding, and evidence obligations inspectable.The paper frames architecture as a shared organizational contract rather than a mandatory organization chart.
  • Contributions: The paper contributes a contract-bounded responsibility architecture, a source-preserving data substrate, and a cluster-period crossover protocol that estimates interaction, semantic noninferiority, and enforcement overhead.The protocol is presented as a proposed experiment, not as completed empirical evidence.

2 Origins: Organization, Boundaries, and Change Cadence

The paper treats enterprise architecture as a shared organizational contract because runs cross communication and ownership boundaries. Distinguishable decision rights and stable interfaces allow objects with different change cadences to evolve without embedding slower infrastructure and data assumptions into every Skill.

  • Organizational boundaries: Enterprise AI crosses business, application, AI runtime, testing, infrastructure, security, operations, and data-stewardship boundaries, so ambiguous organizational handoffs can become ambiguous system dependencies.The architecture makes these handoffs explicit without requiring four teams or four processes.
  • Ownership model: The four responsibility objects are a responsibility model rather than a mandatory organization chart; one team may implement multiple objects while decision rights and evidence responsibilities remain distinguishable.Table 1 frames ownership, change cadence, and stable contracts as separable concerns.
  • Change cadence: Skills may change within hours, whereas isolation boundaries, regional topology, and enterprise semantic standards may remain stable for years.The Harness translates activated business capability into runtime requirements and binds accepted work to compatible capacity and governed data access.
  • Control and execution: Control-plane decisions cover registration, release state, contract compilation, policy versions, and placement, while data-plane work processes accepted payloads and executes effects.Selective activation keeps the full registry and governance state out of each request.
  • Data boundary: The stack-external data substrate owns semantic authority, snapshots, lineage, credentials, retention, and policy-relevant facts, while the Harness mediates access and the Scaffold enforces locality and network constraints.It is neither a fourth runtime layer nor a Skill-owned cache.

3 Foundations and Novelty Boundary

The paper combines established ideas in security, information hiding, control/data-plane separation, agent execution, and structured change rather than claiming a new foundational mechanism. Its novelty boundary is a responsibility model that makes capability–capacity separability and enforcement cost falsifiable.

  • Classical foundations: Reference monitors, complete mediation, non-interference, capability security, least authority, information hiding, and control/data-plane separation supply foundations for the proposed contracts.These foundations constrain the novelty claim rather than serve as new mechanisms introduced by the paper.
  • Related runtime work: The Harness is aligned with prior work that treats the structured execution layer around a foundation model as a first-class object of design, evaluation, and optimization.The paper identifies this shared premise explicitly as the nearest thesis.
  • Runtime governance: Prior governance and composition research motivates complete mediation and path-based authorization because individually benign components can become harmful when composed.These works motivate runtime governance but do not establish the paper’s separability claim.
  • Novel comparison: Existing release-gate work verifies bounded safety invariants across releases, whereas this paper tests capability-by-capacity binding across a deployed capacity range.The cited work does not run a capability-by-capacity factorial or estimate semantic invariance under added Scaffold instances.
  • Novelty boundary: The contribution is not a new scheduler, retrieval algorithm, reference monitor, or modularity principle, but a systems-level composition of established mechanisms into a falsifiable responsibility model.The proposed architecture also treats ownership and non-ownership claims as distinct from product or organizational completeness.

4 Responsibility Model and Primary Claim

The responsibility model separates versioned business behavior, runtime compilation and governance, physical execution, and external data authority. P1 then tests capability–capacity separability within a declared operating region using semantic, runtime, and enforcement measurements.

  • Responsibility objects: A Skill is a versioned independently deployable behavior declaration, while a Scaffold is a physical execution envelope supplying resources, isolation, locality, and runtime identity.The Scaffold may be a sandbox, container, virtual machine, browser session, GPU allocation, or remote execution pool.
  • Harness: The Harness compiles requests into candidate execution graphs, validates them, binds accepted nodes to Scaffold instances, and emits an audit and replay trace.It owns logical admission, schema checking, policy evaluation, effect authorization, budgets, binding constraints, version identities, and evidence obligations.
  • Scaffold: The Scaffold operates the physical execution boundary and measurable NFRs, while the Harness owns logical call selection, authorization, and rationale.NFRs include escape rate, startup and restore latency, failover time, quota adherence, and audit coverage.
  • Operating region: The declared operating region fixes workloads, identities, policy and model versions, data snapshots, compatible Scaffold classes, scheduler regime, and failure regimes.Results outside these bounds constitute a new study rather than an extrapolation.
  • Primary claim: P1 requires runtime-response interaction equivalence, semantic noninferiority under compatible capacity changes, and enforcement overhead within the declared budget.The runtime criterion uses a 90% cluster-aware interval for ∆R inside [−mR, mR], with mR = log(1.10), while other runtime measures remain secondary endpoints.

5 Contract Boundary and Architecture

The Harness resolves an inspectable contract that governs admitted paths, authority, resource bindings, versions, and evidence across control and execution boundaries. Its architecture treats model output and Skills as untrusted inputs while requiring mediation, replay, tracing, and operational controls.

  • The Resolved Harness Contract: The Harness emits a resolved contract containing typed inputs and outputs, an activated Skill graph, authority and effects, resource constraints, and replay identities.These dimensions define the admission decision, activated path, authorized effects, binding constraints, and output postconditions.
  • The Resolved Harness Contract: Authorization decisions, declared effects, selected versions, and evidence requirements can be reconstructed from the recorded contract, although execution outcomes remain variable.The paper summarizes this as probabilistically written, deterministically and auditably executed.
  • Control and Data Planes: Capability interventions change activated behavior on admitted paths rather than registry cardinality, preserving a stable treatment identity for experiments.The registry may contain many Skills without those inactive entries constituting a capability intervention.
  • Control and Data Planes: The control plane manages registration, compilation, policy, placement, and release state, while the data plane executes accepted work through references and resolved contracts.Copying full control state into every request can leak mutable schemas and policy metadata into the execution path and create ambiguous authority.
  • Path-Aware Invariants: Complete mediation and scheduler-independence require observing every crossing, including cache fills, quota checks, retries, and placement hints.Any bypass of the resolved contract remains a potential capability-capacity coupling channel.
  • Evidence and Operations: The runtime traces planner proposals, deterministic gate decisions, and Scaffold execution separately, and supports declared levels of decision, plan, or execution replay.The trace includes identities, versions, graph hashes, bindings, external calls, evidence artifacts, and final effects.
  • Threat Model: Model output is an untrusted authority request, while Skills are authenticated but not assumed correct or benign and must undergo behavioral validation.External content cannot change the activated path, authorized effects, or policy version because these are resolved before fetching.

6 Cohesion, Context Partitioning, and Derivation Closure

The paper partitions context and tools to support cohesion, bounded handoffs, and measurable coupling, then closes unmet dependencies by deriving separately admitted sub-agent contracts. These mechanisms remain hypotheses or scope-bounded design claims where the proposed crossover does not directly test the relevant factors.

  • Context Partitioning: Fixed versions, deterministic serialization, and token-identical prefixes create the measured opportunity for prefix-cache reuse; semantic similarity alone is insufficient.Model, tokenizer, policy metadata, tool ordering, and every prefix token must remain fixed for reuse.
  • Context Partitioning: Stable, version-pinned tool-sets support prefix stability but do not guarantee cache hits, which must be measured directly.Heterogeneous tool-sets can rewrite prefixes and dilute attention.
  • Context Partitioning: Canonical detail should reside in the governed data substrate, with sub-agents exchanging bounded evidence bundles containing conclusions, provenance handles, constraints, and unresolved obligations.Recipients retrieve authoritative detail through governed discovery, navigation, and read operations rather than receiving full context.
  • Production Tool Evidence: 761M model calls and 775M tool invocations across 45 tools showed concentrated usage, with the top 11 tools exceeding 90% of invocations and get_file alone reaching 35.0%.Execution tools were the main latency and failure source in the coding-domain trace, motivating asynchronous execution, timeout fuses, and reclaimable resources.
  • Parallelism and Locality: Disjoint tool declarations reduce only one shared surface: compute pools, locks, services, authorization backends, data dependencies, and scheduler state require separate measurement.Same-seed placement can reuse hot regions, while different-seed placement can reduce contention.
  • Parallelism and Locality: The proposed calibration relations for serial fraction and orchestration efficiency are registered as open questions because the crossover does not vary tool overlap or handoff size as designed factors.Neither linear relation is implied by the architecture or tested by the stated protocol.
  • Derivation Closure: Derivation closure makes an unmet tool or data dependency trigger a fresh admitted child contract rather than inline authority expansion.Each child contract is closed over operations, sources, schemas, effects, and budgets.
  • Derivation Closure: Contractually enumerable operations, sources, schemas, effects, and budgets bound a sub-agent’s authorized action-and-evidence range but not every model token sequence or semantic correctness.Version-bound verifier results may support termination predicates; mutable or uncalibrated verifiers require an independent deterministic gate or named human approval.

7 The External Data Substrate

The external data substrate is governed outside the runtime stack, while the Harness mediates contract-bound access and returns evidence bundles rather than credentials. Versioned, source-preserving data policies support bounded task-family sufficiency and decoupling claims, not universal retrieval guarantees.

  • External Data as a Contract Instantiation: External data is a Harness-contract instantiation with explicit authentication, authorization, schema, snapshot, provenance, freshness, residency, and evidence obligations.
  • External Data as a Contract Instantiation: Figure 6’s boundary gives runs an evidence bundle instead of source credentials, keeping data policy and snapshot identity as fixed experimental inputs.
  • From Query Plan to Intermediate Relation: The source-preserving substrate retains canonical records, versioned snapshots, provenance, access policy, and deterministic reads while treating indexes and summaries as auditable derivatives.
  • From Query Plan to Intermediate Relation: The Intermediate Relation is a versioned, auditable policy connecting a task theme to its admitted source set and is read by the Harness at admission.
  • From Query Plan to Intermediate Relation: P16 tests task-family evidence-path sufficiency against direct reading and controls within a specified access budget, source snapshot, and verifier.
  • From Query Plan to Intermediate Relation: P17 treats compatible registry changes as decoupled within preregistered ranges, while semantic, evidence-policy, or newly exposed dependency changes require IR updates.

8 Skill Lifecycle and Training

Skill-as-Code governs capabilities through validation, staged release, monitoring, rollback, and retirement, then freezes stabilized operation spaces into code. Training uses separate outcome and process signals with a vector-valued admission gate to expose regressions and failure locations.

  • Skill Lifecycle: Skill-as-Code applies source control, schema and effect review, contract and sandbox tests, signed artifacts, staged rollout, monitoring, and rollback to the complete capability contract.
  • Skill Lifecycle: Figure 7 makes the lifecycle reversible: drift returns a Skill to revalidation, rollback restores a staged release, and retirement preserves identity history.
  • Freezing to Code: A stabilized Skill with enumerable branches, structured outputs, and a stable tool set can be frozen into code, removing model sampling from that execution path for fixed inputs and dependencies.
  • Training Before Freezing: A Dual-Subgoal Reward: A single scalar reward cannot distinguish outcome failures from process failures or identify which declared output sub-domain regressed.
  • Training Before Freezing: A Dual-Subgoal Reward: The proposed reward scores each declared output-schema sub-domain separately and adds a process signal for tool, data, artifact, check, and step-gate behavior.
  • Training Before Freezing: A Dual-Subgoal Reward: The output-plus-process vector gate is hypothesized to improve edit discrimination, failure attribution, and convergence without increasing protected-component regressions, subject to preregistered margins.
  • Training Before Freezing: A Dual-Subgoal Reward: Phantom violations constrain process-reward interpretation because optimizers can propose guardrails for failure classes absent from the recorded episode.

9 Six Measured Obligations

The six obligations turn separability into a measured decision rather than an architectural assertion. Coverage, violation bounds, monitor calibration, uncertainty, enforcement cost, and operating-region exclusions determine whether the claim is decidable.

  • Measurement Framework: Each obligation requires instrumentation coverage, observed violations, uncertainty, enforcement cost, and operating-region exclusions.
  • Decision Rules: Support requires coverage above γ_j and a one-sided 95% cluster-aware upper bound for worst-case violation rates below ν_j for every obligation.
  • Calibration: Blinded diagnostic injections must achieve a one-sided 95% cluster-aware sensitivity lower bound above η_j, with injected events excluded from experimental outcomes.
  • Typed Closure: Typed closure enumerates activated-path nodes, interfaces, authorities, data sources, and effects, excluding paths with opaque executors from Ω before outcomes are inspected.
  • Complete Mediation: Complete mediation instruments every effectful boundary and treats any invocation without current resolved-contract authorization as a violation.
  • Isolation Obligations: Effect non-interference and shared-state isolation track cross-run mutations, readers, locks, caches, checkpoints, and undeclared contention across threat-model channels.
  • Decision Rules: Passing all six thresholds supports P1 only within the preregistered threat model; it does not prove that no seventh coupling channel exists.

10 Cluster-Period Crossover Study

The paper proposes a cluster-period randomized crossover to test capability-capacity separability while controlling carryover, reset integrity, fixed workload conditions, uncertainty, and enforcement overhead. The study is explicitly designed to determine whether the obligations are instrumentable, not to claim separability from a small study.

  • Study design: Cluster-periods, rather than individual requests, are the sole randomized units because shared caches, queues, schedulers, and controllers create dependence.Each cluster-period operates under one capability-capacity pair for a fixed period, with requests treated as repeated observations.
  • Study design: Counterbalanced crossover sequences, randomized period assignment, and explicit carryover estimation support comparisons across eligible capability and Scaffold configurations.Transitions use prespecified reset or washout procedures that drain work, restore snapshots, clear state, and await stabilization.
  • Study design: Capability activation changes a versioned bundle on admitted paths, while capacity changes compatible workers, resources, or topology with other settings fixed.Both interventions must be observable in resolved contracts and physical resource records.
  • Controls: Fixed workloads, models, tools, data snapshots, repeated seeds, and crossed failure regimes reduce confounding across crossover arms.Failure regimes include normal operation, worker loss, delayed external service, quota pressure, and injected recoupling channels.
  • Estimands and uncertainty: Primary analysis estimates capability-by-capacity interaction, semantic non-inferiority, and marginal enforcement overhead with cluster-aware uncertainty and prespecified exclusions.The enforcement counterfactual compares identical enforcement-on and minimal pass-through replays, while opportunity costs appear in semantic outcomes.
  • Minimal viable first study: A minimal first study can establish whether six obligations are instrumentable, but cannot establish separability.Its expected outputs include violation rates, semantic and capacity summaries, an interaction estimate with achieved power, and obligation-closure costs.

11 Secondary Protocols

The paper proposes secondary protocols to test mediation, control-plane leakage, composition safety, authority derivation, locality economics, model-version robustness, evidence sufficiency, and structured change propagation. These protocols remain separate from P1 unless preregistered as obligation components.

  • Control and mediation: Harness-bypass ablations compare full mediation with narrowly instrumented direct calls, untyped fetches, unrecorded retries, and direct Scaffold selection.The mediation claim weakens if bypasses reach effectors without typed rejection or fail to affect downstream controls.
  • Control and mediation: Control-plane leakage tests compare eager loading, retrieved activation, and opaque references using canary metadata, deprecated schemas, and policy text.The claim fails if hidden control metadata influences outputs or plans, or if opacity blocks valid requests.
  • Composition and authority: Path-level composition tests compare local allowlists with path-aware admission on benign individual Skills that become hazardous when composed.Measures include hazardous-path detection, false positives, dynamic-graph coverage, and decision latency.
  • Composition and authority: Inline authority expansion is compared with bounded derivation, which is supported only if expansion widens activated authority or the trace.The protocol isolates whether bounded derivation limits the authority surface being activated or recorded.
  • Economics: Dry-run admission and locality-aware binding are evaluated against execution and locality-oblivious baselines using latency, avoided failed-run cost, data movement, and utilization.Dry-run is not justified when predictions are poorly calibrated or costs exceed avoided work.
  • Skill robustness: Model-version robustness freezes Skill source and test corpus while varying planner and executor models, perturbations, tool errors, and partial data.First-attempt scoring and separate scoring components prevent silent self-correction from inflating pass rates.
  • Evidence and change: Evidence-path, policy-contract, and external-data protocols preregister reconstruction and change-propagation tests, while automated training and related measures remain future work.These studies require their own interventions, oracles, and evidence boundaries rather than being added to P1.

12 Discussion

The discussion frames adoption as preserving four distinguishable responsibility objects and evaluating business and runtime success together. It also identifies control-plane concentration, mediation costs, and explicit dispute-resolution rules as adoption conditions.

  • Enterprise adoption: The architecture requires four responsibility objects to remain distinguishable even when one organization owns several of them.Skills, Harness, Scaffold, and data governance retain separate decision rights without requiring four departments.
  • Enterprise adoption: Architecture reviews can use owner, version, stable contract, evidence obligation, rollback authority, and permitted rate of change as concrete agenda items.These fields operationalize the proposed contract boundaries for organizational review.
  • Enterprise adoption: Adoption must report both business and runtime success planes because neither substitutes for the other.A release process reporting only one plane leaves a different enterprise decision unanswered.
  • Control-plane risk: Harness concentration creates availability and compromise risks, requiring replicated control services, signed artifacts, independent attestation, freshness bounds, and fail-closed degradation.Degraded operation should preserve activated in-flight versions where permitted while refusing new admissions and reducing capability rather than widening governance.
  • Costs and trade-offs: Mediation and stack-external data access consume latency, capacity, privacy, and administrative resources, and their overhead is not measured in this paper.The contracts make trade-offs attributable but do not eliminate selective-activation, path-checking, retention, or specialized-hardware constraints.
  • Governance: The organizational thesis requires explicit resolution of ownership disputes and contested releases, with authority, evidence, and timestamps carried in the trace.A stable contract of record governs until a named escalation authority changes it.

13 Limitations and Threats to Validity

The paper is a reference architecture and proposed protocol rather than an empirical validation, and its claims are bounded by operating regions, margins, power, crossover assumptions, and incomplete organizational evidence.

  • Empirical scope: The paper reports no completed runtime, experiment, dataset, benchmark result, measured enforcement budget, or supported deployment scale.It also does not demonstrate operation from 0 to 100,000 admitted or active agents.
  • Interpretation: A supported verdict would mean only that no falsification criterion was triggered within preregistered operating regions, margins, power, and instrumentation.It would not prove independence or justify stronger extrapolation.
  • Organizational validity: The responsibility mapping may underrepresent human approvals, long-running state, multitenant incentives, cross-organization trust, and regulated decision rights.Organizational division, dispute escalation, and cross-enterprise transferability remain unexamined by organizational study.
  • Evidence base: The evidence base motivates the architecture but does not validate it or its organizational claim, and contemporary preprints may change after recorded versions.Classical foundations and contemporary sources therefore have different evidentiary status.
  • Scope and validity: Separability may hold only within a bounded operating region, while obligations can be incomplete, correlated, or difficult to hold fixed.Strict coverage rules reduce false support but can produce inconclusive or conditional-engineering outcomes.
  • Design validity: Equivalence, non-inferiority, and interaction conclusions depend on chosen margins and achieved power, and crossover designs fail under irreversible learning or long carryover.Parallel clusters or longer stepped designs may be needed in those settings.
  • Data-model scope: The formal data appendix assumes finite alphabets, deterministic query-agnostic encoders, exact answers, and separate persistent-versus-online accounting.Randomized encoders, approximate or continuous tasks, changing source distributions, and total lifecycle cost require additional analysis.

14 Conclusion

The paper frames architecture as a shared organizational contract while centering a falsifiable test of cost-aware capability-capacity separability. It calls for separate business/use-case and system/runtime evidence, followed by a minimal crossover study rather than further architectural elaboration.

  • Architecture assigns distinguishable decision rights for business semantics, runtime governance, physical execution, and enterprise data, without requiring four teams or processes.
  • P1 tests whether activated capability preserves capacity response, compatible capacity preserves capability semantics, and required controls remain within an enforcement budget.
  • A cluster-period randomized crossover, six measured obligations, explicit margins, and a four-state verdict make the separability question answerable.
  • Deterministic gates and trace identity make departures detectable, auditable, and attributable, but do not cause independence.
  • Enterprises should require both business/use-case evidence of workflow outcomes and system/runtime evidence of contract and NFR compliance.
  • The proposed next step is a small implemented crossover whose publication includes falsified, conditional-engineering, and inconclusive cases.

15 Technical Appendix: Information-Theoretic and Discrete Foundations

The appendix formalizes limits on fixed write-time representations when future queries are unknown. Its results support source-preserving, task-bounded derivatives and define a falsification boundary: interfaces that merge task-distinguishable states cannot be repaired by downstream intelligence alone.

  • The appendix treats indexes, summaries, and relations as auditable, task-bounded derivatives while retaining governed canonical source evidence.
  • Exact sufficiency is defined relative to a declared task family: a representation must allow some decoder to recover every in-scope answer for every source-query pair.
  • When deficiency ∆(f) is positive, inverse-Fano bounds imply every decoder has a positive error floor determined by the fixed representation and task.
  • Exact sufficiency holds when every encoder partition block lies within a block of the common refinement of all declared query partitions.
  • Expanding the query family can only refine the task partition and cannot reduce the minimum sufficient representation rate Rmin.
  • For k independent queried bits, write-time exact representation requires at least k bits, whereas source fallback can use ceil(log2k) address bits plus one evidence bit.
  • The resulting separation is Theta(k/log2k), excluding raw storage, index maintenance, authorization, and access latency from the online comparison.
  • An interface is insufficient whenever equivalent accessible results correspond to source states with different answers for an admitted query.
Loading 2608.27086v1…