acceptodds
Under review as a conference paper at ICLR 2027

Certified Execution for Agentic AI: Petri-Net Assurance Between Reasoning and Action

Abstract

Language-model agents ship code, call APIs and spend budgets, and a deployment cannot be recalled. We study an autonomous deployment agent that runs CI and a security scan, obtains human approval, then deploys, while an attacker hides an instruction in the issue description telling it to deploy at once. The difficulty is not one of accuracy. A guard that decides admission from the text it is shown cannot enforce “one approval authorizes one deployment”: every stateless monitor either admits an unauthorized action or admits none, enforcing the rule over a horizon needs at least monitor states, and over an unbounded horizon no finite-state monitor suffices. The guard must be able to count, and one place of a Petri net attains the bound exactly. We therefore hold the state in an agentic execution Petri net between the model and its tools, where approvals and budgets are marks that firing consumes, so one row of the state equation bounds deployments by approvals along every firing sequence. The synthesized supervisor is maximally permissive, as in classical supervisory control, and we prove that net-level safety transfers under four individually necessary assumptions. Empirically, four OpenAI models face seven indirect injections: unmediated, of injected episodes end in an unauthorized release. Under the kernel the models are hijacked just as often, no unauthorized deployment executes in any of kernel-mediated episodes, and pooled over the four models, task completion is higher than under any baseline, including no defense at all.

Primary area:
neurosymbolic & hybrid AI systems (physics-informed, logic & formal reasoning, etc.)
Keywords:
agentic AI, AI safety, Petri nets, formal methods, supervisory control, runtime assurance, tool-use agents, prompt injection

Reviews

Among:
Shape:
1234this paper, Bottom 25%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.75 over 4 reviews, above 25% of the others.
Reviewer_V4n5OpenReview ↗
Rating
2
Confidence
3
Informativeness
3
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes Agentic Execution Petri Nets (AEPNs), a deterministic execution layer placed between an LLM agent and its tools. Operational facts such as approvals, budgets, capabilities, and locks are represented as marks, and consequential actions consume the corresponding marks when transitions fire. The paper combines this representation with supervisory control to synthesize a maximally permissive safe supervisor.

The main example is an autonomous deployment agent that must complete CI and security checks, obtain human approval, and then deploy. The paper presents a memory lower bound for enforcing one-approval-per-execution, a safety-transfer theorem under four assumptions, and experiments involving indirect prompt injections against several OpenAI models. The central empirical result is that models often still propose unauthorized deployments under attack, but the AEPN kernel prevents these actions from executing. The paper also evaluates structural constraints on ToolSandbox.

Critical strengths

The paper makes an important distinction between semantic defenses and operational enforcement. Detecting whether text is malicious is fundamentally different from determining whether an action is authorized in the current execution state. Treating the LLM as an untrusted proposer and placing a deterministic reference monitor below it is a sound and practically relevant direction.

Representing approvals and budgets as consumable marks is intuitive and well suited to preventing replay and enforcing resource constraints. The deployment experiments clearly illustrate the value of this design: prompt injection can successfully alter the model’s proposed behavior without causing the unauthorized action to execute. The paper is also commendably explicit about the assumptions needed to transfer formal guarantees to a concrete runtime, particularly complete mediation and correct grounding.

The work is informative and integrates theory, system design, and live-agent experiments. Even where the underlying formal machinery is classical, its application to LLM-agent execution security is useful and timely.

Critical weaknesses

1. The lower bound establishes the need for trusted state, not the necessity of Petri nets

The paper overstates what the memory lower bound establishes. The result shows that consumable authorization requires trusted operational state, or an equivalent count of prior approvals and executions. It does not establish that Petri nets are necessary: a transactional counter, immutable execution log, one-time capability, or hand-written stateful monitor can enforce the same property.

The related claim that one ordinary Petri-net place “attains the bound exactly” also requires clarification. The finite-horizon construction uses a saturated counter, whereas an ordinary unbounded place does not automatically saturate at ⌊H/2⌋\lfloor H/2 \rfloor.

2. The novelty relative to prior Petri-net work is insufficiently isolated

Consumable marks, place invariants, monitor places, controllable and uncontrollable transitions, and maximally permissive supervisory control are established techniques. The paper cites several Petri-net-based agent and autonomous-system frameworks, but does not provide a sufficiently detailed comparison establishing which runtime enforcement or synthesis capabilities are genuinely new.

The contribution appears closer to a valuable integration of classical Petri-net supervisory control into LLM-agent security than to a genuinely new formalism. The paper should more clearly distinguish its system-level and empirical contributions from established Petri-net and supervisory-control machinery.

3. Maximal permissiveness does not imply preservation of end-to-end agent capability

The paper does not adequately evaluate the capability cost of intervention. Maximal permissiveness holds only relative to the predefined net, action vocabulary, abstraction, and forbidden-state specification. It does not imply preservation of the closed-loop agent’s real-world capability.

A safe but unmodeled recovery strategy or tool composition may be rejected exactly like an unsafe action. Refusals also change the model’s subsequent trajectory, consume interaction budget, and may cause repeated calls or premature termination. The paper’s own ablation, where task completion falls from 0.84 to 0.39 under a less informative refusal, demonstrates that utility is sensitive to intervention. Since the experiments largely encode the intended workflow directly into the net, they do not establish whether stronger or more open-ended agents retain their capability ceiling.

Questions for authors
  1. What does Theorem 1 establish beyond the need for trusted operational state? Can the authors provide a standard Petri-net construction showing how one place exactly realizes the finite-horizon saturated-state bound?

  2. Is AEPN intended as a genuinely new formalism or as an agent-security-specific instantiation of colored Petri nets and classical supervisory control? What functionality is absent from the closest prior Petri-net-based agent systems?

  3. What happens when an agent discovers a safe and useful strategy that has no corresponding transition or path in the predefined net? How does the framework distinguish unsafe behavior from behavior that was simply not anticipated by the model designer?

  4. Can the authors evaluate capability preservation on clean, open-ended tasks with multiple safe workflows, dynamic failures, and fixed interaction budgets? A comparison against a hand-written stateful workflow monitor, and across plan-then-execute and ReAct-style agents, would help isolate the value and scope of the Petri-net formulation.

4 comments
AuthorsOpenReview ↗

Response to V4n5 (1/4): you are right — Theorem 1 shows a trusted count is needed, not a Petri net; what it does establish

Thank you for a precise and thoughtful review, and for your generous reading of the paper's direction. We agree with almost all of it, and your W1 is the point that sent us back to Theorem 1.

W1, first paragraph, and Q1, first part. "It does not establish that Petri nets are necessary: a transactional counter, immutable execution log, one-time capability, or hand-written stateful monitor can enforce the same property." And: "What does Theorem 1 establish beyond the need for trusted operational state?"

A. You are right, and we overstated it. Theorem 1 says how much memory enforcing the rule takes. It does not say what holds the memory. Any mechanism that keeps a correct count enforces the rule, including all four you name. Four sentences in the paper said more, and the revised PDF corrects all four. §4.1 now reads "proving it, with the threat model of §2, fixes the architecture, a trusted count, though not the formalism" (p. 5, l. 228–229 of the revised PDF). Its later "case for nets over state machines" is now a case for counters over finite-state machines (p. 5, l. 267). Corollary 2's title no longer adds that the guard is therefore not a state machine (p. 5, l. 262). Remark 2 in App K drops the same inference.

