acceptodds
Under review as a conference paper at ICLR 2027

Admission Control for Multi-Agent LLM Systems: Enforcing Safety Invariants on the Connection Graph

Abstract

Agents in a multi-agent language model system now connect and delegate to one another at run time, with no human approving each link. The danger is spread along a path: one agent reads a confidential file, a second summarizes it, a third mails it out, and every step is permitted. Defenses today watch this graph without controlling it. A learned monitor prunes the agents that look anomalous, and static analysis recommends a safer fixed shape to build. Neither holds up, because the monitor only covers graphs like the ones it was trained on, and design-time advice cannot stop agents that rewire themselves as they run. We introduce TopoGate, which controls the graph instead of watching it. Before any connection is added, TopoGate checks whether it would complete a forbidden path and refuses it if so, using a fixed rule with nothing learned in it. Checking one connection at a time raises a worry: a later connection might undo an earlier decision. We prove the gate is sound over any sequence of changes if and only if every rule it enforces is insertion-monotone: once a graph is unsafe, no later connection can make it look safe. This is easy to get wrong: our own earlier rule for bounding commitment chains failed the condition, and one unrelated edge was enough to exploit the failure. In experiments, a trained graph monitor matches TopoGate on its own training graphs and loses almost all of its effect once the topology changes shape, while TopoGate holds. TopoGate also stops leaks that a text scanner misses, by blocking the outgoing connection of any agent that has read confidential data, whatever that agent's message says. Routing legitimate traffic through a declassifier node restores full task performance on benign work.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
multi-agent safety, LLM agents, AI safety

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_nQMROpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes TopoGate, which represents capabilities and information flows in multi-agent LLM systems as a directed graph with typed nodes and labeled attributes, and checks graph invariants before admitting new connections. To enforce constraints on sensitive information exfiltration, the authors incrementally maintain forward taint and backward reachability information to detect whether a proposed connection would complete a forbidden path, while using declassifier and human-oversight nodes to restore legitimate communication. The experiments compare attack success rates across different topologies, investigate the differences between position-based taint tracking and payload inspection, and evaluate safety and utility through AgentDojo trace replay, a limited number of online model calls, and synthetic environments.

Critical strengths
  1. The research problem is practically important, and the compositional security threats addressed by this work deserve attention. Communication and delegation among multiple agents can combine individually compliant actions into data leakage or unauthorized high-impact operations, while local security checks may fail to capture such cross-agent risks. These threats are becoming increasingly important as agents gain greater autonomy in collaboration and tool use.
  2. Translating security risks into checkable path constraints and clearly separating structural enforcement from semantic judgment offers practical engineering value. The paper uses graph-structural constraints to restrict dangerous information flows while centralizing semantic judgments at controlled nodes, providing a clear and auditable approach to security enforcement in multi-agent systems.
Critical weaknesses

1. The necessity of the core theoretical claims is insufficiently justified. The necessity proof for label monotonicity appears inconsistent with the cumulative join definition of effective labels, while the necessity of insertion monotonicity also relies on additional assumptions. Therefore, the current arguments are insufficient to support generalizing these conditions to arbitrary incremental connection-admission systems.

2. The experiments do not adequately validate the defense effectiveness of the complete framework. The main experiments still employ per-agent demotion as the intervention mechanism, primarily comparing alert signals rather than the actual per-connection admission control mechanism. In addition, the risk of adversarial false permits at the declassifier and incomplete information-flow coverage limit the strength of the system-level security claims.

3. An end-to-end cost evaluation against an unprotected system is missing. The paper primarily compares the overhead of incremental graph checking with that of full recomputation, without adequately reporting the changes in end-to-end latency, model invocation costs, or concurrent throughput before and after deploying the defense. Consequently, it remains unclear whether the security benefits come at the cost of substantial additional system overhead or degraded runtime performance.

