acceptodds
Under review as a conference paper at ICLR 2027

Clawdrain: Resource Exhaustion Attacks in OpenClaw Agent

Abstract

Tool-calling LLM agents rely on third-party skills to extend their capabilities, but this openness exposes a supply-chain attack surface in which malicious skill instructions can manipulate agent execution across multiple turns. In this work, we present Clawdrain, a Trojanized OpenClaw skill that induces resource exhaustion through a Segmented Verification Process (SVP). SVP combines stateful progression, repair-driven repetition, and termination to create costly tool-calling chains while preserving a legitimate final payload. We evaluate Clawdrain in a production-like OpenClaw deployment with a real API backend across Gemini 2.5 Pro, DeepSeek V4 Flash, and Claude Sonnet 4.6. Clawdrain achieves 2–16× token use amplification with plain SVP, while the three models exhibit distinct behaviors, including autoregressive compliance, proactive scripting, and extended trial-and-error reasoning. Our findings reveal that agent resource exhaustion arises not only from output generation, but also from repeated context re-ingestion, tool coordination, reasoning, and recovery, motivating system-level controls over cumulative skill behavior.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
LLM agents, tool calls, contextual privacy, prompt injection, information flow

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

This paper presents Clawdrain, a resource-exhaustion attack delivered through a Trojanized third-party OpenClaw skill. The attack implements a Segmented Verification Process (SVP) that withholds an otherwise legitimate payload until an agent completes several validation stages. Each stage requires the agent to construct and submit a calibration sequence to a companion validator, which returns progress, repair, or terminal signals. The goal is to increase victim-funded model and tool computation while still returning a normal final answer.

The paper's main empirical argument is that deployed-agent resource cost cannot be inferred from output length or nominal tool-call count alone. In a complete OpenClaw runtime, accumulated context may be repeatedly re-ingested, and agents may respond to the malicious workflow through direct generation, scripting, tool coordination, retries, or failure recovery. The authors additionally introduce SVP+N, which provides fresh per-stage checkpoint values to prevent exact reuse of an earlier calibration sequence.

The evaluation uses real OpenClaw deployments and commercial API backends for Gemini 2.5 Pro, DeepSeek V4 Flash, and Claude Sonnet 4.6. With 50 runs per condition, plain SVP yields median cumulative-input amplification from approximately 2.7× to 16.4× over matched ordinary requests. The paper also documents qualitatively different backend behaviors and analyzes costly failed executions that consume substantial resources despite not completing the requested task.

I find the deployment-grounded measurements useful, particularly the observation that resource costs can migrate from visible generation to cumulative context processing, coordination, and recovery. My main concerns are novelty relative to closely related agent resource-exhaustion attacks and the lack of a matched benign multi-stage baseline or causal ablations. The current comparison establishes that a malicious skill that deliberately induces additional multi-turn work is more expensive than a normal request, but it is less clear how much of the reported amplification reflects a specifically exploitable runtime pathology rather than the expected cost of executing a more complex workflow.

Critical strengths

The strongest aspect of the paper is its deployment-grounded evaluation. Rather than evaluating an isolated tool loop, the authors execute Clawdrain in a complete OpenClaw runtime with real model APIs, persistent context, general-purpose tools, and actual provider usage accounting.

The paper also provides a useful systems-level perspective on resource exhaustion. For Gemini, input amplification is much larger than output amplification, demonstrating that economic impact need not manifest as visibly long model responses. The cached/uncached accounting further shows that repeated context remains relevant even when providers optimize repeated prefixes.

The cross-model behavioral analysis is informative. Gemini transitions from direct sequence generation to scripting, DeepSeek scripts proactively, and Claude exhibits substantial trial-and-error and recovery behavior. These results show that capable tool use can reduce one component of an attack without necessarily eliminating cumulative execution cost.

I also appreciate the separation of resource consumption from attack completion and final-answer correctness. The Claude failure cases illustrate why conventional ASR can be misleading for denial-of-service attacks: a run may fail to return the desired answer while already imposing substantial cost. The threat model is plausible for an open third-party skill ecosystem, and the paper is careful not to equate answer preservation with measured stealth. The authors additionally retain timed-out and compacted executions rather than discarding inconvenient traces.

Finally, performing 50 fresh-session trials per condition is substantially stronger than a small proof-of-concept evaluation.

Critical weaknesses

My primary concern is that the central experiment lacks a matched benign multi-stage baseline. The Base condition disables SVP entirely. Clawdrain therefore introduces additional stages, tool calls, and large arguments by design, so significantly higher resource consumption is expected even without any unusual runtime effect. A benign workflow matched for stage count and/or total payload size would help isolate how much amplification is specifically due to context re-ingestion, repair, and malicious workflow structure. Relatedly, the paper provides a mechanistic interpretation involving persistent context, sequence generation, relay state, recovery, and tool coordination, but explicitly states that the measurements capture their combined effect and do not isolate the individual contributions. Controlled ablations would make the central systems claim considerably stronger.

The novelty over prior resource-exhaustion work is also somewhat incremental. The related work already includes malicious MCP/tool attacks that generate costly multi-turn trajectories, including attacks preserving a correct final response. I see the main contribution as the production-runtime measurement and analysis of agent adaptation, rather than the basic staged exhaustion attack itself.

The quantitative reporting does not fully exploit the 50 trials per condition. The main results emphasize medians and a binary result marker but do not prominently report dispersion, timeout/compaction frequencies, or answer-success rates. Because the paper emphasizes model-dependent adaptive behavior, these distributions seem important.

The SVP operating points additionally vary sequence length, stage count, and instruction detail simultaneously, so they cannot support clean conclusions about attack scaling with any individual parameter.

