acceptodds
Under review as a conference paper at ICLR 2027

AgentECC: Repairing Hijacked Agent Actions Wherever the Environment Keeps a Witness

Abstract

Tool-using agents act on data they do not control. A line planted in an email or a file can redirect a payment while the rest of the task runs as asked. An execution guard can refuse the call, but stopping the payment does not recover its intended payee. A person may have to finish the task, and that handoff cost is much of why agents are not left to run unattended. We treat the injected value as corrupted data, with two recovery paths. When an independent, protected record determines the value the authorized action needs, the guard restores it without human involvement. When no record determines it, one scoped question about that field can obtain the missing value from an authorized source. AgentECC is a runtime guard with both responses, refusing when neither is available. Before deployment, an agent reads each tool’s schema and writes a contract naming which arguments carry consequences and which trusted sources hold their copies; a linter admits or rejects each entry. At runtime a deterministic check compares each guarded argument with those sources, without a model judging safety. We state when each response is sound and measure its environmental coverage before attacks. On AgentDojo’s rent tasks, with the same amount-scoped question channel, AgentECC keeps 13 of 20 runs under injection against refusal’s 5 on GPT-4o, 14 against 7 on GPT-5.5, and 10 against 1 on Qwen3.5-9B, with no successful attacks in these cohorts. Evaluated adaptive searches find no injection that passes its check. Given the same power to ask about every contested field, refusal still keeps 5 of 20 on GPT-4o, and asks more questions to do it. Refusal need not be the endpoint: a deployment can make more actions recoverable by engineering the records and authorized answer channels their fields need.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
LLM agents, tool-using agents, prompt injection, agent security, runtime defense, trusted data

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 2 reviews, above 85% of the others.
Reviewer_TXXiOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
2
Soundness
2(+1)
Read review
Paper summary

This paper suggests that refusal under prompt injection is unfavorable, and propose a framework that tries to recover the correct action upon prompt injection. An offline agent proposes a ruleset offline for consequential data fields such as payment recipient and amount, and when the task agent (outside the trust boundary) performs an action via tool call, the approach deterministically validate the action against the ruleset and attempt to fix the hijacked action. Experiments on AgentDogo shows that the proposed approach successful run correct actions compared to approaches that simply refuse execution upon prompt inject.

Critical strengths

The position proposed in the paper that the agents should attempt to recover correct behavior rather than hard refusal upon detection of attacks is a useful and novel research direction.

Critical weaknesses

Weakly justified trust boundary

Despite the proposed approach use deterministic rules and linters to validate the task agent's actions, the rules themselves are proposed by an offline agent. Apparently the task agent is outside the trust boundary, but I am not sure why the offline rule extraction agent is treated within the trust boundary; in practice, a prompt-injected offline agent can generate malicious rules in the first place. What is the justification of this trust boundary setup?

The scope of the application

In order that AgentECC can function, it needs a trusted way to determine the ground truth each consequential tool argument. For example, to prevent unauthorized payment, it must have a trusted record of what amount to pay & who to pay. This seem to be strong assumption, as in practice, the agent may not have access to such trusted records (and often time this is the information to be inferred by the model from noisy user input and context).

Questions for authors

Please see the weakness section and justify the trust boundary and the scope of the application.

3 comments
AuthorsOpenReview ↗

Response to Reviewer TXXi: what is trusted, and what happens without a record

Thank you for the review, and for recognizing recovery in place of hard refusal as a useful and novel direction. Both concerns led to changes in the main text (Sections 2 and 4.3); we answer each below.

New experiment. We ran the complete AgentDojo banking suite with no cell selected: all 16 tasks under all 9 attacker goals, 144 attacked cells per system, at two attack strengths. AgentECC admits no attack in any round and keeps more tasks than refusal-only blocking (Block) in every round: 101 against 72 under the weak attack, 80 against 64 under the strong one, and 98 against 66 when the user replies once to a refused call. The full end-to-end CaMeL port (banking security policies on) keeps 61 (Section 5.6 and Table 5 of the revised PDF).

Complete suite: kept, admitted of 144Weak attackStrong attackStrong, one user reply
No defense130, 16126, 97n/a
Block (refuse only)72, 064, 066, 0
AgentECC101, 080, 098, 0
CaMeL port, full (banking policies)63, 061, 161, 1

W1. Why is the offline agent inside the trust boundary?

