Skip to content

OverServe: Resource amplification attacks on SaaS agents through co-design of tools and prompts

OverServe: Resource Amplification Attacks on SaaS Agents via Tool--Prompt Co-Design

arXiv: 其他 AI 安全论文· arXiv:2611.14808· Ruiheng Yu, Oteo Mamo, Siyu Gan, Weikuan Yu, Mulong LuoFlorida State University; Johns Hopkins UniversityIndexed by this site · 6 days ago· Originally publishedSelected AttacksSelectedAttention38

Quick read

Attacks

Based on the paper PDF (AI-generated); refer to the original

The authors propose OverServe, which co-designs an MCP state tool and a completion-confirmation prompt to amplify SaaS agent resource consumption; the authors report that on AppWorld, Sonnet-5 reaches 93.88× API request amplification.

Threat modelThe attacker is a SaaS tenant user who controls the prompts submitted to the agent and can submit third-party tools via MCP (defining name, description, parameter schema and implementation); the attacker can read exposed tools and query the victim agent but cannot change the victim agent's settings. The victim system is a subscription-based SaaS agent; the provider reviews tools before adding them to the tool library and controls existing tools, the task validator, the backend and the update schedule.

Questions
In subscription-based SaaS, an agent's model and tool calls consume provider resources without additional billing to the customer, so a malicious tenant can keep the agent from stopping in order to waste provider resources. The authors argue that existing attacks relying only on prompts or only on tools are easily detected and unrealistic.
Methods
The OverServe multi-agent framework co-designs a pair of components: an MCP status tool that truthfully reports status and terminates normally on each call, and an ordinary prompt that requires confirming completion before stopping. Each passes static, runtime, and prompt review separately, and combined they make the agent repeatedly check when the backend is continuously updated.
Experiments and results
On selected tasks across four victim models (Qwen, Nemotron, DeepSeek, Sonnet) and nine benchmarks, all attack runs pass the original task checks; on AppWorld, Sonnet-5 reaches 93.88× API request amplification, and the geometric mean across five enterprise benchmarks is 10.30×; five industrial scanners raise zero alerts on 22 tools.
Limitations and future work
The authors note that the evaluation uses selected benchmark tasks and controlled backend simulation, that the original task checks do not verify the newly added synchronization requirements, and that review inputs, baseline eligibility and baseline adaptation are inconsistent across experiments. Token counts use proxy estimates, and the paper states they do not represent billing cost.
Experimental setupQwen3.8-27B、Nemotron-3-Super et al. · MCPMark、BrowseComp-Plus et al. · amplification ratio (×)、tool calls et al.
Evaluated models
Qwen3.8-27BNemotron-3-SuperDeepSeek-v4-FlashSonnet-5Gemini-3.8-FlashDeepSeek-v4.1-Flash
Benchmarks
MCPMarkBrowseComp-PlusSTATE-BenchEnterpriseOps-GymEnterprise-WorldsWorkBenchToolathlon-GYMAppWorldTheAgentCompanyTerminal-Bench
Metrics
amplification ratio (×)tool callsAPI requestselapsed agent timereview scores (S/P/D)task-check pass
AI summaryand selection rationaleThe researchers propose the OverServe attack framework, which through co-design of an MCP status tool and a completion-confirmation prompt launches resource amplification attacks on subscription-based SaaS agents. The attacker, acting as a user, submits an apparently ordinary prompt to a service that allows third-party MCP integration, along with an MCP tool that truthfully reports service status; background updates keep the completion condition perpetually pending, so the agent keeps repeatedly calling the tool after the original task is complete, consuming the provider's inference and backend resources; the tool and the prompt are each harmless in isolation and can separately pass tool review and prompt review. On selected tasks from nine benchmarks with Qwen3.8-27B, Nemotron-3-Super, DeepSeek-v4-Flash and Sonnet-5, all attack runs passed the original task check; Sonnet-5 amplified API requests by up to 93.88 times on AppWorld, and Qwen3.8-27B pushed calls from 5 to 200 on EnterpriseOps-Gym.

