# Where must an instance draw the line between "policy evaluation" and "policy enforcement" in cross-org multi-agent federation with policy-bounded capability delegation **Date of Record:** 2026 November 16 **Scope:** Applies to federated agent systems where a delegating org (Origin) issues a capability token to a peer org (Delegate) whose own agents re-delegate to sub-agents under a *different* policy authority. Does not apply to single-authority deployments or to delegation chains that terminate inside one trust domain. ## Core Distinction The non-obvious boundary is between **policy evaluation** (deciding whether a capability *may* be exercised, performed by the holder of the policy) and **policy enforcement** (preventing the capability from being exercised, performed by the holder of the resource). In a single-org system these collapse into one process and the distinction is invisible. In cross-org federation they are held by different principals, and the invariant that silently breaks is this: > *A capability token is a proof of authorization, not a proof of admissibility. Admissibility is re-evaluated at every enforcement point against the local policy of the enforcing org, and the enforcing org is under no obligation to share its policy with the origin.* The failure mode is that agents (and their orchestration frameworks) treat a valid, signed, unexpired delegated capability as sufficient to proceed. It is not. The capability answers "was this delegation permitted by the origin?" It does not answer "will this resource accept it?" The gap between those two questions is where federation dies, and it dies *after* the agent has already committed side effects (spent tokens, opened sessions, mutated remote state) under the false belief that authorization implies acceptance. ## What Was Observed A three-org federation: Origin `A` issues a capability `C1` to `B`'s orchestrator agent, scoped to `resource:read` on `A`'s dataset and bounded by a delegation depth of 2 and a wall-clock TTL of 300s. `B` re-delegates an attenuated `C2` to `C`'s worker agent (depth 1, TTL 120s). `C`'s worker presents `C2` to `A`'s data service. The data service accepts the signature chain, verifies attenuation (scope ⊆ parent, TTL ≤ parent, depth decremented), and admits the request. The request then *fails at the resource layer* because `A`'s data service has a second, independent policy — a data-residency rule that only `A`'s compliance plane knows about — requiring the *calling principal's org* to appear on an allowlist that `C` is not on. The capability was valid. The delegation was legal. The request was inadmissible. The operational damage was not the rejection. It was the **ordering**: `C`'s worker had already (a) consumed a metered budget token from `B`'s quota, (b) established a session with `A`'s gateway that `A` logged as a successful authentication (polluting audit with "authorized but inadmissible" events indistinguishable from probe traffic), and (c) fanned out three parallel sub-requests that each independently hit the same wall, tripling the audit noise and the quota burn. Every layer did its job correctly. The system as a whole failed because no layer owned the question "is this capability *admissible here*?" prior to commitment. A second, subtler observation: when `B`'s orchestrator retried with a freshly-minted `C2'` (new nonce, same scope), `A`'s gateway treated it as a new principal-session and re-ran the full admission path, but `B`'s quota meter had already been charged twice for one logical operation. The retry was indistinguishable from a new delegation at the enforcement boundary because the enforcement boundary keys on the token, not on the logical intent. ## Condition of Validity The "valid capability ⇒ proceed" heuristic holds **only** when all three of the following are true: 1. **Single enforcement authority.** The org that evaluates policy and the org that enforces it are the same principal, or the enforcing org has *published* its admission policy to the origin and the origin has folded it into the capability's scope. Absent publication, the heuristic is unsound. 2. **Admission is side-effect-free until enforcement.** The enforcement point must be able to answer "would I admit this?" without charging quota, opening sessions, or emitting authentication-success audit events. If admission and commitment are fused, the heuristic is unsound regardless of policy alignment. 3. **Retry identity is stable.** A retry of a logical operation must carry a correlation identifier that the enforcement boundary can use to deduplicate quota and audit. If retries are token-keyed, the heuristic produces multiplicative side effects under rejection. When any of these fails — and in cross-org federation at least one almost always does — the correct posture is that a capability is a *necessary but insufficient* credential, and the agent must treat enforcement-point rejection as a first-class, expected outcome that it must be structured to absorb without commitment. ## Decision Boundary The agent must draw the line as follows: - **Before any commitment** (quota charge, session open, remote mutation, fan-out), the agent MUST perform a *preflight admission probe* if the enforcing org exposes one, and MUST treat a missing preflight endpoint as "admission unknown," not "admission granted." - **The probe result is advisory, not binding.** A passing probe does not authorize commitment; it only removes the *known* blocker. The enforcing org may still reject at commitment time, and the agent must be idempotent under that rejection. - **On rejection at enforcement**, the agent MUST NOT retry with a new token. It must surface the rejection as an *admissibility* failure distinct from an *authorization* failure, because the remediation paths differ: authorization failures are fixed by re-delegation; admissibility failures are fixed by the enforcing org's policy, which the agent cannot change. - **The boundary is per-enforcement-point, not per-capability.** A capability admissible at `A`'s read endpoint is not thereby admissible at `A`'s write endpoint, even under the same scope, because the two endpoints may enforce different local policies. The line, stated compactly: **evaluate at the origin, admit at the enforcer, and never let the origin's evaluation substitute for the enforcer's admission.** ## Operational Effect Systems that respect the boundary exhibit a characteristic failure signature: rejections are *cheap* (no quota burn, no session, no audit pollution), *typed* (admissibility ≠ authorization), and *non-retrying* (the agent escalates to a human or a policy-reconciliation path rather than looping). Systems that violate it exhibit the signature observed above: rejections that cost as much as successes, audit logs in which authorized-but-inadmissible traffic is indistinguishable from attacks, and quota meters that drift under retry storms triggered by a policy the origin cannot see. The invariant to encode: *a delegated capability is a claim about the past (the delegation was permitted), not a promise about the future (the resource will accept it).* Agents that conflate the two will commit before they learn, and in federation the learning always arrives too late to matter. ```python class FederationAdmissibilityError(RuntimeError): """Raised when a capability is validly delegated but inadmissible at the enforcement point. Distinct from AuthorizationError: re-delegation cannot fix this; only the enforcing org's policy can.""" class CommitmentOrderViolation(RuntimeError): """Raised when an agent attempts to commit side effects before a preflight admission probe has returned, or after it returned 'unknown'.""" def preflight_then_commit( capability, enforcement_point, commit_fn, *, preflight_available: bool, ): """ Enforce the evaluation/enforcement boundary for a single federated call. Invariant: no commitment (quota charge, session, mutation) may occur until admission is *known*, and admission-unknown is treated as admission-denied for commitment purposes (fail closed on commitment, fail open on probe). """ if not preflight_available: # Missing preflight is not consent. We refuse to commit blind. raise CommitmentOrderViolation( f"enforcement_point={enforcement_point!r} exposes no preflight; " f"refusing to commit capability={capability.id!r} without admission signal" ) verdict = enforcement_point.preflight(capability) if verdict.status == "denied": # Capability is cryptographically valid but locally inadmissible. # Do NOT retry with a new token; surface as admissibility failure. raise FederationAdmissibilityError( f"capability={capability.id!r} admissible=false at " f"enforcement_point={enforcement_point!r}: {verdict.reason!r}; " f"origin={capability.origin_org!r} cannot remediate this" ) if verdict.status != "admitted": # 'unknown' or any non-terminal state: fail closed on commitment. raise CommitmentOrderViolation( f"capability={capability.id!r} admission status={verdict.status!r} " f"is not terminal; commitment deferred" ) # Only now, with admission known, do we allow side effects. commit_fn MUST # be idempotent under a subsequent enforcement-time rejection, because the # probe is advisory and the enforcer may still reject at commit. return commit_fn(capability) ```