When Does Divide and Conquer Work for Long Context LLM? A Noise Decomposition Framework
Authors: Zach Xu
Shang Zhu
Jue WANG
Junlin Wang
Ben Athiwaratkun
Chi Wang
James Zou
Ce Zhang
Venue: ICLR 2026 Poster (2026)
Keywords: Long Context
Multi-agent
LLM
Primary area: foundation or frontier models, including LLMs

Abstract: We investigate the challenge of applying Large Language Models (LLMs) to long texts. We propose a theoretical framework that distinguishes the failure modes of long context tasks into three categories: cross-chunk dependence (task noise), confusion that grows with context size (model noise), and the imperfect integration of partial results (aggregator noise). Under this view, we analyze when it is effective to use multi-agent chunking, i.e., dividing a lengthy sequence into smaller chunks and aggregating the processed results of each chunk. Our experiments on tasks such as retrieval, question answering, and summarization confirm both the theoretical analysis and the conditions that favor multi-agent chunking. By exploring the accelerated decay of model fidelity with input length, we also explain why, for large inputs, a weaker model configured with chunk-based processing can surpass a more advanced model like GPT4o applied in a single shot. Overall, we present a principled understanding framework and our results highlight a direct pathway to handling long contexts in LLMs with carefully managed chunking and aggregator strategies.

Published as a conference paper at ICLR 2026
WHEN DOES DIVIDE AND CONQUER WORK FOR LONG CONTEXT LLM? A NOISE DECOMPOSITION FRAME- WORK
Zhen Xu', Shang Zhu?, Jue Wang", Junlin Wang", Ben Athiwaratkun", Chi Wang". James Zou Ce Zhangl.2
University of Chicago, TTogtheer AI, Duke University. 'Google DeepMind, *Stanford University
ABSTRACT
We investigate the challenge of applying Large Language Models (LLMs) to long texts. We propose a theoretical framework that distinguishes the failure modes of long context tasks into three categories: cross-chunk dependence (task noise), confusion that grows with context size (model noise), and the imperfect integration of partial results (aggregator noise). Under this view, we analyze when is effective to use multi-agent chunking, i.c., dividing a lengthy sequence into smaller chunks and aggregating the processed results of each chunk. Our experiments on tasks such retrieval, question answering, and summarization confirm both the theoretical analysis and the conditions that favor multi-agent chunking. By exploring the accelerated decay of model fidelity with input length, we also explain why, for large inputs, a weaker model configured with chunk- processing can surpass more advanced model like GPT4o applied in single shot. Overall, we present principled understanding framework and our results highlight a direct pathway to handling long contexts in LLMs with carefully managed chunking and aggregator strategies.
INTRODUCTION
Large Language Models (LLMs) have drawn significant interest from both industry and academia, thanks to their ability to handle tasks ranging from open-ended question answering to complex reasoning. As these models grow in capacity, there is an increasing demand to apply them to extended texts that may span hundreds of thousands of tokens. In principle, self attentttnn architectures powerful, but their reliance on quadratic operations in sequence length can make long-context tasks computationally expensive Tay et al. (2022). Moreover, even if a model technically can process long contexts, studies have reported the quality decline of output once the input surpasses certain length (Hsieh et al.) 2024). This limitation has been attributed to phenomena such as the "lost in the middle" effect, where the model forgets or mishandles portions of the input.
Existing research has explored ways to ease these difficulties. One type of approach has focused on modifying the transformer architecture to reduce memory footprint and compute, often by. for example, shaping the attention pattern through blockwise or window-basse strategies (Qiu al.) 2020 Bellagy et al. 2020). low-rank approximations (Wang et al. 2020) or routing-based approaches (Kitaev et al.] 2020), seeking to prolong the feasible context length without harming accuracy too severely. Although these technical improvements often extend the maximum input size, they do not guarantee stable performance when that size becomes very large.
A more functional approach divides large input into chunks, processes each chunk with one or more worker models, and then aggregates the outputs. Retrieval- augieeetde pipelines are a popular example of this idea (Lewis et al. 2020 Fan al. 2024 Wang al.) (024b), but they often rely on ad hoc rules for aggregating results. Their effectiveness hinges on how well global dependencies preserved. If the aggregation step is weak, cross-chunk reasoning be lost, which leads to

---

Published as a conference paper at ICLR 2026
suboptimal outcomes. While these chunk-basee methods can lower confusion at the worker level, the completeness of the final result is not guaranteed.
In this paper, propose divide and conquer framework Qian et al. (2024b); Zhang et al. (2024c);
Zhou et al. (2024) that offers a more systematic view at these issues. We analyze these challenges by establishing theoretical framework that tracks three main sources of error in long-context tasks. First, task noise arises from cross-chunk dependencies that cannot be handled by processing each segment alone. Second, model noise arises from degraded performance with increasing input length. Third, aggregator noise emerges when partial results are combined incorrectly, even if each chunk was handled well. We show how the balance of these factors determines when chunk-based division is advantageous, and how the design of the aggregator stage plays an important role. In particular, when a task demands only mild cross-chunk reasoning, chunking can reduce model confusion with little downside. However, when cross-chunk synergy is large, only more advanced aggregator can preserve important global connections.
We also show that model noise can worsen at rate that outstrips the benefit of seeing the entire input at once. Beyond a certain length threshold, splitting the text can yield better performance, even if the individual worker models are weaker than single large model. We attribute this to the superlinear growth of the model's 's underlying length- length-induced induced degradation with input length. Our experiments on retrieval, QA, summarization, and other tasks confirm that this superlinear effect surfaces in practice, and demonstrate how a planner can arrange prompts to keep aggregator noise manageable. Across these long context tasks, weak models handling chunks often outperform single-shot strong model.
Our contributions are as follows:
We present theoretical framework for modeling error terms in long context processing. This framework helps to explain when multi-agent chunking is advantageous and when not.
We provide empirical evidence of accelerated performance degradation when input length is large. We then demonstrate that splitting into smaller pieces can help mitigate these effects, except in the case where cross-chunk synergy is very high.
We show that carefully designed prompts for both worker agents and the aggregator can stably improve final performance. This allows smaller models to surpass more advanced models on certain tasks when the input length is large.
These findings broaden our understanding of how to tackle large inputs with LLMs. By breaking down the main sources of error, our framework clarifies why chunking can help. how it can fail, and how planner can structure prompts so that partial outputs lead to correct final answers. Through both theoretical arguments and experiments, we reveal practical guidelines for handling lengthy contexts and show that well-planned division of labor can be strong alternative to single-shot processing with a massive context window.
RELATED WORKS
2.1 LONG CONTEXT LLM
Developing long context LLMs has seen increasing popularity in applications such as long document understanding. Due the attention mechanism, transformer architecture is associated with quadratic computational and memory complexity against sequence length(Tay et al. 2022). thus expensive to train and serve in practice. To mitigate this, researchers have explored various efficient transformer architectures, such as block wise attention(Qin et al. 2020). window attention attentionBBellagy et al.) 2020). routing attention(Kitant (iitev al.) 2020), etc. (Dao al. 2022) proposed flash attention and (Liu et al.)
2023) designed ring attention, both contributed to efficient training of long context LLMs. The recent progress on transformer alternatives also show promises of overcoming the computational complexity of attention mechanisms, including Mamba(Gu & Dao 2024) and Hyena(Poli et al. 2023). Also, given existing LLMs trained on short context, many research works have been presented on length extrapolation based on positional encoding et al. 2023 Peng et al.) 2024 Jin et al. 2024).
and retrieval-augmente generation[Leww et al. 2020; Wang et al.) 2024b). where additional design complexity is added positional encoding adaptation and retriever. Besides, complementary line of work aligns LLMs for long contexts via preference/reward optimization, including LOGO (Tang et al. 2024), RewaReward (Zhang et al. 2024a), and LongPO (Chen al. 2025).
2

---

Published as a conference paper at ICLR 2026
2.2 MULTI-AGENTS
Recent research has explored the potential of multi-agent systems utilizing large language models (LLMs) for complex task-solving. In the realm of task decomposition and planning. QQan al.) (2023) proposed a framework where multiple LLM-based agents collaboratively break down tasks into subtasks and develop execution plans. Similarly, Haji al. (2024) introduced hierarchical mechanism where tree of thoughts reasoners are combined with thought verifiers. Zhao et al. (2024b) breaks down and process long texts using multiple agents, enabling efficient handling of 128K token contexts through task decomposition.
Beyond task breakdown and planning, recent work focused on communication mechanisms within multiple agents. Several studies (Guo et al. 2024) have investigated various approaches to enable effective information exchange between agents. Common communication paradigms such as debate is commonly used (Du et al. 2024 Chan et al. 2024 Liang et al. 2023). Alternatively, Qian et al. (2024a) adapts a cooperative paradigm where agents work together towards a common goal. Many multi-agent works use a layered structure. WWng et al. (2024)) developed a multi-layered framework that separates L.Mss into proposers and aggregators. Liing et al. (2023) encourages more divergent thinking though layered debate among debaters. However, centra lized sharing structure has also been explored by Hong et al. (202)).
2.3 DIVIDE AND CONQUER
Divide-and connqur is a classic computational strategy that has recently been integrated with LLM- based multi-agent systems to handle long- mongccotext processing. Recent works such as LC- Boosst Qian ctt al. (2024b), Chain-of- Agents (CoA) Zhang et al. (2024c), LongAgent Zhhoo et al. (2024a), and LLM x MapReduce Zhou et al. (2024) adopt this paradigm by splitting long inputs into smaller chunks processed by worker agents and then merging their outputs through manager agent. These methods improve efficiency and enable long-text reasoning without requiring large context models.
However, existing approaches lack a formal theoretical framework to analyze the interaction between task complexity, model noise, and aggregation errors, making it difficult to optimize chunking strategies. They also struggle with understanding how cross-chunk dependencies impact performance, often leading loss of contextual coherence when aggregating local outputs. This work addresses these gaps by providing a rigorous modeling framework for analyzing noise propagation in Divide- and-conquer architectures, offering systematic approach optimizing multi-agent collaboration for long-context tasks.
3 THEORETICAL MODELING FRAMEWORK
3.1 PROBLEM FORMULATION: THE FIDELITY DECOMPOSITION
We model the divide-and-conquee (D&C) pipeline as an information transmission channel. Let be long input of length T split into n contiguous chunks. Let S(ū) E (0, 1] represent the normalized evaluation metric for a prediction ý. We assume S(.)
ensure well-defined logarithmic losses.
We define the system's 's score fidelity E (0. 1] as the ratio of the retained score to the ideal score. To analyze the eтror accumulation, we utilize the following telescoping identity, which decomposes the system fidelity into product of score ratios in three stages (explained in following sections):
S(h(a)) ((h"(a))) x S(h(a"))
S(h(a))
Pays = S(y*)
S(y*)
S(h*(ar))
x S(h(a)))
Ptask
Pagx
For analytical convenience, analyze the system in Spg-space by defining the fidelity loss L - log(p). The multiplicative nature of fidelity implics additive losses:
Lays
Lrasse + Lags + Lmodel-
2
We also define the total system error as Evotal == 1 - Peys. In the high-fidelity regime, a first-order expansion yields Etotal R Ptask) + Pagg) (1 -mmodet) (Appendix B)
3