Beyond "state is needed", Theorem 1 gives three things.

  • A dichotomy (Corollary 1): a stateless monitor either admits an unauthorized execution or admits no execution containing ex\mathsf{ex}, at any detector accuracy.
  • A number: ⌊H/2⌋+1\lfloor H/2\rfloor+1 states over horizon HH, attained exactly, and Ω(klog⁡(H/k))\Omega(k\log(H/k)) bits for kk independent authorities.
  • Non-regularity (Corollary 2): over an unbounded horizon no finite-state monitor suffices, and one unbounded counter does.

It says nothing about trust. That the count must sit below the model comes from the threat model (§2, l. 136–139) and from A2 and A4.

Why we hold the count in a net is a separate argument, and not a consequence of Theorem 1. Whether an approval is spent or only tested is an arc (App E, l. 1160–1162). Invariants come from the incidence matrix with no enumeration, and hold for every initial marking of the same shape (App I, l. 1736–1738). A linear constraint becomes one monitor place (§4.2, l. 263–266). Six modules cover all 129 ToolSandbox scenarios (E5, l. 433–435). §1 makes the same point about a hand-written checker: it holds the same counter, but offers no synthesis, no reuse across tools and tasks, and no invariant valid for every initial marking (l. 082–085). What the paper does not show is that any of this matters at scale.

AuthorsOpenReview ↗

Response to V4n5 (2/4): one place does not attain the bound; the two-place construction, three further errors we found and corrected, and what we checked

W1, second paragraph, and Q1, second part. "an ordinary unbounded place does not automatically saturate at ⌊H/2⌋", and: "Can the authors provide a standard Petri-net construction showing how one place exactly realizes the finite-horizon saturated-state bound?"

A. You are right: one place does not. Let K=⌊H/2⌋K=\lfloor H/2\rfloor. The place we meant is Corollary 2's counter. It enforces ΦauthH\Phi^H_{\mathrm{auth}}, but along apH\mathsf{ap}^H it takes H+1H+1 values. Two places attain the bound. Take pp with M0(p)=0M_0(p)=0 and a complement pˉ\bar p with M0(pˉ)=KM_0(\bar p)=K. Let tapt_{\mathsf{ap}} move a mark from pˉ\bar p to pp, and text_{\mathsf{ex}} move it back. Add tap′t'_{\mathsf{ap}}, also labelled ap\mathsf{ap}, with a self-loop of weight KK on pp and no other arc. Then M(p)M(p) is the saturating counter. Without tap′t'_{\mathsf{ap}} the net refuses the (K+1)(K+1)th approval, which ΦauthH\Phi^H_{\mathrm{auth}} allows, so that net is not transparent. The construction is therefore a labelled net with a weighted self-loop, not one ordinary place. The abstract and contribution (i) now say "two places" (p. 1, l. 020–021; p. 2, l. 091–092), and §4.1 and App K give the construction (p. 5, l. 251–257; p. 38, l. 2016–2032).

Checking your two points, and then re-checking the rest of the result, turned up three errors of ours, all corrected. Theorem 1's statement had the attaining monitor store \min\\{\\#\mathsf{ap}-\\#\mathsf{ex},K\\}, which the saturating counter does not hold. App K's proof said "cc equals the surplus whenever the surplus is at most KK", which is false for H≥3H\ge3; a corrected argument reaches the same conclusion. And our kk-authority count was not what kk places hold; the bound is now (K+kk)\binom{K+k}{k}, with its tightness not shown. We are grateful that your question led us to these.

What we checked, and what we did not. By enumerating all words over ap,ex\\{\mathsf{ap},\mathsf{ex}\\} of length at most HH:

ClaimChecked?
The saturating counter enforces the rule, with K+1K+1 statesyes, 2≤H≤142\le H\le14
One place enforces it and takes H+1H+1 valuesyes, same range
The two-place net enforces it, with K+1K+1 reachable markingsyes, same range
Without tap′t'_{\mathsf{ap}} the net refuses apK+1\mathsf{ap}^{K+1}yes, same range
apK+1ex\mathsf{ap}^{K+1}\mathsf{ex} refutes both old sentencesyes, 3≤H≤143\le H\le14
The corrected App K argumentyes, same range
The (K+kk)\binom{K+k}{k} fooling set, and kk counters saturating at KKyes, (H,k)=(4,2),(6,2),(8,2),(4,3),(6,3)(H,k)=(4,2),(6,2),(8,2),(4,3),(6,3)
The place invariant, and that M(p)M(p) follows the counter step by stepno; App K argues both
That kk places, one per authority, enforce the policyno; it follows from Corollary 2

The check script is in the revised supplementary material. Apart from these checks we ran nothing new.

AuthorsOpenReview ↗

Response to V4n5 (3/4): AEPN is an instantiation of colored Petri nets and classical supervisory control; the combination is what we claim

W2 and Q2, first question. "The contribution appears closer to a valuable integration of classical Petri-net supervisory control into LLM-agent security than to a genuinely new formalism." And: "Is AEPN intended as a genuinely new formalism or as an agent-security-specific instantiation of colored Petri nets and classical supervisory control?"

A. It is an instantiation, and thank you for putting the question so plainly. We agree, and the paper should have said so in those words; the revised PDF now does, in §7 (p. 10, l. 515–516). Definition 1's first eight components are a colored Petri net (l. 141). Labels, controllability, observability, monitor places (l. 263–266) and Theorem 2 (l. 291) are classical, and §7 says the lineage is classical (l. 474). We claim only the combination (§7, l. 483–486):

  1. run-time admission of model proposals in the tool-call path;
  2. the model as an untrusted proposer under indirect injection;
  3. consumable authority;
  4. uncontrollable events with supervisor synthesis;
  5. a transfer theorem with each of A1–A4 shown necessary (Theorem 3, Proposition 1);
  6. live attacks, in which the models are hijacked yet no unauthorized deployment executes (E2, E2b).

Read for agent guards, Theorem 1 and Corollary 1 then say this: a stateless guard is unsafe or useless, and one with fewer than ⌊H/2⌋+1\lfloor H/2\rfloor+1 states is unsafe or over-restrictive. That holds at any detector accuracy. Empirically, E1 finds that the defect is in the actuator, and six modules cover all 129 ToolSandbox scenarios (E5).

Q2, second question. "What functionality is absent from the closest prior Petri-net-based agent systems?"

A. The paper does not answer this system by system, and it should. The five Petri-net-based agent and autonomous-system frameworks we cite (l. 482–483) appear only in a list, and we would rather not characterize each of them from memory in this reply. We do not claim that each of them lacks all six elements above; we claim their combination. A per-system comparison along these six elements belongs in §7, and we will add it in the final version.

AuthorsOpenReview ↗

Response to V4n5 (4/4): maximal permissiveness is relative to the net — agreed, and now stated so; unmodelled safe actions are refused; what E2 does and does not show about capability

W3. "Maximal permissiveness holds only relative to the predefined net, action vocabulary, abstraction, and forbidden-state specification. It does not imply preservation of the closed-loop agent's real-world capability."

