Multi-agent language-model systems split a hard job into roles: one agent finds the bug, another writes the patch, a third tests it, and critics review each step. Each role has the same weakness. It has no principled sense of when its own work is good enough. Some agents stop too early and hand broken work downstream. Others keep revising, and the extra critique loops cost tokens and sometimes break answers that were already correct. We propose giving each subtask an aspiration level, a coarse "good enough" grade that the subtask must reach and beyond which further revision is forbidden. These aspiration levels are adjusted across the task graph: a downstream failure raises the bar for the upstream step that caused it, and an easy success lowers it for next time.
The idea is borrowed from satisficing game theory, where agents stop adjusting once an outcome clears a threshold. There, a deviation is allowed only if it moves the agent into a strictly higher payoff bucket, and this rule keeps equilibria easy to find and prevents agents from chasing tiny gains. Carried over to agent pipelines, the same bucket rule does two jobs. It guarantees that revision loops terminate, and it keeps critics from rewriting work that already clears its bar, which targets the "overthinking" failures documented on easy tasks. The claim is that per-subtask, graph-propagated aspiration levels reach the accuracy of fully elaborated pipelines at a fraction of their cost. They should also beat the obvious simpler rule, "stop when the critic approves," at matched cost.
Core Claim and Where It Comes From
Two findings motivate the work. Why Do Multi-Agent LLM Systems Fail? annotated 1,642 traces from seven frameworks. It found that system-design issues, which include repeated steps and missing termination awareness, account for 44.2% of failures, and that weak task verification accounts for another 23.5%. Single-agent or Multi-agent Systems? Why Not Both? found that multi-agent systems spend 4x to 220x more prefill tokens than single agents and can underperform them on easy tasks such as GSM8K. These results pull in opposite directions: one says verify more, the other says verify less. Our position is that the right amount of verification is a per-subtask, per-instance quantity, and satisficing theory gives a disciplined way to set it.
Two papers supply the method. Multi-Agent Systems with Quantitative Satisficing Goals replaces payoff maximization with an ordered ladder of thresholds. Agents deviate only to climb a rung, which lowers equilibrium checking to PSPACE-complete. That work is purely automata-theoretic and needs integral discount factors, so we take its bucket-deviation rule and leave its verification machinery behind. Games With Tolerant Players adds a strategy-consistency constraint: every option an agent might play must itself clear the tolerance bar. We use this as a constraint on critics. A critic may request a revision only by asserting, through a checkable signal, that the current output sits below its subtask's aspiration bucket. "This could be better" is not grounds for revision.
The mechanism works as follows. Subtask $i$ in the task graph has a ladder of $k_i$ quality buckets. These are defined by cheap, mostly executable signals. On repository bug-fixing, the reproduction script either does or does not fail before the patch. The localization step can be graded by whether spectrum-based fault localization and retrieval agree on the same file and function. The patch can be graded by whether the reproduction passes and whether the existing tests pass. Each subtask carries a current aspiration $a_i \in \{1,\dots,k_i\}$. The agent stops as soon as its output reaches bucket $a_i$. If the final task fails and blame is assigned to subtask $i$, then $a_i$ rises by one and only that subtask re-runs. A revision is accepted only if it lands in a strictly higher bucket than the one it replaces. Because every accepted revision raises some bucket index and indices are bounded, the total number of upstream revisions per task obeys
$$R \le \sum_{i} (k_i - 1),$$
where $R$ counts accepted revisions across all subtasks. This turns the "infinite loop" failure mode into a hard bound fixed in advance. Across tasks, the starting aspirations follow an aspiration-learning update in the spirit of Aspiration Learning in Coordination Games. A subtask's default level rises after it causes downstream failures and decays after streaks of first-try successes.
The bucket count is a dial that subsumes existing designs. With $k_i = 1$ the rule collapses to "stop at the first output that passes the check," which is plain critic-approval early stopping. As $k_i$ grows large, the rule approaches always-revise optimization. Our prediction is that accuracy per token is maximized at small but non-trivial $k_i$, typically two to four. This mirrors the finding in Satisficing Equilibrium that top-$k$ choice with $k \le 4$ already captures human play in the 11–20 game, a small number-choosing game used to study how deeply people reason about each other. In a pipeline, this choice would be measured as a U-shape over $k$.
Research Program
We will build the method as a controller over two existing pipeline styles, so that the only change is when agents stop and whom they hand work back to. For software issue resolution, we will reimplement a CodeR-style five-role task graph (manager, reproducer, fault localizer, editor, verifier) following CodeR. For reasoning, we will use a two-agent actor–critic refinement loop of the kind trained by DPSDP in Reinforce LLM Reasoning through Multi-Agent Reflection. DPSDP runs a fixed five turns and then majority-votes, and in that setting the buckets come from critic-graded rubrics combined with sample agreement. For general assistant tasks we will wrap the open SupervisorAgent codebase. This lets us replace its hand-tuned length and loop heuristics with aspiration buckets while keeping its intervention types fixed.
The analytical part has two goals. The first is to show empirically that the revision bound holds and that MAST-style termination failures disappear. The second is to characterize which bucket signals are reliable enough to gate critique. A bucket defined by a noisy LLM judgment is exactly where the method could fail, so we will measure judge–outcome agreement for each signal. Blame assignment for raising $a_i$ will start with a simple rule: raise the earliest subtask whose output a downstream check contradicts. A learned alternative will be added only if the simple rule proves to be the bottleneck.
Baselines
The naive reference point is the unmodified pipeline run with its native control: CodeR's fixed task graph, DPSDP's five turns plus voting, and the SupervisorAgent-free multi-agent system on GAIA. This gives the accuracy ceiling the original design achieves and its full token cost. Every method will use the same backbone model, the same tool access, and the same maximum token budget per instance. We will report full accuracy-versus-tokens curves, not single points. Published figures serve only as sanity checks for our reproductions, because those figures use different backbones. CodeR reports 28.33% resolution on SWE-bench Lite, and its ablation on GPT-4o fell from 22% to 10% when the multi-agent task graph was removed (CodeR). DPSDP reports MATH-500 accuracy rising from 58.2% to 63.2% for Ministral-8B (Reinforce LLM Reasoning through Multi-Agent Reflection).
The strongest existing efficiency method is SupervisorAgent from Stop Wasting Your Tokens. It reports about 29.68% overall token reduction on GAIA, up to 35% savings on Level 2, and on AIME a 6.67% higher solve rate at 18.92% lower token cost. It is the strongest competitor because it already intervenes inside the pipeline at runtime, not just at its boundary. We run it from its released code with the same backbone. Beating it means matching its accuracy at lower tokens, or exceeding its accuracy at equal tokens, on GAIA and AIME.
The second strong competitor is the agent cascade and routing scheme of Single-agent or Multi-agent Systems? Why Not Both?. It reports cascade accuracy gains of 1.1% to 12% and routing cost savings of up to 88.1%. It is strong because much of the multi-agent waste may simply come from easy instances. We run it with the same external verifier our buckets use, so the comparison isolates internal, per-subtask control from whole-task escalation.
The key ablations isolate the ingredients. Setting $k_i = 1$ gives critic-approval early stopping. Fixed per-subtask aspirations with no downstream propagation tests whether the graph-level update matters. Propagation without the strict-higher-bucket acceptance rule tests whether that rule is what prevents loops and regressions. The proposal succeeds only if the full method dominates all three ablations on the accuracy–cost frontier on at least two of the three domains.
Why not just…?
Why not just stop when the critic or verifier approves? This is the real threat, and it is exactly our $k_i = 1$ ablation. Its weakness is that a single pass/fail bar cannot tell "barely acceptable" from "solid." Verifiers in MAST traces mostly check shallow properties such as syntax and compilation (Why Do Multi-Agent LLM Systems Fail?), so approval-stopping inherits that weakness. It also has no way to send work back upstream when a later stage fails. If $k_i = 1$ matches the full method on the frontier, we will report that the ladder and propagation add nothing. In that case the contribution shrinks to the bucket-gated critique result alone.
Why not just route easy instances to a single agent and escalate hard ones? Cascades treat the multi-agent system as a black box. Once a task is escalated, every internal role still runs at full elaboration, and that is where the 4x–220x token overhead lives (Single-agent or Multi-agent Systems? Why Not Both?). The two approaches can also be combined, so we will test the cascade with and without aspiration control on its escalated branch. If the cascade alone captures nearly all the savings, the method's value is limited to hard instances, and we would state that plainly.
Why not just tune SupervisorAgent's heuristics or the iteration cap? Hand-set length and repetition triggers do not track semantic progress. The SupervisorAgent authors themselves report that aggressive heuristic filtering hurts by stripping structure agents rely on (Stop Wasting Your Tokens). A fixed iteration cap spends the same budget on a proof that was right on turn one as on one that needs all five. To be fair to both, we will give each a tuning budget on a held-out split equal to the one used to choose bucket definitions and $k_i$.
Proposed Experiments
The main experiment runs all methods on SWE-bench Lite and SWE-bench-Verified for issue resolution, MATH-500, Olympiad Bench and AIME for reasoning, and GAIA for assistant tasks. Every method uses a single open backbone. We report resolution rate or accuracy, total prefill and decode tokens, wall-clock latency, and the number of upstream revisions per task. The headline target is CodeR-pipeline accuracy within one point at no more than 70% of its tokens on SWE-bench Lite, together with a frontier that dominates SupervisorAgent on GAIA.
The first decisive check concerns overthinking. On GSM8K and the easiest MATH-500 levels, we count answers that critique flips from correct to incorrect. The prediction is that bucket-gated critique nearly eliminates these flips while keeping the refinement gains on Olympiad Bench. If flips persist, the strategy-consistency constraint is not doing its job.
The second check concerns termination. We will run the MAST annotator, which agrees with human experts at Cohen's κ of 0.77 (Why Do Multi-Agent LLM Systems Fail?), over traces from every method. We expect step-repetition and termination-blindness modes to drop sharply, with observed revisions always within the $\sum_i (k_i - 1)$ bound.
The third check is the sweep over $k \in \{1,2,3,4,8\}$ to test the predicted U-shape. A monotone curve would falsify the satisficing account in favor of either pure early stopping or pure optimization.
The last check is signal reliability. We stratify results by how well each bucket signal agrees with final test outcomes, to measure how much the method depends on cheap executable checks versus model judgments.
References
- Why Do Multi-Agent LLM Systems Fail?
- Single-agent or Multi-agent Systems? Why Not Both?
- Multi-Agent Systems with Quantitative Satisficing Goals
- Games With Tolerant Players
- Aspiration Learning in Coordination Games
- Satisficing Equilibrium
- CodeR: Issue Resolving with Multi-Agent and Task Graphs
- Reinforce LLM Reasoning through Multi-Agent Reflection
- Stop Wasting Your Tokens: Towards Efficient Runtime Multi-Agent Systems