How must an instance handle time-bound jurisdictional constraints that conflict across regions?
**Date of Record:** 2026 October 27 **Scope:** Applies when an agentic session operates across multiple jurisdictions with time-bound regulatory constraints (data retention minimums in one region, deletion mandates in another, or processing windows), and the constraints conflict such that satisfying one violates the other. Does not apply to single-jurisdiction sessions or jurisdictions with harmonized regulations.
Core Distinction
The separation between **per-jurisdiction compliance** (each region's rules satisfied independently) and **cross-jurisdiction conflict resolution** (a deterministic policy for cases where rules conflict). Relying on per-jurisdiction compliance creates the **Jurisdictional Time-Collapse**: the agent applies the most permissive constraint by default (to avoid blocking operations), silently violating the stricter jurisdiction, or alternates between constraints based on which region handles the request, producing inconsistent compliance across the same logical operation.
What Was Observed
In cross-regional agent architectures, failing to resolve time-bound conflicts produces three primary failure modes:
- **Retention vs. Deletion Conflict:** EU requires deleting user data after 90 days (GDPR minimization), while a US financial regulation requires 7-year retention. The agent alternately deletes or retains based on which region serves the request, producing inconsistent records.
- **Processing Window Conflict:** One jurisdiction permits data processing only during business hours; another requires 24/7 availability for critical services. The agent's availability policy violates one or the other depending on customer region.
- **Notification Timing Conflict:** One jurisdiction requires breach notification within 24 hours; another permits 72 hours. The agent's notification timing depends on which region detects the breach, violating the stricter jurisdiction's requirement for global breaches.
Recorded Elements
- **`jurisdictional_constraint_matrix`:** The explicit matrix of constraints per jurisdiction, with cryptographic proof of each constraint's authoritative source (regulation ID, effective date, and applicable scope).
- **`conflict_resolution_policy_signature`:** The cryptographic signature of the policy that resolves conflicts (e.g., "most restrictive wins" or "explicit override for critical services"), signed by an authority authorized to make this choice.
- **`applied_constraint_receipt`:** For each operation, the cryptographic proof of which constraint was applied and why, allowing audit of the resolution decision.
- **`conflict_log_receipt`:** When a conflict is detected, the cryptographic record of the conflict, its resolution, and the specific regulation citations that were in tension.
Condition of Validity
* **Applies when:** The session operates across jurisdictions with potentially conflicting time-bound constraints, and the constraints affect the same logical operations. * **Does not apply when:** The session operates in a single jurisdiction, or the jurisdictions have harmonized constraints (e.g., mutual recognition agreements eliminate conflicts).
Decision Boundary
- **Does the session operate across multiple jurisdictions with time-bound constraints?** If no, standard compliance applies. If yes, proceed.
- **Is a `conflict_resolution_policy_signature` defined?** If no, the agent cannot deterministically resolve conflicts. It must fail closed and escalate to legal review.
- **Does the current operation trigger a conflict?** If yes, apply the conflict resolution policy and record the `applied_constraint_receipt`.
- **Conversely, when can the agent act without explicit conflict resolution?** Only when the constraints do not conflict (the operation is compliant under all applicable jurisdictions simultaneously), or the operation is explicitly exempt from one or more constraints under a documented legal basis.
Operational Effect
- **Deterministic Compliance:** Provides a uniform rule for conflict resolution, eliminating region-dependent compliance drift.
- **Audit Clarity:** Preserves the exact conflict resolution for every operation, enabling regulatory audit.
- **Fail-Closed Default:** When no resolution policy exists, the agent escalates rather than guessing.
from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json
class ConflictVerdict(Enum):
NO_CONFLICT = auto()
RESOLVED_BY_POLICY = auto()
ESCALATED_NO_POLICY = auto()
@dataclass(frozen=True)
class JurisdictionalConstraint:
jurisdiction: str
constraint_type: str # "RETENTION_MIN", "RETENTION_MAX", "PROCESSING_WINDOW", "NOTIFICATION_DEADLINE"
constraint_value: float
regulation_citation: str
@dataclass(frozen=True)
class ConflictResolutionContext:
constraints: tuple[JurisdictionalConstraint, ...]
conflict_policy_signature: str | None
policy_strategy: str | None # "MOST_RESTRICTIVE" | "EXPLICIT_OVERRIDE"
@dataclass(frozen=True)
class ConflictManifest:
verdict: ConflictVerdict
applied_constraint: JurisdictionalConstraint | None
directive: str
manifest_digest: str
class JurisdictionalConflictGuard:
@staticmethod
def _hash(data: str) -> str:
return hashlib.sha256(data.encode("utf-8")).hexdigest()
@classmethod
def evaluate_constraints(
cls, ctx: ConflictResolutionContext
) -> ConflictManifest:
if not ctx.constraints:
raise ValueError("At least one constraint required.")
# Gate 1: Group by type
by_type: dict[str, list[JurisdictionalConstraint]] = {}
for c in ctx.constraints:
by_type.setdefault(c.constraint_type, []).append(c)
# Gate 2: Detect conflict within any type
conflicts_detected = False
for ctype, cgroup in by_type.items():
if len(cgroup) <= 1:
continue
if ctype == "RETENTION_MIN" and len({c.constraint_value for c in cgroup}) > 1:
conflicts_detected = True
elif ctype == "RETENTION_MAX" and len({c.constraint_value for c in cgroup}) > 1:
conflicts_detected = True
elif ctype in ("PROCESSING_WINDOW", "NOTIFICATION_DEADLINE") and len({c.constraint_value for c in cgroup}) > 1:
conflicts_detected = True
# Gate 3: No conflict
if not conflicts_detected:
digest = cls._hash(json.dumps({
"constraints": tuple(
{"type": c.constraint_type, "value": str(c.constraint_value), "jur": c.jurisdiction}
for c in ctx.constraints
)
}, sort_keys=True))
return ConflictManifest(
verdict=ConflictVerdict.NO_CONFLICT,
applied_constraint=None,
directive="PROCEED: All constraints compatible.",
manifest_digest=digest
)
# Gate 4: Conflict but no policy
if not ctx.conflict_policy_signature or not ctx.policy_strategy:
return ConflictManifest(
verdict=ConflictVerdict.ESCALATED_NO_POLICY,
applied_constraint=None,
directive="HALT: Conflict detected but no resolution policy. Escalate to legal.",
manifest_digest=cls._hash("NO_POLICY")
)
# Gate 5: Apply policy - most restrictive
if ctx.policy_strategy == "MOST_RESTRICTIVE":
applied = None
for ctype, cgroup in by_type.items():
if ctype == "RETENTION_MIN":
applied = max(cgroup, key=lambda c: c.constraint_value)
elif ctype == "RETENTION_MAX":
applied = min(cgroup, key=lambda c: c.constraint_value)
elif ctype in ("PROCESSING_WINDOW", "NOTIFICATION_DEADLINE"):
applied = min(cgroup, key=lambda c: c.constraint_value)
if applied:
break
if applied:
digest = cls._hash(json.dumps({
"strategy": "MOST_RESTRICTIVE",
"applied": applied.jurisdiction,
"value": str(applied.constraint_value),
"citation": applied.regulation_citation
}, sort_keys=True))
return ConflictManifest(
verdict=ConflictVerdict.RESOLVED_BY_POLICY,
applied_constraint=applied,
directive=f"PROCEED: Applied most restrictive ({applied.jurisdiction}, {applied.constraint_value}).",
manifest_digest=digest
)
# Gate 6: Fallback
return ConflictManifest(
verdict=ConflictVerdict.ESCALATED_NO_POLICY,
applied_constraint=None,
directive=f"HALT: Policy strategy {ctx.policy_strategy} unresolved. Escalate.",
manifest_digest=cls._hash(f"UNRESOLVED:{ctx.policy_strategy}")
)