Paper deep dive
Atomic Decision Boundaries: A Structural Requirement for Guaranteeing Execution-Time Admissibility in Autonomous Systems
Marcelo Fernandez
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 98%
Last extracted: 4/26/2026, 4:25:00 PM
Summary
The paper introduces the concept of the 'atomic decision boundary' to address the structural failure of split evaluation systems in autonomous systems. It formalizes execution as a Labeled Transition System (LTS) and proves that systems where decision-making and state transitions are separate (split systems) cannot guarantee execution-time admissibility in concurrent environments. The author introduces a three-valued decision domain (Allow, Refuse, Escalate) and demonstrates that the 'Escalate' outcome requires its own atomic resolution to maintain safety. The paper provides a structural taxonomy, classifying existing mechanisms like RBAC, ABAC, OPA, and AWS IAM as split systems, while proposing the Agent Control Protocol (ACP) as an atomic alternative.
Entities (10)
Relation Signals (7)
RBAC → isclassifiedas → Split Evaluation System
confidence 100% · We classify RBAC, ABAC, OPA, Cedar, and AWS IAM as split systems
ABAC → isclassifiedas → Split Evaluation System
confidence 100% · We classify RBAC, ABAC, OPA, Cedar, and AWS IAM as split systems
OPA → isclassifiedas → Split Evaluation System
confidence 100% · We classify RBAC, ABAC, OPA, Cedar, and AWS IAM as split systems
Cedar → isclassifiedas → Split Evaluation System
confidence 100% · We classify RBAC, ABAC, OPA, Cedar, and AWS IAM as split systems
AWS IAM → isclassifiedas → Split Evaluation System
confidence 100% · We classify RBAC, ABAC, OPA, Cedar, and AWS IAM as split systems
ACP → isclassifiedas → Atomic System
confidence 100% · and ACP as atomic, providing a structural taxonomy of existing governance mechanisms.
Atomic Decision Boundary → isrequiredfor → Execution-Time Admissibility
confidence 100% · Atomic Decision Boundaries: A Structural Requirement for Guaranteeing Execution-Time Admissibility in Autonomous Systems
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Autonomous systems increasingly execute actions that directly modify shared state, creating an urgent need for precise control over which transitions are permitted to occur. Existing governance mechanisms evaluate policies prior to execution or reconstruct behavior post hoc, but do not enforce admissibility at the exact moment a state transition is committed. We introduce the atomic decision boundary, a structural property of admission control systems in which the decision and the resulting state transition are jointly determined as a single indivisible step in the labeled transition system (LTS) model of execution. We distinguish two classes: atomic systems, where evaluation and transition are coupled within a single LTS step, and split evaluation systems, where they are separate transitions interleaved by environmental actions. The separation introduces an architectural gap -- the decision is evaluated in one system state; the transition fires in a potentially different one -- that no policy, regardless of sophistication, can close from within a split architecture. Under realistic concurrent environments, we prove via a constructive counterexample trace that no construction can make a split system equivalent to an atomic system with respect to admissibility. Three corollaries follow: impossibility of execution-time guarantees in split systems, insufficiency of external state enrichment, and admissibility as an execution-time rather than evaluation-time property. We further formalize the Escalate outcome -- absent from classical TOCTOU analyses -- proving that it transfers rather than eliminates the atomicity requirement: resolution is safe if and only if it is itself atomic. We classify RBAC, ABAC, OPA, Cedar, and AWS IAM as split systems and ACP as atomic, providing a structural taxonomy of existing governance mechanisms. Admissibility is a property of execution, not evaluation.
Tags
Links
- Source: https://arxiv.org/abs/2604.17511v2
- Canonical: https://arxiv.org/abs/2604.17511v2
Trouble viewing inline? Open PDF directly →
Full Text
62,511 characters extracted from source content.
Expand or collapse full text
Atomic Decision Boundaries: A Structural Requirement for Guaranteeing Execution-Time Admissibility in Autonomous Systems Marcelo Fernandez TraslaIA info@traslaia.com (April 2026 arXiv:2604.17511 [cs.AI] DOI: 10.5281/zenodo.19670649) Abstract Autonomous systems increasingly execute actions that directly modify shared state, creating an urgent need for precise control over which transitions are permitted to occur. Existing governance mechanisms evaluate policies prior to execution or reconstruct behavior post hoc, but do not enforce admissibility at the exact moment a state transition is committed. We introduce the atomic decision boundary, a structural property of admission control systems in which the decision and the resulting state transition are jointly determined as a single indivisible step. Formalizing execution as a labeled transition system (LTS), we distinguish two classes: atomic systems, where evaluation and transition are coupled within a single LTS step, and split evaluation systems, where they are separate transitions that may be interleaved by environmental actions. Under realistic concurrent environments (Assumptions 2.1–2.2), we prove that no construction can make a split system equivalent to an atomic system with respect to admissibility under all execution traces. This limitation is a structural property of the system architecture, not of policy expressiveness or state availability. We further formalize the Escalate outcome—absent from classical time-of-check/time-of-use (TOCTOU) analyses— and show that its resolution is itself subject to the atomic boundary requirement, extending the guarantees of the main theorem. We map widely used policy enforcement mechanisms, including RBAC and Open Policy Agent (OPA), to the split model, and contrast them with systems that enforce atomic decision boundaries. Our results establish that admissibility is a property of execution, not of prior evaluation, and that guaranteeing it requires structural guarantees at the decision boundary. This paper is the formal foundation of a 6-paper Agent Governance Series. Companion papers address stateful enforcement (ACP, Paper 1, arXiv:2603.18829 [4]), behavioral drift detection above the enforcement boundary (IML, Paper 2, [6]), fair multi-agent allocation (Paper 3, [5]), composition irreducibility (Paper 4, [7]), and runtime execution validity under partial observability—RAM (Paper 5, [8]). Contents 1 Introduction 2 System Model 2.1 Execution Model 2.2 Environment and Threat Model 3 The Decision Boundary Model 3.1 Decision and Transition Functions 3.2 Atomic Decision Boundary 3.3 Split Evaluation Systems 3.4 Escalation Semantics 4 The Failure of Split Systems 5 Main Results 5.1 Non-Equivalence Theorem 5.2 Corollaries 5.3 The Escalation Closure Requirement 6 Mapping to Existing Systems 7 Discussion 7.1 Relationship to Distributed Transactions 7.2 What Atomicity Does Not Prescribe 7.3 Concurrency Models 7.4 Relationship to Formal Verification 8 Related Work 9 Conclusion References 1 Introduction Autonomous systems are increasingly deployed in settings where they plan and execute multi-step action sequences that directly and irreversibly modify system state. Financial transfers, document operations, API calls, and inter-agent delegations all commit changes that cannot simply be rolled back. As a result, the question of whether a given action should be allowed to execute must be resolved precisely at the moment the transition is committed—not before, and not after. Consider a concrete scenario. An agent is authorized to transfer funds from a shared ledger. A policy engine evaluates the request against the current balance and account status, returns Allow, and triggers the transfer. In the interval between that evaluation and the execution of the debit, a concurrent transaction—another agent repaying a loan—reduces the balance below the required amount. The transfer executes against an inadmissible state. The guarantee the policy was meant to enforce has evaporated. No refinement of the policy expression could have prevented this: the failure is not in what the policy knows, but in when the transition fires relative to the state it governs. We call the gap between these two moments the decision boundary problem, and formalize it precisely in what follows. Current governance approaches address this question indirectly. Policy engines evaluate rules against input data prior to execution. Access control models determine permissions based on static role or attribute assignments. Audit systems reconstruct behavior after the fact. These mechanisms are useful and widely deployed, but they share a structural limitation: the decision to allow an action and the transition that applies that action are separate operations. This separation introduces a gap. The decision is evaluated in one system state; the transition fires in a—potentially different—state. An action admissible when evaluated may become inadmissible by execution time. Under the environment model we formalize in §2, no policy, regardless of its sophistication, can close this gap from within a split architecture: the gap is not an information problem—it is an architectural one. This paper formalizes that observation precisely. We define the decision boundary of a governance system as the point at which the system resolves whether a state transition (s→s′)(s→ s ) is permitted to exist. We then define an atomic decision boundary as one in which the resolution and the resulting transition are jointly computed as a single indivisible step in the labeled transition system model of execution. We prove that systems lacking atomicity at the decision boundary—henceforth split evaluation systems—cannot guarantee admissibility at execution time under all execution traces. The impossibility is constructive: we exhibit a concrete execution trace that witnesses the gap. A distinguishing feature of our model is the three-valued decision domain =Allow,Refuse,EscalateD=\ Allow, Refuse, Escalate\. The Escalate outcome—absent from classical TOCTOU analyses [2, 16]—suspends the transition pending supervisor review, a first-class governance action in modern agent systems [4]. We show that Escalate does not eliminate the atomicity requirement; it transfers it to the resolution step, and prove that the same structural gap arises there unless resolution is itself atomic. Contributions. (i) We formalize the execution model for admission control as an LTS and define admissibility as a property of state transitions, not of actions in isolation (§2). (i) We define the atomic decision boundary in LTS terms and contrast it with split evaluation systems via a precise structural distinction (§3). (i) We give a complete formal semantics for the Escalate outcome, including the supervisor resolution function and the state it operates over (§3). (iv) We prove, via a constructive counterexample trace, that no general construction can make a split system equivalent to an atomic system with respect to admissibility (§5). Three corollaries follow: impossibility of execution-time guarantees in split systems, insufficiency of external state, and admissibility as an execution-time property. (v) We prove the escalation closure requirement: the Escalate outcome preserves admissibility guarantees if and only if the supervisor resolution is itself atomic (§5). (vi) We map RBAC, OPA, and ACP to the two classes, providing a structural taxonomy of existing governance mechanisms (§6). This paper is Paper 0 in a series of six. The Agent Control Protocol (ACP) [4] (Paper 1) instantiates the atomic decision boundary for multi-agent governance. The Invariant Measurement Layer (IML) [6] (Paper 2) operates above the atomic enforcement layer and addresses behavioral drift that remains invisible to enforcement-based monitoring. Paper 3 [5] addresses the fair allocation of atomic governance decisions across agents operating under shared resource constraints. Paper 4 [7] proves the irreducibility of the four-layer governance architecture. Paper 5 [8] closes the series by providing the runtime operational mechanism: the Reconstructive Authority Model (RAM), which determines whether execution is valid at every step under partial observability. 2 System Model We model the execution environment as a labeled transition system and derive the formal definition of admissibility from it. The section is organized into two parts: an execution model (§2.1) that establishes the LTS and the admissibility predicate, and an environment and threat model (§2.2) that specifies the assumptions under which the main theorem is stated. 2.1 Execution Model Definition 2.1 (Labeled Transition System). A labeled transition system (LTS) is a triple M=(S,Act,→)M=(S,Act,→) where: • S is a set of states; • Act=A∪AenvAct=A∪ A_env is a set of action labels, partitioned into agent actions A (subject to governance) and environment actions AenvA_env (external state modifications), with A∩Aenv=∅A∩ A_env= ; • →⊆S×Act×S→ S×Act× S is the transition relation. We write s→s′s as for (s,a,s′)∈→(s,a,s )∈→. Definition 2.2 (Execution Trace). An execution trace σ is a finite alternating sequence s0a1s1a2s2⋯ansns_0\,a_1\,s_1\,a_2\,s_2·s a_n\,s_n such that si−1→aisis_i-1 a_is_i for all i∈1,…,ni∈\1,…,n\. We denote the set of all execution traces of M by Traces(M)Traces(M). Definition 2.3 (Admissibility). An admissibility predicate is a function Adm:S×A→,Adm:S× A→\ true, false\. Action a∈Aa∈ A is admissible in state s∈Ss∈ S if Adm(s,a)=Adm(s,a)= true. Admissibility is a property of the state at the moment of transition, not of the action in isolation. Definition 2.4 (Admissibility-Preserving System). A system M preserves admissibility if for every trace σ∈Traces(M)σ (M) and every agent action a∈Aa∈ A appearing in σ, whenever s→s′s as occurs in σ, we have Adm(s,a)=Adm(s,a)= true. The evaluation–execution gap. In many practical systems, deciding whether to allow an action and applying the resulting transition are implemented as distinct operations. Let D:S×A→D:S× A denote the decision function that evaluates admissibility, and let T:S×A→ST:S× A→ S denote the transition function that applies it. In split systems, D and T are invoked separately. The state in which D is invoked, call it sevals_eval, need not equal the state in which T fires, call it sexecs_exec. This is the structural source of the problem we formalize. 2.2 Environment and Threat Model The main theorem (Theorem 5.1) is a conditional result: it holds under a specific model of the execution environment. We state this model explicitly here, as two assumptions, so that the scope of the result is unambiguous. The environment model is adversarial: the environment is assumed capable of interleaving state-modifying actions at the worst possible moment, with no synchronization guarantee for the governance system. This is the standard assumption in concurrent systems analysis and corresponds to the worst-case deployment context for multi-agent systems operating over shared mutable state. Readers who restrict to sequential or single-threaded settings should consult Remark 5.2 for the precise boundary conditions under which the theorem applies. Assumption 2.5 (Non-Triviality). The system satisfies the following: (i) There exist s∈Ss∈ S and a∈Aa∈ A with Adm(s,a)=Adm(s,a)= true and D(s,a)=AllowD(s,a)= Allow (the decision function grants at least one admissible action without escalation). (i) There exist s∈Ss∈ S, a∈Aa∈ A, and e∈Aenve∈ A_env such that s→s∗s es^* and Adm(s∗,a)=Adm(s^*,a)= false. Assumption 2.5 is satisfied by any system where admissibility genuinely depends on state. A governance mechanism over a state-independent system provides no meaningful constraint; a system whose state cannot change between decision and execution is already effectively atomic. In practice, every multi-agent system operating over shared mutable state—including file systems, API quota registries, agent delegation ledgers, and shared databases— satisfies both conditions: actions can be admitted and state can be modified by concurrent environment processes between evaluation and execution. Assumption 2.6 (Environment Model). The environment satisfies the following: (i) Uncontrollability. Environment actions e∈Aenve∈ A_env are not subject to governance control: the admission system cannot prevent, delay, or reorder them. (i) Arbitrary interleaving. In a split evaluation system, environment actions may fire at any point in the LTS between the decision transition (a)dec(a) and the execution transition (a)exec(a). The system provides no synchronization barrier that would prevent such interleaving. (i) State visibility. The decision function D observes the system state at the time it is invoked. It does not have predictive access to future states produced by environment actions that have not yet fired. Assumption 2.6(i) reflects the standard distinction between controllable and uncontrollable events in supervisory control theory [13]. Assumption 2.6(i) is the adversarial model under which the theorem is stated: the environment is assumed capable of interleaving at the worst moment. Assumption 2.6(i) is satisfied by every decision function that operates on observable state; a function with oracular access to future states would not correspond to any implementable system. The three assumptions hold collectively in all multi-agent systems where agents share mutable state with concurrent external processes. Example 2.7 (Running Example). An agent manages file operations on a shared resource. The state s encodes the set of locked files (s)⊆ℱlocked(s) and the current quota usage (s)∈ℕquota(s) . Action (f)write(f) is admissible in s iff f∉(s)f (s) and (s)<maxquota(s)<quota_ . Environment action (f)lock(f) transitions any state s to state s∗=s[↦(s)∪f]s^*=s[locked (s)∪\f\], making (f)write(f) inadmissible. Assumption 2.5 is satisfied. 3 The Decision Boundary Model 3.1 Decision and Transition Functions Definition 3.1 (Decision Domain). Let =Allow,Refuse,EscalateD=\ Allow, Refuse, Escalate\. We call elements of D dispositions. Definition 3.2 (Decision Function). A decision function is a mapping D:S×A→D:S× A that assigns a disposition to each (state, action) pair. We say D is consistent with AdmAdm if the following hold for all (s,a)∈S×A(s,a)∈ S× A: (i) D(s,a)=Allow⇒Adm(s,a)D(s,a)= Allow (s,a); (i) D(s,a)=Refuse⇒¬Adm(s,a)D(s,a)= Refuse (s,a); (i) Adm(s,a)⇒D(s,a)≠RefuseAdm(s,a) D(s,a)≠ Refuse (admissible states are never refused without escalation); (iv) ¬Adm(s,a)⇒D(s,a)≠Allow (s,a) D(s,a)≠ Allow (inadmissible states are never allowed). Conditions (i)–(iv) together imply: D(s,a)=Allow⇔Adm(s,a)D(s,a)= Allow (s,a) whenever D(s,a)≠EscalateD(s,a)≠ Escalate. The Escalate disposition is reserved for cases where admissibility is indeterminate and requires external resolution. Definition 3.3 (Transition Function). A transition function is a mapping T:S×A→ST:S× A→ S such that T(s,a)T(s,a) gives the resulting state when action a is applied in state s. Remark 3.4 (The role of F versus composition of D and T). One might observe that the type signature F:S×A→×SF:S× A × S is mathematically identical to the pointwise pair (D,T)(D,T): given (s,a)(s,a), compute D(s,a)D(s,a) for the disposition and T(s,a)T(s,a) for the resulting state. Any system—including a split one—can define such a function as a mathematical object. The contribution of the Atomic Decision Boundary (Definition 3.5) is not in the signature but in the indivisibility axiom: the computation of (d,s′)(d,s ) must correspond to a single arc in the LTS, exposing no intermediate state to environment actions. In a split system, the same pair (d,s′)(d,s ) is eventually produced, but the path from s to s′s passes through the intermediate state sDs_D (introduced formally in Definition 3.7 below, §3.3) where environment actions can interleave. The structural difference between the two classes is in the topology of the LTS—specifically, whether there exists an intermediate state—not in the domain or codomain of the function. 3.2 Atomic Decision Boundary Definition 3.5 (Atomic Decision Boundary). A system satisfies an atomic decision boundary if there exists a function F:S×A→×SF:S× A × S such that for every (s,a)∈S×A(s,a)∈ S× A: F(s,a) F(s,a) =(d,s^′) =(d,\, s ) (1) d d =D(s,a) =D(s,a) (2) s^′ s =(T(s,a),P)if d=Allow =(T(s,a),\,P) d= Allow (3) s^′ s =(s,P)if d=Refuse =(s,\,P) d= Refuse (4) s^′ s =(s,P∪(s,a))if d=Escalate =(s,\,P∪\(s,a)\) d= Escalate (5) where s^′∈S^=S×Req s ∈ S=S×Req is the post-transition state in the escalation-extended state space (defined formally in Definition 3.8, §3.4). For d∈Allow,Refused∈\ Allow, Refuse\, the pending-request component P is unchanged by the transition; the state reduces to S in those cases. The computation of d and s^′ s corresponds to a single indivisible transition in the LTS: s→F(s,a)s^′s F(s,a) s with no intermediate state between the evaluation of d and the determination of s^′ s . The indivisibility condition in Definition 3.5 is a model-level axiom: it asserts that no environment action e∈Aenve∈ A_env can be interleaved between the evaluation of D(s,a)D(s,a) and the firing of T(s,a)T(s,a). In terms of the LTS, the F(s,a)F(s,a) transition is a single arc; it does not decompose into two separate transitions with any state in between. Remark 3.6 (Implementation independence). Atomicity in Definition 3.5 is a structural property of the system architecture, not of any particular implementation. Whether it is realized via a database transaction, a monitor lock, a hardware instruction, or a protocol contract is an implementation matter. The definition abstracts over all of these and asserts only that the LTS representation of the system does not expose an intermediate state. 3.3 Split Evaluation Systems Definition 3.7 (Split Evaluation System). A system is a split evaluation system if the decision function D and the transition function T are evaluated as distinct LTS transitions, potentially separated by environment actions. Formally, the execution of agent action a from state s decomposes into: (1) A decision transition: s→(a)sDs dec(a)s_D, where sDs_D encodes the recorded disposition d=D(s,a)d=D(s,a) alongside the current state. (2) An optional sequence of environment transitions: sD→e1⋯→eks∗s_D e_1·s e_ks^*, for k≥0k≥ 0. (3) An execution transition: s∗→(a)T(s∗,a)s^* exec(a)T(s^*,a), contingent on d=Allowd= Allow. The states s (evaluation state) and s∗s^* (execution state) may differ whenever k≥1k≥ 1. The structural distinction between atomic and split systems is not a matter of policy expressiveness, state availability, or evaluation latency. It is a matter of whether the LTS exposes an intermediate state between decision and execution. In atomic systems it does not; in split systems it does. 3.4 Escalation Semantics The Escalate disposition is structurally distinct from Refuse: rather than terminating the request, it suspends the transition pending external review. This outcome has no counterpart in classical TOCTOU analyses, which operate in binary (permit/deny) models. We give it a precise semantics. Definition 3.8 (Escalation State). Let Req=fin(S×A)Req=P_fin(S× A) denote the set of finite sets of pending requests. The escalation-extended state space is S^=S×Req S=S×Req. A state s^=(s,P)∈S s=(s,P)∈ S encodes the current system state s together with the set P of pending (state, action) pairs awaiting supervisor resolution. Definition 3.9 (Escalation Transition). When F(s,a)=(Escalate,s^′)F(s,a)=( Escalate, s ), the system transitions to s^′=(s,P∪(s,a)), s = (s,\;P∪\(s,a)\ ), recording the pending request (s,a)(s,a) with the originating state s, while leaving the system state unchanged. No transition of T fires. Definition 3.10 (Supervisor Resolution Function). The resolution function resolve:S^×(S×A)×Allow,Refuse→S^resolve: S×(S× A)×\ Allow, Refuse\→ S is defined, for (sorig,a)∈P(s_orig,a)∈ P (precondition: the request being resolved must be in the pending set), by: resolve((st,P),(sorig,a),Allow) ((s_t,P),\;(s_orig,a),\; Allow ) =(T(st,a),P∖(sorig,a)) = (T(s_t,a),\;P \(s_orig,a)\ ) (6) resolve((st,P),(sorig,a),Refuse) ((s_t,P),\;(s_orig,a),\; Refuse ) =(st,P∖(sorig,a)) = (s_t,\;P \(s_orig,a)\ ) (7) where sts_t is the current system state at resolution time, which may differ from sorigs_orig. The function is undefined when (sorig,a)∉P(s_orig,a)∉ P; resolution of a request not in the pending set is a protocol error. Two observations are immediate. First, when Allow is issued at resolution, T fires in state sts_t, not sorigs_orig. The supervisor therefore cannot rely on the admissibility evaluation performed in sorigs_orig; it must re-evaluate Adm(st,a)Adm(s_t,a). Second, the resolution function itself is a decision point: it evaluates a disposition (Allow or Refuse) and potentially fires a transition (T(st,a)T(s_t,a)). This is precisely the structure of a decision boundary. Remark 3.11 (The supervisor as a second decision system). The Escalate outcome introduces a second decision point operated by an external supervisor, which raises a natural question: is this the same system, or a different one? The model is agnostic. The supervisor may be a human reviewer, an automated policy agent, or a recursive invocation of the same governance pipeline. What Corollary 5.6 (to follow) establishes is independent of this: wherever the supervisor sits, its resolution function resolveresolve constitutes a decision boundary of its own, and the same structural argument that applies to the primary boundary applies there. The escalation model does not solve the atomicity problem by deferral; it makes explicit that the problem cannot be avoided by deferral, only transferred. Split Evaluation SystemAgentPolicyEngineStateTransitione∈Aenve∈ A_envaad=Allowd= Allowmutates sΔt>0 t>0: exploitable gapAtomic Decision SystemAgentAtomicBoundary FFStateTransitionaa(d,s′)(d,s )e∈Aenve∈ A_envblocked Figure 1: Architectural contrast between a split evaluation system (left) and an atomic decision system (right). In the split system, environment actions e∈Aenve\!∈\!A_env may interleave between the policy evaluation and the state transition, producing the exploitable gap Δt>0 t>0 proved in Theorem 5.1. In the atomic system, F determines both the decision and the resulting state as a single indivisible LTS step; no environment action can interleave within it. 4 The Failure of Split Systems Before stating the main theorem, we illustrate the failure mode concretely. Example 4.1 (Admissibility Violation in a Split System). Return to Example 2.7. The following three-step trace witnesses the failure (steps correspond to those in the proof of Theorem 5.1): (1) The system is in state s with f∉(s)f (s). The agent requests (f)write(f); the split system evaluates D(s,(f))=AllowD(s,write(f))= Allow and records the decision. (2) Before execution fires, another agent issues (f)lock(f), an environment action that transitions s→s∗s→ s^* with f∈(s∗)f (s^*). (3) The original decision (Allow) is already recorded. The execution transition ((f))exec(write(f)) fires in s∗s^*, applying T(s∗,(f))T(s^*,write(f)). At the moment of execution, Adm(s∗,(f))=Adm(s^*,write(f))= false: the file is locked. The split system has executed an inadmissible transition. In contrast, an atomic system would evaluate F(s∗,(f))F(s^*,write(f)) at the moment of the transition and obtain (Refuse,s∗)( Refuse,s^*), preventing the inadmissible execution. The failure in Example 4.1 cannot be remedied by: • Richer policies. The decision function D already produces the correct result for every state it is given. The problem is that it is given s, not s∗s^*. • External state. Adding an external store (e.g., a shared lock registry read by D) reduces the window in which the gap can be exploited but does not reduce it to zero. The store must be read before T fires; between that read and the firing of T, the store can be updated. • Re-evaluation before execution. If the system re-evaluates D immediately before firing T, the re-evaluation and the execution are themselves two separate transitions—which is exactly the structure of a split system. Unless the re-evaluation and the execution are jointly atomic, the gap is merely shifted, not closed. 5 Main Results 5.1 Non-Equivalence Theorem We now prove the central result. Throughout this section, equivalence between two systems is taken with respect to admissibility preservation (Definition 2.4): two systems are equivalent if and only if they agree on which execution traces preserve admissibility under all environments satisfying Assumptions 2.5 and 2.6. The theorem is stated for the general case; the proof is constructive via the execution trace in Example 4.1. Theorem 5.1 (Non-Equivalence of Split and Atomic Systems). Let MsplitM_split be any split evaluation system and let MatomM_atom be any atomic decision boundary system, both defined over the same state space S, action set A, environment actions AenvA_env, admissibility predicate AdmAdm, and transition function T. Under Assumptions 2.5 and 2.6, there exists an execution trace σ∗∈Traces(Msplit)σ^* (M_split) such that: (i) σ∗σ^* contains a transition s∗→(a)T(s∗,a)s^* exec(a)T(s^*,a) with Adm(s∗,a)=Adm(s^*,a)= false. (i) No corresponding trace exists in Traces(Matom)Traces(M_atom) that commits T(⋅,a)T(·,a) in a state where Adm(⋅,a)=Adm(·,a)= false. Consequently, MsplitM_split does not preserve admissibility, while MatomM_atom does. Proof. By Assumption 2.5(i), there exist s∈Ss∈ S and a∈Aa∈ A with Adm(s,a)=Adm(s,a)= true. By Assumption 2.5(i), there exists e∈Aenve∈ A_env and s∗∈Ss^*∈ S with s→s∗s es^* and Adm(s∗,a)=Adm(s^*,a)= false. Constructing σ∗σ^*. Consider the following trace in MsplitM_split: σ∗:s→(a)sD→s∗→(a)T(s∗,a).σ^*: s\; dec(a)\;s_D\; e\;s^*\; exec(a)\;T(s^*,a). 1. The decision transition (a)dec(a) fires in state s. By Assumption 2.5(i), D(s,a)=AllowD(s,a)= Allow. The system records Allow and transitions to sDs_D (encoding the recorded decision alongside the current state; the underlying system state is still s). 2. The environment transition e fires, producing s∗s^* with Adm(s∗,a)=Adm(s^*,a)= false. 3. The execution transition (a)exec(a) fires in s∗s^*. In MsplitM_split, execution is triggered by the recorded disposition Allow, which was evaluated in s. The split system applies T(s∗,a)T(s^*,a), yielding the inadmissible transition. By construction, σ∗∈Traces(Msplit)σ^* (M_split) (all three transitions are valid in a split system), and the transition at step (3) is inadmissible in s∗s^*. This establishes (i). Atomic system behavior. In MatomM_atom, the agent action a corresponds to a single indivisible LTS transition F(s′,a)F(s ,a) from whatever state s′s holds at the moment the agent acts. If the agent acts before the environment transition e fires (system in state s): F(s,a)=(Allow,T(s,a))F(s,a)=( Allow,T(s,a)). The transition completes atomically; e cannot interleave within the single LTS step. The resulting state is T(s,a)T(s,a), produced from s where Adm(s,a)Adm(s,a) holds. If the agent acts after e fires (system in state s∗s^*): D(s∗,a)∈Refuse,EscalateD(s^*,a)∈\ Refuse, Escalate\, since Adm(s∗,a)=Adm(s^*,a)= false and D is consistent with AdmAdm (condition (iv): ¬Adm⇒D≠Allow D≠ Allow). In either case, no transition of T fires: Refuse keeps the state unchanged, and Escalate records the pending request without firing T (Definition 3.9). In neither case does MatomM_atom commit T(⋅,a)T(·,a) in a state where admissibility fails. This establishes (i). Conclusion. MsplitM_split produces an inadmissible transition under σ∗σ^*; MatomM_atom does not. Therefore MsplitM_split does not satisfy Definition 2.4 (admissibility preservation) under all execution traces. No construction applied to MsplitM_split can restore admissibility preservation without introducing an atomic boundary: any mechanism that prevents the violation in σ∗σ^* must either (a) block environment actions from interleaving between (a)dec(a) and (a)exec(a)—which is precisely Definition 3.5—or (b) re-evaluate D at execution time jointly with T as a single indivisible step—which is again Definition 3.5. In both cases, the fix is the atomic boundary condition itself. ∎ Remark 5.2 (Scope and boundary conditions of the impossibility). Theorem 5.1 is a conditional result: it holds under Assumptions 2.5 and 2.6. In a sequential system where no concurrent environment actions occur (k=0k=0 always in Definition 3.7), the trace σ∗σ^* is unreachable and the gap cannot be exploited. Similarly, if mutual exclusion is enforced at the operating-system or runtime level over the entire interval between (a)dec(a) and (a)exec(a), the split system becomes effectively atomic within that exclusion scope—but this is precisely an implementation of the atomic boundary (see Remark 3.6). Two common objections deserve direct answers. First: “What about locks, transactions, CAS, or linearizable storage?” These are valid implementation mechanisms for the atomic boundary; they are not alternatives to it. A system that wraps both the decision call and the execution call inside a single database transaction, or acquires a lock before (a)dec(a) and releases it only after (a)exec(a), satisfies Definition 3.5 by construction—because no environment action can fire between the two. Second: “Isn’t this just data atomicity?” No. Data atomicity (2PC, MVCC) ensures that a data record is fully written or not written at all. Admissibility atomicity ensures that the policy check and the data write are evaluated against the same system-state snapshot. A 2PC-coordinated write preceded by an OPA policy call is still a split system in our model (§7.1). 5.2 Corollaries Corollary 5.3 (Impossibility of Execution-Time Guarantees in Split Systems). A split evaluation system cannot guarantee admissibility at execution time under all execution traces. Proof. Immediate from Theorem 5.1: the trace σ∗σ^* is a constructive witness to a violation. Since σ∗σ^* is a valid trace of any split system satisfying Assumption 2.5, no such system can claim universal admissibility preservation. ∎ Corollary 5.4 (External State Does Not Restore Atomicity). Augmenting a split system with access to external state does not restore equivalence with an atomic system unless evaluation and the resulting state transition are jointly enforced as a single indivisible step. Proof. External state enriches the domain of the decision function D: let D′:S×A×ℰ→D :S× A×E where ℰE is the external state. The augmented system still decomposes into a decision transition (invoking D′D with the external state read at that moment) and a subsequent execution transition. The environment action e in σ∗σ^* may act on the external state or the system state between these transitions; the structural gap is unchanged. Formally, D′(s,a,ϵ)D (s,a,ε) with ϵ=ϵsε= _s (the external state corresponding to s) may return Allow, while by the time T fires the external state has evolved to ϵs∗ _s^* reflecting the lock acquired by e. The gap in σ∗σ^* is not closed. Atomic coupling of D′D and T is required. ∎ Corollary 5.5 (Admissibility is a Property of Execution). Admissibility cannot be reduced to a property of evaluation alone; it is a property of the state at the moment the transition is committed. Proof. In the trace σ∗σ^*, the same action a is admissible in state s (evaluation state) and inadmissible in state s∗s^* (execution state). Since execution commits the transition in s∗s^*, admissibility must be determined with respect to s∗s^*. Any governance guarantee that is computed only at s is therefore insufficient. ∎ 5.3 The Escalation Closure Requirement Corollary 5.6 (Escalation Closure Requirement). An Escalate outcome preserves the atomic decision boundary guarantee if and only if the supervisor resolution function resolveresolve is itself atomic: the evaluation of Adm(st,a)Adm(s_t,a) at resolution time and the application of T(st,a)T(s_t,a) must be jointly determined as a single indivisible step. Proof. Let the system issue Escalate for action a in state s, recording the pending request (s,a)(s,a) per Definition 3.9. (Necessity.) Suppose resolveresolve is split: the supervisor evaluates D(st,a)D(s_t,a) in state sts_t, and then fires T separately. We verify that Assumptions 2.5 and 2.6 hold for the resolution sub-process operating on S^=S×Req S=S×Req. Assumption 2.5(i) holds because (st,a)(s_t,a) has Adm(st,a)=Adm(s_t,a)= true (otherwise the supervisor would not issue Allow) and D(st,a)=AllowD(s_t,a)= Allow (this is the split supervisor’s decision). Assumption 2.5(i) holds because the system state sts_t (the first component of S S) can be modified by environment actions between the supervisor’s decision transition and the execution of T; the same Assumption 2.6 that applies to the primary system applies to the projected S-component of S S. Assumption 2.6(i)–(i) carry over verbatim to the projected S-component: environment actions are uncontrollable, may interleave between the supervisor’s evaluation and the firing of T, and the supervisor observes only the current state sts_t at the time of evaluation. By Theorem 5.1 applied to this resolution sub-process, there exists a trace in which the supervisor’s Allow is computed in sts_t but T fires in s∗s^** with Adm(s∗,a)=Adm(s^**,a)= false. Thus, resolveresolve admits an inadmissible transition. (Sufficiency.) Suppose resolveresolve is atomic: the evaluation D(st,a)D(s_t,a) and the application T(st,a)T(s_t,a) are a single indivisible step in the LTS. Then by Definition 3.5 applied to resolveresolve, the resolution satisfies the atomic decision boundary condition, and Theorem 5.1 guarantees no inadmissible transition at resolution. ∎ Corollary 5.6 has an important practical consequence: the Escalate outcome does not relax the atomicity obligation; it transfers it from the primary enforcement point to the supervisor. A chain of escalations each requiring their own atomic resolution corresponds precisely to the notion of a supervisory hierarchy in discrete event systems [13]. 6 Mapping to Existing Systems Table 1 classifies common governance mechanisms according to the distinction established in §3. The classification is structural and does not reflect comparisons of expressiveness or performance. Table 1: Structural classification of existing governance mechanisms. System Class Basis for classification RBAC [14] Split Permission check and execution are distinct operations ABAC [9] Split Attribute evaluation external to transition; attributes may change OPA [12] Split Policy evaluation external to state transition Cedar [3] Split Authorization decision external to the enforcing runtime OPA + Redis Split External state enriches D; structural gap remains (Cor. 5.4) AWS IAM Split IAM evaluation precedes API call execution; no shared-snapshot guarantee Kubernetes Admission Partially atomic Webhook admits before object creation, but cross-resource state (e.g., a ResourceQuota modified concurrently) is not jointly atomic with the admission decision (Remark 6.1) ACP [4] Atomic Decision and state mutation jointly enforced via single-use Execution Token Role-Based Access Control (RBAC). RBAC assigns permissions to roles and roles to principals. At access time, the system evaluates whether the requesting principal holds a role that permits the requested operation. The evaluation produces a disposition; the operation is then executed by the application. The RBAC system has no mechanism to ensure that the role assignment—or the system state on which the permission check depends—remains unchanged between evaluation and execution. RBAC implements: d=DRBAC(s,a),s′=T(s,a),d=D_RBAC(s,a), s =T(s,a), as separate operations. RBAC is a split evaluation system. Concrete trace. In state s, an agent holds the Editor role and requests (r)write(r). The RBAC check returns d=Allowd= Allow. Before the write executes, an administrator revokes the role via environment action e, transitioning to s∗s^* where the agent is no longer an Editor and Adm(s∗,(r))=Adm(s^*,write(r))= false. The recorded Allow nonetheless triggers execution of T(s∗,(r))T(s^*,write(r)). This is precisely the trace σ∗σ^* of Theorem 5.1. Open Policy Agent (OPA). OPA evaluates policies expressed in Rego against an input document. The evaluation produces a decision; execution is performed externally by the calling system. In its standard deployment model: d=DOPA(s,a),d=D_OPA(s,a), with T(s,a)T(s,a) executed outside the policy engine. Even when OPA is augmented with external data injected at query time (e.g., via the bundle API or a data source), the execution transition remains external. By Corollary 5.4, this augmentation does not restore atomicity. OPA is a split evaluation system. Concrete trace. An OPA bundle is evaluated against input document encoding state s (e.g., current API quota usage =q<qmax=q<q_ ) and returns d=Allowd= Allow. Between the policy call and the application’s write execution, a concurrent request exhausts the remaining quota, producing s∗s^* with Adm(s∗,)=Adm(s^*,write)= false. The application, holding the recorded Allow, proceeds. Injecting a real-time Redis data source into OPA narrows the window but does not close it: the Redis read is itself a distinct LTS transition exposed to interleaving between (a)dec(a) and (a)exec(a) (Corollary 5.4). ACP (Agent Control Protocol). ACP implements admission control as a stateful runtime mechanism in which the decision and state mutation are jointly enforced at the execution boundary [4]. Each agent action must obtain an Execution Token—a single-use cryptographic proof of admission—before the action is permitted to proceed. The token is issued and consumed atomically relative to the ledger state, ensuring that the system state against which admissibility is evaluated is the same state against which the transition commits. ACP further implements the Escalate outcome as a pending-review state tracked in the Audit Ledger (ACP-LEDGER-1.3), where subsequent resolution passes through the same admission pipeline. By Corollary 5.6, this satisfies the escalation closure requirement. Formally: FACP(s,a)=(d,s′),F_ACP(s,a)=(d,s ), where d and s′s are determined by a single evaluate-then-mutate execution contract [4]. ACP is an atomic decision boundary system. AWS IAM. AWS IAM evaluates authorization requests against a set of policies attached to principals, resources, and conditions. An IAM authorization call (e.g., to the IAM policy simulator or to the underlying STS service) produces a decision of Allow or Refuse. The resulting API call is executed by the service (e.g., S3, EC2) independently of the IAM evaluation context. No shared-snapshot guarantee exists between the IAM policy evaluation context and the service’s execution context: condition keys (e.g., aws:CurrentTime, ec2:ResourceTag) are evaluated at IAM call time, while the resource state at execution time may differ. Concrete trace. An agent requests an S3 write. IAM evaluates the policy in state s where the bucket’s ACL permits writes from the agent’s role, returning d=Allowd= Allow. Before the write reaches S3, a concurrent process changes the bucket policy (environment action e), producing s∗s^* where the write is inadmissible. The S3 service executes T(s∗,)T(s^*,write) regardless, since it received the IAM authorization token produced in s. This is the trace σ∗σ^* of Theorem 5.1. AWS IAM is a split evaluation system. Cedar. Cedar is a policy language and evaluation engine designed for authorization decisions in service-oriented architectures [3]. Like OPA, Cedar evaluates policies against entities (principal, action, resource, context) and returns a decision. The enforcement of that decision—the actual execution of the requested operation—occurs outside Cedar, in the calling application or service. Cedar provides no mechanism to jointly enforce its authorization decision with the subsequent state transition; the two remain separate LTS transitions. By Corollary 5.4, augmenting Cedar with an entity store does not restore atomicity: the entity store is read at evaluation time, and the application may mutate relevant entity attributes between Cedar’s decision and the action’s execution. Cedar is a split evaluation system. Remark 6.1 (Partially atomic systems). Table 1 uses the term partially atomic for Kubernetes admission webhooks. This denotes a system that satisfies the atomic decision boundary condition (Definition 3.5) for a restricted subset of state—specifically, single-object lifecycle operations—but fails atomicity when the relevant admissibility predicate AdmAdm depends on shared or cross-resource state that is not included in the joint evaluation-and-execution snapshot. Formally: let S decompose as S=Slocal×SglobalS=S_local× S_global. If the system is atomic with respect to SlocalS_local but split with respect to SglobalS_global, it is partially atomic. When AdmAdm depends only on SlocalS_local, the system provides full guarantees; when AdmAdm depends on SglobalS_global, Theorem 5.1 applies to the SglobalS_global component. Kubernetes Admission (Partially Atomic). Kubernetes admission webhooks intercept API server requests before the object is written to etcd, providing a form of pre-execution evaluation. Within a single object’s lifecycle, the webhook decision and the subsequent write to etcd are reasonably coupled. However, Kubernetes does not enforce atomicity across resources: consider an agent Pod requesting a batch job that is admissible given the current ResourceQuota state. Between the webhook’s admission decision and the Pod’s binding to a node, a concurrent namespace operation updates the ResourceQuota to a value that would have caused refusal. The transition fires in an inadmissible cross-resource state. In terms of our model, the state s relevant to AdmAdm encodes cluster-wide resource state; the admission decision is evaluated in s but the execution commits in a state s∗s^* that the webhook did not observe. The system is partially atomic (per-object) but split with respect to the full admissibility predicate over shared cluster state. 7 Discussion 7.1 Relationship to Distributed Transactions Two-phase commit (2PC) and multiversion concurrency control (MVCC) achieve atomicity for data transitions: they ensure that a database record is either fully updated or not updated at all. This is a different plane from the admissibility atomicity we define. Admissibility is a predicate over the system state at transition time; its enforcement requires that the policy check and the transition commit occur in the same snapshot of that state. 2PC coordinates multiple data stores to commit together; it does not ensure that the policy check preceding the commit was evaluated in the same snapshot. A system can run an OPA policy check followed by a 2PC-coordinated database update and still be a split system in our model: the OPA call and the 2PC commit are separate operations with an exploitable window between them. An atomic decision boundary requires that the policy evaluation and the state commit are the same operation—not merely that they are coordinated. Relationship to linearizability. Linearizability [10] is the standard correctness criterion for concurrent objects: an operation appears to take effect instantaneously at some point between its invocation and its response. This is a property of data operations on shared objects. The atomic decision boundary operates at a distinct level of abstraction: it is a property of governance decisions over state transitions. A linearizable data store guarantees that each read or write appears atomic in isolation; it does not guarantee that a policy check and the write it governs were evaluated against the same state snapshot. A system that runs a policy evaluation followed by a linearizable write is still a split system in our model: the policy call and the write are separate operations with an exploitable window between them. These are complementary guarantees, not competing ones. A system achieves the atomic decision boundary by implementing the policy check and the resulting state transition as a single linearizable operation— precisely collapsing the gap. Linearizability specifies what it means for a single operation to be atomic; the atomic decision boundary specifies which operations must be made atomic together. 7.2 What Atomicity Does Not Prescribe Our results characterize a necessary structural condition for admissibility guarantees. They do not: • prescribe a specific implementation of the atomic boundary (hardware CAS, database transaction, protocol contract, or otherwise); • claim that atomic systems are immune to all governance failures— behavioral drift operating below the enforcement threshold is addressed separately [6]; • argue that split systems have no valid use. Split systems can provide probabilistic assurance, reduce latency, or serve in contexts where admissibility is defined conservatively. The theorem establishes only that they cannot provide the universal guarantee. 7.3 Concurrency Models The trace σ∗σ^* in Theorem 5.1 assumes an adversarial environment: the environment action e is assumed to be able to fire between (a)dec(a) and (a)exec(a). In a stochastic model, e fires with some probability p>0p>0; the guarantee degrades from universal to probabilistic. In a sequential model where no concurrency is possible, the gap does not arise. The relevance of Theorem 5.1 is therefore proportional to the degree of concurrency in the deployment environment. For modern multi-agent systems operating over shared state, p>0p>0 is the realistic assumption. 7.4 Relationship to Formal Verification TLA+ and other model-checking frameworks verify safety and liveness properties of system models. In a TLA+ model of a split system, the gap in σ∗σ^* can be made explicit: if environment actions are part of the model, the checker will find traces that violate admissibility invariants. This paper provides the structural characterization that motivates where to look and why no refinement of the split architecture can eliminate the counterexample trace. The ACP specification [4] is model-checked with TLC and verifies safety invariants that hold precisely because ACP enforces an atomic boundary. 8 Related Work Time-of-Check/Time-of-Use (TOCTOU). The TOCTOU pattern—in which a security check and the operation it governs are separated in time—has been studied extensively in operating systems security [2, 16]. The classic form involves a file system race: a process checks file permissions and then opens the file; an attacker replaces the file between check and open. Our model generalizes TOCTOU from OS primitives to governance systems, with three key extensions. First, we operate at the level of state transitions rather than file handles: the relevant state is the full system state encoding all properties on which admissibility depends, not merely a permission bit. Second, we add the Escalate outcome, which TOCTOU analyses do not consider. Classical TOCTOU mitigation strategies (e.g., using openat or atomic rename) work by removing the gap; our framework shows that the same principle applies to governance systems and that the gap cannot be closed by re-evaluation alone. Third, we provide a positive characterization of systems that are immune to the gap (atomic systems), not only a characterization of vulnerable systems. Supervisory Control of Discrete Event Systems. Ramadge and Wonham [13] introduced the formal theory of supervisory control, in which a supervisor enables or disables events in a plant modeled as a DES. Their framework distinguishes controllable events (which the supervisor can prevent) from uncontrollable events (which it cannot). Our framework is related: agent actions correspond to controllable events; environment actions correspond to uncontrollable ones. The Escalate outcome corresponds to the supervisor suspending a controllable event pending further observation—a concept formalized in the DES literature as conditional enabling [13]. Corollary 5.6 is the governance-system analogue of the requirement that supervisory decisions be enforced at the moment of event firing. Access Control. The access matrix model of Harrison, Ruzzo, and Ullman [9] is the classical foundation of access control theory. RBAC [14] and attribute-based access control (ABAC) elaborate on it. These models define what operations principals are permitted to perform; they do not model the temporal relationship between the permission check and the operation execution. Our work complements access control theory by characterizing when that temporal relationship matters for correctness. Reference Monitors. Anderson [1] defined the reference monitor as a component that must be invoked on every access, must be tamper-proof, and must be small enough to be verified. Our atomic decision boundary captures the first and third properties at a formal level: the boundary is invoked at the moment of transition (complete mediation) and its definition is minimal (a single function F). The ACP protocol [4] is explicitly designed as a decentralized reference monitor; the present paper provides the formal basis for why complete mediation requires atomicity. Runtime Enforcement and Security Automata. Schneider [15] characterized which security properties are enforceable by inline reference monitors modeled as security automata: a property is enforceable if and only if its violations are detectable in finite traces (i.e., it is a safety property). The admissibility preservation requirement of Definition 2.4 is a safety property in precisely this sense—each violation is witnessed by the finite trace σ∗σ^*. Schneider’s framework assumes the monitor can observe and halt executions; our work identifies the structural condition under which that halt can be guaranteed atomically with respect to the state transition being governed. A monitor that halts asynchronously with the transition is still a split system in our model. Ligatti, Bauer, and Walker [11] extended security automata to edit automata, which can suppress or insert events to enforce a broader class of policies. The Escalate outcome in our model corresponds structurally to suppression: the transition is prevented pending external resolution. The Escalation Closure Requirement (Corollary 5.6) is the governance-layer analogue of the requirement that edit operations themselves be applied consistently with the current state of the running system—a condition edit automata assume implicitly but do not formalize at the level of decision boundaries. Policy Engines. OPA [12] and Cedar [3] provide expressive policy languages for evaluating authorization decisions. These systems are powerful within their class (split evaluation) and our taxonomy does not imply that they are deficient—only that they cannot provide execution-time admissibility guarantees by construction. Hybrid architectures in which a policy engine provides the decision function D inside an atomic enforcement layer are consistent with our model; the atomicity requirement falls on the enclosing layer, not on the policy engine itself. Temporal Logic and Model Checking. Safety properties in temporal logic (e.g., □¬bad ) can express admissibility requirements. Model checkers verify whether a system satisfies such properties. Our contribution is complementary: we identify which system architectures can satisfy admissibility properties universally (atomic) and which cannot (split), independent of any particular property specification. 9 Conclusion We have introduced the atomic decision boundary as a structural requirement for governance systems that must enforce admissibility at execution time. Using a formal LTS model, we proved that split evaluation systems cannot provide this guarantee under all execution traces, and showed that no enrichment of the split architecture—whether through additional policies, external state, or re-evaluation—can close the structural gap without introducing atomicity. The Escalate outcome extends classical binary decision models and captures supervisor-mediated governance. We proved that escalation transfers, rather than removes, the atomicity obligation: any system that resolves an Escalate must itself be atomic at the point of resolution. The core result is direct: admissibility is not a property of evaluation—it is a property of execution. Under Assumptions 2.5 and 2.6, no system that separates evaluation from execution can guarantee admissibility at execution time; only a system that couples them as a single indivisible step at the decision boundary can provide this guarantee. This characterization serves as the formal foundation for the subsequent papers in this series of six. The Agent Control Protocol (ACP) [4] (Paper 1) instantiates F as a concrete atomic boundary: each agent action acquires a single-use Execution Token that is issued and consumed in the same ledger operation, ensuring that the state against which admissibility is evaluated is precisely the state against which the transition commits. The Invariant Measurement Layer [6] (Paper 2) operates above the atomic enforcement layer—taking atomicity as given—and detects behavioral drift that accumulates across sequences of individually admissible actions, remaining invisible to per-action enforcement signals. Paper 3 [5] extends the framework to the fair allocation of governance decisions across competing agents, proving that correct enforcement does not imply fair allocation and characterising the allocation layer explicitly. Paper 4 [7] proves that the four layers are irreducible: no strict subset can replicate the governance guarantees of the full stack, and the composition itself produces emergent properties absent from any single layer. Paper 5 [8] closes the series by addressing the runtime question left open by Papers 0–4: given that observability is incomplete (Paper 2) and the architecture is irreducible (Paper 4), the Reconstructive Authority Model (RAM) provides the operational mechanism for determining whether execution authority can be constructed from the current real state—and halts or narrows privileges when it cannot. Note on terminology. Throughout this paper the non-admissible outcome is written Refuse. Subsequent papers in the series (Papers 3–5) adopt the synonym Deny, following ACP’s DENIED protocol response (Paper 1). The decision domain =Allow,Escalate,RefuseD=\ Allow, Escalate, Refuse\ is the same object across the series. All six papers rest on the structural guarantee established here: that the boundary they operate relative to is, in fact, atomic. References [1] J. P. Anderson (1972) Computer security technology planning study. Technical report Technical Report ESD-TR-73-51, USAF Electronic Systems Division. Cited by: §8. [2] M. Bishop and D. Bailey (1996) A critical analysis of vulnerability taxonomies. Technical report Technical Report CSE-96-11, University of California at Davis. Cited by: §1, §8. [3] J. Cutler et al. (2023) Cedar: a new policy language. In USENIX Security Symposium, Cited by: §6, Table 1, §8. [4] M. Fernandez (2026) Agent control protocol: admission control for agent actions. Note: https://arxiv.org/abs/2603.18829arXiv:2603.18829 [cs.CR], DOI:10.5281/zenodo.19672575 External Links: Document Cited by: §1, §1, §6, §6, Table 1, §7.4, §8, §9. [5] M. Fernandez (2026) Fair atomic governance: allocating decision boundaries under shared resource constraints in multi-agent systems. Note: https://doi.org/10.5281/zenodo.19672597Zenodo. DOI: 10.5281/zenodo.19672597 External Links: Document Cited by: §1, §9. [6] M. Fernandez (2026) From admission to invariants: measuring deviation in delegated agent systems. Note: https://doi.org/10.5281/zenodo.19672589Zenodo. DOI: 10.5281/zenodo.19672589. arXiv:2604.17517 External Links: Document Cited by: §1, 2nd item, §9. [7] M. Fernandez (2026) Irreducible multi-scale governance: composition and limits of atomic admission systems. Note: https://doi.org/10.5281/zenodo.19672608Zenodo. DOI: 10.5281/zenodo.19672608 External Links: Document Cited by: §1, §9. [8] M. Fernandez (2026) Reconstructive authority model: runtime execution validity under partial observability. Note: https://doi.org/10.5281/zenodo.19669430Agent Governance Series, Paper 5. Zenodo. DOI: 10.5281/zenodo.19669430 External Links: Document Cited by: §1, §9. [9] M. A. Harrison, W. L. Ruzzo, and J. D. Ullman (1976) Protection in operating systems. Communications of the ACM 19 (8), p. 461–471. Cited by: Table 1, §8. [10] M. P. Herlihy and J. M. Wing (1990) Linearizability: a correctness condition for concurrent objects. ACM Transactions on Programming Languages and Systems 12 (3), p. 463–492. Cited by: §7.1. [11] J. Ligatti, L. Bauer, and D. Walker (2005) Edit automata: enforcement mechanisms for run-time security policies. International Journal of Information Security 4 (1–2), p. 2–16. Cited by: §8. [12] Open Policy Agent Contributors (2026) Open policy agent. Note: https://w.openpolicyagent.orgAccessed April 2026 Cited by: Table 1, §8. [13] P. J. Ramadge and W. M. Wonham (1987) Supervisory control of a class of discrete event processes. SIAM Journal on Control and Optimization 25 (1), p. 206–230. Cited by: §2.2, §5.3, §8. [14] R. S. Sandhu, E. J. Coyne, H. L. Feinstein, and C. E. Youman (1996) Role-based access control models. IEEE Computer 29 (2), p. 38–47. Cited by: Table 1, §8. [15] F. B. Schneider (2000) Enforceable security policies. ACM Transactions on Information and System Security 3 (1), p. 30–50. Cited by: §8. [16] D. Tsafrir, T. Hertz, D. Wagner, and D. Da Silva (2008) Portably solving file TOCTTOU races with hardness amplification. In USENIX Conference on File and Storage Technologies (FAST), Cited by: §1, §8.