We trust the checked contract table, not the agent that drafted it. The trust root is the provider registry that the deployer writes, and nothing the synthesizer proposes can add a trusted source to it.

  • The offline agent never reads attacker text. The attacker controls text that tools return at runtime. The synthesizer runs once before deployment, reads only the tool schemas and the registry, and never runs at runtime.
  • Its output is a proposal. A deterministic linter admits an entry only if the guarded path is a real parameter, every provider it names is already registered for that operation and field, and the response fits the field's shape. A rejected entry refuses at runtime. An empty proposal does not unlock a tool either: the linter rejects it, and the tool refuses at runtime instead of running unchecked.
  • We tested the attack you describe. Appendix B.9 gives an attacker full control of the synthesizer's output: seven poisoned proposals, among them tool output smuggled in as a trusted source, an invented provider, and a refusal turned into an unsafe repair. The linter rejects all seven.
  • The registry plays a familiar role. It does what hand-written security policies do in CaMeL: a short frozen file that the deployer reads once (11 entries for banking). Synthesis only lowers the cost of drafting it.

Revision. Section 2 now states this trust root and points to the test in Appendix B.9.

W2. Does AgentECC need a trusted record of every consequential argument?

No. Safety needs no record; a record only decides how much AgentECC recovers. The guard has three responses: restore the argument from a record, ask the user one scoped question, or refuse. Only the first needs a record. Redundancy gives the security, and interaction gives the recovery.

  • Your payment example. A user asks to change the rent amount on a standing order, and injected text swaps the recipient. The standing order records who to pay, so AgentECC restores the recipient. No record holds the new amount, so AgentECC asks the user for it and never guesses (Section 4.1).
  • No record, no guess. The case you describe, a value "to be inferred by the model from noisy user input and context", is where AgentECC asks the user and does not infer.
  • Safety without records. Only 3 of the 16 banking tasks have a record-backed field. AgentECC still admits no attack in any round, while the strong attack hijacks 97 of 144 undefended cells.
  • Utility without records. The scoped question supplies most of the gain over refusal on the complete suite (101 against 72; 98 against 66). In tau2 airline, where the customer names no payment method, it takes attack success from 4, 14 and 2 of 20 to 0 on three agents (Section 5.5).
  • Where records exist, the application already holds them. The payee on a standing order, the address on an order and the participants of an email thread were written by earlier authenticated user actions; the model does not infer them. Table 2 counts such fields in 11 of 33 guarded AgentDojo tasks, 7 of 105 tau2 retail tasks and 11 of 76 AppWorld tools.

Revision. Section 4.3 now states that a missing record lowers recovery, not security, and Section 5.6 reports the complete suite.

We hope this resolves the soundness concern, and we are glad to answer any follow-up.

Thank you for your response. I have a better understanding of the setups & assumptions of the paper now, and I have update my review scores.

Thank you for taking the time to read our response, and for updating your review. Your questions showed us where a careful reader would stop and ask what the paper assumes, and answering them made us state the setup and assumptions more clearly than we had. The paper is better for it. We sincerely appreciate the time and care you gave to this submission, and we are grateful for your open-mindedness throughout the discussion.

Reviewer_gomQOpenReview ↗
Rating
3
Confidence
3
Informativeness
3
Presentation
3
Soundness
3
Read review
Paper summary

Prompt injection remains a challenging problem for tool-using LLM agents. Existing approaches include detecting malicious content, improving robustness through training, and system-level defenses that enforce security constraints. While system-level defenses offer stronger security guarantees, they can sacrifice utility by blocking actions that depend on untrusted external data, even when the intended action could be recovered.

AgentECC addresses this security–utility tradeoff by treating corrupted tool-call arguments as an error-recovery problem. The framework constructs field-level contracts that specify trusted evidence sources, called witnesses. These contracts are generated offline from tool schemas and a trusted-provider registry, validated by a deterministic linter, and enforced at runtime. When an agent proposes an unsupported argument, AgentECC attempts to restore the correct value from a qualified witness. If no suitable witness exists, it can ask the user a scoped question or refuse the action.

The paper also provides a theoretical characterization of when sound recovery is possible and evaluates the approach across several benchmarks. The results show that AgentECC can substantially improve task completion over blocking while maintaining security, particularly in settings where trusted witnesses are available.

Critical strengths

S1. Well-motivated problem formulation with practical significance.

The paper presents a well-thought-out formulation of an important problem. Existing system-level defenses can prevent unsafe actions but often do so at the expense of task completion. Improving this security–utility tradeoff is important for practical agent deployment. The idea of recovering corrupted arguments using independent evidence, rather than simply refusing the action, is intuitive and addresses a meaningful limitation of refusal-based defenses.

