acceptodds
Under review as a conference paper at ICLR 2027

When Reasoning Fails to Stop: Prompt-Induced Resource Exhaustion in Black-Box Reasoning Models

Abstract

Reasoning large language models allocate additional inference-time computation to improve multi-step reasoning and complex problem solving. Existing studies have demonstrated excessive computation and high resource consumption by constructing or optimizing inputs. However, attack effectiveness alone does not explain the task conditions under which resource exhaustion occurs. We therefore investigate which prompt conditions induce continued computation and resource exhaustion in a black-box setting limited to normal question-answering requests. We construct Reasoning-Bench with five task types and three task-complexity levels, evaluating 400 prompts on 10 reasoning models to obtain 4,000 runs. Resource statistics, execution-behavior analysis, and condition ablations yield six findings: task complexity cannot directly determine resource consumption; code, cryptography, and algorithmic-reasoning tasks tend to exhibit higher resource consumption; models tend to execute first and judge later when tasks are declared solvable; continuously decomposable tasks encourage local exploration; missing or unverifiable information encourages multiple hypotheses and continued reasoning; and detailed-process requirements further increase resource consumption. To test whether these findings guide resource-exhaustion task construction, we propose ReasoningSink, a resource-exhaustion prompt generation framework for black-box reasoning models. The framework defines prompt conditions and model-behavior checks through State Constraints, organizes tasks through Dynamic Retrieval-Augmented Generation, and revises candidates through Execution-Feedback Optimization. Across the 10 reasoning models, ReasoningSink produces averages of 35.4K Completion Tokens (CT) and output-to-input Amplification Ratio (Amp). For every evaluated model, ReasoningSink achieves higher CT and higher Maximum-Budget Hits (MaxH) than the comparison methods. Reasoning text from ReasoningSink-generated tasks again exhibits executing before judging, local exploration, hypothesis-space expansion, and detailed-process elaboration, validating the findings' guidance for resource-exhaustion task construction. Code, dataset, and evaluation scripts are available at the anonymous repository Reasoning-Bench-and-ReasoningSink.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
reasoning large language models, prompt-induced resource exhaustion, inference-time attacks, black-box model security, denial of service, prompt benchmarks, prompt generation

Reviews

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

This paper studies prompt-induced resource exhaustion in black-box reasoning models. The authors construct Reasoning-Bench, a benchmark covering different task types, complexity levels, and task constraints, and analyze the model behaviors elicited by its prompts. Based on this analysis, they propose ReasoningSink, a framework for generating resource-exhaustion prompts. The authors report higher completion-token consumption than the comparison baselines across the evaluated models.

Critical strengths
  • This paper studies an interesting and useful security question: how attackers can exploit normal reasoning tasks to exhaust computational resources, which may serve as a reference for future work on defenses against such attacks.
Critical weaknesses
  • My main criticism is that the paper provides limited insight and it is unclear how its findings could guide future work.
    • The analysis of Reasoning-Bench is somewhat disappointing. Many findings are intuitive and unsurprising, while others appear specific to the constructed benchmark. The paper does not show whether these observations reflect general model behavior that can be validated on other existing datasets. I discuss these concerns in more detail in the Questions section.
    • ReasoningSink also appears closely tied to the authors' own benchmark, with insufficient evidence of generalizability beyond this setting. Moreover, adding more task constraints to prolong model reasoning appears to be an intuitive strategy. This does not seem to offer a compelling methodological contribution.
