What invariants preserve signal integrity when signaling is costly?

**Date of Record:** 2026 October 27 **Scope:** Applies when an agentic session sends costly signals (signals that would be irrational to send if the signal were false) to convey information to peers, and the signal's cost structure must preserve its signaling value under manipulation, framing, or partial-cost-sharing. Does not apply to costless signals or signals that are not intended to convey information.

Core Distinction

The separation between **signal dispatch** (the signal was sent) and **signal validity** (the signal conveys accurate information because its cost structure ensures honesty). Relying on dispatch creates the **Costly-Signal Dilution**: signals are sent, but their cost structure has been altered (the cost is partially shared, the signal is diversified across multiple dimensions, or the signal is bundled with other signals), and the receiver can no longer infer truth from the signal's presence.

What Was Observed

In signaling-intensive agent architectures, failing to preserve signal integrity produces three primary failure modes:

  1. **Cost Sharing:** The signal cost is partially borne by third parties, so sending the signal is no longer irrational when false. The signal's informational content collapses because it can be sent regardless of truth.
  2. **Signal Inflation:** The session sends many signals, each individually costly but collectively diluting the signal value. The receiver cannot distinguish "I sent signal X because X is true" from "I send all signals to appear thorough."
  3. **Signal Mimicry:** A different agent with a different cost structure sends the same signal at lower cost, and the receiver cannot distinguish genuine from mimicked signals.

Recorded Elements

  1. **`signal-cost-structure-receipt`:** The exact cost the signaler bears when sending the signal, with the cost structure (who pays, under what conditions), so cost-sharing is disclosed.
  2. **`signal-specificity-signature`:** For each signal, the informational content it is designed to convey and the alternatives (what could be signaled without cost), so signal-value inflation is detectable.
  3. **`signal-mimicry-indicators-receipt`:** For each signal, the mechanisms that would distinguish genuine signals from mimics (cost asymmetry, historical consistency), so mimicry is detectable.
  4. **`signal-aggregation-manifest-signature`:** For signal bundles, the exact set of signals and their individual costs, so the bundle's informational content is verifiable rather than assumed.

Condition of Validity

* **Applies when:** Signaling is costly, signals are intended to convey information, and receivers rely on signal presence as evidence. * **Does not apply when:** Signals are costless, signaling is not informational, or receivers verify information independently of signals.

Decision Boundary

  1. **Is the signal costly?** If no, standard communication applies. If yes, proceed.
  2. **Is the cost structure disclosed (`signal-cost-structure-receipt`)?** If yes, the informational content can be evaluated. If no, the cost is assumed full.
  3. **Is the signal specific (conveys one fact, not a bundle)?** If yes, the informational content is clean. If no, the signal's value is diluted by aggregation.
  4. **Conversely, when can a receiver trust a costly signal without cost verification?** Only when the cost structure is verified by independent observation, or the signal is from a signaller whose cost structure is well-known and stable.

Operational Effect

  1. **Signal Validity:** Cost structure is explicit, preserving informational content.
  2. **Inflation Prevention:** Signal bundles are disclosed and their value evaluated individually.
  3. **Mimic Detection:** Cost asymmetry is checked, distinguishing genuine from mimic signals.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json

class SignalVerdict(Enum):
    NO_SIGNAL = auto()
    SIGNAL_VALID = auto()
    SIGNAL_DILUTED = auto()
    SIGNAL_MIMICRY_SUSPECTED = auto()

@dataclass(frozen=True)
class CostlySignal:
    signal_id: str
    signaler_id: str
    cost_to_signaler: float
    is_cost_shared: bool
    is_part_of_bundle: bool
    bundle_size: int
    mimicry_indicators: int

@dataclass(frozen=True)
class SignalPolicy:
    max_bundle_size_for_valid: int
    min_cost_for_valid: float

@dataclass(frozen=True)
class SignalManifest:
    verdict: SignalVerdict
    directive: str
    manifest_digest: str

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

    @classmethod
    def evaluate_signal(
        cls, signal: CostlySignal, policy: SignalPolicy
    ) -> SignalManifest:
        
        # Gate 1: No signal
        if not signal.signal_id:
            digest = cls._hash(json.dumps({
                "signal": "NONE"
            }, sort_keys=True))
            return SignalManifest(
                verdict=SignalVerdict.NO_SIGNAL,
                directive=f"PROCEED: No signal to evaluate.",
                manifest_digest=digest
            )

        # Gate 2: Cost sharing
        if signal.is_cost_shared:
            return SignalManifest(
                verdict=SignalVerdict.SIGNAL_DILUTED,
                directive=f"FLAG: Signal {signal.signal_id} cost shared, informational content reduced.",
                manifest_digest=cls._hash(f"COST_SHARED:{signal.signal_id}")
            )

        # Gate 3: Bundle inflation
        if signal.is_part_of_bundle and signal.bundle_size > policy.max_bundle_size_for_valid:
            return SignalManifest(
                verdict=SignalVerdict.SIGNAL_DILUTED,
                directive=f"FLAG: Signal {signal.signal_id} in bundle of {signal.bundle_size}, value diluted.",
                manifest_digest=cls._hash(f"BUNDLE:{signal.signal_id}")
            )

        # Gate 4: Mimicry
        if signal.mimicry_indicators >= 2:
            return SignalManifest(
                verdict=SignalVerdict.SIGNAL_MIMICRY_SUSPECTED,
                directive=f"FLAG: {signal.mimicry_indicators} mimicry indicators for {signal.signal_id}.",
                manifest_digest=cls._hash(f"MIMIC:{signal.signal_id}")
            )

        # Gate 5: Insufficient cost
        if signal.cost_to_signaler < policy.min_cost_for_valid:
            return SignalManifest(
                verdict=SignalVerdict.SIGNAL_DILUTED,
                directive=f"FLAG: Signal {signal.signal_id} cost {signal.cost_to_signaler:.2f} < {policy.min_cost_for_valid:.2f}.",
                manifest_digest=cls._hash(f"LOW_COST:{signal.signal_id}")
            )

        # Gate 6: Valid
        digest = cls._hash(json.dumps({
            "signal": signal.signal_id,
            "signaler": signal.signaler_id,
            "cost": f"{signal.cost_to_signaler:.3f}",
            "bundle": signal.bundle_size
        }, sort_keys=True))
        
        return SignalManifest(
            verdict=SignalVerdict.SIGNAL_VALID,
            directive=f"PROCEED: Signal {signal.signal_id} valid.",
            manifest_digest=digest
        )