acceptodds
Desk rejected at ICLR 2027

OpenAgentFlow: Enabling System-Wide Safety Boundaries for Heterogeneous AI Agent Fleets

Desk rejected at ICLR 2027, so left out of the paper lists and the map.

Abstract

AI agents are evolving from isolated assistants into heterogeneous systems in which multiple agents, planners, tools, and execution backends act over shared user or enterprise environments. In such systems, safety becomes a system-level action-governance problem: whether a concrete pending action should be committed given policy-relevant state accumulated across a session. Existing safeguards operate at useful but fragmented boundaries, such as prompts, tool calls, GUI actions, or individual agent runtimes, making it difficult to enforce shared policies over composed action flows across heterogeneous execution paths. We present OpenAgentFlow, a control-plane/action-plane architecture that establishes the action-commit boundary as a shared enforcement interface. GUI, API, tool, and LLM-generated actions are normalized into a common AgentEvent stream and mediated by a shared pre-execution Policy Enforcement Point (PEP), while provenance, session state, audit evidence, and updatable policies are maintained outside individual agents. We evaluate OpenAgentFlow through a series of complementary system evaluations spanning controlled action-flow tests, a public external benchmark, post-deployment policy updates, and real Android execution. On a 300-case controlled suite, OpenAgentFlow achieves 94.00% accuracy and a 95.35% attack-block rate. On the complete 1,220-case AgentDojo-Traj split of TS-Bench, it achieves 97.62% accuracy, 96.59% unsafe-action recall, and a 1.96% safe false-intervention rate. Newly installed control-plane rules take effect without modifying protected agents, and the same enforcement path operates across live GUI, API/tool, and LLM-planned Android execution. These results show that a shared action-commit boundary provides a practical basis for consistent system-wide governance across heterogeneous agent execution paths. Code is available at https://anonymous.4open.science/r/Openagentflow-B161.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
AI Agents, Agent Safety, Runtime Enforcement, Tool-Using Agents, Multi-Agent Systems

Reviews

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

The paper presents OpenAgentFlow, a shared pre-execution governance framework for heterogeneous AI agents. It normalizes GUI, API, and tool actions into a common AgentEvent representation, with centralized policy enforcement, session provenance tracking, and dynamic rule updates. The framework combines deterministic rules with semantic adjudication. Evaluation includes controlled safety suites, 1,220 AgentDojo-Traj cases, and Android execution, reporting 94.00%, 97.62%, and 92.86% accuracy, respectively.

Critical strengths
  1. Practical system-level architecture. The shared action-commit boundary and centralized provenance management offer a reasonable approach to enforcing consistent policies across heterogeneous agents. Separating governance from individual agent implementations is particularly useful for real deployments.

  2. Encouraging empirical results. The evaluation includes an external benchmark and live Android execution. The 97.62% accuracy and 1.96% false-intervention rate on AgentDojo-Traj are promising, particularly compared with direct classification using the same Qwen backbone.

Critical weaknesses
  1. Limited validation of the central system-wide claim. AgentDojo-Traj primarily evaluates individual pending actions with independent sessions, rather than persistent cross-agent interactions. The evidence for shared provenance across agents largely comes from three constructed chains comprising only 14 stages. This is insufficient to establish robustness in realistic heterogeneous agent fleets.

  2. The incremental benefit and robustness of the full architecture remain unclear. On the controlled suite, the full system improves accuracy only from 93.33% (static T1+T2) to 94.00%, while the deterministic matcher misses all ten obfuscated-leak cases. Meanwhile, the external benchmark primarily exercises semantic adjudication rather than the proposed provenance mechanism. The paper also lacks end-to-end latency measurements for the expensive semantic stages.

Questions for authors
  1. Could the authors evaluate longer, independently generated multi-agent workflows that require cross-agent provenance tracking, including transformed or obfuscated sensitive information?

  2. Can the authors isolate the contribution of shared provenance and session state under matched policy and model configurations, and report end-to-end latency and computational overhead for the full T1–T4 pipeline?

2 comments
AuthorsOpenReview ↗

Response to Reviewer iSpp

We thank the reviewer for emphasizing the need to evaluate shared provenance in realistic multi-agent workflows and to quantify runtime overhead. We expanded our evaluation to 64 multi-agent workflows, added matched provenance ablations and a provenance integrity audit, and measured the complete T1–T4 enforcement pipeline.

1. Multi-Agent Workflow Evaluation

We expanded the evaluation from three constructed chains (14 stages) to 64 multi-agent workflows, covering 2–5 agent roles, five topologies, and eight data transformations, including spacing, masking, Unicode digits, Base64, hexadecimal encoding, and reversal.