S2. Thorough experimental evaluation.

The paper provides an extensive evaluation across different models, environments, and attack settings. I particularly appreciate the controlled comparisons that isolate the benefit of repair over refusal, as well as the ablations separating correction and user questioning. The authors also investigate witness availability, adaptive attacks, and cases where recovery is impossible. The inclusion of negative results and limitations makes the evaluation more convincing.

Critical weaknesses

W1. Semantic ambiguity in witness selection and construction. The correctness of AgentECC depends on whether a witness is appropriate for the user's intended action. This introduces two sources of semantic ambiguity:

  1. Selecting an existing witness: The system must determine whether a previously established value should remain unchanged for the current request. For example, restoring an existing recipient is appropriate for an amount-only rent update, but not for a request that also changes the recipient. The paper assumes that this applicability condition is established by the contract, but it is unclear how this can be reliably determined for arbitrary natural-language requests.
  2. Obtaining a new witness: When no existing witness is available, the system obtains one through a scoped question. However, identifying the missing information, formulating the appropriate question, and interpreting the response may themselves require semantic reasoning. The theoretical guarantees assume that the admitted evidence correctly identifies the intended value. It is unclear how robust the method is when these assumptions are difficult to establish, or when the user's request is ambiguous.

W2. Reliance on user confirmation may limit practical applicability. When no witness is available, AgentECC relies on user confirmation. Frequent questions could significantly reduce agent autonomy and lead to approval fatigue, particularly in workflows involving multiple consequential actions. More importantly, the security of this mechanism depends on the user's answer being independent of attacker-controlled information (Assumption 2). This may not hold in practice. For instance, if the agent asks the user to confirm a new rent amount, the user may simply consult the same compromised landlord document. The response is now authenticated, but the underlying value remains attacker-influenced. This raises a question about what security is actually gained through confirmation when the user cannot independently verify the requested information. In such cases, abstention may be preferable to treating the user's response as a qualified witness.

Questions for authors

Q1. Why expose already-established arguments to the agent? In the recurring-payment example, the correct recipient is already known and is not supposed to change. Why allow the agent to propose a new recipient in the first place? Could the tool interface simply preserve this field and expose only the arguments that the user intends to modify?

Q2. Comparison with CaMeL and deployment complexity. Table 17 shows that the full CaMeL port achieves the same task completion (75%) and attack success (0%) as AgentECC. Could the authors clarify where AgentECC offers a practical advantage over CaMeL in terms of reducing restrictions or improving task completion? Relatedly, how much effort is required to deploy AgentECC in a new environment? In particular, how difficult is it to identify appropriate witness sources, establish their integrity, and construct the necessary contracts? This seems especially relevant when qualified witnesses are not readily available.

Q3. Witness correctness and practical applicability.

3a. Semantic correctness: How does the system determine which witness is appropriate for a given user request? In particular, how does it establish that a field should remain invariant when the request is expressed in natural language? What happens when multiple legitimate witnesses exist?

3b. Witness integrity: How is the witness-selection process protected against attacker influence? Section 5.4 primarily evaluates attacks against an established witness check. Could an attacker instead influence which source is selected or which record is used as the witness?

3c. User confirmation: How does the system ensure that an answer to a scoped question is independent of attacker-controlled information? In realistic settings, users may consult the same document that the agent relied on. Wouldn't this allow compromised information to become an authenticated witness?

3d. Approval fatigue: Table 4B reports 11 question events in 20 GPT-4o runs and 23 in 20 GPT-5.5 runs under AgentECC. Further, Table 4A shows that even with questions, clean banking task completion is 11/16 compared with 14/16 for the undefended agent. How practical is this level of interaction in autonomous workflows? Could repeated confirmation requests lead to approval fatigue?

3e. Flexibility of witness policies: Is there a mechanism for controlling which previous records may serve as witnesses? For example, can a user exclude a particular transaction from being treated as evidence for future payments? How would the framework handle one-time payments to new recipients, where no previous witness exists? Is there a middle ground between requiring a qualified witness and refusing the action?

3f. Adaptive evaluation: Could the authors extend Section 5.4 to evaluate attacks against witness construction and selection, rather than only testing whether injected values can bypass an established witness check?

4 comments
AuthorsOpenReview ↗

Response to Reviewer gomQ (1/2): ambiguity routes to a question or a refusal; interaction is bounded

