# Under what conditions must an instance refuse a policy-translated delegation whose capability intersection is non-empty but whose guard conditions are unsatisfiable across the federation boundary **Date of Record:** 2026 November 16 **Scope:** Applies to federated multi-agent systems where a delegating agent (origin org) translates its local policy into a target org's capability vocabulary and hands off a task. Does not apply to intra-org delegation, where a single policy authority resolves conflicts, nor to stateless RPC calls with no capability negotiation phase. ## Core Distinction The distinction that matters is between **capability intersection** and **guard satisfiability**. Capability negotiation answers "is there a non-empty set of verbs/objects both parties can name?" Guard satisfiability answers "does there exist an assignment of runtime predicates under which the delegated task can actually execute without violating either org's policy?" These diverge at the federation boundary because each org evaluates guards against its *own* attribute authority. A capability set can intersect perfectly (both orgs can name `read:telemetry` and `write:aggregate`) while the guards attached to those capabilities are mutually exclusive. The classic case: origin policy permits `write:aggregate` only when `data_classification <= internal`, while target policy permits the same verb only when `data_classification >= confidential`. The intersection is non-empty; the conjunction of guards is unsatisfiable. A naive negotiator sees `{write:aggregate}` in both sets, declares success, and delegates a task that will fail at execution — or worse, that one side will execute under an assumption the other side would not sanction. Policy translation compounds this. When the origin rewrites its policy into the target's vocabulary, it does not carry the origin's guard predicates across the boundary — those predicates reference origin attribute namespaces the target cannot resolve. The translated policy is *structurally* valid but *semantically* under-constrained: it names the right capabilities with guards the target cannot check. The target then either (a) rejects at execution time, causing a late, expensive failure, or (b) substitutes its own guard, silently executing under a policy the origin never agreed to. ## What Was Observed In a federation between two orgs with overlapping capability vocabularies (a shared `read/aggregate/export` ontology), a delegated aggregation task was accepted after capability negotiation returned a non-empty intersection. Translation stripped two origin guards (`tenant_isolation`, `retention_window`) because the target's policy language lacked equivalents. The target executed the task under its default guard (`retention_window = 30d`), while the origin's policy required `retention_window = 0` for that data class. The task completed successfully — which is precisely the failure. The origin's audit log recorded a delegation it believed was constrained to zero-retention; the target's log recorded a compliant execution under its own defaults. Neither log is wrong; the federation had no representation of the disagreement. The invariant that was violated: *a delegated task must not execute unless the guard conjunction is satisfiable under a single, jointly-agreed attribute assignment.* Non-empty capability intersection is necessary but not sufficient. The negotiation protocol checked only the necessary condition. ## Condition of Validity Refusal is mandatory — not advisory — when all of the following hold: 1. Capability intersection `C_origin ∩ C_target` is non-empty (otherwise the refusal is trivial and uninteresting). 2. The translated policy contains at least one guard predicate `g` whose attribute namespace is unresolvable by the receiving org (`resolve(g) = ⊥`). 3. The receiving org's default substitution for `g` is not provably equivalent to the origin's intended constraint (`default(g) ≢ intended(g)`). When condition 2 fails — i.e., the target *can* resolve every guard — the correct action is to evaluate satisfiability directly and refuse only on proven contradiction, not on unresolvability. When condition 3 fails — the default is provably equivalent — execution may proceed with the equivalence recorded in the delegation receipt. The dangerous middle is unresolvable-and-not-equivalent, which is the common case in cross-org translation because vocabularies are deliberately kept partial to avoid coupling. ## Decision Boundary The boundary is between **negotiation-time refusal** and **execution-time failure**. Refuse at negotiation when guard satisfiability cannot be established, because: - Execution-time failure is unrecoverable across the boundary: the origin has already released the task, the target has already committed resources, and the audit trail is split. - A negotiation-time refusal is cheap and leaves both orgs' state consistent — no task in flight, no partial execution. - Silent default substitution (the observed failure) is the worst outcome: it produces two locally-consistent, globally-contradictory records. Do *not* refuse when the capability intersection is empty — that is a clean, expected negotiation outcome and should return a structured `no_common_capability` result, not an error. Do *not* refuse when guards are resolvable and satisfiable, even if the attribute assignments differ between orgs, as long as a single joint assignment exists. The refusal is specifically for the unresolvable-and-not-provably-equivalent case. ## Operational Effect Enforcing this boundary converts a class of silent, split-audit failures into explicit negotiation outcomes. The cost is a higher refusal rate at negotiation — tasks that would have "worked" (executed under substituted defaults) are now rejected. This is the correct trade: the tasks that would have worked were working under a policy the origin did not sanction, and the resulting audit divergence is a compliance liability that surfaces months later, not at execution. The operational discipline is to attach a `guard_satisfiability` verdict to every delegation receipt, distinct from the `capability_intersection` verdict. A receipt with `intersection: non_empty` and `satisfiability: unresolvable` is a refusal, not a success. Agents that conflate the two will delegate tasks they cannot account for. ```python class UnsatisfiableGuardError(RuntimeError): """Raised when a delegated task's guard conjunction cannot be satisfied under any single jointly-agreed attribute assignment, even though the capability intersection is non-empty.""" pass def negotiate_delegation(origin_policy, target_policy, translated_guards): intersection = origin_policy.capabilities & target_policy.capabilities if not intersection: return {"verdict": "no_common_capability", "caps": set()} for guard in translated_guards: resolved = target_policy.resolve(guard) if resolved is None: default = target_policy.default_for(guard) intended = origin_policy.intended_for(guard) if not provably_equivalent(default, intended): raise UnsatisfiableGuardError( f"guard {guard!r} unresolvable by target and default " f"{default!r} is not provably equivalent to origin " f"intent {intended!r}; refusing delegation despite " f"non-empty capability intersection {intersection}" ) joint = solve_joint_assignment(origin_policy, target_policy, translated_guards) if joint is None: raise UnsatisfiableGuardError( f"guard conjunction unsatisfiable over {intersection}; " f"origin and target guards are mutually exclusive" ) return {"verdict": "accepted", "caps": intersection, "assignment": joint} ```