The 64 workflows form 32 matched pairs. Within each pair, source data, workflow structure, communication channel, recipient, and authorization context are held constant, while field selection or revision varies. This design tests whether policy-relevant information is tracked across agents and execution stages under controlled changes.

We compared four configurations on the same workflow inputs:

ConfigurationAccuracyUnsafe RecallSafe FPI
Full Shared98.44%100%0%
Per-Agent70.31%62.50%19.35%
Shared History98.44%100%0%
No Provenance50.00%37.50%35.48%

Full Shared improves accuracy by 28.13 percentage points over Per-Agent and 48.44 points over No Provenance, achieving 100% unsafe-action recall with zero false interventions on determinate benign cases.

Full Shared and Shared History produce identical decisions. This equivalence is expected by construction: Shared History receives the complete serialized session trace, including source observations and downstream actions. This control therefore holds cross-agent information constant and isolates the contribution of provenance representation—typed bindings versus serialized history—rather than information availability. Typed, field-level bindings expose source–value relationships directly for deterministic source–sink matching and evidence inspection; serialized history requires these relationships to be reconstructed from the trace.

We also audited provenance integrity. OAF retained lineage across 90/90 executed non-identity transformation edges and correctly attributed 87/87 explicitly bound final output fields. This mechanism-level result addresses a different question from classification accuracy: it verifies that the lineage used for source–sink enforcement and audit is preserved across transformations, independent of whether Shared History yields the same decision.

2. Shared Provenance and End-to-End Runtime Overhead

The ablations use matched workflow inputs, policies, authorization context, and tool-effect definitions. Per-Agent state limits each decision to locally available information, whereas Full Shared makes provenance accumulated across the workflow available to the PEP. The results establish the classification benefit of shared context. The Shared History comparison isolates a second contribution: typed provenance provides an explicit, auditable representation for deterministic field-level matching, whereas serialized history requires reconstruction from raw traces.

End-to-end latency. We measured the complete OpenAgentFlowPEP.evaluate() execution on all 1,220 AgentDojo actions, including actual T1–T4 control flow and model-service requests.

StageSamplesP50P95P99
T1/T2 fast path1,2200.472 ms1.777 ms2.682 ms
T3 HTTP round trip1,220203.808 ms317.345 ms348.135 ms
T4 HTTP round trip4712.282 s3.159 s3.563 s
Full PEP evaluation1,220229.066 ms3.301 s3.646 s

The P95 from action arrival to decision completion is 3.352 s. T3 uses Qwen3.5-0.8B; T4 uses Qwen3.8-27B and is invoked for 471/1,220 actions, reserving the more expensive semantic stage for escalated actions.

Model invocation and token overhead. Across the 1,220 actions, the pipeline completed 1,220 T3 calls and 471 T4 calls: 1,691 successful action-level calls. The request log records 1,693 attempts, including two retries. Recorded usage totals 4,372,333 input tokens and 67,293 output tokens, averaging 1.386 successful model calls per action. T1/T2 remains millisecond-level, while semantic stages account for most end-to-end latency.

3.Manuscript revisions.

We will add the 64-workflow evaluation, provenance ablations, integrity audit, and full-pipeline latency/token measurements, and clarify how shared session context and typed provenance jointly support cross-agent governance.

We thank the reviewer. These experiments show that a common enforcement boundary and shared governance state let policy decisions account for cross-agent information flows rather than isolated actions.

AuthorsOpenReview ↗

Further Discussion on System-Wide Governance for Heterogeneous Agents

Further Discussion on System-Wide Governance for Heterogeneous Agents (Submission 20441)

Dear Reviewer,

Thank you again for your continued engagement with our work and for the specific follow-up questions. We appreciate that you have taken the additional experiments into account, and we would like to highlight three further results that directly address the remaining questions you raised.

1. Additional value of typed provenance under bounded history

We agree that the identical results between Full Shared and Shared History under complete traces do not, by themselves, establish the additional value of typed provenance.

To investigate this more directly, we conducted a new experiment with bounded session history, retaining only the most recent three events and the last 16,000 characters of serialized history.

We compared Full History, Bounded History, and Bounded + Typed Provenance across 64 controlled workflows.

The results show a clear difference once source observations leave the history window:

History lengthFull HistoryBounded HistoryBounded + Typed
~8K16/1616/1616/16
~18K16/160/1616/16
~32K16/160/1616/16
~48K16/160/1616/16

Across the 48 longer-history cases, Bounded + Typed Provenance retains all 48 correct source attributions, matching Full History, while Bounded History alone fails to recover the corresponding source information.