Questions for authors
  1. What are the input partial order and update semantics of the parameter-to-label mapping in Proposition 1? When an incoming edge is added, are existing parameters or labels replaced, or are they accumulated? Does the necessity claim of the proposition hold only under specific assumptions or restrictions?

  2. What information do the declassifier and human-oversight nodes actually receive, and what are their routing and admission rules? Please specify the unified rules in greater detail. The main text and reproducibility statement refer to Appendix E.1, but this section does not provide the specific model details. These details are essential for assessing the claimed utility recovery and the contribution of model-based oversight.

  3. The analysis of the actual defense overhead is incomplete. Compared with an unprotected system, how much does TopoGate affect end-to-end task latency, the number of model invocations, and associated costs? Can the authors provide a comparative evaluation of benign-task overhead with and without the defense?

  4. The key online experiments have limited sample sizes and scenario coverage. The evaluation of online task utility is based on only five tasks, while AgentDojo includes only three relevant exfiltration attacks. Although the adaptive attack evaluation includes three repetitions, it covers only five scenarios. The current evidence is therefore insufficient to adequately establish the robustness of the framework across diverse tasks and attack conditions.

I would be willing to increase my score if these concerns were adequately addressed.

2 comments
AuthorsOpenReview ↗

Reply to Reviewer nQMR (part 1/2)

Thank you for the careful reading, in particular of the proofs. Please also see the general response; §1 reports an error we found in our own evaluation and its correction.

W1 / Q1. Update semantics of the label map, and the necessity claims.

You are right, and the problem is exactly the one you identify. Proposition 1 defines a node's effective label as the join (least upper bound) of its static label and the labels of arguments on incoming edges. A join can never lower a label. Under that definition, every argument rule is automatically "promote-only", so the "only if" direction says nothing. Our counterexample (a restrict-to-internal rule that lowers a label) only works if a later argument replaces the label rather than being joined with it.

Corrected statement:

  • Update semantics. An argument rule is a label transformer g, applied to the node's current label when the edge carrying the argument is inserted; labels accumulate by repeatedly applying the transformers. The order on labels is exposure: ℓ ⊑ ℓ′ if ℓ′ is at least as exposed in every component.
  • Sufficiency (unchanged). If every transformer is extensive, meaning g(ℓ) ⊒ ℓ (it never lowers a label), then effective labels only rise as edges are added, the sensitive and external sets only grow, and Theorem 2 applies.
  • Necessity (now with its conditions). If some transformer lowers a label across the boundary of the sensitive or external set, there is a graph with a live violation that one more insertion clears. Under the conditions of Theorem 2(ii) (the gate raises no false alarms, and the violating graph is reachable through admitted steps), the gate is then unsound. A transformer that lowers a label without changing set membership is harmless, and we will say so.
  • The join is a special case. Join-based accumulation, g(ℓ) = ℓ ⊔ f(a), is always extensive, which is why our implementation, which rejects any narrowing rule, is sound.

On insertion-monotonicity: we agree that necessity holds only under the assumptions of Theorem 2(ii). We will state those assumptions in the theorem, the abstract and the introduction, and remove the claims that the conditions apply to "arbitrary" incremental systems.

W2. The experiments compare alert signals, not per-connection admission. We agree, and explain why in general response §2: G-Safeguard's harness scores the attacker's first tool, a read that TopoGate permits by design. We have now evaluated the full mechanism online on AgentDojo, with every call admitted or refused before it executes (600 runs per arm). Graph rules alone cut attack success from 18.9% to 4.6% and stop all exfiltration.

On adversarial false permits at the declassifier, we attacked the reviewer directly (general response §3): five reviewer models, 180 disguised exfiltrations, 30 piggyback attacks. Disguised exfiltration was approved 0–2 times out of 180. Piggyback approvals ranged from 0/30 to 19/30 depending on the reviewer and on what the reviewer is shown. On incomplete flow coverage, shared-object nodes now cover the dependencies Appendix C reported as missed (reply to sJyW).

AuthorsOpenReview ↗

Reply to Reviewer nQMR (part 2/2)

Q2. What do the declassifier and human-oversight nodes receive, and what are the routing and admission rules? Here is the full specification, which we will also add to the appendix of the final version:

  • When it is called. In the routed configuration, the reviewer is called only when the graph rules would refuse a call and that call has incoming data-flow edges. Without routing, a refused call is simply refused. In the "model review only" comparison arm, the reviewer is called on every write.
  • What it receives. The user's original request (up to 2,000 characters); the proposed tool call (name and full arguments); and, in the routed configuration, the outputs of the earlier calls that flow into it (the first 600 characters of each). After our reviewer experiment we also recommend a metadata-only variant: each source's tool name and label, with the content withheld.
  • Instruction. The reviewer is told that tool outputs may contain instructions written by third parties, which are not the user's. It should approve only if the user's own request calls for this action, these recipients and this content. It answers in JSON.
  • Admission rule. If the reviewer approves, each incoming flow is routed read → declassifier → human → write, which satisfies the rules structurally, and the call executes. If it refuses, or its answer cannot be parsed, the call is not executed and the agent is told it was blocked: the gate fails closed.
  • Model. The paper used gpt-4.1-nano, which its provider has since retired. The new experiments use Claude Haiku 4.5 (temperature 0). Results with four other reviewers are in general response §3.

