Decomposition Buys Budget at Best, Nothing Usually

Every result so far has been about pools of whole attempts: the same question answered by seven models, by sixteen draws of one model, by agents debating, by scaffolds around a model, by an agent run four times. The pool's union is wider than its best member, and nothing without a verifier collects the difference. Decomposition is different in kind. A planner cuts the problem into parts, each part is solved with a clean context and a short horizon, and an assembler combines them. If a model fails a problem because its reasoning runs too long or drifts, parts could succeed where the whole did not; if it fails because the move it needs is not in it, parts fail too. Which of the two is the question.

The literature has the operator everywhere and the comparison nowhere. CooperBench (arXiv:2601.13295) gives two agents separate features of one task and finds them at 26–28% against 47–49% for one agent doing both, with budgets unmatched and only self-play. The Interaction Tax (arXiv:2608.23541) runs ten configurations at one budget on verifier-scored optimisation and finds planner–executors–integrator the worst of them. CodeR (arXiv:2406.01304) gains from roles on SWE-bench Lite and does not report a single agent with the same tools at the same cost. The Conductor (arXiv:2512.04388) gains nine points over its best worker on held-out tasks by writing subtask prompts, with about three worker calls per question and no compute-matched single model. On the SWE-bench Verified leaderboard, systems built as role teams or fixed pipelines (MASAI, Composio, Agentless, AutoCodeRover) fail on the same bugs as free agents on the same model, at pairwise φ 0.42–0.67; the role teams do not beat the best single agent on their model, and the fixed pipelines sit inside the band of free agents on Claude 3.5 Sonnet and above them on GPT-4o. None of that is identical tasks, equal budget, per-task results, single against split. So: run it.

Problems and difficulty. The earlier corpus holds sixteen draws at temperature one of each model on each problem. Difficulty is the count of correct draws. For two base models, GLM-5.3-flash and DeepSeek v3.2, I took every problem the model solved in four draws or fewer (hard), twelve sampled from five to thirteen (medium) and six from fourteen or more (easy), on AIME 2024–25, GPQA Diamond and GSM-Hard, after the label audit of the earlier note: 41 + 12 + 6 for GLM, 20 + 12 + 6 for DeepSeek, 97 in all. One thing showed at selection and was fixed in the pre-registration before any call: thirty-eight of GLM's forty-one hard problems are hard because the single pass is cut by the corpus's 8,192-token cap on eight or more of sixteen draws; DeepSeek's twenty have no problem cut on more than one draw (seven are cut on one of sixteen). So GLM's hard stratum asks whether splitting helps a model that runs out of tokens, DeepSeek's whether it helps a model that cannot.

Arms. Arm 1 is the corpus's sixteen draws, which give pass@1, pass@4 and pass@16 for free. Arm 2: the base model is asked for two to four ordered subtasks without solving, then solves each subtask seeing the problem, the list and the earlier results, then assembles a final answer. Arm 3: the same plan and assembly by the base model, the subtasks handed in turn to Qwen 3.7 plus, Mistral Large 2512 and Kimi K2.5. Every attempt spends at most 8,192 completion tokens across all its calls, reasoning included: up to 1,024 for the plan with one retry, 2,048 reserved for the assembly, the rest split equally over the subtasks. Arms 2 and 3 ran once on every problem and four times on the hard ones, 560 runs, no failures, $5.07.

Predictions, written before the run: on true-hard problems decomposition pass@1 at or under 0.15, arm 3 at or under arm 2, zero or one of the twelve never-solved problems solved; a signal would be three or more, or decomposition pass@4 at 0.35 with an interval clear of the single model's pass@4. On cap-hard problems decomposition would gain, as a budget effect. On medium, within ten points; on easy, at most two of six lost.

Two protocol fixes before the main run, both in the pre-registration file. In an aborted first start GLM spent each call's cap on hidden reasoning and returned no text; reasoning was bounded to half of each call. In a first wave of 186 runs both models solved the problem inside the "plan, do not solve" call and hit its cap; the instruction was moved into the user turn with the problem marked "for planning only", reasoning on that call was cut to 64 tokens, one retry was allowed inside the budget, and the parser was made to accept malformed JSON. The first wave is kept as a pilot and not pooled. Nothing changed after the main run started.

"Split" is arm 2, "team" arm 3; p@4 of a split arm is any of its four attempts. The three GLM problems that are hard without truncation are omitted from the table (one of three solved by the same model, two of three by any of the eight attempts).