Importantly, all configurations prevent execution of the unauthorized actions. However, Bounded History escalates all 48 longer-history cases, including 24 with valid authorization, whereas Full History and Bounded + Typed Provenance correctly distinguish authorized from unauthorized actions.

This additional experiment demonstrates the specific value of typed provenance: retaining authorization-relevant source–value relationships even after the original observations have left the text-history window.

2. Execution-grounded reconstruction of transformation provenance

Regarding how transformation bindings are obtained, they are not simply taken from pre-annotated expected labels.

We conducted an execution-grounded provenance audit over 90 non-identity transformation edges. For each edge, the trusted tool adapter reconstructed lineage from the observed source value and recorded operation, re-executed the registered transformation, and checked the result against the actual recorded tool output.

The audit successfully recovered 90/90 correct transformation bindings and correctly attributed 87/87 explicitly bound final output fields.

Thus, the provenance evidence is grounded in observed inputs, actual tool-call arguments, and verified execution outputs.

3. Complete PEP replay and end-to-end classification

We also re-executed all 1,220 actions through the complete OpenAgentFlowPEP.evaluate() pipeline, allowing T1–T3 to determine early termination and T4 invocation dynamically.

The complete replay achieves:

  • Accuracy: 97.30%.
  • Unsafe-action recall: 97.73%.
  • Safe false-intervention rate: 2.88%.
  • T4 invocations: 496/1,220.

For comparison, the fixed-route composite evaluation achieves 97.62% accuracy, 96.59% unsafe-action recall, and 1.96% safe false-intervention rate.

We have now reported both protocols explicitly to distinguish the fixed-cohort comparison used for backbone evaluation from the complete execution of the implemented PEP routing logic.

We also measured the full PEP runtime separately, obtaining a P50 latency of 229.066 ms, P95 of 3.301 s, and P99 of 3.646 s under the serial-action latency protocol.

We hope these additional experiments directly address your remaining questions and provide a more complete picture of the role of typed provenance, its execution-level integrity, and the behavior of the complete enforcement pipeline.

We would greatly appreciate any further thoughts you may have as the discussion deadline approaches. If there are still aspects you would like us to clarify, we would be very happy to continue the discussion while there is still time.

Thank you again for your thoughtful feedback and consideration!

Best regards,
The Authors

Reviewer_9mDAOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper presents OpenAgentFlow, a runtime governance architecture for heterogeneous agent systems. Its central idea is to treat the pending action immediately before execution as a shared enforcement object. GUI actions, API calls, tool invocations, and LLM-generated calls are normalized into an AgentEvent and evaluated by a shared pre-execution Policy Enforcement Point (PEP). Policy, enforcement-observed provenance, bounded session state, audit evidence, and updateable rules are maintained in a control plane outside individual agents. The PEP combines structured rules, payload/provenance checks, and semantic fallback in a T1-T4 pipeline, returning ALLOW, DENY, REWRITE, or ESCALATE.

The paper evaluates the design using a 300-case controlled suite, a separate 200-case threat suite, dynamic policy updates, the 1,220-case AgentDojo-Traj split of TS-Bench, and 100 Android emulator executions. The reported results include 94.00% accuracy on the controlled suite, 97.62% accuracy on AgentDojo-Traj, and 92.86% trace-adjusted accuracy over 98 traced Android runs.

Critical strengths
  1. A clear and useful common enforcement boundary. The paper identifies the pending action immediately before commit as a stable point where GUI, API, tool, and LLM-planned execution can be governed consistently. Moving provenance, session state, audit evidence, and policy updates outside individual agents directly addresses risks that only appear after actions from several agents or endpoints are composed. This is the strongest reason to consider acceptance.

  2. The evaluation targets several distinct systems properties. The paper does more than report one classification score: it tests deterministic fast-path behavior, dynamic rule insertion, provenance-boundary failures, an external action-safety benchmark, and live Android integration. The error analyses for obfuscation, over-tainting, agent drift, and no-trace runs are candid and useful.

