What federation authority-limit invariants prevent agents from delegating beyond their reachable authority?
**Date of Record:** 2026 October 27 **Scope:** Applies when agentic sessions operate in a federated environment (multiple organizations, trust domains, or administrative zones) and delegate tasks or credentials to peers, and the delegation must respect the delegator's actual authority boundaries—an agent cannot delegate authority it does not have, nor can it delegate to peers outside its federation reach. Does not apply to strictly single-federation deployments or cases with unlimited delegation rights.
Core Distinction
The separation between **delegation intent** (the agent intends to grant authority) and **delegation validity** (the delegatee is within the delegator's federation reach, and the specific authority being delegated is within the delegator's own scope). Relying on intent creates the **Federation Overreach**: the agent delegates authority to a peer in another federation, believing the peer can act on its behalf, but the peer's federation does not recognize the delegator's authority, and the delegation fails silently (or worse, is interpreted differently in the peer's federation).
What Was Observed
In federated agent architectures, failing to respect authority limits produces three primary failure modes:
- **Cross-Federation Delegation Rejection:** Agent A in federation X delegates to Agent B in federation Y. Federation Y does not recognize X's delegations, so B's actions are rejected as unauthorized. A believes delegation succeeded because Y's agent accepted it locally, causing silent failure of downstream operations.
- **Scope Overreach:** Agent A is authorized to make decisions up to $10k, but delegates to B authority to make decisions up to $100k (or delegates without scope limits). B executes a $50k decision, and the federation audit reveals the delegation exceeded A's authority.
- **Delegation Chain Breakage:** A delegates to B, B delegates to C. Each hop must be verified within the appropriate federation, but if B's federation does not verify A's delegation, C inherits authority that is technically valid in B's view but invalid in A's federation's view.
Recorded Elements
- **`delegator_authority_scope_receipt`:** The cryptographic proof of the delegator's own authority scope, establishing what the delegator can legally delegate.
- **`delegation_federation_reach_receipt`:** The cryptographic proof of which federations recognize the delegator's authority, confirming the delegatee's federation accepts delegations from the delegator.
- **`delegation_scope_bound_receipt`:** The exact scope of the delegated authority (amount, time, actions), which must be a subset of the delegator's own scope.
- **`delegation_chain_validation_signature`:** For multi-hop delegations, the cryptographic proof that each hop's federation accepted the previous hop's delegation, ensuring the chain is valid end-to-end.
Condition of Validity
* **Applies when:** Agents operate across federations, delegate authority to peers, and downstream operations depend on delegated authority being valid. * **Does not apply when:** All agents are in a single federation, or delegations are cryptographically bounded by the delegator's actual scope (no overreach possible).
Decision Boundary
- **Is the delegatee in a different federation than the delegator?** If no, single-federation delegation applies. If yes, proceed.
- **Does the delegatee's federation recognize the delegator's authority (`delegation_federation_reach_receipt`)?** If no, the delegation will fail in the delegatee's federation. Do not proceed.
- **Is the delegated scope a strict subset of the delegator's scope (`delegation_scope_bound_receipt`)?** If no, the delegation exceeds the delegator's authority and is invalid.
- **Conversely, when can an agent delegate without federation validation?** Only when the delegation is strictly intra-federation, or the delegatee verifies the delegation via a root authority that both federations share (e.g., a global PKI).
Operational Effect
- **Cross-Federation Failure Prevention:** Delegations are checked against federation reach before issuance.
- **Scope Overreach Prevention:** Delegated scope is bounded by the delegator's own scope.
- **Chain Validity:** Multi-hop delegations are validated end-to-end, ensuring every hop is recognized by its federation.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json
class DelegationVerdict(Enum):
INTRA_FEDERATION = auto()
CROSS_FEDERATION_VALID = auto()
FEDERATION_NOT_RECOGNIZED = auto()
SCOPE_OVERREACH = auto()
@dataclass(frozen=True)
class DelegationRequest:
delegator_id: str
delegatee_id: str
delegator_federation: str
delegatee_federation: str
delegator_scope: dict
delegated_scope: dict
federation_reach_receipt: str | None
@dataclass(frozen=True)
class DelegationPolicy:
require_reach_for_cross_federation: bool
require_scope_subset: bool
@dataclass(frozen=True)
class DelegationManifest:
verdict: DelegationVerdict
directive: str
manifest_digest: str
class FederationDelegationGuard:
@staticmethod
def _hash(data: str) -> str:
return hashlib.sha256(data.encode("utf-8")).hexdigest()
@classmethod
def evaluate_delegation(
cls, request: DelegationRequest, policy: DelegationPolicy
) -> DelegationManifest:
# Gate 1: Intra-federation
if request.delegator_federation == request.delegatee_federation:
digest = cls._hash(json.dumps({
"delegator": request.delegator_id,
"delegatee": request.delegatee_id,
"federation": request.delegator_federation
}, sort_keys=True))
return DelegationManifest(
verdict=DelegationVerdict.INTRA_FEDERATION,
directive=f"PROCEED: Intra-federation delegation in {request.delegator_federation}.",
manifest_digest=digest
)
# Gate 2: Federation reach
if policy.require_reach_for_cross_federation and not request.federation_reach_receipt:
return DelegationManifest(
verdict=DelegationVerdict.FEDERATION_NOT_RECOGNIZED,
directive=f"HALT: Cross-federation delegation {request.delegator_federation} -> {request.delegatee_federation} lacks reach proof.",
manifest_digest=cls._hash(f"NO_REACH:{request.delegator_id}")
)
# Gate 3: Scope subset check
if policy.require_scope_subset:
for key, value in request.delegated_scope.items():
delegator_value = request.delegator_scope.get(key)
if delegator_value is None:
return DelegationManifest(
verdict=DelegationVerdict.SCOPE_OVERREACH,
directive=f"HALT: Delegated key '{key}' not in delegator's scope.",
manifest_digest=cls._hash(f"KEY:{key}")
)
if isinstance(value, (int, float)) and isinstance(delegator_value, (int, float)):
if value > delegator_value:
return DelegationManifest(
verdict=DelegationVerdict.SCOPE_OVERREACH,
directive=f"HALT: Delegated {key}={value} > delegator's {delegator_value}.",
manifest_digest=cls._hash(f"OVERREACH:{key}")
)
# Gate 4: Valid cross-federation
digest = cls._hash(json.dumps({
"delegator": request.delegator_id,
"delegatee": request.delegatee_id,
"from_fed": request.delegator_federation,
"to_fed": request.delegatee_federation,
"reach": request.federation_reach_receipt,
"scope": request.delegated_scope
}, sort_keys=True))
return DelegationManifest(
verdict=DelegationVerdict.CROSS_FEDERATION_VALID,
directive=f"PROCEED: Cross-federation delegation with reach and scope verified.",
manifest_digest=digest
)