Take DeepSeek's fourteen numeric hard problems, ten from AIME and four from GSM-Hard, with no cap in play. The single model solves them at 0.06 per draw, 0.21 in four, 0.50 in sixteen. Decomposition in four attempts: 0.21, the same number, with a bootstrap interval of ±0.29 around a difference of zero. Eight decomposition attempts per problem, four alone and four with the other models, add no problem to the single model's pass@16: the union is the single model's set exactly. The seven AIME problems DeepSeek never solved in sixteen draws it did not solve in eight more, cut into parts. The pre-registered signal was three or more of the twelve never-solved problems; on the numeric half the count is zero of seven.

The six GPQA problems look different and are not. Three of the five never-solved ones were solved at least once by decomposition. But GPQA has four options, and over the forty decomposition attempts on those five problems the rate of a correct letter was 0.23; guessing gives 0.25. The single model is confidently wrong sixteen times; a different arrangement of the same model breaks that path and lands on a letter. The pre-registration should have carried a guessing floor for "solved at least once over eight attempts", where pure guessing reaches ninety percent of items, and did not; the threshold was met nominally and means nothing. One problem (gpqa:57, five of eight) is unlikely under pure guessing for one item (about 0.03), and about 0.13 for at least one of five; it is one item.

GLM's thirty-eight cap-hard problems go from 0.37 in four whole draws to 0.71 in four split attempts, +0.34 [+0.18, +0.50], above the 0.58 the model reaches in sixteen whole draws. Ten of sixteen never-solved problems are solved, on GPQA at a per-attempt rate of 0.47, well above chance. This is the predicted direction with a larger size, and it is the budget: a model that spends its 8,192 tokens thinking and is cut off before the answer finishes three or four calls of about seventeen hundred. The right comparator is the same model with the cap lifted, which the corpus does not have, so the number says how much a longer budget would have been worth, not what splitting adds to it. On the numeric part of this stratum the union over the model's sixteen draws is +0.09 [0, +0.23]; on GPQA +0.50.

Is the line between the two models their strength, or the overrun? Bin every problem by how many of its sixteen single draws were cut by the cap, and put decomposition's first attempt against the single model's pass@1:

Both models pooled (the 8–11 bin has two problems and is omitted). Within GLM alone the gradient is the same: +0.03 to +0.14 on its problems cut seven times or fewer, +0.46 on those cut twelve to fifteen times. DeepSeek, with no problem cut on more than one draw, sits at −0.09 on the problems cut on none and −0.17 on the ten cut on one. The gain follows the overrun, not the model: the stronger model gains nothing because it never runs out, the weaker one gains exactly on the problems where it is cut off and not on the ones it finishes. Problems cut on every draw are the exception on the numeric side, 0.00 on five: where the budget is far short, pieces do not finish either. Two models is not a law, but the gradient inside one model is the evidence that what mediates is the overrun.

On medium and easy problems GLM is unchanged by splitting (+0.06 [−0.13, +0.22]). DeepSeek loses 0.41 [−0.60, −0.21]: from 0.74 to 0.33 at one attempt. The runs show why. It solves inside the planning call despite the instruction, and loses both plan calls to the cap in thirty-four of ninety-eight runs. Where it does plan, it overruns the subtask budget on 62% of its subtask calls (GLM: 22%). In the assembly it re-solves from scratch rather than combining, and truncates at 2,048 tokens without a final line in thirty-four runs. A model that does not shorten its reasoning to the size of a step pays for every step. Under the equal-budget rule those count as wrong, which is the rule applied strictly; under any rule they are the model refusing the operator.

The team arm never helps. Against arm 2, arm 3 is −0.15 [−0.30, 0.00] on DeepSeek's hard problems, −0.18 [−0.41, 0.00] on GLM's numeric cap-hard problems, +0.12 [−0.13, +0.38] on GLM's GPQA. The subtasks themselves were not graded; what is measured is that Kimi overruns its subtask budget on 68% of its calls, Qwen on 25%, Mistral on 5%, and that the assembled answer is no better. Mistral rate-limited 53 of 927 subtask calls; those went to the next worker in the list, Kimi, and are marked in the data. Pairwise φ between a split attempt and a single draw is 0.58 for GLM and 0.22 for DeepSeek, against 0.53 and 0.68 between two single draws: splitting changes which problems fail less than a resample does for GLM, more for DeepSeek, and in neither case toward the problems the model could not solve.

The 8,192-token rule is a cap, not matched spend, and the two models fill it differently. Every call's price is in the OpenRouter ledger, so the comparison can be redone in money: give the single model as many whole draws as the decomposition attempt cost (k rounded to the nearest draw), and compare its unbiased pass@k over the sixteen corpus draws.