Thank you for the careful review, and for recognizing the problem formulation and the evaluation. This comment answers W1 and W2 with Q3a, Q3c and Q3d; the next answers Q1, Q2, Q3b, Q3e and Q3f.

New experiment. We ran the complete AgentDojo banking suite with no cell selected: all 16 tasks under all 9 attacker goals, 144 attacked cells per system, at two attack strengths. AgentECC admits no attack in any round and keeps more tasks than refusal-only blocking (Block) in every round: 101 against 72 under the weak attack, 80 against 64 under the strong one, and 98 against 66 when the user replies once to a refused call. The full end-to-end CaMeL port (banking security policies on) keeps 61 (Section 5.6 and Table 5 of the revised PDF).

W1 and Q3a. Semantic ambiguity in witness selection and construction.

The guard never resolves ambiguity by inference: an ambiguous case routes to a scoped question or a refusal. Semantic judgment happens once, offline, in a contract that a human reads. The runtime only compares values.

Selecting an existing witness. The contract fixes before deployment, per operation and field, which record may restore the field. Restoration needs exactly one witness on the current object; with several legitimate witnesses the guard asks and does not pick. A requested change needs a value the user named or confirmed. On the complete suite all 30 strong-attack repairs restored the recorded payee against the attacker's redirect, and none altered an action the user requested. Your rent example marks the boundary, and we probed it. When the user has moved and names a new landlord account, no attacker value is written: the evaluated guard falls back to the user's own earlier payee, which leaves the new request unfulfilled. The rule that completes it: a value of the same kind in the user's own turn removes the record as a restoration candidate, so the guard asks. Revision. Section 4.2 now states the rule and notes that the evaluated guard does not yet enforce it.

Obtaining a new witness. The runtime again infers nothing. The contract names the field to ask about, the question restates the request without quoting the suspect value, and the guard admits an answer only for the object and field it asked about. If the request itself is ambiguous, more than one candidate remains and the guard refuses. Where a deployment cannot establish that the answering source is qualified for a field, the contract sets that field to refuse.

W2, Q3c and Q3d. Reliance on user confirmation.

Interaction is the design's second source of recovery, and it is bounded: one scoped question per guarded field that no record resolves. Where the user cannot answer independently, the contract refuses, as you suggest.

  • Repair lowers the question count where a record exists. Table 4B has 11 against 14 questions on GPT-4o and 23 against 25 on GPT-5.5, at higher completion.
  • What a question buys. On clean banking, six question events recover five tasks (6 to 11 of 16, Table 4A). On the complete suite one fixed user reply recovers 19 strong-attack tasks and loses none (79 to 98). An oracle answers in these runs, so the counts measure what a qualified answer buys.
  • Q3d: the gap to the undefended agent comes from refusals, not from questions. Of the 46 strong-attack cells AgentECC does not keep, 38 sit on tasks 11 to 15, whose calls (update_user_info, update_password, payments with no witness) the frozen table refuses outright. On tasks 0 to 10 it keeps 91 of 99. Enforcement in general pays this price: AgentECC completes 11 of 16 clean tasks, and the full CaMeL port 6.
  • Q3c: independence of the answer. We agree that authentication alone does not give independence. Two rules narrow the path: a value the user repeats after the agent relayed it is not an attestation (Section 4.2), and the question never quotes the suspect value (Section 4.3). A user who copies from the same poisoned document is outside Assumption 2. There abstention is the right response, and the contract sets that field to refuse.

Revision. Section 4.3 now states that where no qualified source can answer, the contract sets the field to refuse, and Section 6 names a user study as future work.

AuthorsOpenReview ↗

Response to Reviewer gomQ (2/2): CaMeL comparison, deployment, attacks on witness selection, interface

Q2. Practical advantage over CaMeL, and deployment effort.

Against the full CaMeL port, with its banking security policies enforced, AgentECC keeps more tasks in every round, at 5 to 8% of the model cost.

Complete suite: kept, admitted of 144Clean, of 16Weak attackStrong attackStrong, one user reply
AgentECC11101, 080, 098, 0
CaMeL port, full (banking policies)663, 061, 161, 1
  • The table you cite. The 75% row of submission Table 17 runs the port with its security policies off; the same table reports 50% for the full configuration. Appendix D.4 now says so next to the table.
  • Cell by cell. In the user-reply round AgentECC keeps 38 tasks the full port loses and loses 1 it keeps.
  • Why. In CaMeL a denied call ends the action; AgentECC restores or asks at that point. The two designs act at different stages: CaMeL isolates the plan, and AgentECC decides what happens when an argument fails its check.
  • Deployment. The agent loop stays unchanged: no planner and no quarantined model, one guard at the tool boundary. The deployer writes a provider registry, which declares which stored field may vouch for which argument, and reviews the synthesized table once. Banking's table has 11 entries. For AppWorld's 473 tools, synthesis yields 5 guarded entries, 400 non-sensitive and 68 rejected, and rejected tools refuse by default. Where no qualified witness exists, the deployer chooses per field between an answer channel and refusal.

