acceptodds
Withdrawn from ICLR 2027

Implicit-Tool Attacks in Coding Agents

Withdrawn from ICLR 2027, so left out of the paper lists and the map.

Abstract

Coding agents are increasingly integrated into software development workflows. Yet existing safeguards for coding agents primarily scrutinize their declared tool interfaces and may miss the consequences of persistent configuration edits consumed by downstream components. We term attacks exploiting this gap **implicit-tool attacks**: an adversary induces an agent to configure a benign, unmodified component to perform a sensitive operation later, outside the agent's direct execution path. To systematically evaluate this threat, we design ImpCraft, an automated framework that discovers implicit capabilities in benign extensions, synthesizes scenario-consistent attack instances, and validates their end-to-end runtime effects. Across 810 trials spanning 21 real-world extensions, three commercial products and three frontier foundation models over three independent rounds, implicit-tool attacks achieve an overall success rate of 80.1%, compared with 0.2% for matched direct requests seeking the same effects. Motivated by the role of downstream consequence recognition in attack failures, we propose a consequence-guided reasoning defense that directs agents to inspect referenced programs, endpoints, and execution paths before modifying configuration. In a focused GPT-5.5 evaluation across the three products, this defense substantially reduces attack success. This work provides insights for coding-agent security governance by uncovering an attack surface across component boundaries.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
Coding Agent, AI Security, AI-Assisted Development

Reviews

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

The paper studies implicit-tool attacks in coding agents, where persistent configuration edits cause benign, unmodified IDE components to perform sensitive operations after the agent session. It introduces ImpCraft to discover relevant settings, generate attack scenarios, and validate downstream effects. Across 810 trials involving three commercial products and three foundation models, the authors report an 80.1% attack success rate, compared with 0.2% for direct requests. A consequence-guided reasoning skill prevents successful attacks in 90 GPT-5.5 trials.

Critical strengths
  1. The paper addresses an important security risk arising from the interaction between agent-generated configuration changes and downstream execution in development environments.

  2. The evaluation uses commercial coding-agent products and unmodified extensions, requiring configuration writes, extension execution, and observed effects to establish attack success.

  3. Controlled network receivers and canary files enable concrete runtime verification. The appendices describe the experimental protocol and provide the complete defense instructions.

Critical weaknesses
  1. The novelty relative to Cuckoo Attack (Liu et al., 2025) and UntrustIDE (Lin et al., 2024) appears insufficiently established. The former already separates agent-mediated configuration writes from delayed execution, while the latter demonstrates execution through configured script paths. Section 7 seems to understate this overlap. Please clarify which mechanisms are new and establish the technical contribution of automated discovery and validation.

  2. Section 3.2 allows adversaries to construct task prompts and repository content, but the evaluation does not clearly separate authorized user requests from attacker-controlled instructions. Appendix E also specifies exact configuration changes. Please provide the benign user task, injection entry point, and attacker-controlled artifacts for each case, and clarify why attackers can supply executable assets but cannot directly modify the target configuration.

  3. The sandbox-bypass claims need clearer qualification. Appendix C.1 uses trusted workspaces, enables Allow all for Copilot, and places extension execution outside the terminal sandbox. Please specify the authorization guarantee violated, document effective permissions and process boundaries, and explain how these trust and approval settings constrain the conclusions.

  4. ImpCraft's methodological claims lack direct evaluation. The paper asserts high recall, reduced inference overhead, and effective skill-guided generation without reporting scanner precision/recall, generation yield, repair effort, or computational cost. Please evaluate the scanner against independently annotated settings and compare rule-only, model-only, and combined variants. Generation ablations should establish what the skill contributes beyond the underlying model and repository templates.

  5. The selection of 27 third-party cases from 235 candidate settings remains insufficiently documented. Please report attempted generations, validation failures, revisions, and exclusions. Because offline pre-validation retains executable configuration channels, the reported ASR is conditional on this selection. Please explain case representativeness and delimit the population to which the results apply.

  6. The network/local ASR gap may reflect differences in payload visibility. Network cases require agents to encode credential contents into configuration references, whereas local cases place harmful behavior inside referenced scripts. This confounds capability category with the information available during configuration decisions. Please control for malicious-content visibility, inspection requirements, and task framing before attributing the gap to capability-specific safety weaknesses or model alignment improvements.

  7. The defense is evaluated only on attack cases, leaving its utility and false-positive rate unknown. Its conservative refusal policy could also block legitimate toolchain setup. Please evaluate benign configuration tasks and report completion rates, false refusals, token usage, and latency. The claims of zero token overhead, zero behavioral interference, and preserved productivity in Appendix D.5 require empirical support.

  8. The stealth and persistence claims exceed the demonstrated evidence. The Flake8 wrapper in Appendix E deletes the canary and exits, without establishing that normal linting remains functional. The protocol verifies one trigger after session termination but does not systematically evaluate repeated activation or IDE restarts. Please assess legitimate functionality, user-visible traces, and persistence across relevant lifecycle events, or qualify these claims.

Questions for authors
  1. Section 7 distinguishes this work through configuration-mediated capabilities of benign, unmodified extensions. What is the mechanism-level novelty relative to Cuckoo Attack and UntrustIDE? Beyond the implementation details in Appendices B.2-B.3, what quantitative evidence supports the claimed scanner recall, inference savings, and contribution of the generation skill?

  2. Section 3.2 permits attacker-constructed prompts and repository content, while Appendix E.3 specifies the exact settings in a README task. In the evaluated trials, how are the authorized user task and attacker-controlled instructions separated? Given the trusted-workspace and approval assumptions and the Extension Host boundary documented in C.1, which authorization guarantee is violated, and how should the sandbox-bypass claim be scoped?

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

