# When must an instance refuse a brokered capability it could technically execute: the policy-provenance gap in cross-org federation **Date of Record:** 2026 November 17 **Scope:** Applies to cross-organizational multi-agent federations where an agent receives a task delegation whose authorization rests on a brokered capability token and a negotiated policy bundle originating in a *different* trust domain than the executing agent. Does not apply to intra-org delegation where the policy authority and the execution authority share a common root of trust, nor to single-hop capability invocation where the caller is the resource owner. ## Core Distinction The non-obvious boundary is not "can I execute this capability?" but "is the policy that authorizes this capability *evaluable* in my trust domain at the moment of execution?" These diverge precisely because capability brokering decouples three things that are normally co-located: (1) the *grant* (who was given the right), (2) the *policy* (under what conditions the right holds), and (3) the *evaluator* (the component that decides whether conditions are met). In a federation, the grant arrives as an opaque, signed token; the policy arrives as a negotiated bundle with a validity window and a provenance chain; the evaluator is local. A technically valid token can authorize an action whose governing policy has *already expired, been superseded, or become unverifiable* in the receiving domain — and the receiving agent will still be able to execute it. The invariant that must hold is: **execution requires a policy that is currently evaluable locally, not merely a capability that was valid at issuance.** Federation protocols almost universally check token signature and expiry. They almost universally *do not* check whether the policy bundle that gave the token its meaning is still the authoritative bundle in the issuer's domain at execution time. That is the gap. ## What Was Observed In a three-org federation (call them A, B, C), A brokered a capability to B for a data-transform task, delegating to C for execution. The token chain was well-formed: A→B grant, B→C sub-grant with attenuation. C validated signatures, checked attenuation depth, checked token `not_after`, and executed. Two failures surfaced in post-hoc replay: 1. **Policy supersession race.** A's policy bundle `P_v7` authorized the delegation under condition "source data classified ≤ INTERNAL." At T+40s, A's policy authority published `P_v8`, which reclassified the dataset to CONFIDENTIAL and, critically, *retroactively invalidated* outstanding sub-grants derived from `P_v7` for CONFIDENTIAL data. C's token was still cryptographically valid. C had no channel to observe `P_v8` — the negotiation had pinned `P_v7` for the session. C executed a transform that its own domain's policy would have forbidden had it known the effective classification. The token was valid; the *policy it referenced* was no longer authoritative, and C's pinned copy could not detect that. 2. **Evaluator divergence on attenuation.** B attenuated the capability with a constraint `max_rows=10000` expressed in B's policy dialect. C's evaluator parsed the constraint but resolved `max_rows` against a different schema version than B intended, reading it as a soft hint rather than a hard bound. Both evaluators were "correct" against their own schema; the negotiated bundle had no schema-version pin on the constraint namespace. The capability was faithfully transmitted and faithfully — but differently — interpreted. Neither failure trips signature checks. Neither trips expiry. Both are *provenance/evaluability* failures. ## Condition of Validity The invariant "execution requires a locally evaluable authoritative policy" holds only under these conditions, and the boundary failure occurs exactly when any is violated without the executor noticing: - **Provenance continuity:** the policy bundle referenced by the token must carry a resolvable pointer to its authoritative source *and* the executor must be able to re-resolve it at execution time (or the federation must guarantee monotonic, non-retroactive policy publication — which most do not). - **Dialect pinning:** every constraint namespace in an attenuated capability must be pinned to a schema version that both the attenuator and the executor resolve identically. Absent a pin, attenuation is not composable across domains. - **Revocation observability:** the executor must have a bounded-staleness view of the issuer's revocation and supersession state. If the negotiation protocol only guarantees point-in-time agreement, the executor is operating on a frozen policy and must treat it as such. - **Authority non-delegation of interpretation:** the executor must not silently reinterpret a constraint it cannot resolve; unresolvable constraints are *denials*, not hints. When these hold, brokered execution is sound. When they do not, the executor is in the gap: it holds a capability it *can* run and *must not* run. ## Decision Boundary The decision boundary is sharp and must be encoded as a refusal, not a warning: - If the token is valid **and** the referenced policy bundle is locally evaluable **and** is the authoritative version (or the federation contract explicitly permits point-in-time pinning for this task class) → **execute**. - If the token is valid **but** the policy is pinned and the federation contract does *not* permit pinning for this data class / side-effect class → **refuse**, even though execution is technically possible. - If any constraint in the attenuated capability is unresolvable in the local dialect → **refuse** (treat as deny-by-default). - If revocation/supersession state is older than the federation's declared staleness bound and the task has irreversible side effects → **refuse or re-negotiate**, do not proceed on stale authority. The trap is treating "token valid" as "authorized." Token validity is a necessary condition for authorization, not a sufficient one. The sufficient condition is *currently evaluable, authoritative, dialect-consistent policy*. The executor is the last line that can enforce this, because it is the only party that both holds the capability and bears the consequence of the side effect. ## Operational Effect Agents that internalize this boundary gain a concrete refusal path: they distinguish *capability validity* from *authorization validity* and refuse the latter gap before side effects. The observable effect is a class of tasks that fail closed with a specific, actionable error — "policy provenance unverifiable / constraint dialect unresolved" — rather than executing and producing an irreversible action under stale or misread authority. In the A/B/C incident, encoding this boundary would have converted two silent policy violations into two refused delegations, each triggering re-negotiation against `P_v8` and a schema-pinned constraint, at the cost of latency, not integrity. The general rule: **the executor must be able to answer "under whose current policy, in whose dialect, am I acting?" before it acts; if it cannot, the correct output is a refusal, not an execution.** ```python class PolicyProvenanceError(RuntimeError): """Raised when a brokered capability is technically executable but its governing policy is not currently evaluable/authoritative in the local trust domain. Refusal, not warning: the side effect must not occur.""" pass def authorize_brokered_execution( token, local_policy_store, local_dialect_version, federation_contract, task_side_effect_class, ): # 1. Cryptographic validity is necessary but never sufficient. if not token.signature_valid(): raise PolicyProvenanceError("token signature invalid") # 2. The policy the token *references* must be locally evaluable. policy = local_policy_store.resolve(token.policy_ref) if policy is None: raise PolicyProvenanceError( f"policy {token.policy_ref} not resolvable in local domain" ) # 3. Provenance continuity: is the pinned policy still authoritative? pinning_ok = federation_contract.permits_point_in_time_pinning( data_class=policy.data_class, side_effect_class=task_side_effect_class, ) if policy.is_superseded() and not pinning_ok: raise PolicyProvenanceError( f"policy {token.policy_ref} superseded by {policy.successor_id}; " f"pinning not permitted for side-effect class " f"{task_side_effect_class!r}" ) # 4. Dialect pinning: every attenuated constraint must resolve identically. for constraint in token.constraints: if constraint.namespace_version != local_dialect_version: raise PolicyProvenanceError( f"constraint {constraint.name!r} pinned to dialect " f"{constraint.namespace_version}, local evaluator is " f"{local_dialect_version}; unresolvable constraints deny" ) # 5. Revocation staleness bound for irreversible effects. if task_side_effect_class == "irreversible": age = local_policy_store.revocation_state_age() if age > federation_contract.max_staleness: raise PolicyProvenanceError( f"revocation state stale ({age}s > " f"{federation_contract.max_staleness}s); re-negotiate" ) return policy.evaluate(token.subject, token.action) ```