Technical Summary: Parallel-Synthesis for Direct Latent-Space Synthesis in LLM-Agent Workflows

1. Problem Formulation

Large Language Models (LLMs) serve as the execution engines for modern agentic systems, yet they operate through a sequential text interface. This creates a fundamental mismatch with structured agent workflows, particularly those organized as Directed Acyclic Graphs (DAGs) where independent sub-agents (workers) execute parallel branches—such as retrieving evidence, solving subtasks, or generating candidate solutions—before a downstream synthesizer merges their findings.

Current systems handle this "parallel-then-synthesize" pattern by concatenating the textual outputs of all worker branches into a single, expanded prompt for the synthesizer. This approach suffers from two primary limitations:

1. Loss of Structure: It flattens the rich dependency structure of the DAG into a linear sequence, discarding the independence of the branches.
2. Redundant Computation: The synthesizer must re-encode (prefill) the worker outputs as text, even though these tokens have already been processed and encoded into Key-Value (KV) caches during the workers' decoding phase. This incurs significant latency and computational overhead.

While summarization is a potential mitigation, it relies on natural language communication, which still requires re-encoding and risks discarding critical details. This paper investigates a more direct alternative: Can a synthesizer agent directly consume the latent KV states of parallel worker branches without converting them to text?

2. Methodology: Parallel-Synthesis

The authors introduce Parallel-Synthesis, a plug-and-play framework that enables a downstream synthesizer to directly reuse the KV caches produced by parallel worker agents. The framework consists of three core components designed to bridge the gap between disjoint parallel caches and the synthesizer's generation process:

2.1 Model Architecture

1. Positional Re-encoding:
   Worker outputs $z_j$ are originally generated relative to their specific branch context $c_j$, resulting in distinct RoPE (Rotary Positional Embedding) positions. To synthesize them jointly, the framework re-aligns the positional embeddings of all worker outputs to a shared post-branching position $n$. Specifically, the $r$-th token of a worker's output is re-encoded to position $n+r$ using the RoPE rotation operator, ensuring all branches appear as parallel continuations from a single branching point rather than a serialized sequence.

2. Cache Mapper:
   To calibrate the independently generated caches, a learnable Multi-Layer Perceptron (MLP) maps worker-specific metadata (output length and total number of workers) to affine coefficients. These coefficients apply element-wise transformations to the re-encoded keys and values ($\hat{K}, \hat{V}$), effectively adjusting the latent states to better approximate a sequential context before they are concatenated.

3. Synthesizer LoRA Adapter:
   A Low-Rank Adaptation (LoRA) module is trained on the synthesizer side to help the model interpret and reason over the non-sequential, multi-branch cache interface. This adapter is activated only during synthesis, leaving worker execution unchanged.

2.2 Training Strategy

The framework is trained using a two-track post-training approach, with checkpoints merged afterward to preserve complementary capabilities:

• Track 1: General Adaptation to Parallel Contexts:
  • Continued Pre-training: Uses large-scale multi-turn dialogue data (e.g., WildChat, UltraChat) where dialogue turns are encoded as parallel caches rather than a serialized history. This acts as an architectural warm-up.
  • Supervised Fine-Tuning (SFT): Uses tasks with naturally decomposable inputs (e.g., tool-use trajectories, few-shot exemplars, multi-document QA) to teach the model to actively synthesize information across parallel branches.
• Track 2: Distillation from Text-Based Synthesis:
  To capture complex reasoning behaviors, the authors distill trajectories from a standard text-serialization pipeline (using BrowseComp). High-quality synthesis traces, where the synthesizer reasons over and compares worker outputs, are converted into the cache-based format. This teaches the model to perform higher-level reasoning and judgment over parallel agent trajectories.

3. Key Contributions

• Direct Latent-Space Interface: Proposes a novel interface where synthesizers consume KV caches directly from parallel agents, bypassing the text serialization bottleneck.
• Calibration Mechanism: Introduces a cache mapper and positional re-encoding to align disjoint parallel caches into a coherent context for the synthesizer.
• Training Paradigm: Demonstrates that effective parallel synthesis requires specific post-training (both general adaptation and reasoning distillation) rather than just inference-time cache reuse.
• Plug-and-Play Design: The framework is designed as an adapter that can be integrated into existing agentic workflows without modifying the worker agents.

4. Experimental Results

The authors evaluated Parallel-Synthesis across nine downstream datasets spanning mathematical reasoning (AIME, GSM8K), scientific QA (GPQA, MedQA), code generation (HumanEval, MBPP), and multi-agent benchmarks (GAIA, MARBLE).

• Performance: Parallel-Synthesis matches or outperforms standard text-based synthesis on 7 out of 9 datasets. Notably, it achieves significant gains on reasoning-heavy tasks (e.g., AIME 2025, GPQA, MARBLE), suggesting that direct latent-state synthesis preserves richer reasoning traces than text. It performs comparably on evidence-centric tasks (e.g., GAIA, MBPP).
• Efficiency: By avoiding the re-prefill of worker outputs, Parallel-Synthesis reduces Time-to-First-Token (TTFT) by 2.5× to 11× compared to text-based synthesis.
• Reasoning Capability: The method outperforms simple majority voting baselines on most datasets, indicating it leverages intermediate reasoning steps and evidence quality rather than just aggregating final answers.
• Ablation Studies:
  • Merging Track 1 and Track 2 checkpoints yields better results than sequential tuning, preventing catastrophic forgetting.
  • Both the Cache Mapper and the Synthesizer LoRA are necessary; removing either degrades performance.
  • Providing full trajectory information (including tool observations) yields the highest accuracy but at a latency cost; final outputs offer the best trade-off.

5. Significance and Claims

The paper claims that Parallel-Synthesis demonstrates that direct cache-based synthesis is a promising interface for more native and efficient agent workflows. The results suggest that:

1. Latent states are superior for reasoning: For tasks requiring deep integration of parallel reasoning traces, direct cache consumption can be competitive with or superior to text-based synthesis.
2. Efficiency is inherent: The method fundamentally reduces redundant computation by eliminating the need to re-encode processed information.
3. Training is essential: Unlike RAG-style cache reuse methods which often rely on inference-time calibration, robust parallel agent synthesis requires explicit post-training to learn how to interpret and aggregate heterogeneous branch states.

The authors conclude that while the framework is not yet a universal replacement for text communication in all complex workflows, it provides strong evidence that DAG-structured workflows can be executed and merged more natively, avoiding the overhead of text serialization. Future work would require scaling post-training to broader collections of agent workflow data to cover more diverse tool-use patterns and branching structures.