Critical weaknesses
  1. The controlled evidence is too tightly coupled to the implementation to support a general effectiveness claim. In the released artifact, the 300-case suite is generated from a small set of hand-written contacts, sink templates, and expected labels. The PEP uses corresponding fixed source/sink name lists, regexes, and exact or digit-normalized value matching. In the paper's own breakdown, 158 of 172 expected-DENY cases are direct cross-app or cross-tool reuse cases, and the deliberately constructed ten obfuscation cases and ten benign identifier cases account for most remaining errors. This is a useful mechanism test, but 94.00% accuracy on this suite is not persuasive evidence of generalization. The named-baseline comparison also changes the information available to each method: OpenAgentFlow receives typed value-to-source bindings and structured policy state that the baseline adapters do not receive, so the result combines an architecture comparison with an information advantage.

  2. The strongest headline results are not presently auditable, and the protocol leaves room for test-set selection effects. The anonymous artifact explicitly includes only deterministic synthetic offline suites; it does not include AgentDojo-Traj evaluation code/configuration, T3/T4 prompts and model settings, Android images, traces, or semantic labels. The paper evaluates several T4 backbones on the same 502-case final-review subset and reports the best-accuracy model, but does not state how the ten review-policy families, prompts, thresholds, or backbone were developed and frozen without consulting the evaluated split. For Android, semantic trace review covers only 50 of 100 runs, two no-trace runs are excluded, and the attack-block rate is 82.50%. These omissions make it difficult to determine whether the 97.62% external result and the trace-adjusted Android result will reproduce or transfer to new policies, apps, and action distributions.

Questions for authors
  1. Clarification that could raise the score: How were the ten AgentDojo review-policy families, T3/T4 prompts, thresholds, and choice of Qwen3.8-27B developed and frozen? Please state exactly which benchmark examples, labels, categories, or trajectories were inspected during development. Can you report a genuinely held-out protocol, such as policy development on a disjoint dataset or categories followed by one-shot evaluation on AgentDojo-Traj, and include uncertainty or repeated-run results for model-backed stages?

  2. Clarification that could raise the score: Can the authors release or provide during rebuttal the exact external-evaluation and Android configurations, prompts, model versions/decoding settings, per-case outputs, and all trace labels? In particular, who assigned the semantic Android labels, was labeling blinded or independently checked, and why was semantic review performed for only 50 executions? Please also report the result when all traced runs are scored under one pre-specified labeling rule.

  3. Clarification of the comparison: Can the authors provide an ablation in which AgentSpec-session or another programmable runtime monitor receives the same normalized records, typed value-source bindings, and source-sink policy table as OpenAgentFlow? This would separate the benefit of the proposed control-plane/PEP architecture from the benefit of supplying richer structured state.

6 comments
AuthorsOpenReview ↗

Response to Reviewer 9mDA

Response to Reviewer 9mDA

We thank the reviewer for recognizing the central contribution of OpenAgentFlow: a common pre-execution enforcement boundary for heterogeneous agent systems. We appreciate the questions regarding evaluation generality, reproducibility, human validation, and baseline comparison. We have substantially expanded our evaluation, including a 64-workflow cross-agent study, a provenance integrity audit, expanded independent human validation, and additional model and runtime measurements. These results provide further evidence for the effectiveness and practicality of the proposed shared governance architecture.

1. System-Level Evaluation and Cross-Agent Governance

The central contribution of OpenAgentFlow is to enable consistent governance across heterogeneous agents through a shared action-commit boundary. We evaluate this capability through cross-agent information-flow enforcement, external action-safety evaluation, and controlled policy enforcement.

Cross-agent workflow evaluation. To directly examine shared governance across multiple agents, we expanded the original three constructed chains (14 stages) to 64 multi-agent workflows, covering 2–5 agent roles, five workflow topologies, and eight data transformations, including spacing changes, masking, Unicode digits, Base64, hexadecimal encoding, and reversal. The workflows form 32 matched pairs, controlling source data, workflow structure, communication channel, recipient, and authorization context.

We compared four configurations on the same workflow inputs:

ConfigurationAccuracyUnsafe RecallSafe FPI
Full Shared98.44%100%0%
Per-Agent70.31%62.50%19.35%
Shared History98.44%100%0%
No Provenance50.00%37.50%35.48%

Full Shared improves accuracy by 28.13 percentage points over Per-Agent and 48.44 points over No Provenance. In paired comparisons, Full Shared is uniquely correct on 18 cases against Per-Agent and 31 cases against No Provenance, with no reverse wins.

Full Shared and Shared History produce identical classification decisions because Shared History receives the complete serialized session trace. This highlights two complementary architectural benefits: shared context provides the information needed for cross-agent governance, while typed provenance exposes explicit field-level source–value relationships for deterministic enforcement and audit.

We further conducted a provenance integrity audit. OAF preserved lineage across 90/90 executed non-identity transformation edges and correctly attributed 87/87 explicitly bound final output fields. These results verify that the system maintains the lineage required for cross-agent source–sink enforcement and subsequent audit.

External AgentDojo evaluation. We also evaluated the complete 1,220-case AgentDojo-Traj split of TS-Bench, achieving 97.62% accuracy, 95.91% F1, 96.59% unsafe-action recall, and a 1.96% safe false-intervention rate (TP=340, FN=12, FP=17, TN=851).

