PaCoRe: Learning to Scale Test-Time Compute with Parallel Coordinated Reasoning

Abstract: We introduce Parallel Coordinated Reasoning (PaCoRe), a training-and-inference framework designed to overcome a central limitation of contemporary LLMs: their inability to scale test-time compute (TTC) far beyond sequential reasoning under a fixed context window. PaCoRe departs from the traditional sequential paradigm by driving TTC through massive parallel exploration coordinated via a message-passing architecture in multiple rounds. Each round launches many parallel reasoning trajectories, compacts their findings into context-bounded messages, and synthesizes these messages to guide the next round and ultimately produce the final answer. Trained end-to-end with large-scale, outcome-based reinforcement learning, the model masters the synthesis abilities required by PaCoRe and scales to multi-million-token effective TTC without exceeding context limits. The approach yields strong improvements across diverse domains, and notably pushes reasoning beyond frontier systems in mathematics: an 8B model reaches 94.5% on HMMT 2025, surpassing GPT-5's 93.2% by scaling effective TTC to roughly two million tokens. We open-source model checkpoints, training data, and the full inference pipeline to accelerate follow-up work.

• The paper introduces a parallel coordinated reasoning framework that scales test-time compute by iteratively compacting and synthesizing parallel trajectories with reinforcement learning.
• It demonstrates significant performance gains, achieving 94.5% accuracy in mathematics and robust improvements in coding benchmarks using an 8B parameter model.
• The framework overcomes context window limits by enabling multi-million token reasoning through coordinated parallel exploration and efficient message compaction.

PaCoRe: A Scalable Parallel Coordinated Reasoning Framework for Test-Time Compute

Introduction and Motivation

The "PaCoRe: Learning to Scale Test-Time Compute with Parallel Coordinated Reasoning" (2601.05593) paper addresses a fundamental constraint in LLM reasoning: an LLM’s ability to perform extended, high-effort reasoning at inference is strictly bounded by the model's context window. Nearly all prior techniques for boosting test-time reasoning—especially those using search, chain-of-thought, and self-consistency—rapidly saturate context limits. This prevents exploiting vast computational resources available at inference for solving complex problems. The paper introduces the Parallel Coordinated Reasoning (PaCoRe) framework, which is designed to achieve arbitrarily large effective test-time compute (TTC) via scalable parallel reasoning coordinated through iterative message passing and compaction within the context window.

PaCoRe iteratively launches broad waves of parallel reasoning trajectories, summarizes their results into compact messages, and synthesizes these messages (with the question) to guide the next round. This is in contrast to prior paradigms, where reasoning is essentially a single, sequential chain directly limited by the context. Crucially, PaCoRe is trained end-to-end with outcome-based reinforcement learning (RL) to master the nontrivial reasoning synthesis competencies required to effectively aggregate and act on parallel evidence.

PaCoRe Inference and Training Pipeline

The core of PaCoRe is a generic pipeline that alternates between two phases across multiple rounds:

1. Synthesis and Parallel Exploration: For a problem $x$ and current message set $M_{r-1}$, the model generates $K_r$ parallel reasoning trajectories. These are produced independently, each representing an attempt to explore potential solution paths conditioned on both the input problem and summaries from the previous round.
2. Message Compaction: After each round, PaCoRe processes the set of complete trajectories $\Omega_r$ and extracts only the salient end-conclusions to form the next set of compact messages $M_r$. This transformation $\mathcal{C}(\Omega_r) \rightarrow M_r$ keeps the context use bounded; only a problem statement and a fixed-size set of conclusions are ever passed forward, regardless of the overall number or size of trajectories generated. This permits PaCoRe to scale the product $R \times K_r \times \text{length}(\omega_r^{(i)})$—i.e., the total test-time reasoning effort—to millions of tokens, far beyond what fits into the model's actual context window.

   Figure 1: PaCoRe's inference pipeline, with parallel trajectory generation, message compaction, and iterative synthesis enabling scaling of effective TTC.

The iterative process concludes with a final round producing a single output message representing the system’s final answer.

PaCoRe's effectiveness hinges on training the model to coordinate and synthesize. To elicit these high-level reasoning skills, the paper introduces a tailored RL setup: each coordinated reasoning step is instantiated as an RL episode, the message input set is drawn from a large, curated distribution, and the reward is sparse and outcome-based (verifiable correctness). The training curriculum is carefully designed to avoid degenerate instances where majority-voting heuristics suffice and instead focuses the model on cases where true synthesis is required.

Empirical Results and Quantitative Evaluation