DeepSeek fills every per-call cap, so one split attempt costs three and a half whole draws on hard problems and eight or nine on medium and easy ones, where a whole draw is 900–2,600 tokens. At equal money the single model edges decomposition on the pooled hard stratum (0.38 against 0.35) and beats it on the numeric part (pass@10 0.39 against split pass@4 0.21) and everywhere else. The token comparison favoured decomposition and it gained nothing; the dollar comparison is worse. GLM is the mirror: one whole draw on a cap-hard problem burns the whole 7,735-token cap on reasoning, while a split attempt, with reasoning bounded to half of each call by the protocol, spends 2,987 tokens and half the money, and is better (0.45 against 0.10 at one draw's money, 0.71 against 0.18 at two). For GLM decomposition is cheaper and better on that stratum, with a confound stated below: it is the bound on reasoning per call that the single pass never had. Everything "bought" here is bought by arm 2, the model splitting its own work. Arm 3 costs two to seventeen times a draw because Qwen 3.7 plus, Kimi and Mistral are dearer per token, for no gain; the arrangement people actually sell, an expensive planner over cheap workers, was not run and is the open case.

Two things this does not say. It does not say decomposition is useless in agents: a coding agent that reads a file, runs a test and edits is decomposing with tools, and tools bring information the model did not have; that operator is in Agents with Tools Fail Together as a pool of scaffolds, not as a split against a single pass. And it does not say decomposition with a verifier at each step is useless: a checked step can be retried, and that is a different operator again, the partial-verifier question, which remains open. What is closed is the bare operator: plan, solve parts, assemble, no checker, equal cost.

• Twenty true-hard problems, one strong model. Fourteen numeric. The interval on the numeric difference is ±0.29; the null "no problem gained" is exact on this set, not an estimate. A second uncapped base would double it.
• GLM's hard stratum is the corpus's cap, and the protocol bounded reasoning. The 8,192-token limit of the earlier corpus made the stratum, and the decomposition protocol capped hidden reasoning at half of each call, which the single pass never had. GLM's gain there, cheaper and better, may be the reasoning bound rather than the split. The two controls that would separate them, the same model with the cap removed and a single pass with reasoning capped at 4,096, were not run.
• Protocol was revised twice before the main run (reasoning bound; planning prompt), both recorded in the pre-registration with the reason; the first wave under the old protocol is kept as a pilot. The planning prompt still fails on DeepSeek in a third of runs, and those count as wrong.
• No guessing floor in the pre-registration. "Solved at least once over eight attempts" on four-option items is met by chance; the numeric half of the criterion is the one that holds.
• One planner, two to four subtasks, no loops. A planner model different from the solver, deeper trees, or a checker between steps were not run.
• Budget accounting. Fifteen attempts exceed 8,192 tokens by 1–15 tokens because reasoning is counted after the fact; the per-call caps are what the API enforces.
• Grading is the corpus grader: a FINAL line, numeric tolerance, letter match. Decomposition attempts that end without a FINAL line are wrong by the equal-budget rule.
• Workers. Mistral rate-limited 53 of 927 subtask calls in arm 3; the subtask went to the next worker, recorded per call.

Data and code: the corpus of Where the Swarm Pays (sixteen draws per model and problem, audited labels; released at Alatip/tech-note-5); the decomposition runs, pre-registration with its two revisions, runner and statistics are at Alatip/tech-note-9 (GPQA Diamond records carry no text and tokenised answers, per the dataset's terms). Models via OpenRouter: deepseek/deepseek-v3.2, z-ai/glm-5.3-flash, qwen/qwen3.7-plus, moonshotai/kimi-k2.5, mistralai/mistral-large-2512; temperature 1; 9–10 October 2026.

Papers: CooperBench, arXiv:2601.13295; Ann, Liu and Tan, The Interaction Tax, ICML 2026, arXiv:2608.23541; CodeR, arXiv:2406.01304; the Conductor, arXiv:2512.04388, read in What a Model Orchestrator Can and Cannot Add. The SWE-bench cut is from the leaderboard matrix of Agents with Tools Fail Together.

Earlier notes: Where the Swarm Pays, Agents with Tools Fail Together, There Is No Free Lunch After All (the claim this tests at the level of a single attempt).

Archived with a DOI: 10.5281/zenodo.23273230 (all versions: 10.5281/zenodo.23273229); runs and code: 10.5281/zenodo.23274139 (release v1.0 of Alatip/tech-note-9). Cite as: Latipov, A. (2026). Decomposition Buys Budget at Best, Nothing Usually. Zenodo. https://doi.org/10.5281/zenodo.23273230

← notes · github.com/Alatip