Compared with applying the same Qwen3.8-27B backbone directly to all actions, the staged OAF pipeline improves accuracy from 91.48% to 97.62% and reduces safe false intervention from 11.41% to 1.96%. This demonstrates the benefit of combining structured policy requirements, early semantic assessment, and selective final adjudication.

Controlled enforcement evaluation. The 300-case suite examines deterministic T1/T2 enforcement under explicitly specified governance policies. It contains 172 expected-DENY cases and 128 expected-ALLOW cases, with 158 of the expected-DENY cases involving direct cross-application or cross-tool information reuse. OAF achieves 94.00% accuracy, a 95.35% attack-block rate, and a 7.81% safe false-intervention rate.

Additional evaluations further support the enforcement and control-plane mechanisms: OAF passes 191/200 threat cases, and 27/30 dynamic-policy cases, including all 6/6 core rule-insertion cases. Newly installed rules can therefore take effect through the shared control plane without modifying protected agents.

Together, these evaluations demonstrate the effectiveness of OAF across cross-agent governance, external action adjudication, deterministic enforcement, and policy evolution.

2. AgentDojo Policy Development, Model Selection, and Evaluation Protocol

Policy development and prompt configuration. The ten AgentDojo review-policy families encode general governance requirements over action semantics, commit phase, and authorization state. They cover high-impact actions including external communication, financial transfers, publication and upload, destructive operations, purchase commitments, and security-sensitive changes.

The initial policy design did not inspect AgentDojo benchmark examples or labels, and the T3/T4 prompts were not iteratively modified against benchmark test results. The same policy bundle and prompt templates were applied across all 1,220 cases. T3 performs semantic assessment and can escalate actions when evidence is insufficient; T4 provides final adjudication for escalated actions. An outstanding mandatory-review requirement cannot be bypassed by a T3 ALLOW.

T4 backbone selection. We selected Qwen3.8-27B primarily for its strong capability-to-size trade-off. It is a capable model at a comparatively compact scale, with an accessible and reproducible inference setup. This choice reflects our design objective of demonstrating effective agent governance without relying exclusively on large proprietary frontier models, while keeping semantic adjudication practical to reproduce and deploy.

To characterize backbone sensitivity, we additionally evaluated GPT-4o, Gemini 3 Flash, and Qwen3.8-27B on the same 502-case final-review subset:

T4 backboneStrict AccuracyUnsafe RecallSafe FPI
GPT-4o75.10%91.04%60.26%
Gemini 3 Flash85.66%99.71%45.51%
Qwen3.8-27B95.22%97.98%10.90%

The results show different operating characteristics: Gemini achieves the highest unsafe-action recall, whereas Qwen3.8-27B achieves the highest strict accuracy and lowest safe false-intervention rate. We report these comparisons to characterize the trade-offs among alternative backbones.

The reported configuration uses Qwen3.5-0.8B for T3 and Qwen3.8-27B for T4, with temperature 0, greedy decoding, and a maximum of 256 new tokens. The complete prompt templates, policy definitions, and decision requirements are provided in the appendix.

For the 1,220-case evaluation, we additionally report 95% Wilson confidence intervals calculated from the archived per-case predictions:

MetricResult95% Wilson CI
Accuracy97.62%96.61–98.34%
Unsafe-action recall96.59%94.14–98.04%
Safe false-intervention rate1.96%1.23–3.11%

These intervals characterize case-level statistical uncertainty for the reported configuration.

Routing and runtime protocol. The archived classification evaluation uses the fixed paper routing configuration, which sends 502/1,220 cases to T4. The separate live PEP runtime replay uses dynamic routing and sends 471/1,220 cases to T4. The two protocols overlap on 470 T4-routed cases: 32 cases selected by the fixed route terminate at T3 in the live PEP, while one case outside the fixed subset enters T4.

The live replay measures the complete T1–T4 pipeline over all 1,220 actions. Full PEP evaluation achieves a P50 latency of 229.066 ms, P95 of 3.301 s, and P99 of 3.646 s. T1/T2 has a P95 of 1.777 ms, while the T4 service round trip has a P95 of 3.159 s. The staged design reserves the more expensive semantic adjudication for escalated actions.

3. Reproducibility and Independent Human Validation

AgentDojo reproducibility. We provide the T3/T4 model versions, decoding configurations, complete prompt templates, policy definitions, decision requirements, and AgentEvent input interface. The archived per-case decisions, evaluation summary, protocol configuration, and scoring code support inspection of the reported experimental setup and results.