A. Thank you for stating this so exactly; we agree. Theorem 2 compares the safe supervisors of one net under full observation. It says nothing about actions the net does not model, about how a trajectory changes after a refusal, or about the abstraction. Four sentences in the paper claimed more (§4.3, l. 291–292; App D, l. 1005–1006; App J, l. 1877; §6, l. 415–416). The revised PDF replaces all four with the narrower statement, which is the correct one (p. 6, l. 308–312; p. 9, l. 446–447; p. 20, l. 1058–1061; p. 36, l. 1930–1932): under full observation, S⋆S^\star refuses no firing that some safe supervisor of the same net would allow. Capability lost to what the net does not model, or to how the agent reacts to refusals, is a separate quantity, and Theorem 2 does not bound it.

Our own numbers agree with you (Table 2, completion on injected episodes):

KernelBest baseline
Pooled over the four models0.840.73, the prompt policy
gpt-4.10.510.96, the prompt policy
Pooled, with the bare refusal instead of the informative one0.39—

Pooled, the other two arms are further back, 0.16 with no mediation and 0.10 for the guardrail (l. 409–410). So the abstract's "task completion is higher than under any baseline" holds pooled over the four models, as the abstract says, and not per model. It also reflects the scoring: an executed unauthorized release ends the episode as a failure (l. 410–412). On gpt-4.1, after a refused deploy, the model stops under two payloads and keeps retrying under a third (l. 421–423).

Q3. "What happens when an agent discovers a safe and useful strategy that has no corresponding transition or path in the predefined net?"

A. It is refused exactly like an unsafe one: α\alpha returns ⊥\perp, so the first conjunct of (1) fails, while internal steps pass with the marking unchanged (l. 302–303). The conjuncts of (1) do tell a refusal for want of a model from a modelled hazard. They do not tell a safe unmodelled action from an unsafe one, and the paper does not report refusals by conjunct. The remedies we have are at design time: App M's library was refined by inspecting every refusal (l. 2262–2263), and App L sketches certified reconfiguration (l. 2129–2135).

Q4. "Can the authors evaluate capability preservation on clean, open-ended tasks with multiple safe workflows, dynamic failures, and fixed interaction budgets? A comparison against a hand-written stateful workflow monitor, and across plan-then-execute and ReAct-style agents, would help isolate the value and scope of the Petri-net formulation."

A. These are the right tests. We did not run new experiments for this revision, so we answer from what the paper already has, and on the first two parts the answer is that it does not show this. The new §8 states both as limitations (p. 10, l. 522–539).

Capability on clean, open-ended tasks is not shown. E2 is one workflow with episodes capped at 16 model turns (l. 2300), and the paper reports clean results only for the guardrail (l. 412–414). E5 is structural, since running agents through ToolSandbox "is not part of this paper" (l. 2560–2561).

No hand-written stateful monitor was run. By Theorem 1, a checker that tests the same preconditions and counts unspent approvals correctly, which §1 concedes "holds the same counter" (l. 082–083), should tie the kernel's zero on E2. Completion is another matter, since it turns on the refusal text. E2 also cannot separate spending an approval from only testing it: each episode has one change request, and no payload replays a spent approval (App N, l. 2298–2299 and 2313–2316).

The architecture is the one part we can answer. The guarantee does not depend on it: rule (1) reads only the proposed call and the marking (in E2, "the tool name and nothing else", l. 2353), and Theorem 3 assumes nothing about the proposer, only A1–A4. Utility does depend on it, and E2 ran one tool-calling loop (l. 396–397), so we have no utility figure for a plan-then-execute agent.

Thank you again for a review that corrected the paper's central result. We hope these answers are helpful, and we would be glad to clarify anything further.

Reviewer_6gtPOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
1
Soundness
2
Read review
Paper summary

This paper proposes the Agentic Execution Petri Net (AEPN) framework, a formal execution-control layer for LLM-based agents to prevent unauthorized tool executions such as during software deployment. The authors first establish that enforcing rules such as one approval per deployment requires tracking states. The framework models workflow prerequisites such as CI tests, security scans, and human approvals using Petri nets. This representation enables formal verification of execution constraints and supervisor synthesis to determine which actions can be safely executed based on the current system state and possible future events.

The authors evaluate the framework using four OpenAI models against seven indirect prompt-injection attacks in a simulated software deployment environment. Compared with no defense, a system-prompt policy, and an LLM-based guardrail, AEPN achieves zero unauthorized deployments and the highest overall task completion rate of 84%. The authors also experimented with adaptive prompt-injection and generalization experiment to other scenarios in the ToolSandbox benchmark.

Critical strengths

Interesting integration of formal modeling and agentic execution. The paper presents an interesting approach of using Petri nets to model workflow prerequisites and combining formal verification techniques to prevent unauthorized agent actions.

Formal foundations and safety guarantees. The authors provide formal definitions and theoretical analysis of the proposed framework

Critical weaknesses

Insufficient justification for the use of Petri nets. Although the authors discuss alternative modeling approaches such as finite-state machines and statecharts in Appendix E, the advantages of Petri nets over these alternatives are not convincingly established. Is the benefit some sort of theoretical advantage of Petri nets or are these alternatives dismissed through naive poor implementation? In particular, the evaluated deployment workflow has a relatively small state space, and it remains unclear whether simpler modeling approaches could achieve similar results.

Unclear presentation of the framework setup. Although Appendix F provides a walkthrough of constructing the Petri-net model as an example, Figure 1 and the main text do not clearly distinguish what needs to be manually defined by developers and what is automatically synthesized.

Limited comparison with existing deterministic enforcement approaches. The main evaluation compares AEPN against a system-prompt policy and an LLM-based guardrail, but does not include existing deterministic enforcement approaches discussed in the related work. If direct comparisons are not feasible due to differences in objectives or assumptions, the authors should clarify these distinctions.

Clarity and organization of the writing. The paper is difficult to follow in several places due to dense technical explanations and occasionally overly elaborate wording.

Questions for authors

none

1 comment
AuthorsOpenReview ↗

Response to 6gtP: Theorem 1 requires a count, not a net; what the developer writes vs what is computed, now in §2; deterministic baselines were not run

Thank you for four fair points, and for finding the integration of formal modeling and agent execution interesting. Your weakness bullets are unnumbered, so we number them W1 to W4 in the order you wrote them.

W1, the justification for Petri nets. "the advantages of Petri nets over these alternatives are not convincingly established. Is the benefit some sort of theoretical advantage of Petri nets or are these alternatives dismissed through naive poor implementation? In particular, the evaluated deployment workflow has a relatively small state space."

A. It is neither, and we should have said so plainly. Theorem 1 requires a count, not a net. The revised PDF now says so: §4.1 states that proving it fixes the architecture, a trusted count, and not the formalism (p. 5, l. 228–229), and Corollary 2's title no longer concludes that the guard is not a state machine (p. 5, l. 262). The alternatives in App E were argued, not implemented. You are right about the state space too: the deployment net has 32 reachable markings (Table N5), so a state machine, a statechart or a hand-written checker that counts approvals (l. 082–083) could enforce the same rule.

