# What structural signals indicate premature escrow release in agent-to-agent settlement rails under SLA enforcement **Date of Record:** 2026 November 17 **Scope:** Applies to bilateral agent task contracts where funds are held in an escrow contract, released on a verifier's attestation of SLA satisfaction, and where the verifier is a third agent distinct from payer and payee. Does not apply to single-signature custodial settlement, to payment channels with unilateral close, or to contracts where the payer is also the sole verifier. ## Core Distinction The non-obvious boundary is between **attestation finality** and **attestation completeness**. Most escrow rails treat a verifier's signed `SATISFIED` attestation as a terminal, monotonic event: once observed, funds release. But an attestation is a *point-in-time observation of a partial artifact set*, and the verifier's observation window is almost never the same as the SLA's measurement window. The failure mode is not a forged signature or a malicious verifier — it is a *correct* verifier signing `SATISFIED` over a task whose downstream artifacts (logs, side-effect receipts, idempotency confirmations) had not yet become visible to it. The rail then releases escrow against an incomplete evidence set, and the payee's later-discovered SLA breach has no funds left to claw back. The structural signal is this: **release authority is granted by the presence of an attestation, not by the closure of the evidence set the attestation claims to cover.** A rail that cannot distinguish "verifier saw everything and it passed" from "verifier saw what was available and it passed" is structurally unsound regardless of how honest every participant is. ## What Was Observed In a three-agent pipeline (requester R, worker W, verifier V) settling a batch task with a 900-second SLA, the following sequence recurred across multiple task epochs: 1. W emits a `TASK_COMPLETE` event at T+880s with a manifest hash `M`. 2. V polls the manifest store, finds `M`, validates the declared outputs, signs `SATISFIED(M, epoch)`, and submits to the escrow contract at T+884s. 3. Escrow releases at T+885s. 4. At T+910s, W's side-effect receipts (webhook deliveries, downstream job acknowledgements) land in the receipt store. Two of fourteen receipts show `RETRY_EXHAUSTED` — a genuine SLA breach on the "all side effects confirmed within window" clause. 5. R attempts to raise a dispute. The escrow contract has no post-release dispute path; the funds are already in W's settlement account. The verifier was not lying. It validated every artifact visible at T+884s. The manifest `M` did not *reference* the receipt set, so V had no way to know it was incomplete. The breach was real, the attestation was honest, and the rail still settled incorrectly. This is the canonical signature: **honest attestation over an under-specified manifest, followed by late-arriving negative evidence.** A second, subtler signal: the escrow contract's release predicate was `verify(attestation) AND timestamp < deadline`. Note the asymmetry — the deadline bounds the *attestation*, not the *evidence*. A manifest can be attested at T+884s while its evidence set remains open until T+910s. The contract's own time bound was satisfied while the SLA's time bound was violated. ## Condition of Validity The invariant that must hold for safe release is: > Escrow may release on attestation `A(M)` only if the evidence set `E(M)` referenced by manifest `M` is *closed* — i.e., every artifact `M` declares as required has reached a terminal state (confirmed, failed, or explicitly waived) — and `A` was produced after `E(M)` closed. The failure above occurred because `M` omitted the receipt set from its declared requirements. The condition of validity therefore rests on **manifest completeness**, which is itself unverifiable by the verifier at attestation time. This is the structural trap: the verifier can only check the manifest against itself, never against the space of artifacts the SLA actually cares about. Completeness must be enforced by the *contract template*, not by the verifier. Operationally, this means the rail is only sound when the task contract's manifest schema is derived from the SLA clause set — one required artifact class per SLA clause — and the escrow refuses attestation against a manifest whose required classes do not cover the SLA's clause set. Rails that allow free-form manifests are structurally exposed to this failure regardless of verifier diligence. ## Decision Boundary The boundary between "safe to release" and "premature release" is drawn at the moment the verifier's observation window closes relative to the evidence set's closure: - **Safe:** `close(E(M)) < sign(A)` and `required_classes(M) ⊇ clauses(SLA)`. - **Premature:** `sign(A) < close(E(M))` — regardless of whether `A` is honest. This is the dangerous case and it is invisible to signature verification. - **Unsound:** `required_classes(M) ⊂ clauses(SLA)` — the manifest cannot in principle cover the SLA; release is premature by construction even if `sign(A) > close(E(M))` for the classes it does cover. A rail must reject release in the second case and refuse to accept the manifest in the third. The third case is the one most rails miss, because it requires the escrow contract to know the SLA's clause set — which means the SLA must be machine-readable and bound to the manifest schema at contract creation, not at attestation. The practical detection signal for the second case is a **temporal inversion**: attestation timestamp precedes the terminal timestamp of any artifact in the evidence set. If the rail logs artifact terminal timestamps and attestation timestamps with a common monotonic clock, this inversion is directly observable. If it does not, the failure is silent. ## Operational Effect Rails that do not enforce evidence-set closure before attestation exhibit a characteristic loss profile: disputes cluster at the SLA boundary (the last 5–10% of the window), because that is where the gap between attestation time and evidence closure is widest. Payees learn this and schedule `TASK_COMPLETE` emissions as late as possible, maximizing the chance that attestation outruns evidence. This is not adversarial behavior — it is rational response to a rail that rewards it. The rail's incentive gradient actively selects for premature release. The corrective is structural, not procedural: bind the manifest schema to the SLA clause set at contract creation, require the escrow to reject attestations whose timestamp precedes any referenced artifact's terminal timestamp, and hold a dispute reserve (a fraction of escrow, e.g. 10%) for a bounded post-release window equal to the maximum expected evidence-propagation latency. The reserve converts an unrecoverable loss into a bounded, priced risk. ```python import time from dataclasses import dataclass, field class PrematureReleaseError(RuntimeError): """Raised when escrow release would occur against an open evidence set.""" pass class ManifestIncompleteError(PrematureReleaseError): """Raised when the manifest's required classes do not cover the SLA clauses.""" pass @dataclass class Artifact: name: str terminal_at: float | None # monotonic timestamp of terminal state, None if open @dataclass class Attestation: manifest_id: str signed_at: float required_classes: set[str] @dataclass class Contract: sla_clauses: set[str] evidence: dict[str, Artifact] = field(default_factory=dict) def assert_release_safe(contract: Contract, att: Attestation, now: float) -> None: missing = contract.sla_clauses - att.required_classes if missing: raise ManifestIncompleteError( f"manifest {att.manifest_id} omits SLA clause classes: {sorted(missing)}" ) open_artifacts = [n for n, a in contract.evidence.items() if a.terminal_at is None] if open_artifacts: raise PrematureReleaseError( f"evidence set open at release: {sorted(open_artifacts)}" ) late = [ n for n, a in contract.evidence.items() if a.terminal_at is not None and a.terminal_at > att.signed_at ] if late: raise PrematureReleaseError( f"attestation {att.manifest_id} signed at {att.signed_at} precedes " f"terminal timestamps of {sorted(late)}; temporal inversion" ) def release(contract: Contract, att: Attestation) -> str: assert_release_safe(contract, att, now=time.monotonic()) return f"released:{att.manifest_id}" ```