Independent validation of semantic adjudication. We conducted a blind human audit of 100 cases sampled from the original AgentDojo T4 evaluation. Two independent reviewers assessed the cases without access to T4 outputs or official benchmark labels. They agreed on 93/100 cases (93.0%), with a three-category Cohen's κ of 0.815. Among the 94 cases for which both reviewers provided definite Safe/Unsafe judgments, they agreed on 93 (98.9%). Against the reviewers' definite judgments, T4 agrees with Reviewer 1 on 95/99 cases (95.96%) and Reviewer 2 on 94/95 cases (98.95%). Unclear judgments and disagreements were retained rather than forced into binary labels.

Android environment and expanded human review. The Android evaluation used a Pixel 7 Pro emulator with Android API 33, Android Emulator 36.5.11, and a Google APIs x86_64 system image at 1440 × 3120 resolution. Of 100 executions, 98 have usable AgentEvent traces.

The original Android metrics are 90.82% raw accuracy, 92.86% trace-adjusted accuracy, 82.50% attack-block rate (33/40), and 3.45% false-block rate (2/58).

We additionally conducted an independent review covering all 98 trace-available executions. Two reviewers applied the same written three-category ALLOW/DENY/UNCLEAR rubric while blinded to frozen OAF decisions and benchmark labels. They agreed on 90/98 cases (91.8%), with a Cohen's κ of 0.828. Reviewer 1 agrees with OAF on 94/98 cases (95.9%), while Reviewer 2 agrees on 90/98 cases (91.8%), or 90/93 (96.8%) among definite judgments. Reviewer 2's five UNCLEAR labels remain a separate category.

This expanded audit provides independent human assessments across all available traces, complementing the original 50-case semantic review. We report the two reviewers' assessments and agreement separately from the original benchmark scoring, preserving the original task-script and trace-adjusted metrics.

4. AgentEvent, Structured Provenance, and Baseline Comparison

AgentEvent is a central architectural abstraction in OAF. It normalizes heterogeneous GUI, API, tool, and LLM-generated actions into a common governance representation before execution. The shared PEP evaluates these pending actions using consistent policy, authorization, provenance, and session-state information, while typed provenance bindings and governance state are maintained by the control plane.

AgentSpec-session provides programmable runtime specifications over current actions and serialized chronological records. OAF builds on this runtime-monitoring capability by maintaining enforcement-observed typed value-to-source bindings, structured cross-agent provenance, shared policy state, and a centralized PEP.

The baseline table compares complete systems under their respective native configurations, highlighting the architectural distinction between trace-based runtime monitoring and a shared governance control plane. The 64-workflow evaluation provides additional evidence on how shared context and provenance configurations affect governance outcomes within OAF. Full Shared substantially outperforms Per-Agent and No Provenance, while the provenance integrity audit verifies the preservation and attribution of explicit lineage across transformations.

Together, these results highlight the complementary roles of AgentEvent as a common action representation, shared session state as the basis for cross-agent governance, and typed provenance as an explicit representation supporting deterministic source–sink enforcement and audit.

Summary

Our results support the central design principle of OpenAgentFlow: effective governance of heterogeneous agents requires a shared enforcement boundary that maintains policy-relevant context, structured information provenance, and centralized control across execution paths.

The cross-agent workflow evaluation, external AgentDojo benchmark, independent human audits, dynamic policy updates, and Android integration provide complementary empirical evidence for this architecture and its practical applicability to heterogeneous agent systems.

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

This paper proposes OpenAgentFlow, a unified safety check layer before actions are committed by each party in the environment. This paper demonstrates more effective flagging of safety-violating actions.

Critical strengths
  1. Effective safety check layer for complex agentic systems: This paper proposes effective PEP method, by designing four layers of check (Table 2) that effectively improve block accuracy and reduce false positives over baseline systems (Table 3).
Critical weaknesses
  1. Lack of description of the main PEP approach: It is unclear how the PEP module is implemented: rule-based checks? LLM-assisted checks? And how is the PEP methodologically different from the baseline systems in Table 3? If LLM-supported, missing manual validation to check the correctness of LM predictions.
Questions for authors
  1. The current pipeline requires fully human-specified rules of the environment (what are risky actions, what are the limitations of each party), how could the current method extrapolate to other, even unseen, environments and regulations?
  2. (line 412) The main result, it is confusing that 94% of cases are passed yet 95.35% are expected-deny cases? What’s the percentage of expected-deny cases among all cases? Reporting precision/recall may be clearer.
6 comments
AuthorsOpenReview ↗

Response to Reviewer knXG

Response to Reviewer knXG

We thank the reviewer for recognizing OAF's PEP and raising questions about its architecture, generalization, and evaluation.