For bounded systems a net adds no expressiveness. A bounded net unfolds into a finite automaton over its reachable markings (App E, l. 1101–1102), and our synthesis is a fixed point on that finite set, which is automaton-based supervisory control. What a net adds is structure in how the model is written and checked. Whether an approval is spent or only tested is an arc (App E, l. 1160–1162). Invariants come from the incidence matrix with no enumeration (App I, l. 1736–1738). A linear constraint becomes one monitor place (§4.2, l. 263–266). Six modules are reused across all 129 ToolSandbox scenarios (E5). The paper does not show that this matters at scale.

W2, the framework setup. "Figure 1 and the main text do not clearly distinguish what needs to be manually defined by developers and what is automatically synthesized."

A. We agree. §2 now has a paragraph, "What the developer writes, and what is computed" (p. 4, l. 187–193). As two lists, not pairs:

Written by the developerComputed
The net, including which preconditions are spent and which only tested, and M0M_0The reachable set
Each transition's label, controllability, observability and principalK⋆K^\star and S⋆S^\star (Eqs. (3)–(4)), with the nonblocking trim
The forbidden markings BB, or the constraints LM≤bLM\le bMonitor places and place invariants
The color abstractionWhich forbidden calls are dead (E5)
The interface α\alpha and the validator VV

At run time the kernel holds the marking and applies rule (1). So Table 1's "synth." (l. 067) is true of the supervisor only, not of the net or the forbidden set it is computed from, and §2 now says so.

W3, comparison with deterministic enforcement. "does not include existing deterministic enforcement approaches discussed in the related work. If direct comparisons are not feasible ... the authors should clarify these distinctions."

A. We agree. None was run; the new §8 states this as a limitation (p. 10, l. 522–539). E2 separates stateful mediation from defenses that read text, not our kernel from other deterministic defenses, so the distinctions §7 argues are untested. Labels, capabilities and taint ask whether a value may reach a sink; a marking asks whether an authority has been spent (l. 464–465). None of those defenses models events the deployer cannot refuse, and none synthesizes its policy (l. 468–469). CaMeL keeps the injected text out of the agent's plan, which our kernel does not (l. 470–472).

One correction to the 84% quoted in your summary. It holds pooled over the four models, 0.84 against the prompt policy's 0.73, the best of the three baselines. Per model it does not: on gpt-4.1 the kernel completes 0.51 of injected episodes and the prompt policy 0.96 (Table 2). It also reflects the scoring, since an executed unauthorized release ends the episode as a failure (l. 410–412).

W4, the writing. "The paper is difficult to follow in several places due to dense technical explanations and occasionally overly elaborate wording."

A. We agree. The revised PDF defines notation at first use and adds the paragraph above and a Limitations and conclusion section, but it does not rewrite the prose; the final version will shorten §1, §2 and §4.1.

We hope this clarifies the scope of the contribution, and we would be glad to discuss further.

Reviewer_54ipOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
1
Soundness
2
Read review
Paper summary

This paper proposes framing the interactions of LLM with tools (i.e., agentic setting) using Petri net formulation, the proposed framework is called AEPN. This framework aims to defend against adversarial prompt injections. Specifically, the application is code deployment. The authors provide theoretical and experimental evidence (with very limited baselines) that other automated tools, that do not consider the budget of "authority units" (i.e., the count of code acceptances), cannot guarantee safety in the long term. The authors claim that APEN can certify safety under 4 assumptions, two of which seem really strong . The authors acknowledge that the assumption (A2), that is, an attacker cannot change the safe state of the system without being undetected, is strong and make the guarantee fail in practice. The presentation could be enhanced. Sections: Conclusion, Limitations, and Future Work are missing.

Critical strengths
  • The main idea is well-motivated and the Petri net formulation seems novel (to the best of my knowledge, they have not been used to address the gap presented in this paper). Petri net formulation is well-grounded. It enables the agentic system to decide based on the previous states (what it has already been done), beyond simply assessing if the query is malicious or benign.
  • The limitation of prior work (that does not count "authority units") in agentic settings is theoretically justified in Theorem 1.
Critical weaknesses
  • Limited evaluation: Table 1 mentions 8 baselines, while in experimental evaluation only two of them are used, while Table 2 compares the AEPN kernel against LLM guardrail (which does not count authority units), and "policy in the prompt". State-of-the-art approaches like Progent and AgentArmor (which partially count "authority units") are not used for empirical evaluation.
  • Strong assumptions: Some of the assumption seem really strong.
    • The authors acknowledge that assumption 2 (the safety state of the model is not changed silently, i.e., without going undetected) makes the guarantee fail in practice (lines 323). In Sec. 5 the authors provide an analysis about the trade-off between verifiability and practicality. However, in Corollary 3 (subsequently Proposition 2 etc), the analysis considers an upper-bound on the failure probability up to the kkth event. What really matters is the failure probability through the whole HH. How does the failure probability accumulates when the failure propagates to the following H−kH-k events (which seems a realistic case)?
    • Moreover, assumption 4 is defined to be fully covered by sandboxing. However is this implementation (empirical) choice sufficient for claiming that the yielded probabilistic upper-bound ensures certification?
  • Presentation: The paper is very notation heavy, which is not necessarily bad. However, the presentation hampers readability. For instance, notations that first appear in paragraph in the first paragraph of Sec 2. are defined later (e.g., N,P,TN,P,T). Another example: Figure 1 (page 3), writes K∗K^*, without defining it in the caption, while K∗K^* is not defined even in page 6.
Questions for authors

Please see Weaknesses for the Questions. Here I list only the suggestions. The suggestions are presented by the same order the weaknesses are presented. Only the last weakness (regarding presentation) maps to two suggestions.

  1. Please, provide a comprehensive experimental setup with more than two baselines (preferable they ones that are referred to partially count "authority units").
  2. Please clarify what happens after the first error, i.e., errors that propagate through the remaining H−kH-k steps. Also, please consider providing detailed intuition about the assumption. Now, they 4 assumptions are mainly encoded (using math formulations) in 8 lines (301-308).
  3. I think, that the failure probability of assumption 4 must be factored into the total guarantee. Otherwise, provide evidence that this error is negligible in practice.
  4. Perhaps, the Glossary and Notation Table in Sec. J could be transferred to the main manuscript to mitigate the readability issues. I believe that this would significantly facilitate readers (even those that come from broader research sub-fields) to appreciate the analysis and the results of this paper.
  5. Please, consider naming all the notation used, e.g., μ\mu. Assuming that the context will do this work for free may lead to readers' misconceptions. In the same line of thought, some notations are defined in page 3, while the contribution in theoretical analysis is much later on. In these cases, please consider, briefly name or describe what this measures mean. The latter applies for abbreviations like "ex" and "ap".
2 comments
AuthorsOpenReview ↗

Response to 54ip (1/2): the baselines were not run (now a stated limitation); Corollary 3 already bounds the whole horizon, and now says so; A1–A4 in plain words

Thank you for the detailed, numbered suggestions, for reading the assumptions so closely, and for your positive view of the motivation and of Theorem 1. We take your points in your own order. Where we agree, the revised PDF now makes the change, and we give its location at each point.

