Arbitration as Semantic Event

Mechanism

In the disclosed LLM integration architecture, every language model occupies the structural role of an untrusted proposal generator. No language model output is authoritative. Every output is a proposal: a candidate semantic mutation that the agent's resident infrastructure must independently evaluate before it can affect any agent field. When the system invokes multiple language models to produce candidate mutations for the same agent operation, each model's output is independently submitted; the system does not aggregate outputs through voting, averaging, or ensemble blending. The arbitration engine is the subsystem that resolves the conflict when two or more of these competing proposals target the same agent field and cannot be simultaneously applied.

The arbitration engine receives conflict sets from the mutation engine. A conflict set is a set of two or more candidate mutations that target the same field. The mutation engine produces these sets through its conflict detection operation: when multiple proposals from multiple language models address the same field, the mutation engine identifies the contention and packages the competing proposals together for arbitration. The arbitration engine then either selects a single winning candidate or synthesizes a reconciled candidate from the competing proposals.

Trust-Weighted Evaluation

The arbitration engine applies trust-weighted evaluation. Each language model carries an accumulated trust score within the agent's governance context. The trust score is a dynamic value updated from the model's historical performance: proposals that were validated and accepted increase the model's trust score, proposals that were rejected decrease it, and proposals that were accepted but later determined to have introduced errors, inconsistencies, or policy violations produce a retroactive trust penalty. The trust score is maintained per agent and per domain, so the system can recognize that a model may be reliable for one category of proposal and unreliable for another.

Each candidate mutation in the conflict set is scored on a plurality of evaluation dimensions: semantic coherence with the agent's current state, consistency with the agent's intent field, alignment with the agent's policy reference, and compatibility with the agent's lineage trajectory. The per-dimension scores are multiplied by the originating model's trust weight to produce a trust-adjusted composite score. The candidate with the highest trust-adjusted composite score is selected as the arbitration winner. If no candidate achieves a composite score above a configurable minimum threshold, the arbitration engine may reject all candidates and request new proposals, or may escalate the conflict to a governance authority for manual resolution.

Reconciliation of Partially Compatible Proposals

When the competing proposals are partially compatible, the arbitration engine may synthesize a reconciled candidate rather than discarding all but one. The reconciliation process extracts the highest-scoring elements from each proposal across each evaluation dimension and combines them into a single reconciled candidate. Reconciliation does not bypass validation: the reconciled candidate is submitted to the validation engine for evaluation as though it were a new proposal.

The reconciled candidate's lineage annotation records the identities of all contributing models and the reconciliation logic that was applied. The provenance of the reconciled output is therefore fully traceable, and no part of a reconciled mutation escapes the same governance, validation, and lineage treatment that governs any other candidate.

Arbitration as a First-Class Semantic Event

Every arbitration decision produced by the arbitration engine is recorded as a first-class semantic event within the agent's lineage. The arbitration event record includes the identities of the competing language models, the candidate mutations they produced, the trust weights applied, the per-dimension scores computed, the selection or reconciliation logic applied, and the identity of the winning or reconciled candidate. The arbitration event record is cryptographically signed and sealed into the agent's lineage chain using the same sealing mechanism applied to other governed events. The sealed event cannot be retroactively altered, deleted, or reordered.

Treating arbitration as a first-class event rather than an opaque internal selection is what makes the decision durable, reviewable, and traceable. The decision is not an implicit code path; it is an explicit, governed artifact in the lineage that downstream consumers read as a primary record.

Structural Consequences

The disclosure identifies three structural consequences that follow from treating arbitration decisions as first-class semantic events. First, arbitration decisions become part of the agent's persistent memory and influence future trust weighting: an arbitration in which one model's proposal was selected over another's, and in which the selected proposal subsequently proved correct, increases the selected model's trust weight for similar future proposals and decreases the other model's weight.