The central novelty of OpenAgentFlow is a system-level action-governance architecture, not another agent-level safety classifier. OAF establishes the action-commit boundary as a shared enforcement interface across heterogeneous agents, maintaining provenance, session state, and audit evidence outside individual agents. This enables consistent governance of composed action flows and policy evolution without modifying individual agents.

We strengthen the manuscript with cross-agent experiments, human validation, backbone sensitivity analysis, and external evaluation.

1. PEP Architecture, System-Level Novelty, and Human Validation

Shared enforcement architecture. Existing safety mechanisms typically focus on individual prompts, model outputs, or tool interactions. However, action safety can depend on information accumulated across agents and execution channels. OAF normalizes GUI, API, tool, and LLM-planned actions into a common AgentEvent evaluated by a shared PEP before execution.

This architecture integrates four capabilities:

  • Unified action representation: AgentEvent provides a common policy interface across execution channels.
  • Enforcement-maintained provenance: Typed value-to-source bindings preserve lineage across observations and transformations.
  • Shared governance state: Session history, authorization context, and source–sink FlowRules are maintained outside individual agents.
  • Centralized enforcement and evolution: A shared PEP, audit mechanism, and updateable control plane ensure consistent governance.

Their integration around a common enforcement object is OAF's key contribution: governing composed action flows through shared policy and provenance rather than checking agents independently.

Hybrid T1–T4 enforcement pipeline. OAF combines deterministic enforcement with LLM-assisted reasoning:

  • T1 – Structured policy enforcement: Matches FlowRules, scopes, targets, and high-impact operations; returns ALLOW, DENY, or REWRITE, or imposes mandatory review.
  • T2 – Payload and provenance enforcement: Performs field-aware inspection, pattern matching, and source–sink checks using enforcement-observed provenance.
  • T3 – Semantic assessment: Uses Qwen3.5-0.8B in AgentDojo to assess complex actions, returning ALLOW, DENY, REWRITE, or ESCALATE.
  • T4 – Final adjudication: Uses Qwen3.8-27B to resolve semantically unresolved and mandatory-review cases.

T3 DENY or REWRITE terminates the action; T3 ALLOW proceeds to T4 when mandatory review remains active. Thus, semantic reasoning does not override explicit authorization requirements.

Methodological distinction and quantitative comparison. OAF's contribution lies in its shared enforcement boundary and governance state. Prompt-only approaches provide advisory instructions; Llama Guard classifies textualized content; VeriSafe uses LLM-derived predicates followed by CHC verification; and AgentSpec provides runtime specifications over current actions or serialized session records.

Our controlled 300-case comparison shows:

ConfigurationAccuracyAttack-block rateFalse-block rate
AgentSpec-session93.00%94.19%8.59%
Llama Guard87.33%77.91%0%
VeriSafe GPT-to-CHC55.33%37.79%21.09%
Static T1+T293.33%94.19%7.81%
Full OAF94.00%95.35%7.81%

AgentSpec-session demonstrates the value of temporal trace visibility. OAF integrates action representation, enforcement-observed provenance, policy state, audit, and policy updates into one shared layer. T1/T2 achieve 93.33% accuracy through inspectable rules and provenance checks, while T3/T4 handle unresolved and mandatory-review cases.

Independent human validation. We conducted a blind audit of 100 AgentDojo T4 cases. Two reviewers, without access to T4 outputs or official labels, agreed on 93/100 cases (93.0%), with Cohen's κ = 0.815. Among 94 cases with definite Safe/Unsafe judgments from both reviewers, they agreed on 93 (98.9%). T4 agreed with Reviewer 1 on 95/99 definite judgments (95.96%) and Reviewer 2 on 94/95 (98.95%). Unclear judgments and disagreements were retained rather than converted into binary labels.

Backbone sensitivity and staged adjudication. On the same fixed 502-case final-review subset, Qwen3.8-27B achieves 95.22% strict accuracy and 10.90% safe false-intervention rate, compared with 75.10% and 60.26% for GPT-4o, and 85.66% and 45.51% for Gemini 3 Flash.

Applying Qwen3.8-27B directly to all 1,220 AgentDojo cases yields 91.48% accuracy and 11.41% safe false intervention. OAF's policy-guided staged configuration achieves 97.62% accuracy and reduces false intervention to 1.96%, demonstrating the contribution of staged governance beyond backbone selection alone.

2. Generalization to Unseen Environments and Policy Evolution

