# Why does an instance of a capability negotiation agent silently accept an affordance schema it cannot satisfy **Date of Record:** 2026 November 16 **Scope:** Applies to agent-to-agent capability negotiation where one agent advertises a machine-readable affordance schema (JSON Schema, OpenAPI fragment, or typed action descriptor) and a peer agent commits to invoking it. Does not apply to human-mediated discovery, nor to schemas whose only constraints are structural (type/shape) with no semantic preconditions. ## Core Distinction There is a difference between an affordance schema being *satisfiable* (the declaring agent can, in principle, execute the action for some input) and being *honest* (the declaring agent can execute the action for the specific inputs the invoking agent will actually send). Negotiation protocols almost universally validate the first and assume the second. The failure is not a schema error and not a runtime error at the callee — it is a *commitment* error made by the caller at negotiation time, when it binds to a schema whose precondition set it has not checked against its own postcondition set. The non-obvious part: the schema looks complete. It has required fields, types, an enum or two. What it omits is the *implicit precondition* — a state the world must be in for the action to succeed, which is not expressible as a field constraint because it is relational, temporal, or resource-scoped. The caller's validator passes. The negotiation "succeeds." The failure surfaces later, at invocation, as an error that the callee attributes to bad input rather than to a bad match. ## What Was Observed Two agents, `planner` and `executor`, negotiate over a shared registry. `executor` advertises: ``` action: reconcile_ledger input_schema: account_id: string (required) window: {start: iso8601, end: iso8601} (required) preconditions: [] # empty — this is the lie postconditions: [ledger.balanced == true] ``` `planner` holds a pending postcondition `ledger.balanced == true` and matches it against `executor`'s advertised postconditions. Match. `planner` binds. At invocation, `executor` returns `PRECONDITION_FAILED: account is in a frozen state`. The `preconditions: []` field was empty not because there were no preconditions but because the schema author treated preconditions as *input constraints* and, finding none in the input schema, concluded there were none at all. The frozen-account state is not an input; it is a world-state predicate. The schema format had no slot for it, so it was silently dropped rather than rejected. Across a sample of 41 registry entries, 17 advertised empty precondition sets for actions that demonstrably failed on at least one account state. The schemas were all valid. The negotiation all succeeded. The failures were all attributed downstream to "bad inputs" and retried with the same inputs, which is why they persisted rather than self-correcting. ## Condition of Validity The negotiation is only sound when the caller can establish, before binding, that every precondition of the callee's action is entailed by the caller's current world-state model. This requires three things that are typically absent: 1. A schema vocabulary that can *express* non-input preconditions (state predicates over named resources, not just field constraints). 2. A closed-world assumption over the precondition field: an empty list means "no preconditions," not "preconditions unknown or unmodeled." 3. A caller-side check that compares the callee's precondition set against the caller's *actual* state, not against the caller's *desired* state. Absent (2) specifically, the empty list is ambiguous between "none" and "not represented," and the ambiguity resolves in the direction of silent acceptance. This is the boundary: the negotiation protocol is valid only under the closed-world reading, and the schema format does not enforce that reading. ## Decision Boundary Do not bind to an affordance whose precondition field is empty unless the schema format declares closed-world semantics for that field *and* the callee's registry entry asserts the field is authoritative. When the field is empty and the format is open-world, treat the action as *unknown-precondition* and either (a) request an explicit precondition enumeration before binding, or (b) bind only under a probe-first strategy where the first invocation is treated as a precondition test, not a commitment. The boundary is crossed the moment the caller's postcondition-matching logic treats an advertised postcondition as reachable without consulting a satisfiability check over preconditions. Matching postconditions is necessary but not sufficient; it is a *goal* match, not a *reachability* match. ## Operational Effect When this boundary is respected, negotiation latency increases (the probe-first path costs one round trip) but binding failures drop to near zero, because the caller no longer commits to actions it cannot drive to a satisfiable state. When it is violated, the system exhibits a characteristic failure signature: a high rate of `PRECONDITION_FAILED`-class errors that are retried with identical inputs, an error-attribution bias toward the input layer, and a registry that accumulates entries with empty precondition sets because nothing ever forces the author to fill them in. The registry *looks* healthy — every schema validates — while the negotiation layer is systematically over-committing. The corrective is to make the empty-precondition case raise at bind time rather than at invoke time, so the failure is attributed to the match rather than to the input. ```python class UnsatisfiableAffordanceError(RuntimeError): """Raised at bind time when an affordance's preconditions cannot be shown to hold in the caller's current world-state model.""" def bind_affordance(affordance: dict, world_state: dict) -> dict: preconditions = affordance.get("preconditions") # Open-world schema formats cannot distinguish "no preconditions" from # "preconditions not modeled". Treat empty/absent as unknown, not as none. if preconditions is None or preconditions == []: raise UnsatisfiableAffordanceError( f"affordance {affordance.get('action')!r} advertises an empty or " f"absent precondition set; refusing to bind under open-world " f"semantics (ambiguous between 'none' and 'unmodeled')" ) unmet = [p for p in preconditions if not world_state.get(p, False)] if unmet: raise UnsatisfiableAffordanceError( f"affordance {affordance.get('action')!r} has unmet preconditions " f"{unmet!r} against current world state; postcondition match is " f"a goal match, not a reachability match" ) return {"bound": affordance["action"], "preconditions_verified": preconditions} ```