Questions for authors
  • Regarding Main Results on Reasoning-Bench: The prompts in the benchmark are generated directly by LLMs, and each investigated condition does not appear to be rigorously controlled. This makes many of the experimental conclusions less convincing for me.
    • Finding 1: How do you define task complexity? Before testing the models, how do you determine whether a prompt, mathematics problem, or coding task is easy or complex for a model?
    • Finding 2: First, the benchmark covers a limited range of task categories. Second, since the questions are LLM-generated, their quality and complexity are difficult to control consistently across categories. How can you directly attribute the observed differences in resource consumption to the task domain?
    • Finding 3: "When a task is declared solvable, reasoning models tend to 'execute first and judge later.'" I find this claim confusing. How can a model be expected to assess solvability without performing any reasoning? Can you provide some representative cases whose unsolvability is apparent without reasoning, but that still lead all evaluated models to perform extensive reasoning?
    • Finding 4: Why does round-by-round iteration constitute "continuous decomposition," and why is repeated computation described as "local exploration"?
    • Overall, these analyses share a common problem: the claimed rules are derived by changing factors that already seem likely to affect reasoning effort, followed by behavioral analysis of only a few cases and models to explain the observations. I do not find this approach convincing, and there is a risk of overinterpreting the results.
    • A stronger approach would be to use existing benchmarks instead of relying on an LLM-generated dataset. The relevant variables could be controlled using existing annotations, such as difficulty labels, or through a rigorous method whose validity is clearly justified. The experiments and analysis would then be more convincing.
  • Regarding ReasoningSink:
    • My main concern is that much of the methodology appears specifically tailored to Reasoning-Bench. Does the method also work on other established datasets to demonstrate its generalizability?
    • For truly black-box model services, such as those offered by OpenAI and Anthropic, where the chain-of-thought length is not observable, how would Execution-Feedback Optimization be applied?
  • Other issues and questions:
    • Figures 1, 2, and 4 are too small, making the text difficult to read.
    • Is the prompt shown in Figure 2(b) the actual template used to generate the prompts in Reasoning-Bench?
    • What is the intended title of Figure 3(c)? It appears to be rendered incorrectly.
    • In Section 4.3, line 355, what exactly is the input qq ? What does it look like in practice? Could you provide a concrete example?
    • Why does performance decline after Round 3 in Table 8?
Reviewer_CbCGOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

The paper asks which prompt conditions make black-box reasoning models keep reasoning until they approach their token budget. It builds Reasoning-Bench, a set of 400 ordinary single-turn questions covering five task types (mathematics, logic, cryptography, code, algorithmic reasoning), 24 subcategories, 88 leaf scenarios and three complexity levels, and runs each prompt once on 10 reasoning models. From token statistics, reasoning traces and condition-removal ablations on five of these models, it reports six findings. The most actionable ones say that solvability assertions, continuously decomposable state updates, missing or unverifiable information, and detailed-process requirements all increase token usage. The authors then propose ReasoningSink, which turns the findings into generation constraints, retrieves three similar Reasoning-Bench cases, and revises candidate prompts for up to three rounds using feedback from DeepSeek-R1-7B. Across the 10 models, the 100 generated prompts average 35.4K completion tokens and a 239.8× output-to-input ratio, compared with 20.2K for AutoDoS and 18.8K for LLM-GEN.

Critical strengths

1. A realistic setting with broad measurements. The attacker only sends normal single-turn questions, with no access to model internals or external context, and the study covers 10 deployed models with budgets from 32,768 to 262,144 tokens. Tables 13 and 14 report CT, Amp and budget hits for every model, task type and complexity level, and code and data are released.

2. Concrete prompt conditions with large effects. Removing solvability assertions cuts the number of near-budget runs roughly in half on several models (Kimi-K2.6 from 208 to 95, Qwen3.7-Plus from 165 to 80, Table 2). Conditions this simple are easy for providers to test and filter for, so the finding is useful for defense as well as attack.

Critical weaknesses

1. The ablations do not support the claimed mechanisms. Tables 2 to 5 delete parts of the task, so a lower CT may simply mean the question now asks for less work. There is no control that removes an equal amount of neutral text, no check that the ablated prompts are still well-posed, and no accuracy before or after.