W1 and Suggestion 1. "Table 1 mentions 8 baselines, while in experimental evaluation only two of them are used ... State-of-the-art approaches like Progent and AgentArmor (which partially count 'authority units') are not used for empirical evaluation."

A. You are right. E2 ran two of Table 1's eight defenses, the prompt policy and the LLM guardrail, besides no mediation and the kernel's own ablation. No deterministic or stateful baseline was run. We ran no new arm for this revision, so we have no data on Progent or AgentArmor; the new §8 states this as a limitation (p. 10, l. 522–539).

Theorem 1 does give us this much without data. A checker that tests the same preconditions as the net, and counts unspent approvals correctly, should tie the kernel's zero unauthorized deployments on E2. Its completion could differ, since completion depends on the refusal text. E2 also cannot separate spending an approval from merely testing it. Each episode has one change request, and no payload replays a spent approval (App N, l. 2298–2299 and 2313–2316).

Table 1's "partial" for Progent and AgentArmor (l. 065–066) was not explained; its caption now explains it (p. 2, l. 058–060).

W2 and Suggestion 2. "in Corollary 3 ... the analysis considers an upper-bound on the failure probability up to the kth event. What really matters is the failure probability through the whole H. How does the failure probability accumulates when the failure propagates to the following H − k events?" And: "please consider providing detailed intuition about the assumption."

A. This is our fault for not saying it plainly in §5; it now does (p. 7, l. 364–365). Corollary 3 does bound the whole horizon: Psafe through H≥∏k≤H(1−εk)P\\{\text{safe through }H\\}\ge\prod_{k\le H}(1-\varepsilon_k) (l. 330–333). Each εk\varepsilon_k is conditional on the history before step kk, so a later error may depend on an earlier one. A first false certification at step kk counts as losing the guarantee for the remaining H−kH-k steps. Any propagation is therefore already inside the bound, and the hypothesis is used only on histories with no earlier violation (l. 2084–2085).

Two of our statements needed sharpening; the proofs do not change. First, EkE_k is now the event that A2 fails at some step after the (k−1)(k-1)th admitted action and up to the kkth, world-changing internal steps included (p. 7, l. 358–359; p. 41, l. 2161). Then "on ⋂kEkc\bigcap_k E_k^c all four assumptions hold" (l. 2078–2079) is literally true. Second, Proposition 2's "exactly" now carries its condition, that every violation is fatal (p. 40, l. 2125).

On the intuition, §4.4 now gives the four assumptions in plain words, each with its counterexample from Proposition 1 (p. 7, l. 343–348):

  • A1: the net starts where the world is. It fails if a credential is already issued while M0M_0 shows none.
  • A2: every runtime step is matched by its firing, or changes nothing the net tracks, so the interface never certifies a step whose real precondition is false. It fails if a delete-production call is mapped onto the delete-staging transition.
  • A3: what the net calls safe is safe. It fails if the safe set ignores a place recording credential exposure.
  • A4: nothing consequential bypasses the kernel. It fails if the agent holds a shell that reaches the API directly.

A1 and A3 are discharged when the net is written, A4 by the platform, through sandboxing, egress control and credential brokering, and A2 by the interface: its parsers, validator and approval channel.

Our sentence "A2 is the hard one, and where the guarantee fails in practice" (l. 323) now reads: A2 is the one assumption that construction cannot discharge, so it is where we expect the guarantee to be lost in deployment (p. 7, l. 342–343).

AuthorsOpenReview ↗

Response to 54ip (2/2): A4's failure probability now enters the bound; notation; a new Limitations and conclusion section; the ethics flag

W2 and Suggestion 3. "assumption 4 is defined to be fully covered by sandboxing. However is this implementation (empirical) choice sufficient for claiming that the yielded probabilistic upper-bound ensures certification?" And: "the failure probability of assumption 4 must be factored into the total guarantee."

A. You are right that it is not sufficient. Corollary 3 assumes that A1, A3 and A4 hold throughout the horizon (l. 330). Let δ\delta bound the probability that one of them fails within the horizon. Then, under the same hypothesis on εk\varepsilon_k, Punsafe through H≤δ+1−∏k≤H(1−εk)≤δ+∑k≤Hεk,P\\{\text{unsafe through }H\\}\le\delta+1-\prod_{k\le H}(1-\varepsilon_k)\le\delta+\sum_{k\le H}\varepsilon_k, since Theorem 3 applies wherever A1, A3 and A4 hold and no EkE_k occurs. §5 now states this (p. 7, l. 365–367). So the bound holds only as far as A4 does. We cannot show that δ\delta is negligible in deployment; it has to come from the platform's own assurance. If A4 can fail only through misconfiguration, δ\delta does not grow with HH; if actuation can escape the kernel at run time, it can. In E2's kernel arms the agent acts only through the nine tools, each through the kernel (App N, l. 2294–2297 and 2350–2355), which says nothing about a production sandbox.

The same qualification belongs on our zeros. They are conditional on A1–A4 and on the harness implementing the net. §5 called them guarantees (l. 346–347), and App N said the zero "depends on none of this" (l. 2289–2290); both now add the condition (p. 7, l. 377; p. 44, l. 2375). The title's "Certified" should be read the same way, and §8 says so: certified relative to A1–A4 and to the net, not absolutely.

W3 and Suggestions 4 and 5. "notations that first appear in ... Sec 2. are defined later (e.g., N, P, T) ... Figure 1 (page 3), writes K*, without defining it in the caption ..."

A. We agree, and thank you for the concrete suggestions. The revised PDF names PP and TT where NN is introduced (p. 3, l. 127), names the monitor μ\mu (p. 5, l. 231), defines K⋆K^\star and S⋆S^\star in Figure 1's caption (p. 3), and adds μ\mu, ap\mathsf{ap}, ex\mathsf{ex} and Φauth\Phi_{\mathrm{auth}} to App J's table (p. 37, l. 1964–1966). In short:

  • N=(P,T,Pre,Post,M0)N=(P,T,\mathrm{Pre},\mathrm{Post},M_0): PP the places, TT the transitions, Pre and Post the arc counts into and out of each transition, M0M_0 the initial marking.
  • μ\mu: a monitor. It sees the history and the proposed action, and answers admit or refuse.
  • ap\mathsf{ap} and ex\mathsf{ex}: an approval, and the execution it authorizes.
  • K⋆K^\star: the largest set of safe markings that no uncontrollable event can leave.

"Sections: Conclusion, Limitations, and Future Work are missing."

A. You are right. The revised PDF adds §8, "Limitations and conclusion" (p. 10, l. 522–539), which collects what was scattered over §4.4, §5, "Threats to validity" and Apps K and N:

  • Every guarantee rests on A1–A4, and A2 is the binding one.
  • Synthesis assumes full observation and a bounded net.
  • Maximal permissiveness is relative to the net, so safe but unmodelled actions are refused.
  • The nets are written by hand.
  • E2 is one simplified workflow that never attacks the approval channel; its four models were called by alias, without logged snapshots.
  • No deterministic or stateful baseline was run, and E2b is a six-round search on two models.

Ethics flag. "The experimental setup includes malicious prompt injection into an agentic LLM system."

