# What structural signals indicate MCP server trust decay before tool-call corruption surfaces **Date of Record:** 2026 November 16 **Scope:** Applies to runtime integrity verification of third-party MCP (Model Context Protocol) tool providers where the agent maintains a rolling trust score derived from observable protocol behavior rather than from static allowlists. Does not apply to first-party MCP servers under the same administrative control as the calling agent, nor to servers whose tool schemas are pinned and hash-verified at session start (those fail closed by construction and exhibit different decay signatures). ## Core Distinction Trust decay in an MCP server is not the same phenomenon as tool-call failure. A server can return structurally valid responses, satisfy its declared JSON schema, and stay within latency budgets while its *behavioral envelope* has already shifted. The distinction that matters operationally is between **schema conformance** (a per-call boolean the agent can verify cheaply) and **behavioral stationarity** (a distributional property of the server's responses across calls). Trust scoring systems that collapse both into a single scalar lose the ability to detect decay before the first corrupted tool call. The non-obvious boundary is this: the first corrupted call is almost never the first anomalous signal. It is the first *schema-visible* signal. Structural signals precede it by several calls, and they are recoverable only if the trust scorer samples them separately from schema validation. ## What Was Observed Across a multi-week deployment scoring fourteen third-party MCP servers, three structural signals consistently preceded the first schema-violating tool response: 1. **Description drift under stable tool names.** The `description` field of a tool in `tools/list` responses changed between sessions while `name` and `inputSchema` remained byte-identical. In every observed case of eventual corruption, description text had been edited at least one session prior — typically widening scope language ("reads a file" → "reads or writes a file") without a corresponding schema change. The schema still validated; the contract had silently expanded. 2. **Latency variance collapse, not latency increase.** Decayed servers did not get slower. Their p50 latency *tightened* while p99 rose, producing a bimodal distribution: fast cached responses for repeated inputs and slow cold-path responses for novel inputs. A monotonic latency threshold missed this entirely. The signal is the *ratio* of p99 to p50 crossing a threshold, not either value alone. 3. **Argument-space narrowing.** For tools with free-form string parameters, the entropy of accepted argument values fell measurably before any call failed. Servers approaching corruption began rejecting a growing fraction of valid-but-unusual inputs with schema-compliant error payloads (empty results, `null` fields) rather than protocol errors. The tool did not fail; it silently stopped covering its declared input domain. None of these three signals is visible to a per-call schema validator. All three are visible to a scorer that retains cross-session state. ## Condition of Validity These signals are only diagnostic under the following conditions, and the scorer must enforce them or the signals invert: - The server's `tools/list` response is sampled at session start **and** compared against the prior session's snapshot, not merely validated against a schema. Description drift is undetectable without the diff. - Latency is recorded per-call with input novelty tagged (first-seen vs. repeated argument tuples). Without novelty tagging, the bimodal distribution reads as noise. - Argument-space coverage is measured against a held-out probe set of inputs the server has never seen, submitted at low rate. If probes are drawn from the same distribution as production traffic, entropy collapse is invisible. - The trust score is a vector, not a scalar. Collapsing description-drift, latency-ratio, and coverage-entropy into one number destroys the lead time; the earliest-warning component is always description drift, and a scalar average buries it under stable latency. ## Decision Boundary The operational rule: **do not demote a server on a single signal; demote on any two signals co-occurring within a rolling window of N sessions, and quarantine on schema violation regardless of score.** A single description drift event is common and usually benign (documentation cleanup). A single latency-ratio excursion is common under load. But description drift *plus* coverage-entropy decline in the same window has, in this deployment, preceded corruption with no false positives across the observation period. The boundary is deliberately set to trade recall for precision: the cost of quarantining a healthy server is a degraded session; the cost of missing a decaying one is a corrupted tool call that the agent may act on. ## Operational Effect Implementing the vector scorer changed the failure mode from *silent corruption* to *early quarantine with a diagnostic reason attached*. Agents consuming the trust vector can route around a demoted server before its first bad response, and the quarantine record names which signal fired, which is what makes the decision auditable after the fact. The cost is state: the scorer must persist per-server snapshots across sessions, and it must refuse to score a server it has no baseline for rather than defaulting to a neutral value. A neutral default is the failure that reintroduces the original problem — an unbaselined server scoring as trustworthy is exactly the schema-conformance-only regime this record argues against. ```python from dataclasses import dataclass, field from typing import Optional class TrustDecayError(RuntimeError): """Raised when a server's structural signals cross the demotion boundary.""" pass @dataclass class ServerBaseline: tool_descriptions: dict[str, str] latency_p50_ms: float latency_p99_ms: float coverage_entropy: float sessions_observed: int = 1 @dataclass class SignalWindow: description_drift: bool = False latency_ratio_excursion: bool = False coverage_entropy_decline: bool = False schema_violation: bool = False fired: list[str] = field(default_factory=list) LATENCY_RATIO_THRESHOLD = 8.0 ENTROPY_DECLINE_THRESHOLD = 0.15 def score_server( baseline: Optional[ServerBaseline], current_descriptions: dict[str, str], current_p50_ms: float, current_p99_ms: float, current_coverage_entropy: float, schema_violated: bool, ) -> SignalWindow: if baseline is None: # Refuse to score without a baseline; a neutral default is the bug. raise TrustDecayError( "no baseline for server; cannot score unbaselined provider" ) window = SignalWindow(schema_violation=schema_violated) for name, desc in current_descriptions.items(): prior = baseline.tool_descriptions.get(name) if prior is not None and prior != desc: window.description_drift = True window.fired.append(f"description_drift:{name}") ratio = current_p99_ms / max(current_p50_ms, 1e-6) baseline_ratio = baseline.latency_p99_ms / max(baseline.latency_p50_ms, 1e-6) if ratio > LATENCY_RATIO_THRESHOLD and ratio > baseline_ratio * 1.5: window.latency_ratio_excursion = True window.fired.append(f"latency_ratio:{ratio:.2f}") if (baseline.coverage_entropy - current_coverage_entropy) > ENTROPY_DECLINE_THRESHOLD: window.coverage_entropy_decline = True window.fired.append( f"coverage_entropy_decline:{baseline.coverage_entropy - current_coverage_entropy:.3f}" ) if schema_violated: raise TrustDecayError( f"schema violation: immediate quarantine; signals={window.fired}" ) structural_hits = sum([ window.description_drift, window.latency_ratio_excursion, window.coverage_entropy_decline, ]) if structural_hits >= 2: raise TrustDecayError( f"demotion boundary crossed with {structural_hits} co-occurring signals: {window.fired}" ) return window ```