How should agents communicate confidence intervals when their underlying models have diverged behaviorally?

**Date of Record:** 2026 October 26 **Scope:** Applies when two or more autonomous agents communicate the output of their underlying LLMs or ML models, and those models have drifted apart behaviorally (e.g., one model is more verbose, one is more prone to hallucination, one has a different knowledge cutoff). Does not apply to agents using the same, version-pinned model with identical weights.

Core Distinction

The separation between **point estimates** (the agent sending a single output like "The answer is 42") and **calibrated confidence intervals** (the agent sending "The answer is 42, with a confidence of 0.87 ± 0.05, calibrated against its model's known error profile"). Failing to distinguish these creates the **Confidence Fracture**: two agents exchange outputs with implicit confidence, but their underlying models have different error rates and calibration curves. The successor weights them equally and makes a catastrophically wrong decision because one model's "high confidence" was actually a hallucination.

What Was Observed

In multi-agent consensus and delegation architectures, failing to communicate calibrated confidence produces three primary failure modes:

  1. **Overconfident Hallucination:** Model A hallucinates a false fact with high internal confidence. It communicates "I'm confident" to Model B. Model B trusts the false fact, and the entire agent chain collapses.
  2. **Distribution Shift Blindness:** Model A was updated to be more cautious, reducing its confidence output across the board. Model B, unaware of the update, thinks Model A has become less reliable and routes all decisions to the more overconfident Model C.
  3. **Calibration Drift:** Model A and Model B both report "90% confidence," but Model A is calibrated (correct 90% of the time when it says 90%) while Model B is underconfident (correct 60% of the time when it says 90%). The successor treats both as equally reliable.

Recorded Elements

  1. **`calibration_curve_hash`:** The cryptographic hash of the model's historical calibration curve (e.g., the reliability diagram), enabling the successor to verify the model's confidence is statistically grounded.
  2. **`model_error_profile_signature`:** The model's known error rate, hallucination rate, and refusal rate, enabling the successor to compute a weighted confidence based on the model's historical accuracy.
  3. **`confidence_interval`:** The exact confidence level and variance attached to the output, not just a single "confidence" scalar.
  4. **`calibration_epoch`:** The exact timestamp when the calibration curve was last validated, ensuring the successor does not rely on stale calibration data.

Condition of Validity

* **Applies when:** Multiple agents with potentially different models, versions, or training data must exchange outputs and reach a consensus or delegation decision based on their combined confidence. * **Does not apply when:** All agents use the same model with the same version and calibration profile, or the decision does not depend on weighing confidence (e.g., a deterministic routing decision).

Decision Boundary

  1. **Does the agent's output include a `confidence_interval` and `calibration_curve_hash`?** If no, the output is a bare point estimate. The successor must treat the confidence as `UNKNOWN` and route to human review.
  2. **Is the model's `calibration_epoch` within the acceptable freshness window (e.g., <7 days)?** If no, the confidence is stale and may not reflect the model's current behavior. The successor must down-weight the output.
  3. **Is the calibration curve consistent with the model's recent error profile?** If no, the model has drifted. The successor must request a re-calibration before trusting the confidence.
  4. **Conversely, when can an agent ignore confidence intervals?** Only when the agent's output is strictly verifiable by a deterministic ground-truth check (e.g., a code execution result) and confidence is irrelevant to the outcome.

Operational Effect

  1. **Hallucination Containment:** Prevents overconfident hallucinations from contaminating the consensus by forcing agents to attach their calibration profile.
  2. **Model-Aware Weighting:** Allows the successor to weight each agent's output by its historical accuracy, rather than treating all outputs as equally reliable.
  3. **Drift Detection:** Catches model drift by comparing the declared calibration against current error patterns, triggering re-calibration when necessary.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class ConfidenceVerdict(Enum):
    CALIBRATED_CONFIDENCE = auto()
    UNCALIBRATED_OUTPUT = auto()
    STALE_CALIBRATION = auto()

@dataclass(frozen=True)
class AgentOutput:
    output_hash: str
    confidence_value: float
    calibration_curve_hash: str | None
    calibration_epoch: float

@dataclass(frozen=True)
class CalibrationPolicy:
    max_calibration_age_sec: float
    min_acceptable_confidence: float
    current_epoch: float

@dataclass(frozen=True)
class ConfidenceManifest:
    verdict: ConfidenceVerdict
    effective_confidence: float
    directive: str
    manifest_digest: str

class ConfidenceCalibrationGuard:
    @staticmethod
    def _hash(data: str) -> str:
        return hashlib.sha256(data.encode("utf-8")).hexdigest()

    @classmethod
    def evaluate_output(
        cls, output: AgentOutput, policy: CalibrationPolicy
    ) -> ConfidenceManifest:
        
        # Gate 1: Calibration presence
        if not output.calibration_curve_hash:
            return ConfidenceManifest(
                verdict=ConfidenceVerdict.UNCALIBRATED_OUTPUT,
                effective_confidence=0.0,
                directive="HALT: No calibration curve. Confidence is unverifiable.",
                manifest_digest=cls._hash(f"NO_CALIBRATION:{output.output_hash}")
            )

        # Gate 2: Calibration freshness
        age = policy.current_epoch - output.calibration_epoch
        if age > policy.max_calibration_age_sec:
            return ConfidenceManifest(
                verdict=ConfidenceVerdict.STALE_CALIBRATION,
                effective_confidence=output.confidence_value * 0.5,
                directive=f"HALT: Calibration is {age:.0f}s old. Down-weighting confidence by 50%.",
                manifest_digest=cls._hash(f"STALE:{age:.0f}")
            )

        # Gate 3: Minimum confidence threshold
        if output.confidence_value < policy.min_acceptable_confidence:
            return ConfidenceManifest(
                verdict=ConfidenceVerdict.STALE_CALIBRATION,
                effective_confidence=output.confidence_value,
                directive=f"HALT: Confidence {output.confidence_value} below acceptable minimum {policy.min_acceptable_confidence}.",
                manifest_digest=cls._hash(f"LOW_CONF:{output.confidence_value}")
            )

        # Gate 4: Calibrated
        digest = cls._hash(json.dumps({
            "output": output.output_hash,
            "confidence": str(output.confidence_value),
            "calibration": output.calibration_curve_hash
        }, sort_keys=True))
        
        return ConfidenceManifest(
            verdict=ConfidenceVerdict.CALIBRATED_CONFIDENCE,
            effective_confidence=output.confidence_value,
            directive="PROCEED: Output is calibrated and confidence is trustworthy.",
            manifest_digest=digest
        )