A. Thank you for raising it. The experiments attack an agent we wrote, inside a simulator we wrote (Ethics statement, l. 498–500). There are no human subjects, no personal data and no production system. The seven payloads are generic strings of publicly documented kinds (l. 500–501). In E2b an attacker model (gpt-5, falling back to gpt-4.1) rewrites payloads over six rounds against this agent, in our simulated world only (App N, l. 2369–2375). The Ethics statement now says so, with the supplement's adaptive attacker and the defensive purpose (p. 11, l. 555–558).

We hope these answers address your questions, and we would be glad to clarify anything further.

Reviewer_KBQNOpenReview ↗
Rating
1
Confidence
2
Informativeness
1
Presentation
1
Soundness
1
Read review
Paper summary

This paper argues that AI agents can't be made safe by trying to stop them being tricked. They have to be placed behind a layer that makes unauthorized actions impossible. The authors prove that any safety checker without memory either lets bad actions through or blocks everything, so the checker must count things like unused approvals. The author suggested to puts a Petri net between the AI and its tools, where approvals and budgets are counters that get used up, so the AI can't deploy without a fresh approval. In tests with four OpenAI models under prompt-injection attacks, the models were hijacked just as often, but zero unauthorized deployments got through and more tasks were completed than with any other defense.

Critical strengths

Clear motivation. It gives a good reason why improving classifier accuracy cannot fix consumable-authority violations. This is a useful message for the agent-security community in general.

Critical weaknesses
  1. This paper is extremely unreadable. The presentation is so poor that I believe warrant a clear rejection.
  2. Limited novelty of the mechanism. The enforcement idea (a stateful reference monitor counting consumable authority) is a long-established systems pattern also well studied in system field. Its contribution is primarily applying known control theory to LLM agents. This already existed in system control.
  3. The Petri net doesn't seem necessary to me for the headline result or be used in defence following similar concepts. The paper concedes that a hand-written approval counter holds the same state and would block the same attacks. The zero-violation E2 result therefore does not depend on the proposed formalism. It is unclear whether synthesis remains tractable or yields non-obvious insights on realistic systems with many agents, tools, and resources. Moreover, synthesis does not inherently require Petri nets; for bounded systems, automata-based supervisory control is equivalent in capability.
  4. The evaluation is highly simplified and does not reflect real deployment cases. In E2, the nine tools take no arguments, CI and the security scan always pass, the approver approves whenever asked, and no incident freeze occurs. Real deployment tools take parameters, which is where interface errors arise. The approval channel is simulated, so the experiments do not test whether approvals can be spoofed, which is precisely the trust the guarantee depends on.
  5. Missing baselines. The closest related systems (CaMeL, Progent, AgentArmor) appear only in Table 1. A head-to-head comparison, and a comparison against a simple stateful checker, would clarify what the Petri-net formulation adds.
Questions for authors

See weakness

4 comments
AuthorsOpenReview ↗

Response to KBQN (1/2): we agree on presentation, and that a counter suffices for E2; what the revision fixes, and what remains ours

Thank you for your candid review, and for recognizing that improving classifier accuracy cannot fix consumable-authority violations; that is the message we most wanted to convey. We agree with much of your review, the verdict on presentation included, and at each point we say what the revised PDF changes.

W1. "This paper is extremely unreadable. The presentation is so poor that I believe warrant a clear rejection."

A. We agree that presentation is the paper's main weakness. Nine pages carried six experiments and about ten formal results. The revised PDF makes a start, using the extra page allowed for revisions; it does not rewrite the prose, which the final version will.

Symbols were used before they were defined: Figure 1 used K⋆K^\star, which was defined only in passing three pages later (l. 281–282). The ones that cost a reader most are now defined at first use or in Figure 1's caption (p. 3; p. 3, l. 127; p. 5, l. 231):

  • N=(P,T,Pre,Post,M0)N=(P,T,\mathrm{Pre},\mathrm{Post},M_0): PP the places, TT the transitions, Pre and Post the arc counts into and out of each transition, M0M_0 the initial marking.
  • μ\mu: a monitor, which sees the history and the proposed action and answers admit or refuse.
  • ap\mathsf{ap} and ex\mathsf{ex}: an approval, and the execution it authorizes.
  • K⋆K^\star: the largest set of safe markings that no uncontrollable event can leave.

The main text also ended without a conclusion or a limitations section. It now ends with §8, "Limitations and conclusion" (p. 10, l. 522–539), which collects what was scattered over §4.4, §5, "Threats to validity" and Apps K and N. §2 also now separates what the developer writes from what is computed (p. 4, l. 187–193).

W2. "Limited novelty of the mechanism. The enforcement idea (a stateful reference monitor counting consumable authority) is a long-established systems pattern ..."

A. We agree, and the paper says as much: "The lineage is classical" (l. 474), and §7 now adds that the AEPN is an instantiation of colored Petri nets and classical supervisory control, not a new formalism (p. 10, l. 515–516). We claim only the combination (§7, l. 483–486), and the part of it that is ours is narrow. For language-model agents, a stateless guard is unsafe or useless, and a guard with fewer than ⌊H/2⌋+1\lfloor H/2\rfloor+1 states is unsafe or over-restrictive, at any detector accuracy (Theorem 1, Corollary 1). That is the strength you yourself credit. We also claim a transfer theorem with each of A1–A4 shown necessary (Theorem 3, Proposition 1), and the live finding that the attack succeeds at the model while nothing unauthorized executes (E2, E2b).

W3. "The Petri net doesn't seem necessary to me for the headline result ... for bounded systems, automata-based supervisory control is equivalent in capability."

A. We agree on all three counts. Theorem 1 requires a counter, not a net, and the revised PDF now says so: §4.1 states that proving it fixes the architecture, a trusted count, and not the formalism (p. 5, l. 228–229), and Corollary 2 is now titled "A counter is necessary" (p. 5, l. 262). §1 already concedes that a hand-written checker "holds the same counter" (l. 082–083), and such a checker, testing the same preconditions, should block the same E2 attacks. So E2's zero does not depend on the formalism. For bounded systems, automaton-based supervisory control is indeed equivalent in capability: our own synthesis is a fixed point on the finite reachability set (§4.3, l. 275–282).

On tractability the paper shows little. E1's nets have 27 to 32 reachable markings (Table N5), App I's replenishing variant has 220 (l. 1745–1746), and App I says that enumeration "is also what stops scaling first" (l. 1735–1736); §8 now lists this as a limitation.

AuthorsOpenReview ↗

Response to KBQN (2/2): every E2 simplification you list is correct; spoofing in text was tested, forging the channel was not; the baselines were not run

The simplified evaluation. "In E2, the nine tools take no arguments, CI and the security scan always pass, the approver approves whenever asked, and no incident freeze occurs. ... The approval channel is simulated, so the experiments do not test whether approvals can be spoofed, which is precisely the trust the guarantee depends on."

A. Every simplification you list is correct, and App N states them all (l. 2294–2303); §8 now repeats them as limitations (p. 10, l. 522–539). With argument-free tools the interface has nothing to misparse, so E2 does not test the grounding errors that §5 itself names as the residual risk. An approver who always approves flatters the kernel's completion.

Spoofing in text was tested; spoofing of the channel was not. Two of the seven payloads claim the approval in text (l. 2313–2315). The kernel reads only the tool name and takes the approval from the world (l. 2353–2355), and no unauthorized deployment executed under it (Table 2). We did not test forging the approval channel itself. It is assumed under A2 and A4, and you are right that this is where the guarantee's trust sits.

