acceptodds
Under review as a conference paper at ICLR 2027

SkillBloat: Token Amplification Attacks via Skill Injection in LLM Coding Agents

Abstract

Agent skills extend coding agents with task-specific instructions, scripts, and resources. They can enhance coding agents while they may cause unnecessary computation and huge token consumption if agents follow malicious ones. This paper studies token amplification through skill injection: an economic resource-abuse threat in which an adversarial skill induces substantially higher token consumption than execution with the original benign skill. We present SkillBloat, a two-phase framework to produce malicious skills that amplify resource usage while preserving task completion. Across real-world coding-agent tasks, SkillBloat achieves up to 75.86× token amplification on individual tasks, with average best amplification ranging from 5.42× to 10.15× across multiple agent–model configurations. Unlike prior skill-poisoning attacks that target security consequences such as data exfiltration and file tampering, our work shows that skill poisoning can also cause economic resource abuse, which warrants broader research community attention toward resource-aware defenses in agent skill ecosystems.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
LLM Agents, Agent Skills, Resource Amplification

Reviews

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

This paper investigates skill-injection attacks that amplify token consumption in large language model (LLM)-based agents. By modifying a SKILL.md file, attackers induce agents to consume substantially more tokens than under benign conditions while appearing to complete their assigned tasks, thereby increasing computational costs. The authors propose SKILLBLOAT, a two-stage attack pipeline. In Phase 1, the method selects an attack configuration from 15 candidate types and rewrites the entire SKILL.md file using generative adversarial networks (GANs). In Phase 2, the attack is iteratively optimized through an execution–diagnosis–feedback refinement loop.

Critical strengths

(1) Task-specific adaptive optimization.

Unlike prior approaches such as Clawdrain and CDH, which rely on fixed or manually constructed malicious skills, this paper recognizes that effective amplification strategies may vary across skill–task pairs. It addresses this variation through a two-stage optimization pipeline, providing a more adaptive approach to resource amplification attacks.

Critical weaknesses

(1) The problem motivation and threat model are insufficiently justified.

A. Unclear research significance. The introduction acknowledges that prior work, including Clawdrain and CDH, has demonstrated resource amplification using fixed or manually constructed malicious skills. The main contribution of this paper is therefore task-specific skill optimization. However, the paper does not directly compare the proposed method with these existing approaches. Without such comparisons, it is difficult to assess the significance of the proposed contribution.

B. Inconsistent threat model. The threat model assumes that attackers can modify the victim's skill documents and associated resources, including scripts executable in the victim's environment. Given this level of access, attackers could potentially introduce more directly harmful payloads, such as those designed for data exfiltration or system disruption. The paper does not adequately explain why attackers would prioritize resource amplification over these alternatives or what makes this attack particularly attractive.

Furthermore, Phase 2 requires attackers to repeatedly access the target agent's execution traces and refine their payloads accordingly. This appears to require additional access to the agent's inputs and execution behavior, exceeding the stated assumption that attackers control only a single skill document. The paper should clarify how these capabilities are obtained within the proposed threat model.

(2) The experimental evidence does not sufficiently support the main conclusions.

A. Limited experimental scope. The experiments evaluate only two models on each platform and use a dataset of just 50 skills. This limited coverage raises concerns about the generalizability and robustness of the results.

B. Unclear contribution of Phase 2. The ablation results show that Phase 1 alone achieves 4.02×–7.51× token amplification. Moreover, resampling without feedback accounts for 12%–43% of the gains from Phase 1 to Phase 2, whereas the independent contribution of feedback is only 3.7%–14.7%. These findings suggest that the LLM-guided iterative refinement emphasized in the paper is not the primary driver of performance improvements. Given that Phase 2 requires five additional rounds of task execution, its benefits relative to its computational cost remain insufficiently justified.

C. Insufficient defense evaluation. The paper evaluates only output truncation as a defense and demonstrates its limited effectiveness. Other potential defenses, such as monitoring tool invocation frequency, verifying skill integrity, and detecting anomalous execution trajectories, are not examined. Consequently, the authors' call for resource-aware defenses lacks sufficient experimental support.