The authors argue that a coding agent can gain hidden abilities by editing persistent configuration that downstream IDE extensions read and act on later. They call these extensions implicit tools and give a simple formal model in which a setting write, a trigger event and an extension together produce a sensitive effect. They build ImpCraft, which scans extension manifests for risky settings, uses an LLM agent with a skill file to generate attack cases, and checks each case offline before use. On 30 cases from 21 extension environments, with Cursor, Codex and GitHub Copilot paired with three GPT models, the attacks succeed in 80.1% of 810 trials, compared with 0.2% for direct requests. Most failures come from model refusals in network cases, while local execution cases succeed almost every time. The authors also propose a prompt-based defense skill that asks the agent to trace the downstream effect of a setting, and it reduces attack success to 0% in 90 trials with GPT-5.5.

Critical strengths

Strength 1. The evaluation is done on real products and real extensions rather than a simulated environment. Each success requires a correct setting write, a confirmed extension run and an effect seen by an independent oracle, and the trigger happens only after the agent session ends. This design makes me trust that the reported attacks really happen end to end and are caused by the setting change.

Strength 2. The paper points to a real gap in how current agent safeguards work. Sandboxes and approval rules focus on the commands the agent runs, while extensions run in a separate process and are not covered by those controls. The finding that local execution cases succeed in about 98% of trials across all models is a clear and useful signal for people who build agent products.

Critical weaknesses

Weakness 1. The 80.1% versus 0.2% comparison does not isolate the effect of the delegation path. The direct baseline asks the agent to openly delete a file or send secrets, while the implicit prompt asks for a normal looking setting change, so the gap may mostly reflect how harmful the request looks. A baseline that asks the agent to directly run the same repository script under the same benign framing is needed to support the central claim that configuration is the blind spot.

Weakness 2. The threat model makes it hard to see how much risk the agent adds. The attacker writes the task prompt and places the harmful script in a trusted repository, and the prompt tells the agent not to run the tool and, in Cursor, to use a shell command to get around the settings lock. In this setting the agent acts much like a careful user following a team README, so I am not sure the results show an agent failure rather than the known risk of opening an untrusted repository in trusted mode.

Questions for authors

What is the attack success rate when the agent is asked, under the same benign team toolchain framing, to directly run the repository script or call the endpoint instead of writing the setting?

How often does the defense skill refuse benign configuration tasks that point to legitimate local tools or endpoints, and does it still work with other models or when it is not explicitly invoked?

Could the authors clarify what the user prompt contains in each trial compared with the repository content, and report results for cases where the user only gives a generic request such as setting up the project while the harmful instruction appears only in repository files?

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

Authors examine how coding agents can enable harmful operations through seemingly routine configuration edits. An agent might configure an IDE extension to use a repository-local formatter or contact a particular server. Later, an ordinary action such as saving a file causes the extension to execute the selected program or contact that server. Because the extension runs separately from the agent, the resulting operation can fall outside the agent’s sandbox and tool-approval checks. The attack relies on existing, unmodified extensions following their normal configuration behavior. Authors introduce ImpCraft, a framework that identifies relevant extension settings, constructs attack scenarios, and verifies that configuration changes produce the intended downstream effects. They evaluate different scenarios across three coding-agent products and three models. Configuration-mediated attacks succeed in 80.1% of trials, compared with 0.2% for direct requests targeting the same effects.

Critical strengths
  • The paper identifies a practically relevant gap in agent security. The attacks use unmodified extensions and ordinary development events, such as saving or formatting a file. The examples show why reviewing an agent’s immediate tool calls can miss the consequences of its edits. This is useful evidence for developers deciding where sandboxing and approval controls need to apply.
  • Authors present a comprehensive end-to-end validation. In particular, they check that the agent writes the configuration and then the intended extension consumes it, and that the target effect actually occurs. They also distinguish extension-triggered behavior from direct agent execution.
Critical weaknesses
  • My main concern on the paper is on the novelty wrt to existing work. In particular, the paper provides useful outcome-verified evidence of configuration-mediated attacks across coding-agent products. However, its central novelty claim is insufficiently distinguished from existing Cuckoo Attack work. Paper reduces Cuckoo Attack to payload storage despite that work explicitly separating agent-written configuration from subsequent routine-workflow execution. The authors should narrow the conceptual claim and establish their incremental contribution through its discovery methodology, coverage, and measurement capabilities.
  • The reported ASR gap does not isolate the contribution of configuration-mediated delegation. A stronger evaluation would compare equally disguised direct and delegated requests, ideally reporting model willingness separately from runtime blocking. I would also test whether explicitly disclosing downstream consequences changes configuration acceptance.
Questions for authors
  • What is the conceptual distinction from Cuckoo Attack? That work also separates agent-written configuration from later malicious execution.
  • The direct baseline explicitly requests a sensitive operation, while the implicit attack presents a configuration task whose consequences may be less apparent. So it's unclear, how much of the success gap comes from task framing versus execution permissions?

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

Related papers

Discussion (0)

Sign in to comment.