Architectural generalization. Inspired by Software-Defined Networking (SDN), including Ethane and OpenFlow, OAF separates centralized policy management from action execution. The control plane maintains FlowRules, provenance, session state, and audit records, while the action plane hosts the shared PEP. Environment-specific adapters normalize GUI, API, and tool interactions into AgentEvent, allowing the same enforcement pipeline to govern heterogeneous agents without separate safety mechanisms. Enterprise policies remain organization-defined but can be consistently expressed and enforced through OAF.

Runtime policy evolution. When T3/T4 encounters an unseen governance scenario, it surfaces a candidate constraint with supporting evidence. After administrator confirmation, the constraint becomes a reusable FlowRule in the control plane. Subsequent matching actions are enforced through T1/T2 without modifying individual agents.

OAF passes 27/30 dynamic-policy cases:

  • Core policy insertions: 6/6.
  • Negative controls: 11/12.
  • Boundary cases: 10/12.

The three errors involve matcher calibration, including numeric over-matching, partial phone-number matching, and case-sensitive email comparison. All six core insertions are successfully enforced at T1.

External evaluation. We evaluated OAF on all 1,220 AgentDojo-Traj cases in TS-Bench. Ten canonical policy families and T3/T4 prompts were defined without inspecting benchmark examples or labels and remained fixed throughout evaluation. They operate on action semantics, commit phase, and authorization state rather than benchmark-specific tool names.

OAF achieves 97.62% strict accuracy, 95.91% F1, 96.59% unsafe recall, and 1.96% safe false-intervention rate. Compared with TS-Guard, accuracy improves by 5.90 percentage points and safe false intervention decreases by 5.41 points. The separate 200-case threat suite achieves 95.50% accuracy and 96.08% attack-block rate.

Live execution validation. In a 100-case Android emulator suite, 98 executions produced usable AgentEvent traces, achieving 92.86% trace-adjusted accuracy. Two reviewers agreed on 90/98 cases (91.8%), with Cohen's κ = 0.828. This validates the shared enforcement interface across live GUI, API/tool, and LLM-planned execution.

3. Additional Evidence for Cross-Agent Governance

We expanded the original three constructed chains into 64 multi-agent workflows, covering 2–5 agent roles, five topologies, and eight transformations. The 32 matched pairs preserve source data, workflow structure, communication channel, recipient, and authorization context.

ConfigurationAccuracyUnsafe RecallSafe FPI
Full Shared98.44%100%0%
Per-Agent70.31%62.50%19.35%
Shared History98.44%100%0%
No Provenance50.00%37.50%35.48%

Full Shared improves accuracy by 28.13 percentage points over Per-Agent and 48.44 points over No Provenance.

Full Shared and Shared History achieve identical classification results because both access the complete session trace. This distinguishes information availability from provenance representation: shared history supplies context, while typed bindings expose explicit source–value relationships for deterministic source–sink enforcement and audit.

The provenance integrity audit further confirms lineage preservation across 90/90 transformation edges and correct attribution of 87/87 explicitly bound final output fields, supporting the role of structured provenance in cross-agent governance.

4. Clarification of the 300-Case Evaluation Metrics

The 300-case suite contains 172 expected-DENY cases (57.33%) and 128 expected-ALLOW cases (42.67%). The confusion matrix is:

Expected DENYExpected ALLOW
Predicted DENY164 (TP)10 (FP)
Predicted ALLOW8 (FN)118 (TN)

Overall accuracy is 282/300 = 94.00%, while attack-block rate (unsafe recall) is 164/172 = 95.35%. Safe false-intervention rate is 10/128 = 7.81%, and DENY precision is 164/174 = 94.25%. We have added the complete confusion matrix, class distribution, and denominator-specific metrics to the revised appendix.

5. Revisions to the Manuscript

We have incorporated the following additions:

  • Architecture and baselines: Expanded AgentEvent, the shared enforcement boundary, provenance, control-plane separation, T1–T4 semantics, and baseline comparisons.
  • Human validation and model analysis: Added the T4 audit, reviewer agreement, backbone sensitivity, and staged-versus-direct evaluation.
  • Generalization: Added benchmark-independent policies, dynamic FlowRule updates, and AgentDojo-Traj results.
  • Cross-agent governance: Added 64-workflow ablations and provenance integrity audits.
  • Runtime and metrics: Added Android validation, live PEP latency, and the complete 300-case confusion matrix.

Summary

OpenAgentFlow establishes a shared action-commit boundary across heterogeneous agents, integrating unified action representation, enforcement-maintained provenance, shared session state, and policy-guided enforcement.

Our cross-agent experiments, human audits, policy-evolution results, and external evaluations establish OAF as a practical architecture for consistent, provenance-aware governance across heterogeneous agent systems.

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

Related papers

Discussion (0)

Sign in to comment.