Questions for authors
  1. Related to Weakness 1. How can attackers implement the proposed attack in real-world scenarios without prior knowledge of the target agent's configuration or execution behavior? In particular, what access to execution traces is assumed during Phase 2?

  2. Related to Weakness 2 . Given that repeated payload generation without feedback already produces substantial improvements, what additional benefits justify the complexity and computational cost of Phase 2?

  3. Related to Weakness 2 . How effective are existing defense mechanisms against the proposed attack, particularly those based on skill verification, resource monitoring, and execution anomaly detection?

  4. Related to Weakness 1 . How does the proposed attack compare with existing resource amplification attacks in terms of effectiveness, computational cost, and practicality?

7 comments
AuthorsOpenReview ↗

Response to VHLL

We thank the reviewer for the constructive comments.

W1A:

We refer to Table R1 (in the Overview), which compares SkillBloat directly with Clawdrain and CDH on the same 50 skill–task pairs, frontend, backend, workspaces and completion judge; the discussion follows the table. Under comparable or better task utility, SkillBloat leads both methods.

W1B:

Neither part of the concern holds: resource amplification is the more attractive objective precisely because it leaves no observable trace, and Phase 2 needs no access to the victim's execution traces — every run it uses is one the attacker executes on the public model with the public skill.

The Introduction states the scope: resource abuse is a distinct objective, not a substitute for data exfiltration or destructive modification. What makes it attractive is that it is more stealthy. The injected skill runs entirely inside the agent's ordinary task execution: nothing leaves the environment, no destructive or unauthorized operation is issued, and the skill keeps working, so the victim gets no signal that anything is wrong and the excess cost is billed silently. Such an attack is therefore harder to monitor than exfiltration or unauthorized operations, and our LLM reviewer experiment quantifies the gap: a fixed-prompt reviewer that knows nothing about our method labels 94.0% (188/200) of our optimized skills benign.

The loop does require repeated executions, but they are the attacker's own, and no access to the victim is involved. The attacker installs the target frontend and calls the same publicly available backend model with the public skill and task prompt, so every trace used in Phase 2 comes from a run that the attacker executed; the only artifact that reaches the victim is the skill document. What is carried back from each such run is limited to the diagnosed failure type, the amplification ratio, the task-completion status, and the agent's final response; the completion label comes from the judge in Section 3.1, which inspects the files that the same run produced in the attacker's own workspace---never the victim's---and their contents are not passed to the attacker's model. Nor do we assume that every victim's skill is tuned individually: the optimization is done once, by the attacker, on a public skill. The published skill remains aggressive on inputs and deployments it was never optimized for: frozen skills deployed verbatim on three unseen input variants per skill retain a mean retention ratio of 0.92 (Figure 3), and on other deployments they retain 5.1724× on a different backend model and 6.8344× on a different frontend (Table R8, in our response to Reviewer 1 (5jRm) W2).

W2B:

Please refer to the Overview (Table R2), which reports Phase 1, feedback-free resampling and Phase 2 with repeated runs per configuration; the response to Reviewer 1 (5jRm) W1 summarises the same result.

W2C:

We have already revised the paper accordingly, and the updated PDF reflects these changes. We refer to Section 5.1, which now evaluates the defenses: an output-token cap swept over 2×/4×/8× with a benign control under the identical cap, and a fixed-prompt LLM skill reviewer that labels 94.0% (188/200) of our optimized skills benign. Neither removes the amplification without breaking legitimate task completion, and neither can separate maliciously induced computation from legitimate work.

Q1:

Please refer to our response to W1B above: Phase 2 assumes no access to the victim; on unseen inputs of the same task, a frozen skill retains a mean retention ratio of 0.92 (Figure 3), and when the target configuration is unknown it still retains 5.1724× on a different backend model and 6.8344× on a different frontend (Table R8, in our response to Reviewer 1 (5jRm) W2).

Q2:

Please refer to the Overview (Table R2), which reports Phase 1, feedback-free resampling and Phase 2 with repeated runs per configuration; the response to Reviewer 1 (5jRm) W1 summarises the same result.

Q3:

Please refer to our response to W2C above. No existing defense evaluated here separates malicious from benign skill use.

Q4:

We refer to Table R1 (in the Overview), which compares the three methods on effectiveness, task completion and practicality.

Dear Reviewer,

We hope you are well. With the discussion period drawing to a close, we wanted to check whether our response has answered the points you raised. We have tried to address the threat model directly: we clarify that Phase 2 uses only traces the attacker obtains by running the public model, with no access to the victim's execution, and we report transfer to an unseen model and an unseen frontend, together with the retention ratio on unseen inputs.