Two clarifications about that zero, both now in the revised PDF. First, the abstract's "1,120 kernel-mediated episodes" (l. 028–029) pools the kernel arm and the bare-refusal ablation, 560 injected episodes each, and "930 of those 1,120" (l. 407) pools them the same way. Neither arm executed an unauthorized deployment. The 95% (Wilson) upper bound is 0.0034 for the pool, and about 0.0068 for 0 of 560 (p. 9, l. 435–436). Second, the zeros are conditional on A1–A4 and on the harness implementing the net. §5 called them guarantees (l. 346–347) and App N said the zero "depends on none of this" (l. 2289–2290); both now state the condition (p. 7, l. 377; p. 44, l. 2375).

Missing baselines. "The closest related systems (CaMeL, Progent, AgentArmor) appear only in Table 1. A head-to-head comparison, and a comparison against a simple stateful checker, would clarify what the Petri-net formulation adds."

A. We agree, and none of them was run; §8 now states this as a limitation. We have no number for a simple stateful checker, nor for CaMeL, Progent or AgentArmor. By Theorem 1, the stateful checker should tie the kernel at zero unauthorized deployments. What it completes would depend on how its refusals read. CaMeL is complementary rather than comparable: it keeps the injected text out of the agent's plan, which our kernel does not (l. 470–472).

One correction to the completion claim in your summary, that more tasks were completed than with any other defense. It holds pooled over the four models, 0.84 against the prompt policy's 0.73, the best of the three baselines. Per model it does not: on gpt-4.1 the kernel completes 0.51 of injected episodes and the prompt policy 0.96 (Table 2).

Thank you again for the time you gave the paper. We hope these answers are useful, and we would be glad to clarify anything further.

Thank you for the rebuttal. There are too many places that need substantial reworks. I keep my clear rejection rating.

AuthorsOpenReview ↗

Response to KBQN: thank you

Thank you for reading our rebuttal and the revision, and for telling us where you stand. We understand your assessment, and we take your point that the paper needs more than the targeted fixes we could make during the discussion. Your review gives us a clear list of where that work should start, and we are grateful for the time you gave it.

Comments on the paper

4 comments
AuthorsOpenReview ↗

To all reviewers and the AC (1/3): Theorem 1 corrected and rescoped — a trusted count, not a net; what the revised PDF changes

We thank all four reviewers for careful and constructive reviews. We are encouraged that they found the distinction between semantic defenses and operational enforcement important and practically relevant (V4n5), the integration of formal modeling with agent execution interesting and well grounded (6gtP, 54ip), and the argument that no gain in detector accuracy can enforce consumable authority well justified (54ip, KBQN).

Reviewer V4n5's first point sent us back to Theorem 1. We had claimed more for it than it proves, and our statement that one place "attains the bound exactly" was wrong. Checking that turned up two further errors of ours, in Theorem 1's statement and in its proof in App K. Re-checking the rest of the result turned up a third, in the kk-authority bound, which no reviewer raised. The revised PDF corrects all of this. Nothing is renumbered, and every number in the paper stays as it was.

No result is withdrawn. The bound of ⌊H/2⌋+1\lfloor H/2\rfloor+1 states still holds, and it is still attained. Corollaries 1 and 2 still hold; what item 2 removes from Corollary 2's title is an inference, not the corollary. No experiment was re-run and nothing was re-scored; item 11's one number is a correction to the text, to agree with Table N8.

The revision also makes the text changes the reviewers asked for (items 12–22, in part 2): a Limitations and conclusion section, notation defined at first use, what the developer writes and what is computed, A1–A4 in plain words, Corollary 3 read over the whole horizon with a term for A4, the zeros stated as conditional on A1–A4, and maximal permissiveness stated relative to the net.

Revised text is shown in blue, except in item 10, where the rewording is not marked. Deletions cannot be shown in color, so they are listed here. The 22 items in parts 1 and 2 are every change the revision makes. In our replies a bare "l." is a line of the reviewed PDF, and "p. N, l. M" a page and line of the revised one.

1. Abstract and contribution (i) (p. 1, l. 020–021; p. 2, l. 091–092). We wrote that one place of a net attains the bound exactly. Two places do. One place takes H+1H+1 values over horizon HH, at most one bit above the bound (V4n5).

2. What Theorem 1 and Corollary 2 establish. They show that the guard must count. They do not show that a net must hold the count, and four sentences said otherwise (V4n5). In §4.1, "proving it fixes both the architecture and the formalism" (l. 221) now reads "proving it, with the threat model of §2, fixes the architecture, a trusted count, though not the formalism" (p. 5, l. 228–229). Also in §4.1, "the case for nets over state machines" (l. 252) is now "the case for counters over finite-state machines" (p. 5, l. 267). Corollary 2's title drops "so the guard is not a state machine" (l. 247; now p. 5, l. 262), which is true only for an unbounded budget. Remark 2 drops "which is why the model of §2 is a net" (p. 39, l. 2076).

