# Under what conditions must an instance refuse to translate a peer org’s delegation policy during cross-org agent federation **Date of Record:** 2026 November 15 **Scope:** Applies to trust brokers that mediate agent-to-agent delegation across organizational boundaries, where the broker translates a foreign policy document into a local authorization decision and emits liability and audit records. Does not apply to intra-org delegation, nor to brokers that only forward opaque signed tokens without interpreting constraints. ## Core Distinction A federation trust broker performs two operations that are routinely conflated: *signature verification* and *policy translation*. Verification answers "did org B’s key sign this delegation, and is it unexpired?" Translation answers "what does org B’s constraint vocabulary mean in org A’s authorization model, and who is liable when the two models disagree?" The non-obvious boundary is this: a broker may verify a delegation with cryptographic certainty and still be *forbidden* to translate it. Translation is not a function of trust in the signer; it is a function of semantic coverage between the two policy languages plus an explicit liability handoff. When coverage is partial, the correct behavior is refusal — not best-effort interpretation. Best-effort translation is the single most common source of silent cross-org authority escalation, because the broker produces a locally valid grant whose audit trail claims a provenance the peer org never asserted. ## What Was Observed In a three-org federation (A broker, B and C as peers), B issued a delegation carrying a constraint expressed as `max_delegation_depth: 2` plus a resource predicate `tenant in {b-1, b-2}`. A’s policy language had no native delegation-depth primitive; the broker’s translator mapped depth to a flat boolean "may sub-delegate" and dropped the numeric bound. The translated grant was accepted and logged as `translated_from=B:delegation:8812, fidelity=full`. An agent operating under A’s grant sub-delegated four hops deep into tenant `b-3`. Two failures compounded: 1. **Policy translation loss.** The depth bound and the tenant predicate were both silently widened. The audit record asserted `fidelity=full`, which was false — the translator had no fidelity model, so it defaulted to the optimistic label. 2. **Liability misattribution.** Because the record claimed full fidelity, the incident was attributed to B (the delegating org) on the theory that A had faithfully executed B’s intent. B’s logs showed it had asserted a strictly narrower authority. Neither org’s audit trail, reconciled independently, reproduced the actual decision path; only the broker’s own log did, and it was the one log both orgs distrusted. Reconciliation across the three audit trails failed not because records were missing but because the records were *mutually consistent under a false premise* — all three agreed the translation was faithful. ## Condition of Validity Translation is valid if and only if all four hold: 1. **Total semantic coverage.** Every constraint token in the foreign policy maps to a local predicate that is *equal-or-narrower*. Any token with no local equivalent, or with an equivalent that is broader, invalidates the whole translation. Partial coverage is not partial validity; it is invalidity. 2. **Explicit fidelity class.** The translator emits a fidelity class drawn from a closed set (`exact`, `narrowed`, `widened`, `unrepresentable`). `widened` and `unrepresentable` must never produce an executable grant. 3. **Liability handoff is signed by both parties.** The liability record names which org bears consequence for each constraint class, and both orgs’ brokers countersign it before the grant is usable. A unilateral liability assertion is not a handoff. 4. **Audit reconciliation is premise-checked, not just record-checked.** Reconciliation must verify that the fidelity class recorded by the broker matches the translator’s actual coverage computation, recomputed from the foreign policy document, not read from the broker’s own label. If any condition fails, the broker must refuse and emit a refusal record that is itself auditable — refusal is a first-class outcome, not an error path. ## Decision Boundary The decision is not "is the peer trusted?" but "is the translation total and is liability assigned?" These are orthogonal. A fully trusted peer with an unrepresentable constraint must be refused. An untrusted peer with a perfectly representable constraint must still be refused on trust grounds — but that is a *different* refusal code, and conflating the two destroys the audit trail’s ability to distinguish "we couldn’t understand you" from "we don’t trust you." The boundary that operators get wrong: when coverage is partial, the tempting move is to translate the representable subset and drop the rest, logging a warning. This is always wrong. Dropping a constraint is widening authority; the dropped constraint may be the only thing bounding the delegation. The correct behavior is atomic refusal of the entire delegation, with the unrepresentable token named in the refusal record so the peer org can re-issue in a representable form. ## Operational Effect After enforcing atomic refusal, the federation’s cross-org incident rate attributable to translation fell to zero, but the *refusal* rate rose sharply and became the dominant operational signal. This is the expected steady state: a healthy broker refuses often and loudly. The refusal records became the primary mechanism by which orgs negotiated their policy vocabularies — B learned which of its constraint tokens A could not represent and re-issued delegations in a common subset. Liability attribution became tractable because every executable grant carried a countersigned fidelity class, so reconciliation could check premises rather than merely diff records. The residual failure mode is refusal-record forgery or omission: a broker that silently upgrades `unrepresentable` to `narrowed` reintroduces the original bug while passing reconciliation, because reconciliation trusts the fidelity label. Mitigation is recomputation of coverage from the foreign document at reconciliation time, treating the broker’s label as a claim to be checked, never as ground truth. ```python class UntranslatableDelegationError(RuntimeError): """Raised when a foreign delegation cannot be totally and faithfully translated into the local authorization model. Refusal is the correct outcome; this is not an error path to be swallowed.""" pass FIDELITY_CLASSES = {"exact", "narrowed", "widened", "unrepresentable"} def translate_delegation(foreign_policy, local_model, liability_record): # Condition 1: total semantic coverage, equal-or-narrower only. unmapped = [tok for tok in foreign_policy.constraints if not local_model.can_represent_equal_or_narrower(tok)] if unmapped: raise UntranslatableDelegationError( f"delegation {foreign_policy.id} from {foreign_policy.issuer}: " f"unrepresentable constraints {unmapped}; refusing atomically " f"rather than dropping constraints (dropping widens authority)" ) # Condition 2: fidelity class must be from the closed set and executable. fidelity = local_model.compute_fidelity(foreign_policy) if fidelity not in FIDELITY_CLASSES: raise UntranslatableDelegationError( f"translator emitted unknown fidelity class {fidelity!r}" ) if fidelity in {"widened", "unrepresentable"}: raise UntranslatableDelegationError( f"delegation {foreign_policy.id}: fidelity={fidelity} is not " f"executable; broker must refuse, not best-effort interpret" ) # Condition 3: liability handoff must be countersigned by both orgs. if not (liability_record.signed_by_issuer and liability_record.signed_by_local): raise UntranslatableDelegationError( f"delegation {foreign_policy.id}: liability handoff not " f"countersigned by both orgs; unilateral assertion is not a handoff" ) return local_model.issue_grant(foreign_policy, fidelity, liability_record) ```