If any part of this still seems thin—or if there is a different experiment you would find more convincing—we would be very glad to hear it and to respond before the discussion closes.

Thank you for your careful reading and for the constructive feedback.

Best regards, The authors

Thank you for the authors' efforts in revising the paper and providing additional experiments. The rebuttal has addressed some of my concerns, but I still have the following reservations:

  1. Limited Experimental Scope and Generalizability. The concern remains largely unresolved. Although the authors added Tables R1 and R2, these experiments do not substantially expand the evaluation scope. The evaluation still covers only two models per platform and 50 skills. Testing three unseen input variants provides limited evidence of robustness but does not establish generalizability across different tasks, skills, models, and agent configurations.

  2. Insufficient Evaluation of Existing Defenses.The concern remains insufficiently addressed. The authors evaluate output-token caps and an LLM-based skill reviewer but do not examine other defenses explicitly raised in the original review, including skill integrity verification, tool invocation monitoring, and execution anomaly detection.

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

The author introduced SkillBloat, which involves rewriting the skill files used by the intelligent agent to encapsulate repetitive checks, error retries, lengthy reports, and other additional steps into a normal workflow, thereby inducing the agent to consume more tokens. The specific approach is to first filter out effective attack methods, and then repeatedly adjust the skill content based on the actual execution results. In the experiment, after selecting the best attack for each task, the average token usage under different configurations reached approximately 5-10 times the original amount, and for some tasks, it was close to 76 times. However, most tasks were still able to be completed. The risk revealed by the article is that users may think the task is completed, but they might have paid more for a large number of unnecessary operations.

Critical strengths
  1. The research question has certain practical value. The paper focuses on the additional token consumption caused by skill injection and demonstrates that the resource expenditure significantly increases when the task can still be completed. This is of reference significance for the cost control of programming intelligent agents.

  2. The ablation experiments are targeted. The authors set up a no-feedback rewrite control with the same additional execution budget, which helps to distinguish the effects of execution feedback and increasing the number of search attempts, providing certain support for the effectiveness of the feedback optimization mechanism.

Critical weaknesses
  • Experiment consists of 50 skill-task pairs, with only one task for each skill. The main results are derived from the highest consumption execution obtained through multiple screenings and optimizations. Although a few new input tests were added, there is a lack of independent repeated experiments after freezing the final malicious skills. Therefore, it is unclear whether these amplification factors can be stably replicated.

  • The experiment repeatedly optimized the skills for known tasks, but did not adequately explain what task information and execution feedback the attacker could actually obtain. Additionally, the simple cumulative output limit in Table 4 has already reduced the amplification factor to 1.24–1.39 times; currently, only one budget level is tested, and there is a lack of a control for normal skills under the same limit, which is not sufficient to determine the actual harm and defense cost when the budget is controlled.

  • This paper has pointed out that Clawdrain and CDH also studied resource consumption caused by malicious skills, but the experiment did not directly compare with these most relevant methods. The existing ablation studies can support the role of some components, but are not sufficient to explain the actual improvement brought by automatic screening and feedback rewriting compared to existing methods.

  • Final candidates were mainly selected based on the token amplification rate, without considering task completion as a necessary condition; the completion rate of GPT-5.5 also dropped from 94% under normal circumstances to 88%. It is recommended to distinguish between the cases where the original task is still completed and the original task is disrupted, and report the amplification effect separately when both normal execution and attack execution are successful.

  • Main text revolves around the same meditation log classification task, repeatedly introducing the execution stage and consumption changes through diagrams, tables, and lengthy text. The case can help understand the attack process, but the additional analysis provided is relatively limited. It can be compressed, and more space can be allocated for budget constraints, method comparisons, and result stability.

Questions for authors
  • Complete the key comparison under the budget constraints. Run normal skills and malicious skills under the same budget, increase several cumulative total tokens or cost ceilings, and report consumption and completion rates to clearly determine what impact the attack will have in a budget-controlled scenario.

  • Compress the case and tighten the conclusion statement. The main text retains a simple diagram and brief analysis, the detailed execution process is moved to the appendix; clearly state that the main amplification factor is the optimal result in the search, and adjust "maintain task completion" and other generalizations according to the actual completion rate.

3 comments
AuthorsOpenReview ↗

Response to hynS