Q3b and Q3f. Attacks on witness selection and construction.

The attacker cannot steer the source: the frozen contract fixes it, and tool-returned text is never a witness. We extended Section 5.4 as you asked.

  • New probes. Fourteen fixed guard-level probes test the selection boundary without a model (Section 5.4, Appendix D.7). The guard rejects a contextual provider offered in place of the bound one (a contact-list entry cannot vouch for a payee), a bank record offered as witness for a new-payment operation, and a confirmation bound to another object or field.
  • End to end. Under the strong attack and the extra user turn, AgentECC's witness check admits 0 of 576 attacked episodes in each round.
  • Premises. Probes that break a stated premise get through, as the premise implies, and Appendix D.7 lists a remedy for each inside the framework. For example, Section 2 assumes an authorized object selector; when an injected call names a different order from the one the user named, the remedy is to guard the selector as a field whose witness is the identifier the user named.

Q3e. Controlling records, and one-time payments. A new recipient needs no history: a value the user names in their own turn is an attested witness and passes without a question (Section 4.2). When the user did not name it, one scoped question is the middle ground between requiring a witness and refusing. The contract already controls which providers may witness each operation and field. Excluding or expiring an individual record is the natural next control, and Section 6 names it as future work.

Q1. Why expose already-established arguments? A narrower interface that omits recorded fields is a good design for one fixed workflow, and it composes with AgentECC. AgentECC serves the general tools that already exist, whose calls carry unchanged and changed fields together: update_scheduled_transaction takes every field because users sometimes do change the payee, and AppWorld ships 473 such tools. The contract gives each request the same protection without a redesign of each tool. Revision. Section 6 now states this contrast.

Thank you again; we are glad to answer any follow-up.

Thank you for the detailed response and additional experiments. Most of my concerns have been addressed.

I remain unconvinced about W1. My concern is not whether semantic judgment happens offline or at runtime, but how the system determines whether an offline contract applies to a particular user request. The same tool may be used for an amount-only update or a recipient change, and the appropriate witness differs between these cases.

In fact, the reported example where the evaluated guard restores the old payee despite the user requesting a new one seems to confirm this concern. The proposed fix is not yet implemented and appears to address only cases where the user explicitly names a new value, rather than arbitrary natural-language requests.

Thus, while I appreciate the clarification, I believe the semantic-applicability assumption remains an important limitation of the approach. I maintain my positive evaluation of the paper

Thank you for coming back to this point, and for keeping your positive evaluation. Your follow-up makes the question precise, so let us answer it directly.

AgentECC does not decide, request by request, whether a restoration rule applies. The contract is written before deployment, per tool and field, and the runtime follows it. For a tool that serves both an amount-only update and a recipient change, restoring the recipient suits the first, while the second needs a value from the user. The example you point to is of the second kind, and you are right that the same-kind rule only helps when the user names the new value.

For such a field, the right response in our design is the scoped question. If users may change the recipient through this tool, the contract should ask about the recipient instead of restoring it. The user then supplies the value, so the guard handles both kinds of request the same way and has no intent to interpret. Restoration stays the right choice for fields a deployment knows its requests will not change; there it completes the action without interrupting the user.

So we agree with you: this is an assumption of the approach, and an important one to state plainly. Section 4.2 of the paper already says that a requested change needs attested or confirmed evidence, but it does not yet tell a deployer what follows from that. Your comment showed us it should. The final version will say so explicitly: a field a request may change should be bound to a scoped question. Thank you for pressing on this; the paper is clearer for it.

Comments on the paper

3 comments
AuthorsOpenReview ↗

Response to Reviewer bst8: The unselected end-to-end evaluation, novelty, and contract correctness

Thank you for the review, and for recognizing a guard that never asks an LLM to judge safety and an evaluation that is explicit about scope. We ran the evaluation your first question asks for.