The empirical analysis demonstrates that PaCoRe unlocks scalable test-time compute and delivers robust improvements over both its own ablated variants and leading open/proprietary LLM systems.

Figure 2: Left: On HMMT 2025, PaCoRe-8B test-time scaling leads to monotonic performance gains, ultimately surpassing GPT-5. Right: On LiveCodeBench, PaCoRe-8B scales gains with compute, while RLVR-8B plateaus.

Key numerical results include:

• Mathematics: PaCoRe-8B achieves 94.5% accuracy on HMMT 2025, exceeding GPT-5 (93.2%), with multi-million-token effective TTC—despite using only an 8B parameter model.
• Coding: On LiveCodeBench, with higher test-time compute, PaCoRe-8B yields up to 78.2% accuracy, closing the gap and/or outperforming larger open and proprietary models.
• Generalization: Strong transferability to domains such as software engineering (SWE-Verified) and natural conversations (MultiChallenge) is demonstrated, with PaCoRe-8B outperforming the RLVR-8B baseline by substantial margins.
• Scaling Effect: Systematic ablation and scaling studies show parallel coordinated reasoning (even at identical trajectory counts) is substantially more compute-efficient than sequential approaches or majority-voting-based self-consistency, with test-time scaling continuing to produce gains long after those alternatives saturate.

Figure 3: Training dynamics: Reward and response length rise due to stable RL optimization; evaluation accuracy on HMMT 2025 and LiveCodeBench improves in tandem.

Extensive ablations reveal:

• Disabling message passing capably re-demonstrates the context bottleneck; performance quickly collapses when message concatenation is used instead of compaction.
• When trained under broader message set sampling, PaCoRe models show more robust scaling and generalization at inference.

  Figure 4: (Left) Parallel scaling is more efficient than sequential scaling; (Right) Message passing is critical for bypassing context window limits and sustaining scaling.

Analysis of Synthesis and Emergent Reasoning Capabilities

A central finding is that appropriate RL-based training enables PaCoRe to manifest "reasoning synthesis": systematically using and reconciling diverse, possibly erroneous, parallel evidence rather than naively aggregating. Linguistic analysis shows increased emergence of cross-checking markers (e.g., “reference”, “ref <number>”, explicit citation) in model outputs, signifying explicit message synthesis.

Figure 5: Left: Frequency of cross-referencing language grows during training. Right: Model increasingly yields correct solutions even when all input messages are themselves incorrect.

Crucially, the model demonstrates a rising "Emergent Correctness Rate": its probability of reconstructing the correct answer from only incorrect inputs increases as RL training proceeds, showing it does not depend solely on input accuracy or majority heuristics but can extract and interpolate partial information to recover true solutions.

Practical and Theoretical Implications

PaCoRe constitutes a paradigm shift for LLM reasoning, enabling inference compute to scale arbitrarily with minimal changes to the underlying model architecture. Practically, this means that existing LLMs—if equipped with a PaCoRe-style coordinator and RL-trained synthesis skills—can continue improving with increased test-time compute, transcending context window limitations. This is particularly critical for domains like competition mathematics, logical reasoning, and program synthesis, where long chains of robust deliberation and cross-verification are essential.

Theoretically, PaCoRe provides a concrete instantiation of large-scale collective reasoning in a single-model pipeline, opening a path to investigate self-organization, cooperative strategies, and emergent multi-agent behaviors in transformer systems. It also paves the way for further research in the joint optimization of synthesis and compaction policies, and the study of systems where communication and coordination can themselves evolve.

Future Directions

Several research directions are proposed based on PaCoRe’s framework:

• Extreme Scaling: Applying PaCoRe to larger models and problems, extending to multi-modal reasoning, and agentic scenarios.
• Token Intelligence Density: Designing improved compaction and collaboration strategies to maximize the value per token computed, not just raw volume.
• Co-Evolution of Synthesis and Communication: Investigating the joint meta-learning of coordination, compaction, and reasoning—potentially informing multi-agent and collective intelligence research.
• Synthetic Data Generation: Leveraging the framework to automatically synthesize challenging curriculum data for robust pre- and post-training.

Conclusion

PaCoRe demonstrates that for LLM reasoning, coordinated parallel exploration with iterative message compaction and RL-based synthesis enables test-time compute scaling far beyond context window limits. This approach allows even relatively small models to match or surpass the best proprietary systems in highly challenging domains. PaCoRe offers a reproducible and extensible test-time scaling framework, effectively bridging a key gap between reasoning research and practical application of AI systems requiring deep, iterative exploration.