2. ReasoningSink adds little over its own retrieval base. The 100 generated prompts average 35,385 CT (Table 14), close to the 34,461 of the 400 Reasoning-Bench prompts (Table 13). On DeepSeek-R1-7B, the feedback model, they are even lower (28,088 versus 29,620). Reasoning-Bench itself is therefore the missing baseline. The only attack baseline, AutoDoS, falls below its own LLM-GEN seed prompts on four of the ten models, and ThinkTrap is not evaluated.

Questions for authors
  1. How were the conditions removed in Tables 2 to 5? Please add a control that removes an equal amount of neutral text. This would show whether the CT drops come from the claimed behaviors or from shorter tasks.

  2. How does ReasoningSink compare with the original Reasoning-Bench prompts, and what is the MaxH of each baseline?

  3. How were the four behaviors identified in the reasoning text, and how often do they appear on LLM-GEN and AutoDoS prompts?

Reviewer_CCmsOpenReview ↗
Rating
1
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper studies how normal question-answering prompts can induce excessive resource consumption in black-box reasoning models. Paper first introduces Reasoning-Bench, which contains 400 prompts across five task types and three complexity levels (under three design principals: attack stealthiness, multiple task types, and multiple difficulty levels), and evaluate 10 reasoning models on it. Based on the experimental results and ablation studies, paper reports six findings on task characteristics and prompt conditions associated with excessive resource consumption, including solvability assertions, missing information, and detailed-process requirements. Building on these findings, paper then proposes ReasoningSink, a prompt-generation framework combining State Constraints, Dynamic Retrieval-Augmented Generation, and Execution-Feedback Optimization.The experiments show that ReasoningSink produces higher average completion-token counts than the five comparison datasets and methods.

Critical strengths
  1. The paper introduces Reasoning-Bench, a benchmark for systematically investigating resource exhaustion in reasoning models. It contains 400 prompts across five task types and three complexity levels, evaluated on 10 reasoning models. Its construction follows three design principles: attack stealthiness, multiple task types, and multiple difficulty levels. The benchmark also provides useful insights into task characteristics associated with excessive reasoning through resource-consumption measurements and behavioral analysis.

  2. The paper proposes ReasoningSink, a structured framework that connects empirical findings to prompt generation. It builds on the findings from Reasoning-Bench and constructs candidate prompts through three components: State Constraints, Dynamic Retrieval-Augmented Generation, and Execution-Feedback Optimization. The framework provides a coherent approach to incorporating task conditions and observed model behaviors into prompt generation.

Critical weaknesses
  1. The paper does not explain how the five task types, 24 subcategories, and 88 leaf scenarios were chosen, or why this taxonomy represents the conditions that cause resource exhaustion without introducing the critical motivation in Introduction section. More importantly, the prompt-generation process lacks key details: the generation model for Reasoning-Bench, the full instruction, and the screening protocol (i.e. number of annotators, agreement, and removal rate). Since the six findings and ReasoningSink are both derived from this benchmark, these lackness make the findings hard to assess and reproduce. Moreover, the condition ablations (Tables 2–5) are single runs, and removing a condition can change the task itself.

  2. Limited novelty and missing comparison with closely related work. POT (arXiv 2508.19277) already uses black-box, LLM-based iterative optimization to generate covert overthinking prompts. Inducing Overthink (arXiv 2605.13338) evolves problem structures with a genetic algorithm, and Missing Premise exacerbates Overthinking (arXiv 2504.06514) is closely related to Finding 5. None of these is cited, and among the five baselines only AutoDoS is an attack method. In addition, the gain over the benchmark itself is small. The 100 ReasoningSink prompts reach a mean CT of 35,385 tokens (Table 14), compared with 34,461 tokens for the 400 Reasoning-Bench prompts (Table 13). The paper does not state what the combination of constraints, retrieval, and feedback adds. A comparison with other baselines under matched conditions, and with Reasoning-Bench prompts as a baseline, is needed.