New experiment. We ran the complete AgentDojo banking suite with no cell selected: all 16 tasks under all 9 attacker goals, 144 attacked cells per system, at two attack strengths. AgentECC admits no attack in any round and keeps more tasks than refusal-only blocking (Block) in every round: 101 against 72 under the weak attack, 80 against 64 under the strong one, and 98 against 66 when the user replies once to a refused call. The full end-to-end CaMeL port (banking security policies on) keeps 61 (Section 5.6 and Table 5 of the revised PDF).

SystemClean, of 16Weak attack: kept, admitted of 144Strong attackStrong, one user reply
No defense15130, 16126, 97n/a
Block (refuse only)872, 064, 066, 0
AgentECC, restoration only872, 066, 066, 0
Block + answers1196, 073, 097, 0
AgentECC11101, 080, 098, 0
CaMeL port, full (banking policies)663, 061, 161, 1

W1 and Q1. A pre-specified, unselected evaluation. The run follows your list.

  • Pre-specified. We fixed the weak-attack round before any run. The strong-attack and user-reply rounds are post hoc; we committed each protocol and its predictions before any paid episode, and all five predictions for the user-reply round held.
  • Complete workload. One agent (gpt-4o), all 16 tasks, clean and under all 9 attacker goals. No cell is conditioned on clean completion or on a witness, and the tools our contract refuses outright stay in the denominator.
  • Full published baseline. The end-to-end CaMeL port in its full configuration, with banking security policies, not our in-engine CaMeL-style ablation. Appendix D.5 and Table 19 give the protocol and every arm.
  • Same question channel. "Block + answers" gives refusal the same oracle answers, and AgentECC stays at or above it in every round.
  • Same continuation policy. In the last column each guard arm receives the same fixed message after a refused call, "Please continue with my original request.", which names no value. The port's denials end inside its interpreter, so its counts stand.

Reading. AgentECC keeps 29, 16 and 32 more tasks than refusal and 38, 19 and 37 more than the full CaMeL port, at 5 to 8% of that port's model cost. Cell by cell in the user-reply round, AgentECC keeps 38 tasks the port loses and loses 1 it keeps. The gain concentrates where the paper predicts: only 3 of 16 tasks have a record-backed field, so the scoped question supplies most of it here and restoration pays where records exist (Section 5.2).

W2. Novelty. AgentECC adds a capability that the systems you name leave to the policy author, and three parts separate it. Formulation: the contract itself declares the response to a failed check: per operation, field and object, which record may restore the argument, when to ask one scoped question, and when to refuse. An agent drafts it and a linter checks it; in PACT, CaMeL or AgentSpec an author writes such a recovery by hand, rule by rule. Condition: identifiability states when restoration is sound (one qualified witness on the current object, and a request that leaves the field unchanged), and the runtime enforces exactly this test. Evidence: the full CaMeL port, where a denied call ends the action, keeps 61 to 63 of 144 tasks per round; AgentECC restores or asks at that point and keeps 80 to 101, with no attack admitted. The claim concerns this capability and its condition, not expressiveness. Revision. Section 7 now states this positioning.

Q2. Contract correctness, and a concrete task. Two layers establish a binding. Mechanically checked: the path is a real parameter, every provider is registered for that operation and field, and the response fits the field's shape; when an attacker dictates the synthesizer's output, this layer rejects 7 of 7 poisoned proposals (Appendix B.9). Declared by the deployer: semantic authority comes from the registry, as with a hand-written CaMeL policy, and the deployer reviews it once on a short frozen table (11 entries for banking). Each inexact match in Table 27 of the submission is a provider or destination kind that the registry vocabulary lacked; none over-trusts, and a rejected entry refuses at runtime. Concrete task: banking task 2, a rent adjustment, with the payee substituted in the landlord's file. Refusal keeps 0 of 5 runs, AgentECC 4 of 5, and the CaMeL port 0 of 5, under the same trusted inputs. We offer it as an observed outcome, consistent with our answer on expressiveness. Revision. Section 4.1 now separates the two layers.

We hope the complete-suite result provides the evaluation you asked for, and we are glad to answer any follow-up.

Thank you for the detailed response and additional experiments. The new end-to-end evaluation and clarifications on novelty and contract correctness help address my main concerns. I appreciate the authors' efforts and will take these updates into account in my final assessment.

Thank you for reading our response so carefully, and for your kind words about the additional work. Your suggestion to evaluate the complete suite end to end strengthened the paper, and your questions on novelty and contract correctness helped us state the contribution more precisely. We sincerely appreciate the time and thought you put into this submission.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.