---

Published as a conference paper at ICLR 2026
3.2 STAGE 1: DECOMPOSITION (TASK FIDELITY)
Let y" - (x) be the global ground truth. Let a* = (af,...,,0) G..) denote the optimal chunk-level artifacts constrained by fixed schema (e.g., restricted bandwidth or token budget). Specifically, a" represents the information bottleneck imposed strictly by the decomposition interface. We define an ideal aggregator h* the optimal function in the model class H. given these artifacts:
h arg max S(h(a"() hEHt
Task fidelity measures the information retained under these decomposition constraints:
S(h
Ptask
S(y*)
If Ptask < 1, the task inherently resists decomposition under the chosen schema.
3.3 STAGE 2: AGGREGATION (AGGREGATOR FIDELITY)
Let h be the actual aggregator model used in the pipeline. We define Aggregator Fidelity by comparing the actual aggregator against the ideal aggregator on the same perfect inputs a":
S(h(a")) S(h (ar))
Pags
(4)
This term isolates the limitation of the aggregator model itself (e.g., failure to reason over long sequences of artifacts), assuming perfect input artifacts.
3.4 STAGE LOCAL PROCESSING (MODEL FIDELITY)
Let denote the actual noisy outputs generated by worker models. We define Model Fidelity the ratio performance given actual noisy inputs versus perfect inputs:
S(h(a))
Pmodel
S(h(a*))
(5)
We assume monotonicity in expectation: replacing noisy worker outputs with ideal artifacts does degrade performance, ensuring Pmodel < 1. The term Lmodel quantifies the loss caused strictly by worker errors.
3.5 THE D&C ADVANTAGE
We now formally characterize when system of weaker agents outperforms single stronger agent on very long inputs.
Proposition 3.1 (The D&C Advantage). Let Catrong (T) be the loss of a single strong model and (D) be the loss of divide-and-conquer system input length T. Assume:
1. Super-Lines Collapse: The strong model's loss grows super-linearly with context length: Lavong (T) (T) (i.e., lim--+00 Lavonng (T) (T) = oc).
2. Bounded Unit Loss: The D&C system processes inputs in fixed-size chunks, and the error per chunk (and associated overhead) is bounded by a constant.
Then, the D&C C loss accumulates linearly (LD&-c(T) = O(T),, and there exists critical threshold To such that for all T > To, the D&C system strictly outperforms the single strong model.
This proposition justifies D&C strategies despite the overhead: as T x., the super-linear "brain fog" of a single model inevitably exceeds the linear costs of decomposition and aggregation.
3.6 THREE REGIMES OF ERROR
Based the decomposition, categorize long-context tasks into three regimes:
4

---

Published as a conference paper at ICLR 2026
Regime 1: Trivial (Negligible Noise). L 0. Tasks like sparse retrieval where decomposi- tion is lossless and models are robust.
The "Silo Effect" (Task Noise Dominates). Fass > model- The task requires global reasoning that is lost under the chunking schema. In this regime, D&C strategies saturate below the optimal performance regardless of model quality.
Regime 2:
The "Brain Fog" (Model Noise Dominates). Lmodel >> Lrask- The input length 7' is so massive that single-agent fidelity collapses. This is the optimal regime for D&C strategies.
Regime 3:
A SIMPLE IMPLEMENTATION OF THE FRAMEWORK
We develop minimal three-part system as illustrated Figure 1 a planner to manage how the original query is segmented and how prompts arranged, multiple worker agents that each handle a different sub-chunk, and a single manager agent that merges all sub-results. Below we briefly introduce the worker and manager roles, followed by more detailed description of the planner.
Long Documents
Workers
Kan prampt (Mith ccample)
(contest)
W
Manager
Workem agane prurpe (p (parn (appal)
Divide
Conquer
W2
M
agent
asalyong
provided beloww ideatlly and
smallest
mumbers order. ffest chank)
Pleaor
smallas numbere find
Q: Return the two smallest numbers
Manager agent pronpt oplenerr outpet)
You are the managr agen takkd with symthehhingg recals. from multppe worker agents Each werker
Task Query
Input
spcai has provided the tou snalhat sumbers from feiir respective chunks of lager list. Your talk is couplle these resulss and deternise the Ind agent.. Respetaci from agentic (respanses)
Q: What is the 2nd smallest number?
Planner
smalles mumbher
Figure 1: A simple implementation of the divide and conquer framework. The Math task example (right panel) illustrates the planner's critical role by translating instructions of returning 2nd smallest number into returning the two smallest numbers per chunk.
Worker agent:
We split the input sequence into chunks of approximately equal length, and each worker agent is assigned single chunk. Each worker focuses solely on its segment, without managing cross-segment dependencies. Although we use identical models for the workers, one can easily extend the architecture to mix different worker models as needed.
Manager agent: After the worker agents produce partial outputs, the manager agent merges them into one final result. In our baseline, this manager agent is the same model type the workers, but one may employ more specialized manager for tasks requiring deeper global reasoning.
The planner orchestrates how the input is divided, what instructions each worker agent receives, and how manager agent is prompted unify the partial outputs. Rather than having a human specify how to break down the input, direct the planner to do by following steps: (1) Job Assignment. The planner decides how many chunks to create and which segments each worker agent will process. (2) Prompt Preparation. Based the task details, the planner modifies the worker prompts so that each worker's 's output can be correctly integrated downstream. It also sets up the manager prompt combine partial results properly. (3) Iterative Refinement. The planner can run a brief evaluation step using some validation data to identify mispredicted cases. It then revises the prompt structure chunking strategy reduce errors. If repeated excessively on the same data, there is risk of overfitting, so the planner typically does only few refinements.
Planner:
Fast chunk-size estimation via sparse sampling Selecting appropriate chunk size is critical when model noise dominates. Motivated by our theoretical framework, we adopt a minimal budget procedure pick approximately optimal chunk size without exhaustive grid search.
5

---

Published as a conference paper at ICLR 2026
Inputs. Candidate chunk sizes C, small per-configuration sample budget m, development set D of tasks, and a task-specific metric M.
Procedure. For each C, draw random documents S. D (without replacement). Run the D&C pipeline with chunk size с on S. and record š(c) = vn Eves. M(D&C(x; c)). Select c² = arg maXcec 8(c). Deploy the D&C pipeline on the full set using c*.
Complexity and rationale. This reduces the search cost from O([)) (CI) evaluations to O(m (C)) with m < [D]. When Lmoddl dominates and the underlying length-induced degradation g(L)) grows superlinearly and is near-monotone in L. (Sec. (.6), the D&C error versus chunk size typically exhibits a clear near-convex optimal region; a few random samples per configuration suffice to localize this optimum.
EXPERIMENTS
5.1 SETTINGS
In our empirical analysis and general discussions, we use the terms task noise, model noise, and aggregator noise as intuitive, macroscopic shorthands for the performance degradations driven by their corresponding formal terms Lrask; mmodel, fagg. We present experiments to assess how the three primary noise components model noise, task noise, and aggregator affee-affect system performance under different context lengths and across multiple tasks. Section (.tioom...innniitttt.... that the model term Lmodel can grow more than linearly with input length, and that cross cross-chunk dependencies (captured by Lrask) can impose strong requirements on any mechanism for merging partial outputs. Our experiments test the ideas on six tasks with different data scales and use several agents.
Tasks We experiment on six diverse tasks including: Key-Value Retrieval, Math Find Number, Summarization, Dialogue Character Inference, and Open Question QA with and without choices. These tasks are based on InfiniteBench /Zhang al. (202bb) and LongBench- V2 Bai et al. (2024) but we have modified the generation and prepared different lengths of these tasks. These tasks include: Key-Valus Retrieval (KV), Math Find Number (Math), Summarization (Sum), Open Question QA (QA-IB and QA-LB), Dialogue Character Inference (Char). Detailed task descriptions are provided in Appendix D
LLM Agents We have experimented with diverse agents choices from commercial Ope- nAI models and open sourced models from Meta and Alibaba. gpt-40-2024-08-00
(gpt4o) 128K model from OpenAl. spt-4oo-iin-2224-07- model from OpenAl. Llama-3.0 1-70B-IInttrnn
(gpt4omini)
128K
(Ilama70b) 128K 70B LLM model,
3-3 (llama3b) 128K 3B LLM model from Meta Grattafioni (024).
Qwen2 Swen2.5-72BB --rBB--tree- (qwen72b) 32K LLM model from Alibaba QWen Yang et al. 22024
In the experiments where divide and conquer agents are implemented. the manager and worker agents are homogeneous and the planner agent is QWen72b. The temperature is set to 0 to minimize stochasticity during decoding. In the following sections, we study these effects through three empirical lenses: single-agent length-induced degradation, task-termddcoooosabiiit effects, and aggregator effects. The robustness of these observations and the practical applicability of our framework are further underscored by comprehensive supplementary analyses (detailed in Appendices F. which include utility of the framework, explorations of chunking variants, comparisons with RAG, evaluations across diverse model architectures, and etc.
5.2 LENGTH-INDUCED MODEL DEGRADATION
We estimate the single-agent model error for input z directly via the empirical task score: Esingle 1 S(fsingle where S(-) is the sask-specific normalized score (e.g., Accuracy). By evaluating this for different input lengths T = ||ar|], we see how the model's performance declines context grows. In Figures (2b] (Math) and (KV), each agent processes the entire input directly (up to 128K tokens). We measure accuracy each length; the detailed numerical scores supporting these figures are provided in Appendix

---

model degradation), Published as a conference paper at ICLR 2026
For KV retrieval (Fig- ure 2ap, most agents show downward trend in accuracy as input length increases, consistent with the Super-Linear Collapse behavior assumed in Propo- sition 3.1 (loss growing 0.0
10
0.8
llamaB llsms70b
0.4
0.3
apoéomiri
Tomaão
02
foma
0.1-
go040
faster than linearly with context length). Once the length exceeds tens of thousands of tokens, performance rapidly decays. Similar observations stark for gpt4omini and llama70b. Interestingly, Ilamaāb is already too weak at shorter lengths, so its performance saturates at near-random levels. These results reinforce length-induced degradation can become the dominant error term for long (the "Brain Fog" regime in Sec. (.6). For tasks that do require intense synergy into shorter segments (i.e., reducing L per worker) should mitigate this growth, an idea formalized in Proposition
1k
86
16k
32k
64k
128k
1k
2k
1.5
32k
64k
128k
Lengths
Lengg
Single agent model performance (b) Single agent model performance w.r. imput length: KV Task
w.r. input length: Math Task
for Math (Figure 2bp. where the loss of accuracy at longer contexts is
theoretical statement that
the entire input, splitting the input
5.3 TASK TERM AND DECOMPOSABILITY
Next, examine how multi-agent performance depends the task term (cross-chunk dependency / decomposabilitty ftask) and the model term (length-induced degradation, fmodel). Since these decomposition terms not directly observable from task metries. we use proxies: we vary the chunk size to control per-worker context length (capturing sensitivity to length-induc and we summarize cross-chunk dependency using a proxy based on how D&C outputs deviate from the single-agent baseline over the discrete set of chunk configurations C.
0.8
0.5
0.6
Azunc
0.5
0044
geMo
gpiie
geMo
loma700
aptiomini
0.2
ibama70b
qut-Ammiii
getiomini
loma700
owen722
qwen726
72b
0.8
16k
66x
0.1
16k
0.1
16k
52k
Model Contest Length
Model Contect Length
Model Contect Length
(a)
(b) Math
(c) QA-IB
0.8
0.8
uot4o
Nama700
0.35
Bama73e
0.7
0.6
a244omin
quen72b
0.30
0.5
3pMo
lama700
0.4
0.20
aptiomiii
0.15
owo
0.7
0.2
011
64k
Modill Content Lenggth
Model Context Lengtth
Model Context
Length
(d) QA-LB
(c) Sum
(f) Char
Figure 3: Joint effect of the task term (decomposabilityy / cross-chunk dependency. Lrack) and the model term (length-induced degradation, Lmodel). According to the discussion in Sec 3.6 (a) has negligible task/model terms; (b)-(e) are model-term dominated; (f) is task-term dominated.
Figure 3 illustrates the performance of five agents the 128K version of each task, varying the chunk size from IK to 64K tokens. The comprehensive performance metrics for all tasks and models underpinning this figure available in Appendix G We observe three patterns that match the
7

---

Published as a conference paper at ICLR 2026
three regimes described in Section 3.6 (1) Low task noise (KV). When cross-chunk synergy is minimal, splitting yields similar results regardless of n. This matches the "low task noise, low model noise" regime, where Lissk is negligible and Lmodel remains small, so aggregator choices have little impact. (2) Dominating model noise (Math, QA, Sum). In these tasks, large input length makes single-shot usage prone confusion, so model becomes significant. However, task is moderate enough that basic aggregator can handle partial results effectively. Splitting into smaller chunks thus reduces per-chunk confusion and outperforms single-shot approach. This behavior aligns with Proposition 3.1 showing that the accelerated growth of model error can be contained with conquer. (3) Dominating task noise (Char). In this scenario, cross-chunk interactions are so extensive that partial outputs cannot capture the global context unless the aggregator reintroduces nearly the entire input. the aggregator does not do so, performance remains low. This corresponds to the "'oomnaatigg task noise" regime, where frask is large enough to overshadow the benefits of splitting.
We also explored whether introducing small token overlap between chunks could mitigate task noise effects. However, as detailed in Appendix [1 a 1K token overlap yielded mixed and generally marginal benefits for the Llama-70B model on 128K tasks, suggesting it does not fundamentally alter these noise trade-offs for the scenarios tested. Furthermore, to assess the generalizability of our noise framework, we evaluated additional diverse models across various tasks, as detailed in Appendix L These results confirm that while effective context length (e.g., per Ruler benchmark) influences performance, the observed noise patterns and the utility of our decomposition are consistent, with task complexity significantly interacting with these factors across different architectures.
Overall, these empirical data show that the relative magnitudes of mmodel and Lrask determine whether chunking helps or hurts. Moderate-synergy tasks benefit most from a chunk-based approach, character-inference
validating our theoretical insights in Section[3.6] Apart from the high-synergy problem, divide-an und-conquer methods achieve performance on par with or exceeding the strongest single-shol model, reinforcing the idea that chunking is advantageous when the model term dominates and the task term remains modest.
5.4 AGGREGATOR EFFECTS
We examine the aggregator term Lagg, which reflects how well the partial results are merged. Here, we compare stronger aggregator prompt pplanee-baseed to weaker one (manual) over the discrete set of chunk configurations C. Figure contraasts two approaches on the Math and QA-LB tasks for large T: (I) manual aggregator prompt, which simply asks each worker to solve its subproblem in isolation, and (2) a planner-based aggregator prompt, which enforces a structured approach to partial outputs. This yields visible performance gap (shaded area in Figure 44) showing that aggregation errors can be substantially reduced via more coordinated prompts. The same effect seen QA-LB, where the aggregator must reconeile partial answers from each worker. These empirical results consolidate Section 3.6 and our claim that aggregator prompting plays a major role: a robust aggregator prompt can keep Lagg modest, while naive prompts inflate the final error. The planner effectively refines aggregator instructions to align worker outputs with the manager's s requirements, illustrating how a minimal overhead aggregator can preserve the theoretical advantages of chunking large inputs.
opilem Lipleme
0.1
6.3
0.7
24
12c
6fc
33c
(a) Math
(b) Math
(c) QA-LB
(d) QA-LB
Figure 4: Aggregator errors across different tasks and models.
8

---

Published as a conference paper at ICLR 2026
Table 1: Predictive Utility: Optimal Chunk Size Estimation on QA-IB and Summarization (Score (Optimal Chunk Size Found)). Total task length 128K tokens.
Model
3-sample
5-sample
10-sample
Optimal after Exhaustive Search
QA-IB
gpt4omini
0.38 (64K)
0.42 (32K)
0.42 (32K)
0.42 (32K)
Ilama70b
0.55 (2K)
0.63 (16K)
0.63 (16K)
0.63 (16K) 0.48 (8K & 16K)
qwen72b
0.40 (2K)
0.48 (16K)
0.48 (8K)
Sum
gpt4omini
0.15 (16K)
0.14 (8K)
0.14 (8K)
0.15 (4K 16K)
Ilama70b
0.23 (32K)
0.24 (16K)
0.28 (8K)
0.28 (8K)
qwen72b
0.23 (8K)
0.29 (4K)
0.29 (4K)
0.29 (4K)
5.5 FAST ESTIMATION OF THE OPTIMAL CHUNK SIZE
We evaluate the cheap-sampling estimator from Sec. 4 on tasks where model noise dominates: QA-IB and Summarization. For each candidate chunk size, we evaluate D&C on only m E {3,5, 5, 10} randomly selected documents from the 128K-token setting and pick the best-performing chunk size to deploy. Tables compares this low-budget selection against the exhaustive grid search over all documents and all chunk sizes. We observe that even with three to five samples per configuration, the selected chunk sizes are near-optimal and often exactly match the exhaustive-search optimum, delivering the same final scores while avoiding full grid search. This trend aligns with our framework: superlinear and near-monotone model noise in I. drives a clear optimal region in chunk size: handful of samples per configuration enough to trace the coarse error contour and locate the optimum, yielding significant computational savings without sacrificing peak performance.
6 CONCLUSION
In this work, we presented theoretical and empirical framework understand when and why the Divide-and-Conquer (D&C) strategy is effective for long-context LLMs. Our framework decomposes long-context failure modes into three fundamental fidelity loss components (Ltask, Lmmodets Leagg) that we intuitively refer to as task noise (cross-chunk synergy), model noise (length-induc confusion). and aggregator noise (integration flaws).
Through our formal analysis and empirical validation, we demonstrated that when the length-induceh degradation (model noise) grows superlinearly with context size, chunk- based processing can effec- tively suppress this loss. Provided that the cross-chunk dependencies (task noise) are manageable, D&C enables a weaker model significantly outperform more advanced model operating single shot. Furthermore, we introduced an LLM-based Planner to dynamically align worker outputs, demonstrating practical approach to minimizing aggregator errors.
Overall, by bridging the formal fidelity-loss mechanisms with observable noise patterns, our results highlight a principled and actionable pathway to handling massive contexts in LLMs through carefully managed chunking and aggregation strategies.
REFERENCES
Yushi Bai, Shangqing Tu, Jiajie Zhang, Hao Peng, Xiaozhi Wang, Xin Lv, Shulin Cao, Jiazheng Xu, Lei Hou, Yuxiao Dong, Jie Tang, and Juanzi Li. Longbench v2: Towards deeper understanding and reasoning on realistic long-contex: multitasks. arXiv preprint arXiv:2412.15204 2024.
Iz Beltagy, Matthew E. Peters, and Arman Cohan. Longformer: The document transformer. arXiv:2004.05150. 0555000 2020.
Chi-Min Chan, Weize Chen, Yusheng Su, Jianxuan Yu, Wei Xue, Shanghang Zhang, Jie Fu, and Zhiyuan Liu. Chateval: Towards better llm-based evaluators through multi-agent debate. In The Twelfth International Conference Learning Representations, ICLR 2024, Vienna, Austria,

---

Published as a conference paper at ICLR 2026
May 7-11, 2024. OpenReview.net, 2024. U.L.htposs//ppenneeeeeeeeeeee/ee FCepisCUMu
Guanzheng Chen, Xin Li, Michael Qizhe Shich, and Lidong Bing. Longpo: Long context self- evolution of large language models through short-to-long preference optimization, 2025.
Shouyuan Chen, Sherman Wong, Liangjian Chen, and Yuandong Tian. Extending context window of large language models via positional interpolation, 2023. httttps://arxiv.oott
2306. 15595
Tri Dao, Daniel Y. Fu, Stefano Ermon, Atri Rudra, and Christopher Ré. FlashAttention: Fast and memory-efficien exact attention with -0aaarensss. Advances Neural Information Processing Systems (NeurIPS), 2022.
Yilun Du, Shuang Li, Antonio Torralba, Joshua B. Tenenbaum, and Igor Mordatch. Improving factuality and reasoning in language models through multiagent debate. In Forty-first International Conference on Machine Learning, ICML 2024, Vienna, Austria, July 21-27, 2024. OpenReview.net, 2024.
ew net/ wtt.//oormmmiddp.mm (atimmmid=jj7770
Wenqi Fan, Yujuan Ding, Liangbo Ning, Shijie Wang, Hengyun Li, Dawei Yin, Tat-Seng Chua, and Qing Li. A survey on rag meeting Ilms: Towards retrieval-augmenne large language models, In Proceedings of the 30th ACM SIGKDD Conference on Knowledge Discovery and Data Mining, KDD '24, pp. 6491-6500 New York, NY, USA, 2024. Association for Computing Machinery. doi: 10.1145/3637528..6 3677775588.77714 URLhhttp:://doi wtt.///ii..r//1.111..13..11
ISBN 9798400704901.
3637528.. 3671470
Aaron et al Grattafiori. The llama herd of models. (arXiv:2407.21789) 2024.
Albert Gu and Tri Dao. Mamba: Linear-time sequence modeling with selective state spaces. In First Conference on Language Modeling, 2024. URL /ttps:://ppenzeeiieee http:/ewwwee....eeeeeeeeeeeeeeee netm:ormm?fi
LEYskwIVV2
Taicheng Guo, Xiuying Chen, Yaqi Wang, Ruidi Chang, Shichao Pei, Nitesh V. Chawla, Olaf Wiest, and Xiangliang Zhang. Large language model based multi-agents: A survey of progress and challenges. arXiv preprint arXiv: 2402.01680, 2024.
Fatemeh Haji, Mazal Bethany, Maryam Tabar, Jason Chiang, Anthony Rios, and Peyman Najafirad. Improving Ilm reasoning with multi-agent rre-oofthoughh validator agent. arXiv preprint arXiv: 2409. 1527,1277222 2024.
Sirui Hong, Mingehen Zhuge, Jonathan Chen, Xiawu Zheng, Yuheng Cheng, Ceyao Zhang, Jin- lin Wang, Zili Wang, Steven Ka Shing Yau, Zijuan Lin, Liyang Zhou, Chenyu Ran, Lingfeng Xiao, Chenglin Wu, and Jürgen Schmidhuber. Metagpt: Meta programming for multi-agent collaborative framework. arXiv preprint arXiv: 00355, 2023.
Cheng-Ping Hsich, Simeng Sun, Samuel Kriman, Shantanu Acharya, Dima Rekesh, Fei Jia, Yang Zhang, and Boris Ginsburg. Ruler: What's the real context size of your long-context language models? arXiv preprint arXiv:2404.0660 06654,, 2024.
Hongye Jin, Xiaotian Han, Jingfeng Yang. Zhimeng Jiang, Zirui Liu, Chia- Yuan Chang, Huiyuan Chen, and Xia Hu. Llm maybe longlm: Self-extend 1lm context window without tuning. (arXiv:2401.01325), 2024.
Nikita Kitaev, Lukasz Kaiser, and Anselm Levskaya. Reformer: The efficient transformer. In International Conference on Learning Representations, 2020. URL http:ttst//ppeeeiiiiii
net htte//oouunnid.xxkkkkke.ec
Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Küttler, Mike Lewis, Wen-tau Yih, Tim Rocktäschel, Sebastian Riedel, and Douwe Kiela. Retrieval-angmenned generation for knowledge-intensivee nlp tasks. In H. Larochelle, M. Ranzato, R. Hadsell, M.F. Balcan, and H. Lin (eds.), Advances in Neu- ral Information Processing Systems, volume 33, pp. 2020. URL htttpps www.:eddddinnn.e.eeuueoe 01le6666442200000000000000988880
Curran Associates, Inc., facaaeerrrlleeeeeeeeeeeeeaeeeeee fiwes/papeeeeee #11eesppaprr/220/
10

---

Published as a conference paper at ICLR 2026
Tian Liang, Zhiwei He, Wenxiang Jiao, Xing Wang, Rui Wang, Yujiu Yang, Zhaopeng Tu, and Shuming Shi. Encouraging divergent thinking in large language models through multi-agent debate. arXiv preprint arXiv: 2305.19118 2023.
Hao Liu, Matei Zaharia, and Pieter Abbeel. Ring attention with blockwise transformers for near- infinite context. arXiv preprint arXiv:2310.0158 2023.
Bowen Peng, Jeffrey Quesnelle, Honglu Fan, and Enrico Shippole. YaRN: Efficient context win- dow extension of large language models, In The Twelfth International Conference on Learning Representations, 2024. URL/httts://opeenreeee
net/ www.ooomddwwwnbdhaeae...
Michael Poli, Stefano Massaroli, Eric Nguyen, Daniel Y Fu, Tri Dao, Stephen Baccus, Yoshua Bengio, Stefano Ermon, and Christopher Re. Hyena hierarchy: Towards larger convolutional language models. In Andreas Krause, Emma Brunskill, Kyunghyun Cho, Barbara Engelhardt, Sivan Sabato, and Jonathan Scarlett (eds.), Proceedings of the 40th International Conference on Machine Learning. volume 202 of Proceedings of Machine Learning Research, pp. 28043 28078. PMLR, 23 Jul 2023. RtLhttts: http:///ooceeddeeeeo mlr presspress/ee / wttpp/22/2po2aa...mmm html
Chen Qian, Wei Liu, Hongzhang Liu, Nuo Chen, Yufan Dang, Jiahao Li, Cheng Yang, Weize Chen, Yusheng Su, Xin Cong, Juyuan Xu, Dahai Li, Zhiyuan Liu, and Maosong Sun. Chatdev: Communicative agents for software development. arXiv preprint
2023. URL
abs /ttpss//araiv.occ//ab//2220 07924
Chen Qian, Zihao Xie, Yifei Wang, Wei Liu, Yufan Dang, Zhuoyun Du, Weize Chen, Cheng Yang, Zhiyuan Liu, and Maosong Sun. Scaling large-language-modee modeaa--eeodleleeeeed multi-agent collaboration. arXiv preprint arXiv: 2406.07155, 2024a.
Hongjin Qian, Zheng Liu, Peitian Zhang, Kelong Mao, Yujia Zhou, Xu Chen, and Zhicheng Dou. Are long-Ilms a necessity for long-context tasks? SurXi:2245.155110 2024b.
Jiezhong Qiu, Hao Ma. Omer Levy, Scott Wen tau Yih, Sinong Wang, and Jie Tang. Blockwise self-attention for long document understanding, 2020. URL httpt:://tpppeeeeeeeee
net/
[orum??d=::lp=:T4
Zecheng Tang, Zechen Sun, Juntao Li, Qiaoming Zhu, and Min Zhang, Logo - long context alignment via efficient preference optimization, 2024.
Yi Tay, Mostafa Dehghani, Dara Bahri, and Donald Metzler. Efficient transformers: survey. ACM Comput. Surv., 55(6), December 2022. ISSN 0360-0300. doi: 10.1145/3530811. URL.
https:: wttp://///o..o....111/....
Junlin Wang. Jue Wang, Ben Athiwaratkun, Ce Zhang, and James Zou. Mixture-of-agent, enhances
large language model capabilities. arXiv preprint arXiv: 2406.04692 2024a.
Liang Wang, Nan Yang, Xingxing Zhang, Xiaolong Huang, and Furu Wei. Bootstrap your own context length. farXi:2412..1885 18860), 2024b.
Sinong Wang, Belinda Z. Li, Madian Khabsa, Han Fang, and Hao Ma. Linformer: Self-attention with linear complexity, 2020.
An Yang, Baosong Yang, Binyuan Hui, Bo Zheng, Bowen Yu, Chang Zhou, Chengpeng Li, Chengyuan Li, Dayiheng Liu, Fei Huang, Guanting Dong, Haoran Wei, Huan Lin, Jialong Tang, Jialin Wang, Jian Yang. Jianhong Tu, Jianwei Zhang, Jianxin Ma, Jianxin Yang, Jin Xu, Jingren Zhou, Jinze Bai, Jinzheng He, Junyang Lin, Kai Dang, Keming Lu, Keqin Chen, Kexin Yang, Mei Li, Mingfeng Xue, Na Ni, Pei Zhang, Peng Wang, Ru Peng, Rui Men, Ruize Gao. Runji Lin, Shijie Wang. Shuai Bai, Sinan Tan, Tianhang Zhu, Tianhao Li, Tianyu Liu, Wenbin Ge. Xiaodong Deng, Xiaohuan Zhou, Xingzhang Ren, Xinyu Zhang, Xipin Wei, Xuancheng Ren, Xuejing Liu, Yang Fan, Yang Yao, Yichang Zhang, Yu Wan, Yunfei Chu, Yuqiong Liu, Zeyu Cui, Zhenru Zhang, Zhifang Guo, and Zhihao Fan. Qwen2 technical report. (arXiv:2407. 10677)..1111 2024.
Jajje Zhang, Zhongni Hou, Xin Lv, Shulin Cao, Zhenyu Hou, Yilin Niu, Lei Hou, Yuxiao Dong, Ling Feng, and Juanzi Li. Longreward: Improving long-context large language models with ai feedback, 2024a.
11

---

Published as a conference paper at ICLR 2026
Xinrong Zhang, Yingfa Chen, Shengding Hu, Zihang Xu, Junhao Chen, Moo Hao, Xu Han, Zhen Thai, Shuo Wang, Zhiyuan Liu, and Maosong Sun. ooBench: Extending long context evaluation beyond 100K tokens. In Lun-Wei Ku, Andre Martins, and Vivek Srikumar (eds.), Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume I: Long Papers), pp. 15262-152777 Bangkok, Thailand, August 2024b. Association for Computational Linguistics. URL httpt::://// mattps://aclanthol.og
2024//2222..2 acl long. 814
Yusen Zhang, Ruoxi Sun, Yanfei Chen, Tomas Pfister, Rui Zhang, and Sercan Ô Arik. Chain of agents: Large language models collaborating on long-context tasks. (arXiv:2406.028) (00008),,.8. 2024c.
Jun Zhao, Can Zu, Hao Xu, Yi Lu, Wei He, Yiwen Ding, Tao Gui, Qi Zhang, and Xuanjing Huang. Longagent: Scaling language models to 128k context through multi-agent collaboration. (555)) 2024a.
Jun Zhao, Can Zu, Hao Xu, Lu, Wei He, Yiwen Ding, Tao Gui, Qi Zhang, and Xuanjing Huang. Longagent: Scaling language models to 128k context through multi-agent collaboration. arXiv preprint Xiv: 2402. 1 1150, 2024b.
Zihan Zhou, Chong Li, Xinyi Chen, Shuo Wang, Yu Chao, Zhili Li, Haoyu Wang. Rongqiao An, Qi Shi, Zhixing Tan, Xu Han, Xiaodong Shi. Zhiyuan Liu, and Maosong Sun. Lim x mapreduce: Simplified long-sequena sequence processing using large language models. (arXiv:2410.09344), 2024.
A USAGE OF LLMS
Large Language Models (LLMM)) were minimally employed during manuscript preparation, specifi- cally enhance the clarity and fluency of the writing. The role of LLMs strictly limited to minor linguistic refinement, and the authors retain full responsibility for the content and accuracy of the work.
B DERIVATION AND APPROXIMATIONS
This appendix details the relationship between the exact fidelity product and the additive noise approximation.
Exact Decomposition.
As defined in Section the system fidelity is an exact telescoping product:
Pays = Ptask Pags Pmodel-
By defining the log-loss L = log(p), the decomposition becomes exactly additive in log-space:
Cays Lrask + Lags + Cmodel
Linear Error Approximation. For high-fidelity regimes (p Ro 1), we can recover an intuitive additive enror formulation. Let étask Praski Eagg, Paggr and emodel Pmodel- Then
Pays
= (tack) )1 Cags )1 Emodel).
Expanding the product and dropping higher-order interaction terms (c.g., Crask yields Prask) + (1 Pags) + (1 Pmodel). Erotal Pays Rs. Grask + Cagg + Gmodel =
(6)
C JUSTIFICATION OF PROPOSITION
We analyze the crossover point where the D&C strategy outperforms single strong agent. We derive the asymptotic behavior directly from the Fidelity Decomposition framework.
Single Strong Agent (The Brain Fog). By the Super-Linear Collapse assumption, the strong model suffers from attention dispersion as context grows. Its fidelity loss grows super-linearly:
Latrong (T)
Estrong (T) w(T)
lim T
co.
T
12

---

Published as a conference paper at ICLR 2026
2. Weak D&C System (Deriving Linearity). Recall the additive decomposition of the D&C
system loss:
(T) = Ltask + Lagg + Lmodel
We analyze the growth of each term under the Bounded Unit Loss assumption:
Model Loss (mmodel): ) The input is split into n x 7 chunks of fixed length. Assuming the error introduced by each local worker is bounded and independent of I', the accumulated log-loss scales linearly with the number of chunks: Lmodel (T') = (n) = O(T).
Overhead (Ctak + Lagg): Assuming the task is feasible (finite Ltssk) and the aggregation process scales linearly with the input size (or uses a hierarchical structure with bounded error), the overhead grows at most linearly: Ltask
Lags (
Combining these terms, the total D&C loss is bounded linearly:
(T) = O(T).
3. Asymptotic Crossover. We compare the growth rates. Since Latrong (T) grows super-linearly
(T) while (T) grows linearly (O(T)) the ratio diverges:
Latrong (T) DC.
lim T-000
CD&c((T
This shows that there exists threshold To such that for all T > To, LD&C Eatrong.
D TASKS DESCRIPTION
We experiment on six diverse tasks including: Key-Value Retrieval, Math Find Number, Summa- rization, Dialogue Character Inference, and Open Question QA with and without choices. These tasks are based InfiniteBench (Zhng et al. (2024b) and LongBench- Bai et al. (2024) but we have modified the generation and prepared different lengths of these tasks. These tasks include: Key-Value Retrieval (KV) We randomly generated Key-Value pairs. For given key, the task is to retrieve the value associated. This task only evaluates the capability of retrieval. The evaluation metric is accuracy. We prepare synthetic KV task to have lengths ranging from 1K to 128K. Math Find Number (Math) We randomly generated long list of integers following Gaussian distribution and the task is to find the Kth largest or smallest number in this list. Each query is slightly different in K. This task evaluates the memory and mathematical reasoning. The evaluation metric is accuracy. We prepare synthetic Math task have lengths ranging from 1K to 128K. Summarization (Sum) We provide English texts and the task is to summarize them. The ground truth summarization comes from the InfinitBBench. This task evaluates the language summarization. The evaluation metric is ROUGE score. Open Question QA (QA-IB and QA-LB) We provide English text and some open questions for question answering. These questions are very diverse and the task requires L.M to do multi-hop reasoning answers. The task QA-IB comes from InfiniteBench and doesn't 't come with choices and the task QA-LB comes from LongBench-V V2 and is provided with four choices. The evaluation metrics are respectively F1 score and accuracy. Dialogue Character Inference (Char) We provide English dialogue scripts between many characters. One the characters is masked and the task is to infer the name of the masked person. This task evaluates the capacity of language reasoning and will require LLM to focus on the interaction of people discussions to understand the relation. The evaluation metric is accuracy. This task comes from InfiniteBench.
E SAMPLE PROMPTS FOR PLANNER, MANAGER AND WORKER AGENTS
The planner provides automated way to transform raw prompt into structured instructions for both worker and manager agents. It parses the original task prompt, identifies key requirements, and then generates appropriate prompts for the workers and the manager. This reduces manual overhead in designing separate prompts, since the planner consistently creates focused directives for each agent.
13

---

Published as a conference paper at ICLR 2026
Planner Prompts
Here is prompt that use for one L.M agent. Now since my input is too long, divide into multiple chunks and feed one chunk to one worker agent. Suppose now that are the manager agent to synergize the responses multiple worker agents in order to complete the prompt task. Write the prompt for each worker agent and the prompt for manager agent to synthesize the answer.
(RAW TASK PROMPT)
E. EXAMPLE: SUMMARIZATION
To further illustrate the planner, we use Summarization task as another example. We first show the manual (default) prompts for worker and manager agents as below.
Raw prompt from benchmark
Read the book paragraphs below and summarize. Book: [context)
Worker agent prompt (manual)
Read the book paragraphs below and summarize. Book: (text chunk)
Manager agent prompt (manual)
There is a list of candidates. Each candidate has been given one sequential part of a book and summarize their own parts. You have been provided with their responses. Summarize their summaries into one. Responses from candidates: cespoose_from_wooe
Now we use the designed planner to automatically prepare the appropriate prompts for workers and manager. We feed the raw prompt from benchmark to the planner.
Worker agent prompt (planner)
You part of team tasked with summarizing portion of a book. Below is an excerpt from the book assigned to you. Please provide concise summary of this specific section, highlighting key points and themes. Excerpt: (book chunk) Please ensure your summary is clear and focuses the main ideas presented in the excerpt.
Manager agent prompt (planner)
You the manager agent responsible for synthesizing the summaries provided by multiple worker agents. Each worker agent has been given a different section the book to summarize. Your task is to combine these individual summaries into coherent and comprehensive summary of the entire book section provided to the worker agents.
Responses from Worker Agents: (response from (rom_workerss Please integrate these summaries, ensuring that the overall summary captures the main points, themes, and any important details necessary for understanding the book's 's content as whole.
14

---

Published as a conference paper at ICLR 2026
E.2 EXAMPLE: QA
Raw prompt from benchmark
{context)
How do users most likely plan to dress for master's graduation?
A. Wear tuxedo or robe.
B. Dress business casual.
C. Wear business attire.
D. Wear whatever clothes they feel comfortable in.
Worker agent prompt (planner)
{context)
You are worker agent. You will receive portion of data related to how users plan to dress for a master's s graduation. Your task is to analyze the provided information and offer insights based your assigned chunk. Focus one of the possible dress options and any relevant context or rationale behind the choice. The options include:
A. Wear tuxedo or robe,
B. Dress business casual,
C. Wear business attire.
D. Wear whatever clothes they feel comfortable in.
Please focus only on any details in your data relevant to one specific option and clearly summarize its findings and rationale. Provide examples if necessary.
Manager agent prompt (planner)
You are Manager Agent. You will receive responses compiled from several Worker Agents, each analyzing different portions of input data related to dressing for master's graduation. Your task is to review and synthesize these individual analyses into a comprehensive overview. Consider each worker agent's 's insights on the various dress options:
A. Tuxedo or robe,
B. Business casual,
C. Business attire,
D. Comfortable clothes.
Highlight the most popular trends and any notable reasons supporting these choices. Pay attention to diversity in preferences, cultural considerations, and any statistical or anecdotal evidence provided by worker agents. Your final output should deliver clear synthesis on how users most likely plan to dress for this occasion, potentially indicating preferences, influences. and recommendations.
Responses from candidates: (response
E.3
EXAMPLE: MATH
Raw prompt (Math)
(context) (long list of numbers)
What is the 2nd smallest number?
15

---

Published as a conference paper at ICLR 2026
Worker agent prompt (planner)
You are worker agent tasked with analyzing a portion of list of numbers. From the chunk of numbers provided below, identify and return the two smallest numbers in ascending order. Here your list:
[text_ cext__
Please output the two smallest numbers you find in your assigned list.
Manager agent prompt (planner)
You are the manager agent tasked with synthesizing results from multiple worker agents. Each worker agent has provided the two smallest numbers from their respective chunks of larger list. Your task is to compile these results and determine the 2nd smallest number from combined outputs all worker agents. Responses from worker agents: fresponse from workers) Please analyze these results and provide the 2nd smallest number from the original list.
F MODEL NOISE RESULTS
This section provides the detailed numerical data that form the basis for Figure 2 presented in Section 5.2 of the main paper. Figure illustrates the performance degradation of single-agent Large Language Models (LLMs) as the input context length increases, phenomenon consistent with length-induced model degradation. Table tabulatss the specific accuracy scores for the evaluated models (gpt4o, gpt4omini, Ilamaāb, and Ilama70b) on the Key-Value Value Retrieval (KV) and Math Find Number (Math) tasks, across a range of input lengths from 1K to 128K tokens. These raw scores directly support the visualizations and analysis concerning the growth of model error with increasing context size discussed in the main text.
Table 2: Model noise results. Scores for both tasks are accuracy.
Task
Task length
gpt4o
gpt4omini
Ilama3h
1lama70b
KV
1K
1.00
1.00
1.00
1.00
KV
2K
1.00
1.00
0.98
1.00
KV
4K
1.00
1.00
0.95
1.00
KV
8K
1.00
1.00
0.88
1.00
KV
16K
1.00
1.00
0.66
1.00
KV
32K
1.00
0.99
0.24
1.00
KV
64K
1.00
0.86
0.01
0.91
KV
128K
1.00
0.60
0.01
0.15
Math
1K
0.67
0.71
0.23
0.63
Math
2K
0.68
0.65
0.19
0.65
Math
4K
0.71
0.64
0.19
0.66
Math
8K
0.69
0.61
0.10
0.55
Math
16K
0.62
0.54
0.06
0.55
Math
32K
0.63
0.51
0.06
0.52
Math
64K
0.54
0.37
0.04
0.39
Math
128K
0.33
0.11
0.00
0.09
G TASK NOISE RESULTS
This section contains the detailed numerical results corresponding Figure in Section 5.3 of the main paper. Figure illustrates the joint effect of cross-chunk dependency (the task term, Lrast) and length-induced degradation (the model term, fmodel), showcasing how performance varies for
16

---

Published as a conference paper at ICLR 2026
different LLM agents 128K-token length tasks when the effective model context length (i.e., chunk size in the D&C setting) is altered. Table the precise performance metrics (accuracy, F1 score, ROUGE score, depending the task) for the models gpt4omini, llama70b, and qwen72b. These scores are provided for all six benchmark tasks (KV, Math, QA-IB, QA-LB, Sum, Char) across various model context lengths ranging from 1K to 64K tokens (when processing total input of 128K tokens). This data underpins the analysis of the three noise regimes and the conditions under which D&C approaches advantageous, discussed in the main text.
Table Task noise results. Scores for all tasks are accuracy except sum which is ROUGE and qaib which is F1 score.
Model
Context
Char
KV
Math
QA-IB
QA-LB
Sum
gpt4omini
1000
0.12
0.99
0.49
0.22
0.33
0.08
gpt4omini
2000
0.12
0.99
0,50
0.27
0.44
0.11
gpt4omini
4000
0.15
0.99
0.55
0.39
0.44
0.15
gpt4omini
8000
0.17
0.99
0.54
0.36
0.48
0.14
gpt4omini
16000
0.15
1.00
0,50
0.37
0.44
0.15
gpt4omini
32000
0.18
1.00
0.55
0.42
0,46
0.11
gpt4omini
64000
0.16
0.98
0.45
0.39
0.38
0.11
Ilama70b
1000
0.04
0.99
0.47
0.44
0.15
0.16
Ilama70b
2000
0.05
0.96
0.49
0.55
0.36
0.19
1lama70b
4000
0.05
0.99
0.50
0.55
0.46
0.23
1lama70b
8000
0.07
0.98
0.50
0.56
0.33
0.28
1lama70b
16000
0.07
1.00
0.57
0.63
0.26
0.24
10bma70b
32000
0.13
1.00
0.53
0.54
0.28
0.23
10ama70b
64000
0.17
0.91
0.39
0.41
0.31
0.21
qwen72b
1000
0.08
0.98
0.33
0.32
0.31
0.08
qwen72b
2000
0.07
0.95
0.46
0.40
0.28
0.18
qwen72b
4000
0.07
0.97
0.41
0.44
0.41
0.29
qwen72b
8000
0.15
0.98
0.40
0.48
0.54
0.23
qwen72b
16000
0.15
1.00
0.36
0.48
0.46
0.18
qwen72b
32000
0.13
0.88
0.31
0.42
0.46
0.19
H FRAMEWORK UTILITY OF PREDICTIVE PARAMETER ESTIMATION
An important measure of a theoretical framework's 's value lies in its empirical utility, extending beyond explanatory power to offer practical benefits. This section discusses both the explanatory strengths of our noise decomposition framework and its predictive utility in efficiently determining optimal parameters for Divide and Conquer (D&C) strategies.
H.1 EXPLANATORY POWER
Our framework provides principled understanding of why and when D&C methods succeed or fail in the context of long-document processing by Large Language Models (LLMss. By decomposing the overall eтror into distinct terms-tasis (Crask), model (Cmodel), and aggregator (Cage) the the framework facilitates the disentanglement of various contributing factors performance. This structured understanding has been instrumental in deriving the key insights presented throughout this paper, such as the conditions favoring chunking and the impact of accelerated performance degradation with length.
H.2 PREDICTIVE UTILITY FOR OPTIMAL CHUNK SIZE ESTIMATION
A practical challenge in deploying D&C methods is the selection of optimal chunk size, which often requires costly exhaustive grid searches over various configurations. We conducted new experiments evaluate whether framework's insights could guide more efficient estimation
17

---

Published as a conference paper at ICLR 2026
of this parameter, particularly in regimes dominated by model noise (Regime 3 in Section 3.6), where chunk size significantly impacts performance. In other regimes (Regime 1 and Regime 2), performance tends to be less sensitive to chunk size variations, making this estimation less critical.
We focused on tasks where model noise is a dominant factor (QA-IB and Summarization, as identified in Figure 3) and attempted to estimate the optimal chunk size by evaluating performance on very small number of randomly selected document samples (3, 5, or 10 samples) for each potential chunk size configuration. The D&C performance achieved with the chunk size selected via this minimal sampling approach was then compared to the optimal performance found through an exhaustive grid search over all samples for all chunk sizes.
The results for the QA-IB and Summarization (Sum) tasks are presented in Table 4 and Table 5 respectively. These results demonstrate that even with minimal sampling (as few as 3-5 samples per configuration), it is possible to identify chunk sizes that yield near-optimal D&C performance. This suggests a pathway to significant computational savings when setting up D&C pipelines for new tasks or models, by avoiding exhaustive searches. For example, in the QA-IB task with 'llama70b', using just samples per chunk size configuration allowed us to identify 16K chunk size yielding a score of 0.63, identical to the optimal score and chunk size found via exhaustive search. Similarly, for "qwen72b' on the Summarization task, samples were sufficient to find the optimal 4K chunk size and achieve the optimal score of 0.29.
Table 4: Predictive Utility on QA-IB: Optimal Chunk Size Estimation (Score (Optimal Chunk Size Found)). Total task length 128K tokens.
Model
3-sample
5-sample
10-sample
Optimal after Exhaustive Search
gpt4omini
0.38 (64K)
0.42 (32K)
0.42 (32K)
0.42 (32K)
Ilama70b
0.55 (2K)
0.63 (16K)
0.63 (16K)
0.63 (16K)
qwen72b
0.40 (2K)
0.48 (16K)
0.48 (8K)
0.48 (8K & 16K)
Table 5: Predictive Utility on Summarization (Sum): Optimal Chunk Size Estimation (Score (Optimal Chunk Size Found)). Total task length 128K tokens.
Model
3-sample
5-sample
10-sample
Optimal after Exhaustive Search
gpt4omini
0.15 (16K)
0.14 (8K)
0.14 (8K)
0.15 (4K & 16K)
10bma70b
0.23 (32K)
0.24 (16K)
0.28 (8K)
0.28 (8K)
qwen72b
0.23 (8K)
0.29 (4K)
0.29 (4K)
0.29 (4K)
RATIONALE FOR EFFICIENT ESTIMATION
The feasibility of accurately estimating optimal chunk sizes from sparse samples can be understood through our framework's ' characterization of length-induced degradation. We posit that model length- induced degradation exhibits superlinear growth with context length L ||>|| It is reasonable to infer that this underlying length- degradation function g(L) is, in practice, often (or can be approximated as) monotonic with respect to L over relevant ranges. Consequently, within the D&C paradigm, reducing the per-worker chunk size is expected to lead to predictably monotonic (or near- mon-monotoni) decrease in the dominant model term, Lmodel-
When Lmodel dominates (and the task and aggregator terms, Lrask and Lugg. are relatively small or controlled), the overall D&C system error as a function of chunk size is likely to exhibit a discernible optimal region (e.g.. a convex-like shape region where decreasing length-induced degradation is balanced by slowly increasing decompositionn/ggreeaati and unpredictably. Therefore, a small number of samples across different chunk sizes can provide sufficient information to sketch the rough contour of this error curve, allowing for the identification of the approximate location of this optimal trade-off point without exhaustive evaluation.
overhead) rather than fluctuating randomly
18

---

Published as a conference paper at ICLR 2026
1 THE IMPACT OF OVERLAP IN CHUNKING STRATEGIES
In our main analysis, we primarily considered non-overlapping chunks. To further explore variations in chunking methodologies, we investigated the impact of introducing a modest overlap between adjacent chunks. This strategy is sometimes employed with the aim of mitigating potential information loss chunk boundaries, which could otherwise increase cross-chunk dependency effects (the task term, L. We conducted experiments using the Llama-70B model on several 128K-token long- context tasks, comparing non-overlapping chunks with chunks having IK token overlap (base chunk sizes were 4K and 16K tokens before overlap).
The results are presented in Table The inclusion of a 1K token overlap led mixed and generally
Table 6: Impact of 1K Token Overlap on Llama-70B Performance (128K Tasks)
Llama-70B Strategy
KV
QA-IB
Sum
Char
16K chunks, no overlap
1.00
0.63
0.24
0,07
16K chunks, IK overlap
1.00
0.54
0.25
0.07
4K chunks, no overlap
0.99
0.55
0.23
0.05
4K chunks, 1K overlap
1.00
0.53
0.19
0.05
noted in some specific instances, other cases showed minor degradations or no discernible effect. This suggests that while a small over- lap might offer limited benefit for certain local cross-chunk dependencies, it does not consistently or substantially alter the overall performance trade-offs identified by our framework for these tasks. Moreover, extensive overlap could introduce processing redundancies even conflicting information for the aggregator, potentially increasing aggregation errors (the aggregator term, Lagx). For the configurations tested, the benefits of this overlap strategy did not appear to consistently outweigh the increased complexity or computational cost.
marginal changes in performance. While slight improvements
J COMPARATIVE ANALYSIS WITH RETRIEVAL-AUGMENT GENERATION (RAG)
Retrieval-Augmennedd Generation (RAG) represents a prominent alternative for addressing long- context tasks by first retrieving presumptively relevant segments of the input, which are then processed by the LLM. To situate our Divide and Conquer (D&C) framework in relation to this approach, we performed a comparative analysis. We applied RAG to the single-shot baseline models for the 128K-token versions of our benchmark tasks, employing both BM25 (sparse retrieval) and 'all-mpnet- base-v2' embeddings (dense retrieval). Based on the task query, the RAG pipeline retrieved document sections that were then provided as context to the LLM.
The performance of RAG is detailed in Table 7 For several tasks, RAG was notably less effective than
Table 7: Comparison of D&C (Implicit via "noRAG" baseline) and RAG Strategies
Model
Method
KV
QA-IB
QA-LB
Sum
Char
noRAG (Baseline)
0.60
0.23
0.31
0.13
0.19
gpt4omini
RAG (BM25)
0.79
0.13
0.23
0.12
0.11
RAG (mpnet)
0.73
0.19
0.27
0.13
0.13
noRAG (Baseline)
0.15
0.56
0.23
0.19
0.18
11ama70b
RAG (BM25)
0.81
0.14
0.23
0.15
0.10
RAG (mpnet) 0.77
0.38
0.26
0.15
0.14
both our D&C methodology and the original single-shot baseline. Tasks such as summarization or character inference, which often require global understanding or synthesis of diffuse information not easily targeted by simple query, proved challenging for the retrieval step. Inaccurate or incomplete retrieval frequently provided the L.M with partial skewed view of the overall context, leading to
19

---

Published as a conference paper at ICLR 2026
degraded performance. These findings highlight the sensitivity of RAG to retrieval quality and its applicability to processing the entirety of the text through structured decomposition, can offer greater robustness for such scenarios.
tasks where key information is sparse or not easily queryable. Our D&C approach, by
K
RELATION TO ARCHITECTURAL CONTEXT EXTENSION METHODS
Alongside algorithmic approaches like D&C, significant research efforts focus on extending the native context window capabilities LLM architectures, often through modifications positional encodings (e.g., RoPE scaling) or continued training on longer sequences. It is noteworthy that one of our primary baseline models, extension techniques and has undergone training with them.
1ann2.5772B-nnttreie already incorporates such advanced context
To further understand the landscape, particularly regarding training-free extension methods, we examined the behavior of Llama-2 (a model with nominal 4K token context window) when its context was extended to 32K tokens via RoPE scaling, without additional fine-tuning. The results The data indicate decline in performance the input length significantly
are shown in Table 8
Table 8: Performance of Llama-2 with RoPE Scaled Context Extension (Trining-FFees
Model
Tested CTX
KV
QA-IB
Char
Llama2-4K
4K
0.47
0.23
0.00
0.42
0.19
0.00
Llama2-32K (Scaled)
16K
0.23
0.17
0.03
32K
0.12
0.13
0.00
surpassed the model's original training parameters. This aligns with broader observations in the field (e.g., the LongRoPE study) suggesting that while training-free scaling offers some benefit, achieving robust performance at substantially extended context lengths typically requires further training or architectural adaptation. The D&C framework presented in this paper is complementary, providing a strategy to handle extensive sequences that can be applied irrespective of model's inherent maximum context length.
L CONNECTION EFFECTIVE CONTEXT LENGTH RULER BENCHMARKS
The efficacy of any long-contert strategy is intrinsically linked the underlying LLM's capabilities. Benchmarks like Ruler aim to quantify the "effective context length" of models, often focusing on retrieval-based tasks. To assess the generalizability of our noise decomposition framework across a spectrum of models and task types beyond simple retrieval, we conducted additional evaluations. We selected three models with differing architectural characteristics and reported long-context capabilities: Bistral-7B-Insstuet--o
Qwenl @wwnl..5-7BB-. 1-72B---haha and GPT-4-Turbo.
These models were evaluated several of benchmark tasks with varying input context lengths. The performance patterns are summarized in Table While longer effective context is generally advantageous, the specific manifestation of the model term (Cmodel) and the task term (Less)) remains highly task-dependent. Complex reasoning or generation tasks can stress long-conted capabilities differently than retrieval tasks. These observations reinforce the utility of our noise decomposition framework as an analytical tool. The framework helps explain performance variations by considering the interplay of the task's intrinsic decomposability, the model's confusion threshold with increasing context, and the aggregator's ability to synthesize information, providing insights that extend beyond a single metric effective context length.
M FRAMEWORK IMPLEMENTATION IN MORE DETAILS
We present a simple implementation the framework as in Figure I Our implementation consists of three parts: planner for automated query planning, numerous worker agents, and single manager
20

---

Published as a conference paper at ICLR 2026
Table Performance of Diverse Models with Varying Context Lengths
Model
Ruler CTX (Approx.)
Tested CTX
KV
QA-LB
Sum
4K
0.03
0.230
0.090
Mistral-7B
16K
8K
0.00
0.290
0.090
16K
0.11
0.170
0.090
4K
0.92
0.360
0.110
8K
0.97
0.260
0.130
Owenl.5-72B-CU. BhCtt
32K
16K
0.95
0.310
0.110
32K
0.93
0.270
0.150
4K
1.00
0.431
0.088
8K
1.00
0.461
0.091
16K
1.00
0.435
0.092
GPT-4 (Turbo)
64K+
32K
0.98
0.399
0.085
64K
0.87
0.384
0.081
128K
0.77
0.373
0.074
agent. For a long context task, we divide it into chunks of approximately equal length and feed each chunk to one worker agent. Thus, we need to design how worker agents process their chunks and how manager agent could synthesize the appropriate answer from the interaction.
M.1 WORKER AGENT
In our framework, the long context sequence is divided into multiple segments, with each worker agent independently responsible for processing one specific segment. This design isolates the processing of individual segments, deliberately omitting any consideration of dependencies across segments. The goal is to simplify each worker's task by restricting its scope to a single context segment. While our implementation employs homogeneous worker agents for simplicity, this setup be extended to accommodate heterogeneous agents with varying capacities in more complex scenarios.
M.2 MANAGER AGENT
The manager agent tasked with aggregating the outputs generated by the worker agents. It analyzes the responses received and synthesizes unified, refined output. For simplicity in our current design, we use the same model architecture for the manager agent as for the worker agents. However, this design can be adapted to allow for specialized managerial processing in more advanced applications.
M.3 PLANNER
The planner plays a central role in the coordination of the system. While we have outlined the basic structure of worker and manager agents, the specific responsibilities of each agent will vary depending on the task and the data. Instead of manually assigning tasks to the agents, we introduce a planner that autonomously determines the optimal distribution jobs between the worker and manager agents. The planner is given the original task description (c.g., "identify the second largest number in this list") and is responsible for generating appropriate prompts for each agent, taking into account the segmentation of the long sequence. Moreover, human-designe agent workflows typically involve trial-and-error approach: initial job prompts are tested on a small dataset, the failures are analyzed, and the design is iteratively refined. We integrate this iterative process into the planner by having it perform an initial zero-shot job assignment, followed by an evaluation on holdout validation data. The planner receives feedback mispredieted cases and revises the job prompts accordingly. While this iterative process can be repeated to improve performance, there is a risk overfitting if carried out for too long. In our experiments, iterate only once avoid trivial problems.
21

---

Published as a conference paper at ICLR 2026
N
COMPUTATIONAL COST AND LATENCY OF D&C VS. SINGLE-PASS
Setup and notation.
Let an input have length T tokens and be split into equal chunks. Denote
T Tsiggle (T): latency for single, large model to process the full input,
(T)T//)): latency for smaller worker model process chunk,
T minager L:gg): latency for the manager/aggregattor process the short aggregation input of length Luge (concatenated worker outputs/prompts, where typically Lags < T.
We assume worker calls are issued in parallel up to the available concurrency of the deployment.
N.1 LATENCY
Single-pass wall-clock latency.
Latency single
T single (T)-
D&C wall-clock latency with parallel workers.
Latencypac s (Tc(T/n) + mmanager Lagg))
(8)
When is D&C faster?
T Trigle((2 (T/T))) + T Tmanagor Lage)
This inequality is often satisfied in practice because (i) per-call latency grows with input length, so shrinking from 7 to T /n reduces each worker's processing time, and (ii) Lage is short, so the manager adds a small, near-constant overhead. Crucially, D&C does not require n sequential LLM calls; with parallelization the critical path is one worker pass plus a single manager pass.
Practical caveats. The achievable speedup depends available parallel capacity (API/cluster concurrency), network overhead, and the manager prompt design. Excessive chunk overlap or verbose worker outputs increase Tage and can erode gains.
N.2 MONETARY COST
Let Pinvour be per-token prices for the single, flagship model; small for the smaller worker model; and Piarout for the manager, Let lyl the final output length, lys| each worker's output length, and Lggs the manager's input length.
Single-pass cost.
Costsingle
big Pin
T
+
big Pout [y/.
(10)
D&C cost.
Costpac
23
Pin
small
+
small
1yal +
Pin
Lagg
+
Pout [
(11)
Token accounting and implication. With non-overlapping chunks, the dominant input mass remains in both pipelines. D&C adds only a small extra budget for Lagg and Σ, 1ysl (kept short by structured worker outputs). Therefore, when samall & Piniut (using compact/open models as workers and lightweight manager), D&C typically cheaper while processing roughly same number of dominant input tokens.
big
Practical caveats. Chunk overlap, verbose worker outputs, retries, using a large manager increase Lage and E; 1yal- These are controlled by (i) minimizing overlap. (ii) constraining worker output schemas, and (iii) keeping the manager focused on short structured inputs.
22

---

Published as a conference paper at ICLR 2026
N.3 SUMMARY OF THE TRADE-OFF
Latency: With parallel workers, D&C reduces the critical path from processing T once to processing single chunk of size T n plus short aggregation step (Eq.9).
Cost: Because the dominant token mass T is similar in both methods, shifting those tokens to cheaper worker models and paying only a small aggregation overhead typically lowers total cost.
Key condition: Short, structured worker outputs (small Logg) and sufficient parallel capacity make Tsingle (T) Ta (T mumagerr (Lugg) and Costp&c Cost realistic for long inputs.
These considerations complement the performance-centrie analysis in the main paper: when model noise grows with context length and cross-chunk synergy is moderate, D&C can simultaneously improve quality, reduce wall-clock time, and lower cost relative single-pass large- modell run.
WHY STATIC EQUAL-LENGTH CHUNKING?
For clear analysis and diagnosis, adopt control-variable design: set the chunk size equal to the per-chunk context length and use equal-length, non-overlapping splits. This way, the performance change chunk size varies be primarily attributed to the length effect (model noise), rather than multiple moving parts at once.
Why not use adaptive segmentation in the main experiments? Adaptive policies (variable lengths, semantic boundaries, routing) simultaneously change:
the length distribution across chunks (affecting how model noise seales with length),
the boundary placement/routing relative dependencies (affecting task noise).
the structure of worker outputs (affecting aggregator noise).
When several factors vary together, the diagnostic curve (performance vs. chunk size) becomes hard to interpret, and we can no longer cleanly read off the relationship between per-chunk length and model confusion, nor the relative contribution of the three noise sources.
Benefits of equal-length splitting (control of variables) Equal-length, non-overlapping splits concentrate the degree of freedom onto the per-chunk length L, which:
enables a direct estimatioonvisualizzioo of how model noise depends on (the basis for our read of Fig. 2/3),
stabilizes comparisons between D&C and single-shot across different é,
makes the diagnosis of "model-noise dominated" "task-noise dominated" regimes more reliable.
Empirically, we also observed that small overlaps only yield marginal gains in our setting, suggesting the conclusions are not artifacts of brittle boundaries.
The framework does not preclude adaptivity Our decomposition naturally accommodates adap- tive segmentation; when diagnosties indicate high task noise (strong cross-chunk dependencies), adaptive strategies can be useful in engineering practice. However, the focus of this paper is first to identify the length-driven effect under controlled conditions. In other words, we do not reject adaptivity; we fix chunk lengths to keep variables controlled so that the analysis remains interpretable and reproducible.
23


Reviews:
[{"review_id": "V5HztT3lwP", "reviewer": "Reviewer_YK8x", "summary": "The paper proposes a divide-and-conquer (D&C) framework for long-context LLM tasks that decomposes error into three sources: **task noise** (cross-chunk dependencies), **model noise** (degradation as input length grows), and **aggregator noise** (errors when fusing partial outputs). The central claim is that when input length is large, model noise grows **superlinearly**, so chunking with a well-designed aggregator can outperform single-shot inference—even with weaker worker models. The authors provide a planner–workers–manager implementation, experiments on retrieval/QA/summarization and others, and a cheap sampling method to estimate near-optimal chunk size.", "questions": "1. Can you re-run the “weak D&C beats strong single-shot” comparisons under **matched token/compute/wall-clock** budgets and report statistical significance? This is crucial for the main claim. \n2. Can you **directly estimate** the superlinearity exponent (e.g., error ∝ L^α with CI) across models/tasks rather than primarily relying on diagnostic exclusion? \n3. How do results change with **stronger aggregators** (retrieval-augmented fusion, entity/event graph alignment, structured parsers) and with carefully **matched prompt lengths/few-shot examples** across baselines? \n4. The appendix motivates **equal-length, non-overlapping** splits to control variables. Have you evaluated robustness to boundary placement, small overlaps, or adaptive routing at similar budgets?", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "* **Unifying perspective.** The three-noise decomposition offers a clear lens for deciding when to chunk, how to chunk, and how to aggregate. \n* **Actionable empirical takeaways.** The paper documents superlinear performance decay with length and shows cases where chunking beats single-shot, provided aggregator noise is controlled. \n* **Concrete implementation.** The planner/manager/worker design and prompt scaffolding make the approach reproducible in spirit and show how aggregator strength materially affects outcomes.  \n* **Efficient chunk-size selection.** A low-budget sampler often identifies the same chunk size as exhaustive grid search at 128K tokens on QA-IB and summarization.", "weaknesses": "* **Superlinearity is argued largely by phenomenon, not direct estimation.** The paper builds the thesis from diagnostic curves and counter-hypotheses, but does not directly fit an exponent for error growth vs. length with uncertainty quantification. Stronger statistical evidence would help. \n* **Metric/assumption clarity.** Parts of the theoretical setup and noise interactions would benefit from clearer units/assumptions and closer alignment with common additive error analyses (currently the exposition is somewhat abstract). \n* **Baselines and fairness.** The headline claim (“weak D&C > strong single-shot”) should be compared under **matched token/compute/latency budgets**, with significance tests. Aggregator comparisons risk “straw-man” effects if manual prompts are weak; stronger retrieval- or structure-aware aggregators should be included. (The appendix lists a compute/latency section, but main-text results under unified budgets are limited.)", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "BBoVLVFJE2", "reviewer": "Reviewer_vy5A", "summary": "In this paper, the authors propose a theoretical framework that decomposes the error of long context solutions, including one-shot single agent and divide-and-conquer multi-agent, into three parts: task, model, and aggregator errors. Task demonstrates the errors of cross-chunk dependency, model indicates errors with growing task length, and aggregator indicates errors during aggregating results of subagents. Then, the authors propose a simple multi-agent framework and evaluate the real data. Both theory and experiments showed that chunking can outperform single-shot usage in many tasks where superlinear noise growth appears with context length. However, if cross-chunk synergy is too large or the aggregator prompt is ineffective, chunk-based approaches may fail.", "questions": "I am curious if the theory can be applied to the Agentic workflow system as well. This can futher enhance the conclusion.", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "1. Long context tasks are important as many real-world questions are based on long context.\n2. The theoretical analysis gives unique evidence to show that chunking is better than single-agent. This conclusion is non-trivial and might change the understanding of users of Long-LLMs. \n3. Experiments further echo the theory and give a more fine-grained analysis of the problem.", "weaknesses": "I think some settings are over-simplified. For instance, there are a lot of different structures in multi-agent systems, for instance, there are chains, trees, and graphs. However, the theoretical analysis and experiment directly assume the agents (chunks) are independent, where the failure of one agent will not infect its sublings, which is commonly seen in chains. Next, the work in a multi-agent system is different from one-shot agent as they have different tasks to finish (summary vs. generating an answer). Thus, their performance curve might not be the same. Third, it is also assumed that the answers are evenly distributed in the question. However, in many datasets, such as QA, the answer is only in one or two chunks. I suggest that the authors carefully define the problem setting and show how strong the assumption is.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "iC9eNjZQgc", "reviewer": "Reviewer_TKHf", "summary": "This paper aims to explore the applicable boundaries of the divide-and-conquer strategy in long-context tasks. The core of this framework attributes the failure modes in long-text processing to the interaction among three key error sources: task noise, model noise, and aggregator noise. Through modeling and empirical analysis, the study provides insights into when chunking strategies should be adopted.", "questions": "1. Is this mathematical representation strictly valid, or is it merely a formal analogy? If it is an analogy, to what extent does the results derived from such a non-rigorous mathematical form still retain its theoretical validity?\n2. In Sections 5.3 and 5.4 of the paper, integrating and differentiating discrete variables is extremely puzzling, and it weakens the validation strength of the experimental part for the theoretical framework. This part of the content also requires detailed clarification.", "limitations": "", "rating": 4, "confidence": 4, "soundness": 2, "presentation": 2, "contribution": 2, "strengths": "1. The paper not only defines aggregator noise but also demonstrates in practice how to reduce this type of noise by introducing a planner.\n2. The noise framework proposed in the paper possesses diagnostic capabilities. By analyzing the relative dominance of the three types of noise, it divides long-context tasks into three distinct regions. This aids in determining whether a specific task is more suitable for the divide-and-conquer approach.\n3. The paper offers a possible explanation for the phenomenon where weaker models combined with the divide-and-conquer method can outperform top-tier single-pass models in ultra-long contexts.", "weaknesses": "1. It is commendable that the paper attempts to provide a scientific explanation from a theoretical perspective. However, when constructing its core theoretical framework (Sections 3.1 and 3.2), the paper lacks rigor in the use of mathematical operators. There is no explanation as to why multiplication and addition can be directly performed in the output space. For instance, what does the product of the results of two functions imply? This is puzzling and weakens the persuasiveness of the entire theoretical framework.\n2. The validity of the whole framework relies on the super-linear growth hypothesis. Nevertheless, the paper fails to derive this growth pattern from the attention mechanism or information flow bottleneck of the Transformer. Using the method of elimination is difficult to provide a scientific explanation for this phenomenon.\n3. The planner proposed in the paper also has similar role assignment and task planning modules in other multi-agent systems, lacking innovation. The theoretical contribution merely serves as a qualitative metaphor rather than a verifiable mathematical model.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "67b3vq97Aw", "reviewer": "Reviewer_njn8", "summary": "This paper presents a theoretical framework that decomposes the errors in long-context LLM processing into three types of noise: task noise, model noise, and aggregator noise. The empirical results demonstrate that, when task noise is controllable, chunking processing can effectively suppress the superlinear growth of model noise. Ultimately, this framework elucidates why, when dealing with ultra-long contexts, a weaker model employing a divide-and-conquer strategy can outperform the single-pass processing performance of a stronger model.", "questions": "1. Can a detailed argumentation be provided regarding why the multiplicative operator is chosen as the foundation of the theoretical framework, for example, in Section 3.2?\n2. In Section 4, it is mentioned that the planner has the capability of iterative optimization. Can evidence be provided to demonstrate that this iterative optimization indeed outperforms the prompts generated by the zero-shot planner on unseen test sets?", "limitations": "", "rating": 6, "confidence": 3, "soundness": 2, "presentation": 3, "contribution": 3, "strengths": "1. This paper presents a noise decomposition framework, proposing model noise, task noise, and aggregator noise.\n2. The experimental design of the paper is ingenious, with its objective not being to blindly pursue the sota performance but rather to provide validation for the theoretical framework.\n3. The paper devises a well-developed system to validate this theoretical framework, which comprises a planner, a worker agent, and a manager agent.", "weaknesses": "1. Although Appendix N attempts to alleviate concerns about latency by assuming parallelism, this is often impractical in real-world deployments, which undermines its guidance value in engineering practice.\n2. The experiments solely rely on basic methods such as BM25 and embeddings, and then draw the conclusion that the performance of RAG is unsatisfactory. This may underestimate the capabilities of current RAG systems. For instance, semantic chunking or LLM-based chunking could be employed to optimize chunking, and superior semantic retrieval methods could be utilized.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)