We thank the reviewer for the detailed comments.

W1:

We refer the reviewer to Table R2 (in the Overview): every entry there freezes the final malicious skill and executes it three times on the same task, and we report the mean together with the run-to-run standard deviation. Across the three configurations the standard deviation is 0.21–0.57 in amplification and at most 2.31 percentage points in completion, so the amplification factors replicate across independent repeated runs.

W2:

The feedback consists of the diagnosed failure type, the amplification ratio, the task-completion status, and the agent's final response. The completion label comes from the judge in Section 3.1, which inspects the files produced by that run; their contents are not passed to the attacker's model.

We have already revised the paper accordingly, and the updated PDF reflects these changes. Section 5.1 now reports the budget-controlled comparison: the output-token cap is swept over 2×/4×/8×, each level paired with the benign skill of the same pair under the identical cap, reporting both consumption and completion. At 2× the attack is suppressed to 1.36× but completion drops to 62.00%, against 74.00% for the benign skill under the same cap; at 4× and 8× the amplification returns to 3.483× and 7.721× while completion recovers only to 68.00% and 70.00%, still below the benign 74.00% and 76.00%. The benign skill is essentially unaffected by the cap (amplification 1.079×–1.210×, completion 74.00%–76.00% across the three levels). Codex with GPT-6.1-Sol shows the same pattern (benign 1.098×–1.228× and 88.00%–90.00%). No budget setting both preserves task completion and suppresses the amplification.

W3:

We refer to Table R1 (in the Overview), which compares SkillBloat directly with Clawdrain and CDH on the same 50 skill–task pairs, frontend, backend, workspaces and completion judge; the discussion follows the table. Under comparable or better task utility, SkillBloat leads both methods.

W4:

Task interruption is not what produces the effect. Recomputing the main results with the task-completion constraint enforced: for each skill we keep only optimization rounds whose run actually completed the original task, and take the highest-amplification one among them.

Table R9. Amplification when only runs that complete the original task are counted.

ConfigurationOursCompleted runs only
Claude Code + GLM-4.7-Flash9.3105×8.7773×
Claude Code + GLM-55.4184×5.1193×
Codex + GPT-6.1-Sol4.816×4.693×

W5:

We thank the reviewer for this suggestion. We agree that the case analysis can be compressed, and we will revise the paper accordingly: the freed space will be used for the budget-constraint results and the stability analysis. The additional experimental results obtained during the rebuttal period will also be incorporated into the revised version.

Q1:

We have already updated the paper PDF: Section 5.1 now reports the normal and the malicious skill under identical output-token caps at 2×/4×/8×, with both consumption and completion.

Q2:

Please refer to our response to the fifth weakness above.

Thank the author's response, I would like keep my score.

AuthorsOpenReview ↗

Response to hynS

Thank you for your follow-up and for reviewing our response. We are glad the additional experiments addressed your concerns.

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

This paper investigates token-amplification attacks delivered through agent skills, where an attacker who controls a skill (its SKILL.md and, where supported, bundled scripts) rewrites it so a coding agent consumes far more tokens while still appearing to complete the task. The proposed SkillBloat pipeline operates in two phases. In Phase 1, an LLM Attack Agent (GPT-5.5) rewrites the full SKILL.md under each of K=15K=15 attack-type conditions (spanning output inflation, tool-driven amplification, context amplification, and hybrid placement variants, each tied to auxiliary tool scripts) and keeps the condition yielding the highest total-token amplification. In Phase 2, it runs five feedback-guided rewrites, each using a system prompt matched to the diagnosed failure mode (refused, ignored, task failed, low amplification) or a full-rewrite prompt once an amplification threshold is reached; the final skill is the highest-amplification candidate across both phases. The authors evaluate on 50 skill–task pairs from the SkillJect benchmark across two frontends, Claude Code (GLM-4.7-Flash and GLM-5 backends) and Codex CLI (GPT-5.4 Mini and GPT-5.5), using a GLM-5 judge to label task completion. They report average best amplification of 5.42×–10.15× (up to 75.86×) with 80–92% best-attack completion, alongside a no-feedback resampling ablation, a case study, an output-token-cap defense, a transfer test of frozen skills on new inputs (mean retention 0.92), and an analysis of which attack types win screening.

Critical strengths
  1. The evaluations demonstrate that the attack is effective in different settings.
  2. The threat model in this paper provides an interesting insight for model developers and defenders.