The researchers propose the OverServe attack framework, which through co-design of an MCP status tool and a completion-confirmation prompt launches resource amplification attacks on subscription-based SaaS agents. The attacker, acting as a user, submits an apparently ordinary prompt to a service that allows third-party MCP integration, along with an MCP tool that truthfully reports service status; background updates keep the completion condition perpetually pending, so the agent keeps repeatedly calling the tool after the original task is complete, consuming the provider's inference and backend resources; the tool and the prompt are each harmless in isolation and can separately pass tool review and prompt review. On selected tasks from nine benchmarks with Qwen3.8-27B, Nemotron-3-Super, DeepSeek-v4-Flash and Sonnet-5, all attack runs passed the original task check; Sonnet-5 amplified API requests by up to 93.88 times on AppWorld, and Qwen3.8-27B pushed calls from 5 to 200 on EnterpriseOps-Gym.

Why it was selectedThe paper shows that a combination of tools and prompts that each pass review individually can continuously amplify agent resource consumption; teams that review components can use this to add workflow-level resource security checks.

Related events and news

0 events · 1 news mentions

News that mentions this paper

Paper analysis

6 questions; open one to read the full answer

  1. What problem does this paper attempt to solve?

    How a malicious tenant can amplify a SaaS agent's resource consumption without being detected, causing economic loss to the service provider.

    Core problem: In subscription-based SaaS deployments, how can a malicious tenant make the agent continue executing after completing the original task, consuming LLM API resources paid for by the service provider, while bypassing the service provider's review mechanisms.

    • Scenario and motivation: SaaS service providers (such as Salesforce, SAP) use agents to execute long-horizon workflows; model and tool calls consume tokens that the service provider pays to OpenAI and others, but customers pay by subscription, independent of usage. The agent autonomously decides when to stop, and an attacker can exploit this to cause losses for the service provider.
    • Shortcomings of existing methods: The authors argue that attacks relying only on prompts (such as ReasoningBomb, prompt rewriting) or only on tools (such as malicious tool returns, termination manipulation) are easy to detect, because existing work does not consider that real systems detect the two attack vectors of prompts and tools separately.
    • Core observation: The agent judges progress based on tool feedback and decides to stop; if the attacker changes the stopping condition so that the status tool always truthfully reports pending, the agent will repeatedly check until it exhausts the execution budget.
    • Proposed approach: The paper proposes the OverServe multi-agent framework, which co-designs an MCP status tool and a completion-confirmation prompt; each appears normal on its own and passes review separately, but combined they sustain repeated checking when the backend is continuously updated (churn).
    • Threat model:
      • Goal: Amplify the number of tool calls under a single prompt of the agent, beyond what is needed to complete the original task, without being flagged as malicious.
      • Knowledge: The attacker can read exposed tools and descriptions, query the victim agent, and observe responses.
      • Capabilities: As a SaaS user, control the prompt; submit tools as third-party MCP tools, defining their names, descriptions, parameter schemas, and implementations; cannot change the victim agent's settings.
      • Victim system: A subscription-based SaaS agent; the service provider reviews tools before admitting them to the repository, and retains control over the victim agent, existing tools, task validator, backend, and update schedule.
  2. What related research exists?

    Related work falls into three groups: resource amplification within models, multiple entry points for agent resource amplification, and screening and workflow security defenses.

    In-Model Resource Amplification

    • Sponge Examples (Shumailov et al., 2021) target the energy consumption and latency of neural networks; OverThink (Kumar et al., 2025) injects high-load decoy questions into retrieved QA context; ReasoningBomb (Liu et al., 2026) generates short prompts that prolong reasoning. The paper notes that these attacks amplify reasoning within the model response, whereas this paper focuses on tool-use amplification outside the model response.

    Agent Resource Amplification

    • User prompt manipulation: Li and Wang (2026) and Zhang et al. (2025) induce redundant reasoning or repeated calls by changing the instructions given to the agent; STA preserves the original task semantics under query-only access.
    • Indirect prompt injection: Greshake et al. (2023) place adversarial instructions in external content retrieved during execution; Xu et al. (2026c) and Li et al. (2026c) use attacker-controlled content to distort completion judgments or induce high-cost reasoning.
    • Tool and skill manipulation: Lee et al. (2026), Zhou et al. (2026), and Li et al. (2026a) use attacker-controlled tool metadata and return messages to induce looped calls; Dong et al. (2026)'s skill instructions impose high-cost verification; Zhang et al. (2026a) uses retained tool returns to enlarge subsequent inputs. Arif et al. (2026)'s joint attack pairs a user query trigger with a hidden template in a compromised remote agent.

    Screening and Workflow Security

    • Text screening: STA's semantic fidelity criterion and Beyond Max Tokens' task correctness criterion; MCP-ITP (Li et al., 2026b) uses detection feedback; A2M evaluates content screening.
    • Component behavior and consistency checks: Connor (Huang et al., 2026) checks component behavior, and DCI (Shi et al., 2026) checks description–code consistency; other work includes functionally correct but unsafe patches (Peng et al., 2026), agent feedback and stagnation (Hou et al., 2026; Park and Choi, 2026), and resource lifecycle (Luo et al., 2026).

    Baselines and Benchmarks: The comparison baselines are A2M, LoopTrap, and Sponge Tool Attack (STA), compared on the MCPMark text merge and EOG channel add message tasks with Qwen and Sonnet as backbones (Table 2).

    The authors position this paper as: targeting long-horizon business workflows that update service state through multiple tools, exploiting the gap between components being individually accepted and workflow resource security—trusted tool calls can accumulate into resource amplification.

  3. How does the paper address this problem?

    OverServe uses a writer agent to generate tool–prompt pairs, which after three separate reviews are tested on the victim agent in clean/quiet/churn comparisons, and the amplifying pairs are selected.

    OverServe is a multi-agent framework: it analyzes SaaS services to find operations whose completion status can be queried, a writer agent turns completion conditions into tool–prompt pairs, and candidates are then filtered through component review and execution feedback from a victim agent (Figure 2).

    Completion Condition Selection

    • Before the attack, an LLM reads the service and tool descriptions, proposes completion conditions (such as directory sync, permission update, search index update), finds a status API for each condition, writes a matching prompt, and explains why it can complete under quiet and remains pending under churn.
    • Formally: at the j-th check, the service operation status is xj, g(xj) = 1 means complete and 0 means pending; the tool truthfully reports the requirement oj[complete] = g(xj), i.e., the tool's completion determination equals the backend's true state.
    • Continuous external updates can keep this value at 0 within the execution window, so the victim agent repeatedly queries the tool.

    Tool–Prompt Co-Design

    • For each completion condition, the writer generates tool metadata, a parameter schema, implementation code, and a completion prompt q; the metadata uses the terminology of the target SaaS service, and the implementation code queries the operation status and returns whether it is complete and the number of pending updates.
    • Tool constraints: no internal retry loop, no prompt-matching test, no fabricated status, and no instruction that directly requires another call; q requires confirming completion but does not specify repeated calls or an execution budget, and preserves the original task goal.
    • A service-specific environment adapter registers the tool, appends q to the original task p, and connects to the service interface; Figure 3 gives an example of a tool–prompt pair from actual testing.

    Review Constraints

    • Three reviews: static review rs(ta) checks the tool metadata, schema, source code, and backend API contract (the reviewer receives the API specification rather than the backend implementation); runtime check rd(ta) calls at most six times after all backend work is complete, and passes if completion is reported without error within the first two calls; prompt review rp(p′) evaluates whether p′ expresses an ordinary task intent and flags instructions that explicitly exhaust resources.
    • The admission condition is Admit(a, p) = rs(ta) ∧ rd(ta) ∧ rp(p′), and only if all three pass is it admitted to the repository; the protocol thresholds are 0.8 for static and 0.7 for prompt.

    Attack Selection and Confirmation

    • Three conditions test candidates: clean (original task, existing tools, churn backend), quiet (attack pair added with a completed backend), and churn (the same pair with a pending backend); quiet and churn share the initial task state, victim model, and execution budget.
    • Amplification factors α0 = Cc/C0 and αq = Cc/Cq, i.e., the ratio of the median number of calls under churn to the clean and quiet baselines, respectively.
    • Selection requirements: pass admission, the quiet baseline passes the task check and stops normally, the attacked run calls the constructed tool, passes the task check, and reaches the amplification threshold; qualifying pairs are sorted by amplification factor, and once selected are fixed and replayed independently, reported separately from the generation stage (Algorithm 1).
  4. What experiments did the paper conduct?

    Four victim models, nine benchmarks plus a command-line task: amplification under churn reaches up to 93.88×, all pass the original task checks, and scanners raise zero alerts.

    Experimental setup

    • Victim models: Qwen3.8-27B, Nemotron-3-Super, local DeepSeek-v4-Flash, Sonnet-5 on Bedrock; the appendix additionally has Gemini-3.8-Flash and hosted DeepSeek-v4.1-Flash.
    • Benchmarks: selected tasks from MCPMark, BrowseComp-Plus, STATE-Bench, EnterpriseOps-Gym (EOG), Enterprise-Worlds, WorkBench, Toolathlon-GYM, AppWorld, TheAgentCompany, plus a command-line task derived from Terminal-Bench.
    • Construction and review models: the writer and the static and prompt reviewers use gpt-5.6-sol (G) or z-ai/glm-5.3-flash (L); BrowseComp-Plus query 655 uses Qwen3-14B for answer scoring.
    • Metrics: number of tool calls (API requests for AppWorld, elapsed seconds for Terminal-Bench), amplification factor, the three review scores S/P/D, and whether the execution cap is hit (Hit).
    • Repetitions: vary by setting, e.g., for EOG under 200 iterations, Q/N/S use three pairs and D uses one pair; Table 5 lists the baseline/attack repetition counts for each setting.
    • Baseline attacks: A2M, LoopTrap, STA (four rounds of search), with Qwen and Sonnet as backbones on MCPMark TxtMerge and EOG tasks, 40-round budget.

    Main results

    According to Table 1 (baseline → churn resource usage, Amp. is the ratio, Hit is whether the execution cap is hit):

    Swipe horizontally to read the table

    BenchmarkQwen3.8-27BNemotron-3-SuperDeepSeek-v4-FlashSonnet-5
    MCPMark TxtMerge5.5→101, 18.36×9→32, 3.56×6→102, 17.00×4→72, 18.00×
    EnterpriseOps-Gym5→200, 40.00×5→200, 40.00×6→201, 33.50×5→26, 5.20×
    STATE-Bench4→114, 28.50×5→106, 21.20×5→107, 21.40×6→33, 5.50×
    AppWorld23→213, 9.26×26→559.5, 21.52×68→1478.5, 21.74×29→2722.5, 93.88×
    WorkBench2→120, 60.00×2→16, 8.00×2→120, 60.00×2→17, 8.50×
    Terminal-Bench (seconds)27→332, 12.12×23→1200, 51.76×30→1200, 39.34×22→1200, 53.48×

    (TheAgentCompany, Toolathlon, Enterprise-Worlds, MCPMark Recommender and BrowseComp-Plus rows omitted; Toolathlon has the lowest amplification, 1.38×–1.73× for the four models; BrowseComp-Plus has 4.55× only for Sonnet, and the baseline task was not completed for the other models.)

    • The authors report: the geometric mean amplification across the 20 victim model–benchmark entries on five enterprise workflow benchmarks is 10.30×, and by model it is Qwen 19.30×, Nemotron 8.07×, local DeepSeek 17.75×, Sonnet 4.07×.
    • All OverServe runs pass the original task checks; on WorkBench, Nemotron goes from 2 calls to 16 calls under the 120-step cap (8.00×), and all nine Nemotron attack runs pass the native benchmark checks.
    • On BrowseComp-Plus only the Sonnet row has a result; the other models are marked as baseline task not completed.

    Comparison with existing attacks

    • Table 2: OverServe amplifies 1.25–1.50× under quiet and rises to 7–10× under churn; LoopTrap is 10× under both conditions (quiet overhead 2–10×), A2M is 1.17–1.50×, and four-round STA is below 2×. All 24 runs pass the task checks.
    • Stealthiness: source-code review and the Connor detector can detect all tested A2M and LoopTrap tools but fail to detect OverServe tools; OverServe's prompts pass review (in Table 2, code, runtime and prompt reviews are all 2/2).
    • At the token level: under churn relative to clean runs, OverServe's cumulative input/output token median amplification is 8.70×, the LoopTrap style is 4.97×, and A2M and STA are about 1.2× (Table 6, 12 runs per method per condition).

    Tool–prompt interaction and mechanism controls

    • Table 3 (Qwen, fixed tool): under the original task prompt the agent makes 4 calls and never calls the constructed tool; under an unrelated prompt total calls are 27 (quiet)/25 (churn) but the constructed tool is still called zero times; under a matching or paraphrased prompt, quiet is 5 calls and churn is 40 calls (including 36 constructed-tool calls).
    • Backend conditions: with no new updates, median 5 calls and normal stop; after ten updates, stop at 37 calls; with continuous updates or updates stopping at 45 seconds, both reach the 40-round budget; when only the first queried version is checked, 22 calls and normal stop.
    • Appendix D: the paraphrased prompt scores 0.40/0.70/0.75 across three GLM reviews (median passes the 0.7 threshold), the matching original wording scores 0.60/0.60/0.90 (median does not pass), but both wordings trigger tool calls.

    Tool screening and transfer

    • Table 4: five industrial scanners (Cisco YARA, Lasso regex, MCPInspect, MCPShield, LLM tool review) all raise 0/22 alerts on the 22 archived tools; research detectors DCI reports 3/22, Connor 1/22, Repeat-cue 0/22, No fixed point 6/22.
    • Fixed-artifact transfer (Table 7, MCPMark): the same tool–prompt pair amplifies 2.10×–7.44× on Sonnet-5, hosted DeepSeek-v4.1-Flash, Gemini and Qwen, all passing the churn native checks.
    • Metadata transfer (Table 8, STATE-Bench): Qwen passes the state check 6/6, 3.55×; Gemini passes 11/12, 1.60×.

    Other ablations and analyses

    • Reviewer sensitivity: for the same six G-generated EOG candidates, G review finds 4/6 meeting all score thresholds, and L review likewise 4/6 (component counts 6/4/6 vs 5/5/6).
    • Early MCPMark study (Figure 4, 50-round cap): Qwen goes from 8 calls to 51 on TxtMerge (6.38×) and from 6 calls to 51 on Recommender (8.50×), and all 18 executions pass the benchmark checks.
    • Prompt and metadata controls (Figure 5, Qwen): adding a completion prompt to a pure tool raises the tool-call rate from 1/16 to 16/16 (MCPMark) and from 0/12 to 9/12 (Enterprise-Worlds).
    • Introductory EOG case (Appendix E.1): under the 200-iteration cap, all three pairs go from 5 calls to 200 calls (40×), all passing the channel and message checks.
  5. What are some points that can be further explored?

    The authors note that the evaluation is limited to selected tasks and controlled backend simulation, and that task checks do not cover newly added requirements; the experiments cover four main victim models and ten benchmark environments.

    Limitations and Future Directions Noted by the Authors

    • Evaluation uses selected benchmark tasks and controlled backend simulation (Limitations section).
    • The original task check only evaluates business outcomes (such as channel creation) and does not check the added synchronization requirements (Limitations section).
    • Review inputs, baseline eligibility, and baseline adaptation are inconsistent across experiments; Appendix C documents these conditions (Limitations section).
    • The authors state that the code release should include the reviewed tool and prompt inputs, the status simulation setup, and instructions for reproduction in an authorized environment, including the execution caps needed to limit resource usage (Ethical Considerations section, planned).

    Scope of Experimental Coverage

    • The models tested in the main results are Qwen3.8-27B, Nemotron-3-Super, local DeepSeek-v4-Flash, and Sonnet-5, four in total; the appendix additionally reports transfer results for Gemini-3.8-Flash and hosted DeepSeek-v4.1-Flash.
    • The benchmark covers selected tasks from nine core benchmarks plus one Terminal-Bench-derived command-line task; the number of repetitions for each setting is given in Table 5 (e.g., under EOG 200 iterations, three pairs each for Q/N/S and one pair for D).
    • Defense evaluation includes screening of 22 archived tools by five industrial scanners and four research detectors (Table 4), as well as the comparative detection of A2M and LoopTrap tools by source code review and Connor in Table 2; the paper states that these are screening of imported components, and no full defense benchmark run with the original task plus prompt was conducted.
    • Token statistics are based on 96 attack replays and 4 clean references (12 per method per condition), using cumulative usage and a prefix-reuse proxy; the paper states that cached token estimates do not represent billed cost, and reasoning tokens are not counted separately.
    • The paper does not report that the search budgets of the writer and reviewer models are consistent across methods; Appendix C.2 states that the search budgets differ across methods.
  6. Summarize the main content of the paper

    OverServe co-designs MCP tools that faithfully report status and completion-confirmation prompts; each passes review separately, and combined they amplify SaaS agent resource consumption.

    A paper on a resource amplification attack against SaaS agents. In subscription-based SaaS, the agent's token consumption is borne by the provider, and a malicious tenant can exploit the agent's stopping decision to prolong execution and cause economic loss; the authors argue that existing attacks that go only through prompts or only through tools are easily detected by separately deployed detection.

    • Method: The OverServe multi-agent framework selects, for each service, an operation that can query completion status, and generates a pair of components—an MCP state tool that truthfully reports status and terminates normally on each call, and an ordinary prompt that asks to confirm completion before stopping. The two pass static (threshold 0.8), runtime and prompt (threshold 0.7) reviews separately; once combined, when the backend keeps updating (churn), they make the agent repeatedly check until the budget is exhausted.
    • Main results: Across four victim models (Qwen3.8-27B, Nemotron-3-Super, local DeepSeek-v4-Flash, Sonnet-5) on selected tasks from nine benchmarks, all attack runs pass the original task checks; on AppWorld, Sonnet-5 reaches 93.88× API request amplification, and the geometric mean across 20 entries on five enterprise benchmarks is 10.30× (Table 1).
    • Activation conditions: Under the original or an unrelated prompt, the constructed tool is called zero times; only a matching or paraphrased completion prompt triggers it; with no new updates, the agent stops normally (Table 3).
    • Stealthiness: Five industrial scanners raise 0/22 alerts on the 22 constructed tools, DCI reports 3/22 and Connor reports 1/22; whereas source-code review, which can detect all tested A2M and LoopTrap tools, and Connor are ineffective against OverServe tools (Tables 2, 4).
    • Authors' conclusion: Splitting the attack mechanism across two components, a tool and a prompt, allows it to remain accepted under separate reviews while producing resource amplification once combined; the authors note that the evaluation is limited to selected tasks and controlled backend simulation, and that task checks do not cover the newly added synchronization requirements.
Read originalarxiv.org