The proposed runtime defenses—cumulative per-skill budgets and retry/loop circuit breakers—are sensible but are not implemented. A simple quantitative defense evaluation would substantially strengthen the paper and clarify whether the attack exposes a fundamental challenge or primarily a missing accounting mechanism in the current OpenClaw runtime.

Finally, external validity is limited to one agent runtime with general-purpose shell/Python access. Different context-management policies, tool permissions, spending caps, or skill sandboxes may substantially change the observed amplification.

Questions for authors
  1. Can the authors add a benign multi-stage workflow matched to SVP in stage count, tool-call count, or total payload volume, to separate attack-specific amplification from the ordinary cost of additional work?

  2. Can the authors isolate the contribution of context re-ingestion, turn count, sequence length, repair, and recovery through controlled ablations?

  3. What are the IQR/confidence intervals and per-condition rates of successful task completion, timeout, context compaction, and final-answer correctness across the 50 trials?

  4. How effective are the proposed cumulative per-skill budgets and loop/retry circuit breakers, and what utility degradation do they cause for legitimate multi-stage skills?

  5. Given the close relationship to prior MCP/tool-based multi-turn resource-exhaustion attacks, can the authors more sharply articulate which security phenomenon is newly established by Clawdrain beyond deployment realism?

Reviewer_eTEFOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper investigates resource consumption attacks introduced by third-party Skills in LLM agent ecosystems and presents Clawdrain, a malicious Skill. Through a staged verification process, Clawdrain presents additional sequence submissions, stage transitions, and failure recovery as prerequisites for obtaining legitimate task results. This induces additional model calls and tool interactions while causing accumulated context to be repeatedly processed in subsequent calls. Experiments on a full OpenClaw deployment with three model backends show that the standard SVP configuration increases median cumulative input token consumption to 2.74–16.40 times that of benign queries.

Critical strengths
  1. As LLM agents extend their capabilities through third-party Skills, malicious workflows can induce unnecessary model calls and tool interactions, increasing operating costs and compromising service availability. Identifying such resource abuse risks is practically relevant to the secure deployment of agents.
Critical weaknesses
  1. Missing evaluation against existing defenses. The attack is evaluated only under default runtime conditions, without testing against existing publicly available defenses. Its effectiveness and robustness in the presence of deployed defenses therefore remain unclear.

  2. Insufficient comparison with existing attacks. The main experiments primarily use benign queries with SVP disabled as the baseline, while the appendix provides only an output-inflation comparison based on a single run. The paper does not directly compare Clawdrain with existing resource consumption attacks under the same runtime conditions. Consequently, the results demonstrate increased resource consumption but do not establish its advantages over prior attacks.

  3. Lack of systematic ablation studies. The paper does not sufficiently isolate the contributions of staged verification, repair retries, and nonces to resource amplification. Existing configuration comparisons simultaneously vary several factors, including sequence length, the number of stages, and instruction details. The component comparisons in the appendix are also limited to single execution traces, making it difficult to reliably assess the contribution of each component.

  4. Limited breadth of attack scenarios. The paper primarily examines resource consumption induced by malicious Skills, without investigating whether the same mechanism extends to other attack objectives, such as task deviation, result tampering, or unauthorized actions. This narrows the scope of the study’s assessment of third-party Skill security risks.

Questions for authors

No further questions.

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

This paper studies resource-exhaustion attacks through third-party skills in OpenClaw. It introduces Clawdrain, which uses staged verification, retries, and dynamic checkpoints to induce additional tool calls. Experiments with three model backends in a complete OpenClaw environment show a 2.74–16.40× increase in cumulative input tokens under plain SVP. The paper also examines scripting-based adaptation and costly failures, showing why resource risks should be assessed across the full execution rather than through the final answer alone.

Critical strengths
  1. The evaluation allows agents to adapt their execution strategies. Agents can write scripts, switch tools, and recover from failures. For example, DeepSeek generates sequences through scripts from the outset, while Gemini switches to scripting during execution. This captures practical behavior beyond a predefined tool loop.
  2. The paper shows that task failure can still cause substantial resource loss. Claude fails to return the expected result under the strongest plain-SVP configuration, yet consumes 5.12× the baseline input tokens. This demonstrates why evaluating resource attacks solely through task completion can miss important consequences.
Critical weaknesses
  1. The added value over prior attacks is not sufficiently demonstrated. Prior work already studies resource amplification through multi-turn tool calls, so the paper needs to establish what additional capability SVP provides. For example, Table 1 mainly compares SVP against normal requests with SVP disabled. Gemini’s 16.40× amplification shows that the attack increases overhead, but does not establish an advantage over existing tool-chain attacks. Without a direct comparison in the same runtime, the methodological contribution remains unclear.

  2. The consistency of the attack’s practical impact remains unclear. The evaluation covers one framework and a limited set of tasks, with noticeably different outcomes across models. For example, DeepSeek’s plain-SVP amplification stays near 2.8×, while Claude consumes substantial resources at the highest setting but fails to complete the task. Although the paper reports 50 runs per condition, it does not provide complete success rates or resource-consumption distributions. It is therefore difficult to assess how consistently the attack increases costs while preserving normal results.

Questions for authors
  1. Validation of the current contribution: What key capability does SVP add beyond existing multi-turn tool-chain resource attacks? Could a direct comparison using the same OpenClaw environment and tasks show whether the gains come from the proposed design rather than simply more tool-call rounds?

  2. Clarification of results: Under what conditions does the attack consistently increase costs while returning the expected result? For example, how often does Claude fail at the highest setting across the 50 runs, and how much does resource consumption vary? Do the existing tests support similar conclusions across different ordinary tasks?

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.