Model-Agnostic Inference Governance

Mechanism

The model-agnostic property of the inference-time semantic execution substrate follows from a single design choice: the substrate operates on the interface between the inference engine and the output rather than inside the engine. It does not require access to the inference engine's internal representations, gradient signals, attention weights, or hidden states. It intercepts candidate inference transitions at the point where the engine proposes them, evaluates each for semantic admissibility, and either permits or prevents its commitment. Because the evaluation never reaches into the engine, the architecture, training methodology, parameterization, and inference algorithm of that engine are all irrelevant to whether the substrate can govern it.

The substrate places exactly one requirement on the underlying engine: that it produce candidate transitions mappable to semantic mutation descriptors. A candidate transition may be a candidate token in an autoregressive model, a candidate reasoning step in a chain-of-thought process, a candidate node expansion in a tree-of-thought architecture, or a candidate state update in a probabilistic graphical model. Whatever its native form, it is handed to a mutation mapping module that produces a structured mutation descriptor, and from that point forward the engine that produced it no longer matters to the governance machinery.

Semantic Evaluation, Not Statistical Evaluation

The model-agnostic applicability is a consequence of reliance on semantic evaluation rather than statistical evaluation. The admissibility gate evaluates the semantic admissibility of the mutation a transition would effect, not the probability of the transition. The evaluation is conducted against typed fields using deterministic predicates and comparison operations. Because it inspects the proposed semantic change and not the probability distribution that produced the candidate, it is independent of whether the candidate was produced by a transformer-based language model, a recurrent neural network, a diffusion model, a probabilistic graphical model, or any other architecture.

This distinguishes the substrate from approaches that depend on the statistical character of a particular engine. The evaluation criteria are defined by the semantic state object's governance constraints, not learned from data, so they do not have to be re-derived when the engine changes. The same typed-field evaluation that governs one engine governs the next, because what is being evaluated is the mutation, not the model.

The Mutation Mapping Boundary

The mutation mapping module is the component that absorbs the heterogeneity of underlying engines. It receives the candidate inference transition in its native representation, a token, a text span, a reasoning step, a state vector, and produces a structured mutation descriptor specifying which fields of the semantic state object the transition would modify, what the proposed new values for those fields would be, the semantic category of the mutation, such as assertion, qualification, elaboration, negation, reference, or transition, and the degree of semantic novelty the mutation introduces relative to the current semantic state.

Not every transition maps to a semantic mutation. Some transitions are semantically inert: they contribute syntactic structure, formatting, or connective tissue that does not alter the semantic content of the output. The mutation mapping module classifies such transitions as semantically inert and passes them through without admissibility evaluation. This classification is itself a deterministic evaluation based on the transition's content and the current semantic state. Once a transition has been mapped to a descriptor, admissibility evaluation proceeds identically regardless of the engine that originated the candidate.

Extension to Multimodal Engines

The model-agnostic property extends to multimodal inference engines. Each modality requires a modality-specific mutation mapping module that translates that modality's candidates into structured mutation descriptors. Once mapped, admissibility evaluation proceeds identically regardless of the originating modality. A candidate image region, a candidate audio segment, and a candidate text span are all evaluated as proposed semantic mutations against the same semantic state object using the same governance criteria.

The modality-specific mapping is therefore the only modality-aware part of the substrate. Everything downstream of the descriptor, the admissibility gate, the lineage recording, the trust-slope continuity validation, operates on the descriptor's typed fields and is indifferent to whether those fields were populated from pixels, samples, or symbols.

Multiple Engines on a Shared Semantic State

Because governance is anchored to the semantic state object rather than to any one engine, the substrate supports inference operations in which multiple probabilistic inference engines contribute candidate transitions to the same inference process, sharing a single semantic state object and subject to a single set of governance constraints. At each step, one or more engines produce candidate transitions; each candidate is independently mapped to a mutation descriptor and independently evaluated by the admissibility gate against the shared semantic state object.

When multiple admitted candidates are available at the same step, an arbitration engine selects among them using trust-weighted evaluation, scoring each admitted candidate by the originating engine's trust weight, semantic coherence with the current state, and alignment with the inference intent. An engine whose candidates are predominantly rejected accumulates negative trust-weight adjustments and is progressively de-prioritized; an engine whose candidates are predominantly admitted is progressively favored. The shared semantic state object ensures all participating engines are governed by the same intent, policies, lineage, and entropy bounds, and the lineage records the originating engine for each admitted transition, enabling contribution tracing across engines.

Deployment Independence

The substrate is deployable in three structural configurations that provide the same semantic governance guarantees while differing in implementation characteristics. The embedded configuration deploys the substrate directly within the inference engine's runtime environment, with the admissibility gate, mutation mapping module, trust-slope validation module, anchor resolution module, and lineage recording module implemented as components of the same process and an interface that is a function-call boundary. The co-resident configuration deploys the substrate as a separate process on the same host communicating through a local inter-process communication channel, providing stronger isolation since the inference engine cannot access or modify the substrate's state. The hardware-assisted configuration implements critical components in dedicated hardware or hardware-accelerated processing units, providing the highest tamper-resistance assurance for high-assurance deployments, including scenarios in which the inference engine operator may be adversarial to governance objectives.

All three configurations maintain the same guarantees: every semantically active transition is evaluated before commitment, every admitted transition is lineage-recorded, every rejection rationale is preserved, and the integrity of the semantic state object is maintained throughout inference. The deployment topology affects isolation, latency profile, and tamper-resistance, not the semantics of evaluation.

Independence From the Engine's Training

Because the substrate operates at inference time on the outputs of whatever engine is deployed, it governs engines regardless of training methodology. This independence enables governance of inference engines that cannot be retrained, including proprietary models accessed through application programming interfaces. The substrate is structurally distinct from reinforcement learning from human feedback and related training-time alignment methods, which modify trained parameters at training time and produce properties bound to the specific engine in which they are induced.

It is likewise distinct from constitutional and self-critique mechanisms, which rely on the inference engine's own capabilities to evaluate and revise its outputs, the same capabilities that produced the problematic output. The disclosed substrate performs admissibility evaluation through an architecturally separate engine operating on structured semantic fields with deterministic governance criteria, not the inference engine's probabilistic self-assessment. Replacing one engine with another, or substituting a symbolic engine for a neural one, requires only that the replacement produce candidates mappable to mutation descriptors; the governance criteria, the semantic state object schema, and the lineage record remain unchanged.

Disclosure Scope

The model-agnostic applicability of the inference-time semantic execution substrate, comprising operation on the interface between the inference engine and the output without access to the engine's internal representations, the single requirement that the engine produce candidate transitions mappable to semantic mutation descriptors, the mutation mapping module that translates native candidates into typed descriptors and classifies semantically inert transitions, the semantic rather than statistical basis of the deterministic admissibility evaluation, the modality-specific mapping that extends the property to multimodal engines, the shared semantic state object and trust-weighted arbitration supporting multiple contributing engines, and the embedded, co-resident, and hardware-assisted deployment configurations that preserve identical governance guarantees, is disclosed in the cognition filing (U.S. Application No. 19/647,395 and its international counterpart). This article describes that disclosed mechanism. The scope extends to inference engine architectures not enumerated whose candidate transitions are mappable to semantic mutation descriptors, and to deployment topologies that preserve the evaluation semantics.