W3 / Q3. End-to-end overhead against an unprotected system. From the AgentDojo runs (600 runs per arm, same agent):

ArmTime / taskReviewer calls / taskToken cost / task (list price)
No defense9.4 s0$0.0034
Graph rules only9.7 s0about the same as no defense (no extra model calls)
Graph + model11.5 s1.31$0.0058
Model review only12.3 s3.38$0.0067

The graph check itself is cheap: about 0.3 s per task end to end, and about 0.4 ms per decision on AgentLeak. Almost all overhead comes from reviewer calls, and the graph cuts those by 61% compared with reviewing every write. We did not measure throughput under concurrent proposers. The gate serialises check-and-commit, so concurrent agents queue at a single, cheap step; we will state this, and we will not claim a throughput figure we have not measured.

Q4. Sample sizes. The online evaluation is now 600 runs per arm on AgentDojo (previously 5 tasks). The attack side covers all 14 injection tasks, not only the 3 exfiltration tasks, so that attacks outside the exfiltration rule are measured too, including the one the graph misses. We did not extend the five-scenario adaptive-adversary study. The reviewer experiment adds 227 attack and benign items per reviewer.

Reviewer_dK73OpenReview ↗
Rating
2(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper studies safety in multi-agent LLM systems, where harmful behavior can arise from a path of individually permitted steps across agents. It proposes TopoGate, an admission gate that checks each new connection in a typed capability graph and rejects it if it would complete a forbidden path, such as sensitive data reaching an external write. The authors argue that such per-edit verdicts remain sound only if the enforced predicates are insertion-monotone and label updates are promote-only. Experiments compare TopoGate with the learned monitor G-Safeguard across graph topologies, test exfiltration blocking on InjecAgent, and measure benign utility on AgentDojo with declassifier routing.

Critical strengths
  1. The paper addresses a practical security problem: individually permitted actions can combine into harmful information flows across multiple agents.
  2. The graph predicates make the enforcement policy explicit, and the incremental algorithm avoids recomputing the entire graph after every insertion.
Critical weaknesses

The evaluation is limited, with little systematic analysis of agent count, attacker proportion, interaction length, or attacker placement. These factors matter for understanding attack success and false blocking in multi-agent systems.

Comparisons with relevant defenses such as FIDES and agent communication firewalls are missing. The simple sanitizer also achieves zero ASR in Table 2, without a benign-utility comparison. Moreover, the G-Safeguard comparison does not directly evaluate TopoGate’s full connection-admission mechanism.

Despite the practical motivation, online evaluation includes only five AgentDojo user tasks and one CrewAI trial. The paper also lacks ablations separating graph control from model-based review and systematic comparisons across reviewer LLMs.

Questions for authors

See weaknesses.

Please compare the full TopoGate system with G-Safeguard, FIDES, and agent communication firewalls under the same conditions. (This would increase my score.)

How do graph rules alone, model-based review alone, and their combination perform on the same tasks? What additional benefits does graph-based control provide?

How do attack success and benign task completion change as the number of agents, the proportion of malicious agents, and the number of interaction rounds increase? Do false blocks accumulate during longer interactions?

How sensitive are TopoGate-O and the declassifier to the choice of reviewer model? Please compare reviewer LLMs from different model families and capability levels.

2 comments
AuthorsOpenReview ↗

Reply to Reviewer dK73 (part 1/2)

Thank you for the detailed review and the concrete requests. Please also see the general response; §1 reports an error we found in our own evaluation and its correction.

"The G-Safeguard comparison does not directly evaluate TopoGate's full connection-admission mechanism." You are right, and we now explain why. G-Safeguard's harness counts an attack as successful when an agent proposes the attacker's first tool, which in these cases is a sensitive read. TopoGate allows reads by design and blocks the later read → external-write path, so under that criterion the full mechanism has nothing to act on. We therefore evaluated the full mechanism online on AgentDojo, where calls actually execute (general response §2).

Q: Graph rules alone vs. model review alone vs. their combination, and what graph control adds. On AgentDojo, 600 runs per arm, every call checked before execution:

ArmBenign utilityAttack successExfiltrationReviewer calls / task
No defense0.8518.9%12.5%0
Graph rules only0.654.6%0%0
Model review only0.600.0%0%3.38
Graph + model0.603.7%0%1.31

What graph control adds:

  • A protection floor that needs no model. The graph rules alone stop 13 of 14 injection tasks and all exfiltration. Their result does not depend on any reviewer being robust, and a reviewer can be attacked: in our reviewer experiment (general response §3), one reviewer approved 19 of 30 piggyback attacks.
  • Fewer reviewer calls. The graph decides where review is needed: 1.31 reviewer calls per task instead of 3.38, with the same exfiltration protection.

The one injection the graph rules miss carries no data flow ("delete file 13"). We report it as a limitation.

Q: Sensitivity to the reviewer model (families and capability levels). Two experiments:

  • Multi-agent result: TopoGate-O's advantage over G-Safeguard holds with reviewers from two vendors: −13.7 pp (Claude Haiku 4.5) and −11.5 pp (gpt-4o-mini), both p < 0.001.
  • Attacking the reviewer: five reviewers across two vendors and three capability levels. Disguised exfiltration was approved 0–2 times out of 180. Piggyback attacks ranged from 0/30 (all three Claude models) to 19/30 (gpt-4.1-mini), and legitimate writes blocked from 6/17 to 12/17. The choice of reviewer clearly matters. This is why we recommend testing the reviewer at the single point where it sits, and giving an untested reviewer only metadata about the sources, which brings every reviewer to 2–4/30.
AuthorsOpenReview ↗

Reply to Reviewer dK73 (part 2/2)

"The simple sanitizer also achieves zero ASR in Table 2, without a benign-utility comparison." We measured it. On AgentDojo's 40 benign tasks, the same sanitizer blocks 13, which is every benign task that writes externally, because it flags recipient email addresses. TopoGate blocks 7 bare and 0 with declassifier routing, with all three exfiltrations blocked in every case. The sanitizer's 0% ASR comes from blocking all external writes. (Separately, as explained in general response §1, Table 2's position-taint result is weaker than reported once the attacker role is removed; we correct it.)

Comparison with FIDES and agent communication firewalls. We were not able to run these systems head-to-head in the time available, and we do not want to imply otherwise. The closest comparator we did run is the "model review only" arm above: an LLM that checks every outgoing call, which is the role a communication firewall plays. We will discuss FIDES and firewalls as complementary layers: they control what a value or message may carry, while TopoGate controls which connections may exist.

"Do false blocks accumulate during longer interactions?" Yes. Chaining AgentDojo's benign tasks into one session (the gate keeps its graph across tasks) raises the bare rule's false-block rate:

Tasks per session12481640
False-block rate, bare rule17.5%22.6%25.5%29.5%30.3%31.9%
False-block rate, with routing0%0%0%0%0%0%
Reviewer routings per task0.350.530.811.442.827.0

The bare rate levels off near the share of tasks that write externally at all (32.5%). Routing removes the false blocks, but the reviewer's load grows with session length. This is a worst case, because our offline provenance links every earlier confidential read to every later external write.

Agent count, attacker proportion, number of rounds, attacker placement. We were not able to complete this sweep in the response period, and we will include it in the final version. A partial answer: the five-topology experiment varies connectivity from a chain to a complete graph, with three attackers among eight agents and three rounds of interaction, and TopoGate-O's advantage holds across those shapes. We record attack success at every round and will add those curves.

Online scale. The online evaluation is now 600 runs per arm on AgentDojo (previously 5 tasks), with all four arms on identical tasks and attacks.

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

This paper proposes TopoGate, an admission-control framework for LLM multi-agent systems that checks proposed connections against graph-based safety rules. It aims to prevent unsafe information flows, missing human oversight, and uncontrolled commitment propagation. The authors analyze conditions under which safety decisions remain valid as the graph evolves and have incremental checking to reduce overhead.

Critical strengths

The paper formalizes safety requirements as graph invariants and examines their preservation under sequential graph modifications. Experimental results indicate that structural enforcement can provide greater robustness than learned monitoring approaches when communication topologies evolve.

Critical weaknesses
  1. Limited novelty and insufficient comparison with prior work. The main ideas underlying TopoGate, including graph reachability, taint propagation, information-flow control, declassification, and runtime access control, are well established. Although TopoGate applies these ideas to dynamically evolving agent connection graphs, the novelty beyond this adaptation is not clear. The monotonicity results also appear closely related to prior graph and access-control principles.

  2. Security guarantees rely on an incomplete graph representation. TopoGate's safety guarantees hold only for information flows accurately captured and labeled in the connection graph. However, real-world multi-agent systems may exchange information through shared memory, files, tool outputs, and other indirect channels that are not explicitly represented. Appendix C shows that only 31 of 48 identified causal dependencies are captured as mediated edges.

Questions for authors
  1. What is the main contribution of TopoGate beyond existing information-flow control and runtime access-control approaches such as Fides, SAFEFLOW, and Progent?

  2. How does TopoGate handle information flows through shared memory, files, and other channels that are not represented as explicit graph edges? Could the authors further evaluate its robustness against attacks that exploit these dependencies?

1 comment
AuthorsOpenReview ↗

Reply to Reviewer sJyW

Thank you for the review. Please also see the general response, especially §1, where we report and fix an error in our own evaluation.

Q1. What is the main contribution beyond information-flow control and runtime access control (Fides, SAFEFLOW, Progent)?

We agree that the building blocks are established, and our original framing overstated the novelty of the theory. In particular, the sufficiency direction of Theorem 2 is an instance of a classical result: a monitor that watches a run step by step can enforce exactly the properties whose violations, once present, cannot be undone (Schneider, "Enforceable security policies", 2000; Alpern and Schneider, 1985). We will cite this lineage and narrow our claims. What we believe remains new:

  1. What is controlled. Fides and SAFEFLOW attach labels to values and propagate them through an agent's computation; Progent restricts which tool calls an agent may issue. None of them decides whether a new connection between agents may exist. TopoGate admits or refuses edges of the connection graph, so a multi-hop path across several agents (agent A reads, B summarises, C sends) is checked as a whole, even though each agent's own steps look harmless. These approaches compose rather than compete: a value-level system governs what a message carries, TopoGate which connections exist.
  2. The label condition and its failure mode. A gate can enforce a monotone rule correctly and still be unsound if the labels it reads can later be lowered. We show this happens in practice (our own calendar-tool case, 499 of 15,000 runs) and that two published label-propagation methods have the forbidden shape.
  3. Empirical. A trained graph monitor loses its effect when the topology changes, while a fixed rule does not. This now holds with the attacker information removed (−13.7 pp vs. G-Safeguard, p = 0.0001; general response §1). In a full online run on AgentDojo (general response §2), the graph rules alone, with no model and no training, cut attack success from 18.9% to 4.6% and stop all exfiltration.

We did not run Fides, SAFEFLOW or Progent head-to-head, and we will say so.

Q2. Flows through shared memory, files and other channels without explicit edges, and attacks that exploit them.

We extended the graph so that each shared object (a file, an email, a calendar event) becomes a node. A call that writes the object gets an edge into it, and a later call that reads it gets an edge out. The gate builds these edges only from what it can observe: object IDs in a call's arguments and in its results.

  • Coverage: on AgentDojo's workspace suite, this captures all 3 shared-state dependencies that Appendix C reported as missed (previously 0/3), and adds no edge between calls that do not actually depend on each other.
  • Attack: we built a laundering attack across two separate sessions. The first reads a confidential email and writes it into a calendar event, which is allowed. The second reads the calendar and emails the content out. On AgentDojo as shipped, the gate already blocks this, because calendar reads are labelled non-public. When the shared store is publicly readable (as a shared scratchpad would be), only the gate with store nodes blocks it; without them, the exfiltration is admitted.

What remains outside any reachability rule is influence with no observable object or data path, such as a shared context window or steganography in message text. We will state this boundary explicitly.

Comments on the paper

4 comments
Area_Chair_RicEOpenReview ↗

Entering Last 24 hours of the reviewer discussion period

Dear Authors and Reviewers

Just a reminder we are soon to be entering the last 24 hours of the reviewer discussion period.

Authors: If you have not yet responded to the reviews and intend to please do so ASAP. Please note reviewers will most likely not have time to respond to any late rebuttal comments so please make sure any comments are clear and not in need of further clarification.

Reviewers: If the authors have responded to your reviews and you have not yet responded please do so, even if it is a one line response acknowledging you have read the rebuttal.

Thanks for all your time, and I hope you all learnt something interesting during the process.

Kind regards,

Your ICLR Area Chair

AuthorsOpenReview ↗

General response (part 1/3)

We thank all three reviewers for careful and constructive reviews. We also apologize for posting our response so late in the discussion period. We know this leaves little time for discussion, and we are grateful for any time you are able to give it.

The reviews share four concerns:

  1. Do the experiments test TopoGate's full admission mechanism, or only an alert signal? (dK73, nQMR)
  2. What do the graph rules and the model reviewer (the paper's overseer/declassifier) each contribute, and how sensitive is the result to the reviewer model? (dK73, nQMR)
  3. What does the defense cost end to end? (nQMR)
  4. How far does the guarantee reach: shared state, and the theory's conditions? (sJyW, nQMR)

We ran new experiments for each. While doing so we also found an error in our own evaluation. We report it first, because it affects how two tables should be read.

1. A correction we found ourselves, and what survives it

In the multi-agent comparison (Table 1, Fig. 1), our TopoGate-H and TopoGate-O arms were given information a real defender would not have: the case's list of attacker tools (and, for TopoGate-H, the attacker's instruction text). G-Safeguard was not given it. The same issue affects position taint on InjecAgent (Table 2), where the gate was told which tool call belonged to the attacker.

We removed this information and reran everything that could be rerun:

Five-topology comparison (Table 1, right column; 150 paired cases, case-clustered bootstrap):

ArmAttack successDifference vs. G-Safeguard
Unprotected0.456—
G-Safeguard0.452—
TopoGate-H, without attacker info0.353−9.9 pp [−15.7, −4.0], p = 0.001
TopoGate-O, without attacker info (reviewer: Claude Haiku 4.5)0.315−13.7 pp [−19.9, −7.6], p = 0.0001
TopoGate-O, without attacker info (reviewer: gpt-4o-mini)0.337−11.5 pp [−17.7, −5.2], p = 0.0004
Published TopoGate-O, with attacker info0.331−12.1 pp

The paper's main multi-agent result holds. Removing the attacker information changes neither arm significantly (−1.6 pp for TopoGate-O, p = 0.34; −0.4 pp for TopoGate-H, p = 0.87). The paper's reviewer model (gpt-4.1-nano) has since been retired by its provider, so we reran with two replacements from two vendors; both give the same conclusion. The result therefore does not depend on a stronger reviewer.

InjecAgent position taint (Table 2), without the attacker role: attack success is 1.29% (base) and 2.57% (enhanced), and position taint blocks 43 of the 64 exfiltration attempts that reach the external write (the paper reported 0% and 64/64). This is no longer significantly better than payload inspection (33/63 blocked; pooled p = 0.26), so we withdraw that claim. What remains is narrower but informative: every miss comes from a gap in the tool-name labels (tools named, for example, …DownloadData or …AccessUserInfo were not recognised as sensitive reads), none from paraphrase; and the two mechanisms catch different cases (together they block 40 of 63 on the same trajectories). We will correct §4.2 and Table 2 accordingly in the final version.

In-distribution column (n = 120): the generated test cases and the trained G-Safeguard checkpoint were lost from our storage, and the case generator is unseeded, so the same 120 cases cannot be rebuilt. The TopoGate rows of that column, as currently reported, should therefore be read as the uncorrected version. For the final version we will regenerate a seeded test set and retrain the monitor.

AuthorsOpenReview ↗

General response (part 2/3)

2. New: the full mechanism, online, on AgentDojo (answers concerns 1–3)

The paper's multi-agent experiment could not test admission control directly, for a reason we now state explicitly. G-Safeguard's harness counts an attack as successful when an agent proposes the attacker's first tool, which in these cases is a sensitive read. TopoGate deliberately permits reads and blocks the later read → external write path, so under that criterion full admission has nothing to act on, and the comparison could only be between flagging signals.

We therefore ran TopoGate as an online gate on AgentDojo's own benchmark (workspace suite, standard important_instructions attack, AgentDojo's own utility and security checks). Every tool call is checked before it executes; a refused call is not run, and the agent is told it was blocked. Agent: gpt-4o-mini. Reviewer: Claude Haiku 4.5 (a different vendor). We used gpt-4o-mini because the Claude agents we piloted resisted every attack, which would have left the security comparison with nothing to measure. Each arm is 600 runs (40 benign tasks + 560 attack pairs), up from 5 tasks in the paper.

ArmBenign utilityUtility under attackAttack success [95% CI]Exfiltration tasksReviewer calls / taskTime / task
No defense0.850.3418.9% [16, 22]12.5%09.4 s
Graph rules only (no model)0.650.354.6% [3, 7]0%09.7 s
Model review only (every write)0.600.550.0% [0, 1]0%3.3812.3 s
Graph + model (review only where the graph refuses)0.600.403.7% [2, 6]0%1.3111.5 s

How to read it:

  • Graph rules alone, with no model and no training, cut attack success from 18.9% to 4.6% (p < 0.0001) and stop all exfiltration. They stop 13 of AgentDojo's 14 injection tasks completely. The one they miss ("delete the file with ID 13") carries no data flow at all: the injected text only makes the agent decide to delete. That is control-flow influence, outside what any reachability rule over data edges can see, and we will state it as a limitation.
  • Model review alone is strongest on this attack, but it reviews every write (3.4 calls per task), and these injections target the agent, not the reviewer (see §3).
  • The combination needs 61% fewer reviewer calls for the same exfiltration protection.
  • The utility cost comes mainly from the reviewer refusing delegated tasks such as "do the actions in David's email". Graph rules alone cost less utility than either reviewer arm.
  • Overhead: the gate itself adds about 0.3 s per task; a reviewer adds 2–3 s and roughly doubles token cost.

3. New: how robust is the reviewer? (answers concern 2)

We attacked the reviewer directly. Five reviewer models (Claude Haiku 4.5, Haiku 5.5, Sonnet 5; gpt-4o-mini, gpt-4.1-mini) reviewed 180 disguised exfiltrations (six pretexts, e.g. "Emma asked me to forward this", or a note addressed to the reviewer), 30 piggyback attacks (the attacker added as bcc, participant or share recipient on a write the user really asked for), and 17 legitimate writes.

  • Disguised exfiltration to an unknown address was almost never approved: 0/180 for four reviewers, 2/180 for one.
  • Piggyback attacks are the hard case, and the reviewer matters a lot. With the full provenance the graph supplies, the three Claude reviewers approved 0/30, gpt-4o-mini 3/30, and gpt-4.1-mini 19/30: injected text in the provenance convinced it the request came from the user. Showing the reviewer only each source's tool and label (content withheld) brings every reviewer to 2–4/30. Full provenance is therefore best with a reviewer tested against provenance injection; metadata-only provenance is the safer default when the reviewer is untested.
  • Legitimate writes blocked: 6/17 (Sonnet 5) to 12/17 (Haiku 4.5). The reviewer, not the graph, sets the utility cost.
AuthorsOpenReview ↗

General response (part 3/3)

4. Other new measurements

  • Sanitizer's benign cost (Table 2's baseline): on AgentDojo's 40 benign tasks (ground-truth trajectories, as in the paper) it blocks 13, which is every task that writes externally, because it flags recipient email addresses. TopoGate blocks 7 bare and 0 with declassifier routing.
  • Do false blocks accumulate? Yes. Chaining benign tasks into longer sessions raises the bare rule's false-block rate from 17.5% (1 task) to 31.9% (40 tasks). With routing it stays at 0, but reviewer load grows (0.35 to 7.0 routings per task in this worst case).
  • Shared state: modelling each shared object (file, email, calendar event) as a node closes the shared-state gap of Appendix C (3/3 dependencies covered, previously 0/3, with no spurious edges). In a constructed case where the shared store is publicly readable, it also blocks a laundering attack that the gate otherwise misses.

5. What we will change in the final version

  • Correct Table 1 (five-topology column), Table 2 and §4.2 as described in §1, and report the new experiments in §2–4.
  • Theory: restate the label condition with explicit update semantics, and state the assumptions under which necessity holds (details in our reply to nQMR).
  • Positioning: acknowledge prior work on monitor-enforceable safety properties and state our contribution more narrowly (reply to sJyW).
  • A full specification of the reviewer: inputs, routing and admission rules, model and prompt (reply to nQMR).

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.