Questions for authors
  1. The introduction states that attack effectiveness alone does not explain the conditions under which resource exhaustion occurs (Lines 59–62). However, ReasoningSink is evaluated primarily based on attack effectiveness. Is the paper's main contribution the empirical analysis provided by Reasoning-Bench or the proposed attack framework?

  2. The main text refers to Medium and High complexity levels (e.g., Line 240) without defining them, while the thresholds are only provided in Table 10 of the appendix. Task complexity is determined by the number of features and constraints. How was this definition validated? Moreover, Table 13 shows higher mean CT at the High level than at the Low level across all five task types. Does Finding 1 still hold?

  3. Finding 5 is illustrated by a single example (Lines 292–296), but its generalizability across different task types and complexity levels, particularly in cryptography tasks, remains unclear. Many prompts also explicitly state that an answer exists and should not be questioned, making it difficult to distinguish whether continued reasoning is caused by these instructions or by the missing information itself.

  4. The paper does not clearly explain who evaluates the model-side behaviors or whether these evaluations are validated against human annotations. Moreover, the reasoning text may not accurately reflect the model's internal computation. Since ReasoningSink iteratively revises candidate prompts to induce the expected behaviors, the behavior rates reported in Table 6 should be interpreted in the context of this optimization process. Corresponding behavior rates for the baselines would help establish the effectiveness of the proposed approach.

  5. Section 2.1 states that prompts should avoid obvious attack intent. However, several prompts in the appendix contain strong instructions, such as "the answer exists, do not doubt!!!" (e.g., Figures D.9, D.10, and D.13), some of which are written in Chinese. The paper does not provide an explicit evaluation of attack stealthiness, such as detection rates from a guard model or a rule-based filter, making it difficult to assess whether the generated prompts satisfy this design principle.

  6. Several apparent inconsistencies remain across the paper. The appendix overview mentions 35 case demonstrations, while Appendix D states that it presents 24 cases. Appendix D also includes GLM-5.3 cases, although this model is not among the 10 models evaluated in the main experiments, and the relationship between these additional cases and the main evaluation is not explained. Additionally, Table 14 reports MaxH = 0 for GLM-4.1V-9B, which contradicts the claim that ReasoningSink achieves strictly higher MaxH than the comparison methods on every evaluated model.

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

This paper investigates how attackers can induce excessive resource consumption in reasoning models through prompts in a black-box setting. The attack is restricted to ordinary, single-turn user queries. The paper makes three main contributions:

  • Reasoning-Bench: The authors use an LLM to generate candidate prompts and manually select 400 prompts covering five task categories and three difficulty levels. Each prompt is tested once on 10 reasoning models, resulting in 4,000 runs.
  • Six main findings: Based on aggregate statistics, manual analysis of selected reasoning traces, and condition-removal ablations on five models, the authors identify six findings. Task difficulty does not directly predict resource consumption, while coding, cryptography, and algorithmic tasks tend to incur higher costs. Four prompt features may further increase resource consumption: asserting that a solution exists, encouraging continued task decomposition, providing incomplete or hard-to-verify information, and explicitly requesting detailed reasoning.
  • ReasoningSink: Based on these findings, the authors propose a prompt generation method. It retrieves three similar examples from Reasoning-Bench and iteratively refines candidate prompts for up to three rounds using feedback from DeepSeek-R1-7B. The resulting 100 prompts consume an average of 35.4K completion tokens across 10 models, compared with 20.2K for AutoDoS and 18.8K for direct LLM-based prompt generation.
Critical strengths

1. The research problem is interesting, and the observed phenomena deserve attention.

The paper restricts the attacker to submitting ordinary, single-turn user queries. This setting is more realistic for deployed models than attacks requiring white-box optimization or manipulation of external context. The experiments show that such prompts can induce several commercial reasoning models to generate an average of 30K–60K reasoning tokens.

2. The evaluation covers a diverse set of models.

The authors evaluate 10 models from six providers. Tables 13–14 provide detailed results across models, task categories, and difficulty levels.

Critical weaknesses

1. The effectiveness of ReasoningSink is not convincingly demonstrated, and some central claims are inconsistent with the experimental results.