Critical weaknesses
  • The improvement of the optimization loop is unclear, and it seems that a simple baseline can achieve a satisfying effect for what the attacker wishes. The authors claim that the loop "uses real signal from target-agent executions, rather than merely benefiting from more samples" (l. 313–315), but in three of the four configurations this claim rests on Phase 2 minus No-feedback gaps of 0.34, 0.27, and 0.22 in amplification ratio (Table 2), without uncertainty estimates; by my calculation from Table 2, resampling without feedback already captures about 51%–89% of the Phase 1 → Phase 2 gain per configuration. The paper also lacks a non-optimized baseline, such as a fixed hand-written amplification snippet or a single attack type applied across all pairs, even though it calls full-document rewriting "a key design choice" (l. 166–167) and credits Clawdrain and CDH with task-preserving resource amplification via malicious skills (l. 053, 077–080, 455–457), leaving per-pair optimization as the main differentiator.
  • The threat model is narrower than the marketplace framing, and the source of the amplification is confounded. Each skill is tuned to a single skill–task pair and a single target configuration using 15 screening runs plus five refinement runs of the victim's agent on the victim's task (Sections 2.2, 3.1; l. 238–239). By contrast, an attacker distributing skills through repositories or marketplaces (l. 044–045) generally knows neither the victim's inputs nor their backend. Input transfer is tested on just 10 skills × 3 variants on Claude Code + GLM-5, where three skills retain only 0.52–0.56 (Section 5.2, Figure 3), and transfer across backends or frontends is not evaluated. In addition, every condition relies on attacker-supplied tool scripts whose outputs enter the agent's working context (Table 5; l. 143–144), yet tokens are not broken down by source (input vs. output; tool output vs. model generation) and no SKILL.md-only setting is tested. As a result, it is hard to tell how much of the amplification comes from the optimized instructions versus the sheer size of the payloads the attacker chose to emit (Q2, Q4).
  • Only one defense is evaluated, and detectability is not measured. The sole defense is an output cap set at 2× the benign output tokens of the same skill–task pair (Section 5.1), a quantity a real deployment would not know in advance, and the attack is not adapted to this cap. Completion under the cap is reported only for attacked runs (Table 4), so the "clear usability cost" (l. 402) is measured only under attack, while the cap's impact on benign runs (which determines its cost to legitimate users) is omitted. No LLM-based or static skill review is tested either, even though the introduction argues that existing detectors "may not directly address" such workflows (l. 088–089) and the Phase 2 prompts are explicitly written to "avoid triggering safety filters" (Appendix B.1). Reporting benign completion under the cap, testing a non-oracle budget, and measuring the detection rate of a simple LLM-based skill reviewer on benign vs. optimized skills would clarify the practical takeaways; as it stands, the results represent an upper bound under a strong adversary with many queries to the exact victim setup.
Questions for authors

Please refer to the weaknesses, especially for the second point of the threat model.

6 comments
AuthorsOpenReview ↗

Response to 5jRm

We thank the reviewer for the detailed and constructive comments.

W1:

We report this experiment in full in the Overview (Table R2), with three repeated runs per configuration. The decisive difference is task completion rather than amplification: freezing the Phase 1 winner completes 54.7% and 60.7% of pairs, feedback-free resampling cannot repair this (56.0%, 59.3%), whereas feedback raises completion to 81.3% and 91.3% while amplification still increases.

We also construct a baseline in which the attack type is fixed in advance rather than screened per pair. Each of the 15 attack types is applied unchanged to every skill–task pair in a configuration and then refined through the same five feedback-guided rounds as Phase 2, so the only difference from SkillBloat is that the attack type is not chosen per pair. For each configuration we report the three attack types with the highest mean amplification. None approaches SkillBloat: skill–task pairs respond differently to different attack types, and per-pair selection beats any single fixed type.

Table R3. Fixed single-method baselines, Claude Code + GLM-4.7-Flash.

MethodAmplification
Fixed: self debate5.116×
Fixed: fake error retry6.311×
Fixed: file io loop6.068×
Ours (SkillBloat)9.3105×

Table R4. Fixed single-method baselines, Codex + GPT-6.1-Sol.

MethodAmplification
Fixed: task decomposition4.411×
Fixed: fake error retry3.963×
Fixed: file io loop3.946×
Ours (SkillBloat)4.816×

