# In what scenarios must an instance refuse to translate a peer's authorization decision rather than re-evaluate it locally **Date of Record:** 2026 November 15 **Scope:** Applies to federated multi-agent deployments where a brokering agent receives an authorization decision (allow/deny) from a foreign trust domain and must decide whether to forward it, translate it into local policy terms, or re-evaluate the underlying request against its own policy. Does not apply to single-domain policy decision points, nor to cases where the broker is explicitly designated as a policy enforcement point with full request context. ## Core Distinction The failure mode is not "trusting the wrong peer." It is conflating two operations that look identical at the message layer: **decision translation** (mapping a foreign `allow`/`deny` and its obligation set into local vocabulary while preserving the foreign decision's authority) and **decision re-evaluation** (running the request through the local PDP and producing an independent verdict). A broker that re-evaluates when it was only authorized to translate will silently upgrade a foreign `deny` into a local `allow` whenever local policy is more permissive than the peer's — and it will do so without any error, because both paths return a well-formed decision object. The invariant: **a brokered decision carries the authority of its originating domain. If the broker cannot faithfully represent that authority in local terms, it must abstain, not substitute its own judgment.** Re-evaluation is only legitimate when the broker holds the full request context *and* is the designated authority for that resource. When the resource is owned by the peer, re-evaluation is a privilege escalation dressed as policy translation. ## What Was Observed In a three-org federation (Org A resource owner, Org B broker, Org C agent), Org C requested a scoped read on an A-owned artifact. A's PDP returned `deny` with an obligation `reason=classification:restricted` and a delegation constraint limiting the decision's validity to `purpose=incident-response`. Org B's translation layer mapped `classification:restricted` to a local tag it did not recognize, dropped the unmapped obligation, and — because its local policy had no rule for the stripped constraint — fell through to a default-allow. The broker returned `allow` to C. The audit trail at B recorded a translation event, not a re-evaluation, so the discrepancy was invisible until A's logs were reconciled against B's. The non-obvious part: the broker's fallback-to-local-policy was a *documented feature*, intended to handle obligation vocabularies that don't round-trip. It was correct for obligations that merely annotate a decision. It was catastrophic for obligations that *constrain* the decision's scope. The system had no way to distinguish annotating obligations from constraining ones, so the safe fallback (abstain) and the unsafe fallback (re-evaluate) were selected by the same code path. ## Condition of Validity Translation is valid if and only if all of the following hold: 1. The broker is not the authority for the resource in question (the peer owns it). 2. Every obligation attached to the foreign decision either maps to a local obligation with **equal or stricter** semantics, or is classified as non-constraining and may be dropped with a recorded annotation. 3. The foreign decision's delegation constraints (purpose, time window, subject scope) survive translation without widening. 4. The broker's local policy does not *independently* grant the request — if it does, the broker must surface the conflict rather than resolve it silently. If condition 2 or 3 fails, the broker must abstain. If condition 4 fails, the broker must escalate to a conflict-resolution path; it may not pick the more permissive verdict. ## Decision Boundary The boundary is between **obligation stripping** and **constraint stripping**. An obligation is constraining if removing it would widen the set of requests the decision permits. `reason=...` is annotating. `purpose=...`, `max-uses=...`, `not-after=...`, and any delegation-scope predicate are constraining. A broker that cannot classify an obligation must treat it as constraining by default — the fail-safe direction is abstention, never default-allow. Corollary: re-evaluation is permitted only when the broker's request context is byte-identical to what the peer evaluated *and* the broker is a co-authority for the resource. In federation, the second condition almost never holds for foreign-owned resources, which means in practice the broker should re-evaluate only for resources it owns and translate-or-abstain for everything else. ## Operational Effect Brokers that re-evaluate foreign decisions show a characteristic signature: their allow-rate for federated requests exceeds the peer's allow-rate for the same request population, and the gap concentrates on requests with rich obligation sets. The fix is structural — tag every obligation as `annotating` or `constraining` at the policy schema level, make the translator raise on unclassified obligations, and route unclassifiable decisions to abstention with an explicit `translation_incomplete` outcome that the requesting agent can retry against the origin domain. Abstention is a first-class result, not an error. The following reference implementation encodes the invariant as a hard failure: the translator refuses to fall through to local policy for foreign-owned resources and raises when a constraining obligation cannot be faithfully mapped. ```python from dataclasses import dataclass, field from enum import Enum class ObligationKind(Enum): ANNOTATING = "annotating" CONSTRAINING = "constraining" class TranslationRefused(RuntimeError): """Raised when a brokered decision cannot be faithfully translated. Abstention is the correct outcome; the broker must not substitute a local re-evaluation for a foreign decision it cannot represent. """ @dataclass class Obligation: key: str value: str kind: ObligationKind @dataclass class Decision: verdict: str # "allow" | "deny" obligations: list[Obligation] = field(default_factory=list) LOCAL_OBLIGATION_MAP = { "purpose": "purpose", "classification": "data_class", "not-after": "not_after", } def translate_decision( foreign: Decision, *, resource_owner: str, broker_domain: str, local_policy_grants: bool, ) -> Decision: if resource_owner == broker_domain: # Broker is the authority; re-evaluation is legitimate. return foreign if local_policy_grants and foreign.verdict == "deny": raise TranslationRefused( "local policy grants a request the owning domain denied; " "conflict must be escalated, not resolved by the broker" ) translated: list[Obligation] = [] for ob in foreign.obligations: if ob.kind is ObligationKind.ANNOTATING: # Safe to drop; record as annotation only. continue mapped_key = LOCAL_OBLIGATION_MAP.get(ob.key) if mapped_key is None: raise TranslationRefused( f"constraining obligation {ob.key!r} has no local mapping; " "abstain rather than default-allow" ) translated.append(Obligation(mapped_key, ob.value, ob.kind)) return Decision(verdict=foreign.verdict, obligations=translated) def broker(request_decision: Decision, **kwargs) -> Decision: try: return translate_decision(request_decision, **kwargs) except TranslationRefused: # Surface as explicit abstention for the requesting agent to retry # against the origin domain. return Decision(verdict="abstain", obligations=[]) ```