(1) There is no direct comparison with Reasoning-Bench. Although ReasoningSink retrieves examples from this dataset, its average CT increases only from 34,461 to 35,385 (+2.7%). Performance actually decreases on the feedback model DeepSeek-R1-7B (28,088 vs. 29,620; 53% vs. 62% budget exhaustion rate) and on GLM-4.5 (38,425 vs. 41,870).

(2) The baselines are insufficient and potentially unfair. SimpleQA, SimpleBench, and AIME 2024 are standard benchmarks rather than attack baselines. ReasoningSink uses feedback-based optimization, but the paper does not establish whether its query budget matches that of AutoDoS or other methods. A best-of-N baseline with an equal query budget is also missing. Furthermore, differences in task types may naturally lead to different reasoning lengths, but this factor is not adequately controlled.

(3) The ablation studies are insufficient. Module ablations and the analysis of feedback rounds are conducted only on DeepSeek-R1-7B, with a single run per prompt. The number of feedback rounds is also selected based on performance on the evaluation prompts, raising concerns about tuning on the evaluation set.

2. The six main findings lack sufficient evidence. The conclusions are relatively superficial, and the underlying mechanisms are not adequately investigated.

(1) The ablations do not sufficiently support Findings 3–6. The four prompt conditions appear in 71.5%, 37%, 71%, and 82.5% of prompts, respectively, with an average of 2.6 conditions per prompt. However, the experiments do not account for interactions between these conditions. Each prompt-model pair is tested only once. The condition-removal procedure is unclear, and there is no control experiment involving the removal of equally long but irrelevant text. The criteria for detecting the target behaviors are also unspecified, and the mechanism analysis provides only one example per behavior.

(2) Table 6 does not support the authors' claim that the findings are validated. Using the aggregate results in Table 14 (1,000 runs, mean CT of 35,385, and 278 budget-exhausting runs), the statistics for runs without each target behavior can be inferred. All four behaviors show the opposite trend: runs exhibiting the target behavior have lower token consumption and lower budget exhaustion rates. For example, runs exhibiting "executing before judging" consume 33.0K tokens on average, with a 24.3% exhaustion rate, compared with 39.8K tokens and 34.3% when the behavior is absent. Moreover, the state constraints and feedback-based filtering are designed to encourage these behaviors, so observing them again does not constitute independent validation.

(3) The evaluation metrics cannot distinguish useful reasoning from wasted computation. MaxH depends on model-specific token budgets, but these budgets are not reported. The paper also does not report termination reasons, task accuracy, or the proportion of runs involving repetitive reasoning loops. Therefore, it remains unclear whether the models are genuinely trapped in unproductive reasoning. Natural differences across task types further complicate causal attribution.

Questions for authors

1. Does Table 6 actually support the six findings?

For each model, what is the direction of the CT difference between runs that exhibit each of the four behaviors and those that do not? How are these behaviors detected? If the four behaviors are associated with higher token consumption for most models after stratifying by model, I would consider the authors' claim that the findings are validated largely supported.

2. How is "resource exhaustion" defined?

Please report the token budget ((M_m)) for each model. Among runs that reach the budget limit, how many are truncated before completing their reasoning, how many exhibit repetitive loops, and how many successfully complete the task? Also, how many of the 400 prompts are unsolvable or internally contradictory?

If high consumption is mainly observed in models with 32K–48K token budgets, or primarily reflects computation genuinely required by the tasks, the claim that models fail to stop reasoning should be substantially narrowed.

3. Does ReasoningSink provide an independent performance advantage?

How much does ReasoningSink improve over randomly sampled Reasoning-Bench prompts and a best-of-N LLM-GEN baseline with the same query budget? What evidence supports the abstract's claim that ReasoningSink achieves higher MaxH than the baselines on every model?

4. Are the condition-removal ablations sufficiently reliable?

Were the conditions removed manually or through LLM rewriting? How was task semantics preserved before and after modification? How many samples were collected per prompt? Which models were used in Table 1?

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.