W2:

Neither half of the concern holds: the threat model is no narrower than the marketplace framing assumes, and the source of the amplification is not confounded. We show this from four angles:

1. The amplification is not an output-side artifact. Output tokens alone — the content the model itself generates — are amplified by 11.3264× on Claude Code + GLM-4.7-Flash and 4.4157× on Codex + GPT-6.1-Sol. The victim agent genuinely produces more content while still performing the original task, rather than merely re-reading a longer document.

Table R5. Input vs. output amplification.

ConfigurationInput amplificationOutput amplificationTotal amplification
Claude Code + GLM-4.7-Flash9.3256×11.3264×9.3105×
Codex + GPT-6.1-Sol4.8237×4.4157×4.816×

2. The agent performs more work, not just emits more text. Tool calls rise from 12.80 to 22.52 per run on Claude Code + GLM-4.7-Flash and from 9.11 to 16.93 on Codex + GPT-6.1-Sol, against the benign baseline of the same skill–task pairs, i.e. the attack adds real tool invocations rather than only text.

Table R6. Tool calls.

ConfigurationBaseline tool callsAttack tool calls
Claude Code + GLM-4.7-Flash12.8022.52
Codex + GPT-6.1-Sol9.1116.93

3. The effect does not depend on attacker-supplied payloads. With SKILL.md-only — no bundled scripts, no auxiliary resources — amplification still reaches 4.4077×, i.e. 91.5% of the full-deployment value on Codex + GPT-6.1-Sol. Removing every attacker script therefore bounds the contribution of tool outputs at 8.5%: the optimized instruction document alone drives the agent to perform these operations itself.

Table R7. Full vs. SKILL.md only.

SettingAmplification
SkillBloat (full deployment)4.816×
SKILL.md only4.4077×

4. The optimized skill transfers to unseen deployments. Skills optimized on Claude Code + GLM-4.7-Flash were redeployed unchanged on a different model (GLM-5) and a different frontend (Codex, same glm-4.7-flash backend), retaining 5.1724× and 6.8344×. We do not claim full reproduction of the in-domain 9.3105×: frontend and model jointly determine the tool interface, system prompt and instruction interpretation. What matters for the marketplace is the residual effect — one published skill, no knowledge of the victim's model or frontend, still yields 5–7× on deployments it never saw. These transfers keep the original task text, but the residual amplification is still large enough that a skill published once remains a real threat to the community's deployments.

Table R8. Transfer results.

Deployment configurationAmplification
Claude Code + GLM-4.7-Flash (original)9.3105×
Claude Code + GLM-5 (cross-model)5.1724×
Codex + glm-4.7-flash (cross-frontend)6.8344×

W3:

We thank the reviewer for this constructive comment. We have already revised the paper accordingly, and the updated PDF reflects these changes. We refer to Section 5.1, which now evaluates both defenses raised in this weakness: an output-token cap swept over 2×/4×/8× with a benign control under the identical cap, and a fixed-prompt LLM skill reviewer that labels 94.0% (188/200) of our optimized skills benign. Neither defense removes the amplification without breaking legitimate task completion, and neither can separate maliciously induced computation from legitimate work.

Dear Reviewer,

We hope this message finds you well. As the discussion period approaches its end, with fewer than two days remaining, we would be most grateful if you could take a look at our response. We have run the experiments you asked for—a baseline with a fixed attack type applied across all pairs, a breakdown of input versus output tokens, and a test with SKILL.md only—and we would very much like to know whether they address your concerns.

Should anything remain unclear, or if you would like us to extend any part of the analysis, please do not hesitate to let us know. Your comments have been genuinely helpful in sharpening the paper, and we would be glad to discuss them further.

Thank you for your time and for the care you brought to the review.

Best regards, The authors

Thank you for the additional experiments. The SKILL.md-only and benign-control cap results are helpful. One brief follow-up:

The fixed-type baseline (R3/R4) still applies per-pair LLM rewriting plus five feedback rounds on the victim setup, so it isolates per-pair type selection rather than per-pair optimization. Could you report amplification and completion for a single fixed skill (e.g., one hand-written amplification block appended to every SKILL.md) with no victim executions, on Claude Code + GLM-4.7-Flash (a subset is fine)? This is the baseline closest to the marketplace threat model, and it would show how much of the 5×5\times to 7×7\times transfer amplification comes from optimization.