Second, arbitration decisions become auditable governance artifacts. A governance auditor reviewing the agent's behavior can trace any field value back through the lineage to the arbitration event that selected it, and from the arbitration event to the specific language model proposals, trust weights, and scoring logic that produced the selection. Third, arbitration decisions become inputs to cross-agent governance: when an agent's arbitration history reveals a pattern, for example a model that consistently produces proposals that fail validation or are overridden in arbitration, that pattern can be propagated to other agents that use the same model, enabling network-wide trust recalibration.

Trust Weight Calibration and Decay

The trust weights assigned to language models are subject to continuous calibration and temporal decay. They are not static assignments. Calibration operates through two mechanisms. The first is outcome-based adjustment: when a mutation proposed by a model is accepted and later evaluated as correct, meaning it did not produce integrity violations, did not require governance intervention, and did not contribute to negative outcomes, the model's trust weight for the relevant domain is increased; when an accepted mutation is later evaluated as incorrect, the weight is decreased, and the decrease may be larger than the corresponding increase to reflect the asymmetric cost of accepting incorrect proposals.

The second mechanism is temporal decay: trust weights decay over time in the absence of new evidence, reflecting that a model's reliability demonstrated at one point may not persist due to distribution shift, model updates, or changes in the operational context. The decay rate is configurable per domain and per model category. Because the arbitration event record is sealed and tamper-resistant, this trust-weight feedback loop operates on a record that an adversary cannot manipulate to inflate or deflate a particular model's score.

Composition with Adjacent Subsystems

Arbitration sits between the mutation engine and the validation engine. The mutation engine imposes structural discipline on raw model output: it performs schema mapping, bounds normalization, conflict detection, and lineage annotation. Conflict detection is the operation that produces the conflict sets the arbitration engine consumes. Where only one proposal targets a field, no arbitration is required and the candidate proceeds to validation directly. Where multiple proposals contend, arbitration selects or reconciles, and the result, whether a single winner or a synthesized reconciliation, is then submitted to the validation engine.

The validation engine evaluates each candidate mutation against the full set of agent-resident constraints, including policy compliance, lineage consistency, integrity compliance, capability feasibility, and affective bounds. Arbitration does not substitute for validation. A proposal that wins arbitration must still pass validation before it can be incorporated into agent state, and a validation rejection is itself persisted in the lineage. The arbitration event and the validation record together form the traceable chain from contention through selection through admission.

Distinction from Conventional Multi-Model Selection

Conventional approaches to combining multiple language models aggregate their outputs through voting, averaging, or ensemble techniques that produce a blended output inheriting the authority of multiple models, or they route between models using a selector that emits a choice without producing a structural record of the competitors, the scores, or the grounds. In the disclosed architecture each model's output is treated as an independent, structurally untrusted proposal that must independently satisfy validation, and the resolution among competing survivors is performed by trust-weighted evaluation whose every input and output is recorded as a sealed, first-class semantic event. The distinguishing feature is the structural elevation of multi-model conflict resolution to a governed, signed, lineage-recorded event with full provenance of competitors, trust weights, scores, and selection or reconciliation logic.

Disclosure Scope

The disclosure covers the arbitration engine that resolves conflict sets of competing candidate mutations through trust-weighted evaluation, the per-dimension scoring across semantic coherence, intent consistency, policy alignment, and lineage trajectory compatibility multiplied by per-model trust weight, the synthesis of reconciled candidates from partially compatible proposals with full validation and provenance, the recording of every arbitration decision as a cryptographically signed first-class semantic event sealed into the agent's lineage, and the calibration and temporal decay of per-model, per-domain trust weights. The scope includes the composition of arbitration with the mutation engine that produces conflict sets and the validation engine that evaluates arbitration outputs, and the three structural consequences of first-class arbitration events: future trust weighting, governance audit, and cross-agent trust recalibration. This subject matter is disclosed in the cognition filing (U.S. Application No. 19/647,395 and its international counterpart). The scope does not depend on the number of competing models, the particular trust-update schedule, or whether a given arbitration resolves by selection or by reconciliation; it depends on the structural treatment of multi-model contention as a trust-weighted, governed, lineage-recorded event.