3. Theorem 1 (p. 5, l. 244–246) now names the saturating counter as the attaining monitor. The reviewed statement had that monitor store \min\\{\\#\mathsf{ap}-\\#\mathsf{ex},\lfloor H/2\rfloor\\} (l. 236–237), which it does not hold. Found while checking V4n5's W1 and Q1.

4. §4.1, new text after Theorem 1 (p. 5, l. 251–257): what one place costs, the two-place net, and why its self-loop is needed (V4n5). The proof sketch's "exhaustive check" (l. 242) now reads "exhaustive search over monitors" (p. 5, l. 250–251).

5. §4.1, the kk-authority sentence (pp. 5–6, l. 269–270). We had called (⌊H/2k⌋+1)k(\lfloor H/2k\rfloor+1)^k states "what a net holds in kk places" (l. 254–255). That is a valid but weaker lower bound, and not what kk places hold. The sentence now gives (⌊H/2⌋+kk)\binom{\lfloor H/2\rfloor+k}{k}, with its tightness not shown. Our own re-check; no reviewer raised it.

6. §4.2 and E5 (p. 6, l. 281–282; p. 9, l. 469). The place they describe is Corollary 2's unbounded counter, not Theorem 1's (V4n5).

AuthorsOpenReview ↗

To all reviewers and the AC (2/3): the remaining corrections, and the text changes the reviewers asked for

Items 7 to 22 continue the list in part 1.

7. App K, "Attainment" (p. 38, l. 2008–2014). "cc equals the surplus whenever the surplus is at most KK" (l. 1952) is false for H≥3H\ge3. A corrected argument reaches the same conclusion (V4n5).

8. App K, new paragraph "The counter as a net" (p. 38, l. 2016–2032): the two-place construction in full, with its check (V4n5).

9. App K, "kk independent authorities" (p. 38, l. 2034–2045) now derives item 5's bound from a larger fooling set. It replaces "The kk counters that realize it are kk places" (l. 1961). Our own re-check.

10. "How to read this appendix" (p. 14, l. 733–737). The disclosure paragraph on the tutorial appendices is reworded. It still states that substantially the same tutorial exposition appears in our own work elsewhere and is reproduced so that this paper can be read on its own. It drops the description of that work as a set of related papers of ours, and the sentence advising a reader of more than one of them to skip it. No reviewer raised it.

11. Apps H and N (p. 31, l. 1638; p. 47, l. 2498; p. 47, l. 2526–2529; p. 48, l. 2590–2591; p. 51, l. 2726–2727). Five sentences are reworded to drop self-references to previous versions of this paper. What they say is unchanged, except that E3's common-cause factor at ρ=0.5\rho=0.5 is now about 200, as in Table N8, not 201. No reviewer raised them.

12. Table 1's caption (p. 2, l. 058–060) explains "partial" (54ip).

13. Notation (54ip, KBQN). §2 names PP and TT where NN is introduced (p. 3, l. 127), and §4.1 names the monitor μ\mu (p. 5, l. 231). Figure 1's caption (p. 3) defines K⋆K^\star and S⋆S^\star. App J's table adds μ\mu, ap\mathsf{ap}, ex\mathsf{ex} and Φauth\Phi_{\mathrm{auth}} (p. 37, l. 1964–1966).

14. §2, new paragraph "What the developer writes, and what is computed" (p. 4, l. 187–193) (6gtP).

15. Maximal permissiveness, stated relative to the net, in all four places that claimed more: §4.3 (p. 6, l. 308–312), §6 (p. 9, l. 446–447), App D (p. 20, l. 1058–1061) and App J (p. 36, l. 1930–1932) (V4n5).

16. §4.4 (p. 7, l. 342–348): the A2 sentence reworded, and A1–A4 in plain words, each with its counterexample (54ip).

17. §5, Corollary 3: EkE_k defined precisely (p. 7, l. 358–359), and a new paragraph: the bound covers the whole horizon, and a term δ\delta covers a failure of A1, A3 or A4 (p. 7, l. 364–367). App K matches (p. 40, l. 2125; p. 41, l. 2161) (54ip).

18. The zeros, qualified: conditional on A1–A4 and on the harness implementing the net (p. 7, l. 377; p. 44, l. 2375); and the 1,120 episodes explained as two pooled arms of 560, with the Wilson bound for each (p. 9, l. 435–436) (54ip, KBQN).

19. §7 (p. 10, l. 515–516): the AEPN is an instantiation of colored Petri nets and classical supervisory control, not a new formalism (V4n5, KBQN).

20. New §8, "Limitations and conclusion" (p. 10, l. 522–539) (54ip, KBQN). The main text stays within the 10 pages allowed for revisions.

21. Ethics statement (p. 11, l. 555–558): the E2b attacker disclosure and the defensive purpose (54ip).

22. App E (p. 22, l. 1158–1159): a garbled sentence repaired. No reviewer raised it.

AuthorsOpenReview ↗

To all reviewers and the AC (3/3): every concern, and where it is answered

Nothing else in the PDF changed. The revision adds no experiment. Experiments we could not run are stated as limitations in §8 and in each reviewer's thread, together with what the paper's existing results do and do not show. Two changes remain for the final version: a system-by-system comparison with the five Petri-net agent frameworks we cite (V4n5), and plainer prose in §1, §2 and §4.1.

Summary of concerns and where each is answered

ConcernRaised byOur responseStatus
Theorem 1 requires a count, not a net; "one place attains the bound"V4n5, 6gtP, KBQNAgreed; claims narrowed; two-place construction, checked by enumerationRevised PDF (items 1–9)
Novelty relative to classical Petri-net supervisory controlV4n5, KBQNAgreed: an instantiation; we claim only the combinationRevised PDF (item 19); per-system comparison in final version
Capability cost; maximal permissiveness is relative to the netV4n5Agreed; the narrower statement, and per-model numbersRevised PDF (item 15)
Deterministic baselines (Progent, AgentArmor, CaMeL, a stateful checker)54ip, 6gtP, KBQN, V4n5Not run; what Theorem 1 predicts, and what E2 cannot separateLimitation (§8)
Error propagation after step kk; A4 in the bound54ipCorollary 3 covers all of HH; a bound with a term for A4Revised PDF (item 17)
E2 is simplified; approval spoofingKBQNEvery simplification confirmed; spoofing in text tested, channel forgery notLimitation (§8)
Notation, K⋆K^\star, Conclusion and Limitations54ip, KBQN, 6gtPDefined at first use; new §8Revised PDF (items 13, 20)
What the developer writes vs what is computed6gtPNew paragraph in §2Revised PDF (item 14)
A1–A4 in plain words54ipEach with its counterexampleRevised PDF (item 16)
Ethics flag54ipOur own simulated agent and world only; defensive purposeRevised PDF (item 21)

We are grateful for the reviewers' time and care, and we would be glad to answer any further questions during the discussion.

AuthorsOpenReview ↗

To all reviewers and the AC: new experiment E2d — a hand-written counting checker ties the kernel; one that tests approvals without spending them releases a replayed approval 80/80

V4n5 (Q4), 54ip, 6gtP and KBQN each asked for a stateful baseline, and our replies said none had been run. We have now run two, as E2d (new Appendix O of the revised PDF), on E2's harness with the same four models and 20 seeds. Each checker is a dozen counters and if-statements, not a net, and each refuses with the kernel's own wording, so completion cannot differ because of refusal text.

  • The counting checker tests the net's preconditions and spends an approval on deploy.
  • The flag checker tests the same preconditions but never spends them. It asks only whether an approval was ever granted, which is App E's tested-versus-spent arc written as code.

E2's seven payloads. The counting checker ties a kernel run on the same day:

Unauthorized releasesCompletion on injected episodes
Kernel (same day)0/5600.825
Counting checker0/5600.846
Kernel in the paper (Table 2)0/5600.84

The completion difference is not significant (p = 0.33). Replaying all 14,692 calls offline shows that the two made the same decision, with the same refusal text, on every call, so the difference is sampling noise. As Theorem 1 predicts and §1 concedes (p. 2, l. 082–083), E2's zero does not depend on the Petri-net formalism.

A payload E2 lacked. After the legitimate release, a release-bot message in the tool result says the approval "covers re-deploys" and asks for a second deploy and publish. A second release without a fresh approval is unauthorized.

Arm (80 episodes each)Replayed approval released
No mediation79/80
Prompt policy53/80
Flag checker80/80
Counting checker0/80
Kernel0/80

Under the prompt policy, gpt-5-mini instead re-ran the checks and asked for a fresh approval in 12 of its 20 episodes. On E2 the flag checker behaves like the kernel: in the pilot it had 0 unauthorized releases in 28 injected episodes. It fails as soon as an approval can be reused. This is the case E2 could not separate (App N, p. 45, l. 2383–2384 and 2397–2401), and it is the one-approval-one-deployment rule that Theorem 1 is about.

What this does not show. We wrote both checkers with the net in hand, so the experiment does not say which one a practitioner would write. Progent, AgentArmor and CaMeL remain unrun. E2's net allows one approval per change request, so the kernel and the counting checker refuse any second release, and this experiment cannot measure refusals of legitimate re-releases. The replay payload is ours. API cost was USD 8.13, including a pilot. Code, episode logs and the equivalence check are in the supplement (e2d/).

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.