Comments on the paper

1 comment

We thank the reviewers for their careful reading and constructive feedback. We summarize the rebuttal-period experiments and our responses as follows. Specifically, we have revised the paper on the following four points based on the reviewers' comments:

1. Model substitution on the Codex configuration. GPT-5.5 and GPT-5.4 Mini were officially retired during the rebuttal period, so the Codex configuration in all rebuttal-period experiments is instantiated with GPT-6.1-Sol instead.

2. Re-implementation of Clawdrain and CDH. Neither method is open-sourced, so we reproduced the skill-writing procedure described in each paper and ran it on the same 50 skill–task pairs, the same frontend and backend, the same workspaces and the same completion judge as SkillBloat. For Clawdrain we used the strongest operating point reported in the paper: the segmented verification process (SVP) v3, with sequence length L = 2000 and T_max = 5 sequential segments.

3. Comparison with Clawdrain and CDH.

Table R1. Comparison with Clawdrain and CDH.

MethodGLM-4.7-Flash AmplificationGLM-4.7-Flash CompletionGPT-6.1-Sol AmplificationGPT-6.1-Sol Completion
Ours (SkillBloat)9.3105×80%4.816×90%
CDH2.3764×84%1.8803×90%
Clawdrain10.124×24%4.348×68%

Clawdrain does exceed SkillBloat on GLM-4.7-Flash — 10.124× against 9.3105× — but it does so at 24% task completion: it inflates the bill by breaking the task rather than by performing additional work, and a skill that fails three quarters of its tasks is not a usable capability. SkillBloat reaches 9.3105× while completing 80%. On Codex + GPT-6.1-Sol, Clawdrain falls to 4.348× at 68% completion, below SkillBloat on both quantities.

Against CDH the picture is different: CDH preserves task completion at the same level as SkillBloat (84% vs. 80% on GLM-4.7-Flash, 90% vs. 90% on GPT-6.1-Sol), but its amplification is 2.3764× and 1.8803× — roughly 4× and 2.6× lower than ours on the same pairs. Under comparable task utility, task-specific optimization is therefore what separates SkillBloat from the closest prior method.

4. Phase 2 vs. feedback-free resampling.

Table R2. Phase 1 vs. no-feedback resampling vs. Phase 2, three configurations.

ConfigurationMetricPhase 1No-feedbackPhase 2
Claude Code + GLM-4.7-FlashAmplification7.4632 ± 0.5068.8955 ± 0.4149.1917 ± 0.537
Completion (%)54.67 ± 1.1556.00 ± 2.0081.33 ± 1.15
Claude Code + GLM-5Amplification4.0422 ± 0.5685.1095 ± 0.5315.5293 ± 0.414
Completion (%)60.67 ± 1.1559.33 ± 2.3191.33 ± 1.15
Codex + GPT-6.1-SolAmplification3.639 ± 0.4234.2060 ± 0.2094.680 ± 0.284
Completion (%)90.00 ± 2.0089.33 ± 2.3190.00 ± 0.00

Each column freezes a different skill document and runs it three times on the same task; values are means over the evaluated skill–task pairs, and ± is the run-to-run standard deviation across the three runs. Phase 1 is the skill selected by attack-type screening. No-feedback is the best of the Phase 1 winner and five rewrites generated without execution feedback. Phase 2 is the best of the Phase 1 winner and five feedback-guided rewrites. Because every column is a mean over three independent repeated runs of one frozen skill document, these numbers differ from the main results of Table 1, which report the best evaluated run for each skill–task pair.

Phase 2 achieves the highest amplification in all three configurations (9.19× vs. 8.90×, 5.53× vs. 5.11×, 4.68× vs. 4.21×). The decisive difference, however, is task completion. The Phase 1 winner is selected on amplification alone and never optimized for the task, so freezing it completes only 54.7% and 60.7% of pairs on the two GLM backends; resampling cannot repair this (56.0%, 59.3%), because each rewrite is conditioned on the original skill and attack type but never on the previous outcome, so it resamples the same failure mode. Feedback conditions the next rewrite on the diagnosed failure type, amplification and completion status of the previous run, raising completion to 81.3% and 91.3% while amplification still increases. On GPT-6.1-Sol all arms sit near the 90% ceiling, where the feedback gain is confined to amplification.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.