LongCat-Flash-Thinking-2601 Technical Report

ArXiv: 2601.16725

🎯 Pitch

LongCat-Flash-Thinking-2601 achieves a perfect 100% on AIME 2025 by scaling reasoning in two dimensions at once—depth and width—via a 'Heavy Thinking' mode where the model explores parallel trajectories and then synthesizes a reflective summary, decisively outperforming standard self-consistency methods. Critically, this reasoning power is made robust for noisy, real-world agentic tasks by systematically injecting instruction ambiguity and tool failures into a curriculum-based RL pipeline across 10,000+ environments.

---

1. Executive Summary

This technical report introduces LongCat-Flash-Thinking-2601, a 560B-parameter Mixture-of-Experts reasoning model achieving state-of-the-art open-source performance on agentic benchmarks by unifying environment scaling, multi-domain reinforcement learning, and a Heavy Thinking Mode for test-time compute scaling. The model is evaluated across mathematical reasoning (AIME-25, HMMT-25), agentic search (BrowseComp, RWSearch), and agentic tool-use benchmarks (τ²-Bench, VitaBench), where it attains 73.1% on BrowseComp, 88.2% on τ²-Bench, and 29.3% on VitaBench. The report's core contributions include an automated pipeline for constructing executable, verifiable environments across 20+ domains with controlled graph expansion to preserve supervision reliability, a robust agentic training strategy that systematically injects multi-type environmental noise (instruction ambiguity, tool failures) through curriculum-based reinforcement learning, and test-time Heavy Thinking that jointly scales reasoning depth and width via parallel trajectory exploration followed by a summary model's reflective synthesis. The Heavy Thinking mode enables the model to reach a perfect score on AIME-2025 (100.0%) and 86.8% on IMO-AnswerBench, establishing that expanding both reasoning dimensions at test time outperforms self-consistency baselines, with gains compounding as the computational budget grows.

2. Context and Motivation

The Core Problem: Reasoning Models Don't Know How to Use the World

The paper addresses a fundamental limitation in the current generation of large reasoning models. Recent advances have produced models that can solve olympiad-level math problems and write complex code — feats of internal reasoning. But the paper identifies a critical gap: these models cannot effectively translate their reasoning capability into solving complex, real-world tasks that require interacting with external environments. The authors frame this gap explicitly in the introduction:

"The natural next question then arises: how can such complex problem-solving capabilities be applied to solve complex real-life tasks, and how can complex problem-solving capabilities be extended beyond this point? As intrinsic reasoning ability approaches its limits, we identify that interaction with external environments emerges as a key mechanism for further progress."

This is not merely an incremental improvement problem. It represents a fundamental shift in what reasoning means. Traditional reasoning — the kind tested on MATH or AIME — operates entirely inside the model's internal linguistic space. The model produces a chain of thought, reaches a conclusion, and outputs an answer. There is no external feedback, no tool that might return unexpected results, no database that needs to be queried in a specific sequence, and no user who might ask clarifying questions mid-task. Agentic reasoning, in contrast, requires the model to determine when to interact with the environment, how to interpret environmental feedback (which may be noisy or incomplete), and how to adapt its reasoning based on that feedback. The paper argues this is the natural next frontier after pure reasoning capability has been largely solved by models like DeepSeek-R1 and OpenAI's o1.

Why This Problem Matters: The Gap Between Benchmarks and Reality

The problem has both practical and theoretical significance:

Real-world deployment requires tool interaction. Most valuable applications of language models involve interacting with external systems — searching the web, querying databases, calling APIs, editing code in a sandbox, or booking flights through a reservation system. A model that can solve AIME problems but cannot reliably navigate a complex tool environment is like a brilliant mathematician who has never used a computer: the raw intelligence exists, but it cannot be productively applied to most real tasks. The paper makes this explicit by evaluating on benchmarks that measure exactly this capability: BrowseComp (complex web search requiring multi-hop reasoning), τ²-Bench (conversational agents interacting with business tools), and VitaBench (general interactive tasks across diverse real-world applications).

The scaling path forward depends on environment interaction. The paper argues, controversially but plausibly, that "intrinsic reasoning ability approaches its limits." If this is true, then the primary mechanism for further improvement is not larger models or more pretraining data — it's better interaction with external environments. This is a significant strategic claim about the future of AI development. If correct, it means the field's emphasis should shift from scaling pretraining toward building richer training environments and more robust agentic training pipelines.

Robustness to real-world noise is underexplored. The paper identifies a subtle but critical failure mode: models trained in clean, idealized environments catastrophically degrade when deployed in the messy real world. A user might phrase a query ambiguously. A database might return partial results due to a timeout. A tool might fail silently. The gap between training conditions and deployment conditions creates a brittle system that works on benchmarks but fails in practice. The paper reports concrete evidence: on the noise-augmented version of VitaBench, a cold-start model drops from 10.0 to 6.3 Avg@4; on the noise-augmented τ²-Bench, the drop is from 78.8 to 58.8 (Table 1). This quantification of the robustness gap — and the systematic approach to closing it — addresses a problem that has received relatively little attention in the reasoning literature.

Prior Approaches and Their Limitations

The paper positions itself against several strands of prior work, each of which has specific shortcomings:

1. Pure Reasoning Models (DeepSeek-R1, OpenAI o1, Gemini 2.5 Pro)

The current generation of frontier reasoning models has demonstrated remarkable performance on mathematics and coding benchmarks. DeepSeek-R1, OpenAI o1, and Gemini 2.5 Pro all use extended chain-of-thought reasoning with reinforcement learning to achieve near-perfect scores on competition math. However, these models are fundamentally environment-free — they reason internally but do not interact with external tools or databases. The paper acknowledges this achievement but argues it represents only one dimension of capability:

"Beyond internal deliberation, advanced agentic reasoning capability requires models to determine when and how to interact with the environment, and to effectively integrate environmental feedback to sustain and advance the reasoning process."

The limitation is not that these models cannot use tools — many of them can through prompting. Rather, the limitation is that their training pipelines are not designed to produce generalizable, robust agentic behaviors. The models may know how to call a function in principle, but they have not been trained to handle long-horizon multi-turn interactions, noisy tool responses, or the strategic decision of whether to invoke a tool versus continue reasoning internally.

2. Agentic Coding Models (SWE-bench Approaches)

Several models have been developed specifically for software engineering tasks, achieving strong performance on SWE-bench Verified. These models do interact with tools — code editors, terminals, version control systems — but their agentic capability is domain-specific. The environment they interact with (a code sandbox) is relatively homogeneous: it always involves file editing, command execution, and test running. The interaction patterns are predictable, and the correctness criteria are well-defined (tests pass or fail). The paper argues that general agentic reasoning requires handling heterogeneous environments across many domains — an airline reservation system has fundamentally different tools, interaction patterns, and success criteria than a code sandbox. Extending agentic coding approaches to general tool use introduces new challenges that the coding-focused pipelines do not address.

3. Early Agentic Models (Kimi-K2, DeepSeek-V3.2, Qwen3-Thinking)

Several open-weight models have begun incorporating agentic capabilities, achieving non-trivial performance on benchmarks like τ²-Bench and BrowseComp. Kimi-K2-Thinking, for example, reports 74.3% on τ²-Bench (Table 2). DeepSeek-V3.2-Thinking reports 67.6% on BrowseComp with context management and 80.6% on τ²-Bench. These models demonstrate the feasibility of open-weight agentic reasoning, but the paper identifies specific capabilities where they fall short:

• Generalization across environments: The paper introduces Random Complex Tasks — an evaluation protocol that randomly generates new agentic tasks spanning diverse domains that were not seen during training. On this benchmark, existing models achieve 25.3–32.6% (Table 2), while LongCat-Flash-Thinking-2601 achieves 35.8%. The 3–10 percentage point gap suggests that prior models have acquired domain-specific agentic patterns rather than generalizable agentic reasoning skills.
• Robustness to noise: On the noise-augmented versions of τ²-Bench and VitaBench (Table 2 and Table 1), existing models show steeper performance drops than the proposed model. For example, on τ²-Bench-Noise, DeepSeek-V3.2 drops from 80.6 to 64.1 (a 16.5-point gap) while LongCat-Flash-Thinking-2601 drops from 88.2 to 67.1 (a 21.1-point gap, though from a higher baseline, the final noisy score is higher). On VitaBench-Noise, existing models achieve 6.5–14.0% while the proposed model achieves 20.5%. This suggests that systematic noise-aware training produces more resilient agents.
• Suboptimal test-time scaling: Prior models with heavy thinking modes (e.g., Kimi-K2, PaCoRe) have explored test-time scaling but have not disclosed their implementation details, "limiting their reproducibility and systematic study" (Section 4). The paper positions its Heavy Thinking Mode as both an advance in capability and a contribution to transparency.

4. Infrastructure for Agentic Training

Prior work on reinforcement learning infrastructure (AReaL, AgentRL, roll-flash) has made progress on asynchronous training for agentic scenarios, but the paper identifies specific scalability bottlenecks that remain:

• Long-tailed, latency-skewed environment interactions cause device underutilization in batch-synchronous settings. When some environments take minutes to respond while others finish in seconds, the entire batch waits for the slowest interaction.
• Large numbers of heterogeneous environments (the paper uses up to 32,000 environments across 400+ physical machines) create scheduling challenges that existing frameworks do not handle well at this scale.
• Memory-constrained accelerators (~60GB device memory in the paper's production cluster) make it difficult to fit large MoE models and their KV-caches, especially during multi-turn rollouts where context length grows unpredictably.

The paper's DORA system extension addresses these limitations through fully streaming asynchronous pipelines, PD disaggregation with CPU KV-cache swapping, and a light-weight distributed rollout management architecture.

How the Paper Positions Itself

The paper does not claim to invent any single component — reasoning models, RL for language, MoE architectures, test-time scaling, and agentic frameworks all existed before. Instead, it positions itself as the first end-to-end integration of these components, with three specific advances that address the limitations above:

1. Environment scaling as the foundation for generalization. Rather than relying on a handful of carefully curated benchmark environments, the paper constructs tens of thousands of environments across 20+ domains through an automated pipeline. The key insight is that transferable agentic behavior emerges from diversity of training environments, not from clever architecture or RL algorithm design. This is analogous to how diverse pretraining data produces general language understanding — diverse interaction environments produce general agentic reasoning. Previous work either used small sets of hand-crafted environments (limiting generalization) or did not disclose their environment construction methodology (limiting reproducibility). The paper makes environment construction a first-class contribution with a detailed methodology.

2. Noise-awareness as a training paradigm. The paper makes a strong claim in Section 3.3.3: "Existing agentic models suffer from significant performance degradation when deployed in previously unseen or imperfect environments. This issue largely stems from a common assumption in current agentic training paradigms: agents are typically trained with carefully curated instructions and interact with stable, well-controlled environments." The paper rejects this assumption and instead treats environmental imperfection as a feature to be incorporated into training, not a nuisance to be cleaned away. The curriculum-based noise injection strategy described in Section 3.3.3 is positioned as a systematic solution to the robustness gap that prior work largely ignored.

3. Heavy Thinking as a general test-time scaling framework. While several frontier models have introduced heavy thinking modes (Gemma 3, GPT-5, Kimi-K2, PaCoRe), the implementations are proprietary and the design principles are opaque. The paper positions its Heavy Thinking Mode (Section 4) as a simple, disclosed, and effective framework: parallel reasoning to expand width, summary model for reflective synthesis, and context memory for multi-turn support. The contribution is not the concept of heavy thinking itself but rather the transparent description and the demonstration that it works across reasoning modalities (math, search, tool use), not just pure text-based reasoning.

The paper's overarching thesis is that the next frontier for reasoning models is not more internal computation but more effective interaction with the external world, and that achieving this requires a holistic rethinking of the entire training pipeline — from environment construction through RL infrastructure through test-time deployment — rather than any single algorithmic improvement.

3. Technical Approach

3.1 Reader Orientation

This paper describes a production-scale training pipeline for producing an open-weight Mixture-of-Experts language model—LongCat-Flash-Thinking-2601—that can solve complex real-world tasks by interacting with external tools and environments, not just by reasoning internally. The system solves the problem of teaching a language model to be an effective agent in environments it has never seen before, to handle tools that might fail or return noise, and to scale its own thinking at test time. The "shape" of the solution is a three-stage pipeline: first, a mid-training stage that introduces the model to structured agentic interaction patterns; second, a large-scale reinforcement learning stage that trains the model across tens of thousands of automatically constructed environments; and third, a test-time inference mode called Heavy Thinking that decomposes hard problems into parallel exploration followed by reflective synthesis.

3.2 Big-Picture Architecture (Diagram in Words)

The system consists of five major components that operate sequentially but with feedback loops:

1. Pre-trained Base Model (LongCat-Flash-Chat) — a 560B-parameter MoE model with 27B activated parameters per token, inherited from prior work. Serves as the foundation with general language and reasoning capabilities.

2. Mid-Training Data Pipeline — a hybrid data synthesis framework that constructs structured agentic trajectories from two complementary sources: text-driven synthesis (mining latent procedural knowledge from corpora) and environment-grounded synthesis (generating executable tool-use sequences from verified dependency graphs). Outputs training data that primes the model for agentic behaviors before expensive RL begins.

3. Environment Scaling Pipeline — an automated system that converts high-level domain specifications into executable tool environments. Takes domain definitions as input, synthesizes tools and databases, constructs dependency graphs, and expands environments through controlled graph growth. Produces tens of thousands of training environments across 20+ domains, each with guaranteed executability and verifiable correctness.

4. DORA Asynchronous RL Framework — the reinforcement learning infrastructure. Coordinates three types of distributed components: RolloutManager (manages generation of trajectories across environments), SampleQueue (controls staleness of training samples), and Trainer (performs policy optimization). Supports up to 32,000 concurrent environments, PD-disaggregated generation, and fully streaming asynchronous execution.

5. Heavy Thinking Inference Mode — a test-time scaling strategy that operates in two stages: (1) parallel generation of multiple reasoning trajectories to expand search width, and (2) a summary model that reflectively reasons over all trajectories to synthesize a final answer. Includes a context memory module for multi-turn tool interactions.

Information flows as follows: pre-trained model → mid-training on agentic trajectories → cold-start fine-tuning on curated domain-specific data → multi-domain RL training through DORA (with environment scaling providing the training tasks and noise injection providing robustness) → final model that supports Heavy Thinking at inference time → optional continued RL for the summary module.

3.3 Roadmap for the Deep Dive

• First, the mid-training stage (Section 2 of the paper), which bridges the gap from pure language modeling to agentic interaction patterns through hybrid data synthesis and planning-oriented augmentation. This sets up the model's initial agentic capabilities before RL.
• Second, the RL preparation phase (Section 3.1), which covers environment construction (the automated pipeline that produces training tasks), cold-start policy initialization (how the model is primed for specific agentic domains), and RL task set construction (how training tasks are curated and synthesized). This establishes the "what" and "where" of agentic training.
• Third, the DORA asynchronous RL framework (Section 3.2), which provides the "how" — the distributed infrastructure that makes training at this scale feasible. Includes streaming asynchrony, lightweight rollout management, and PD disaggregation with CPU KV-cache swapping.
• Fourth, the RL training strategy (Section 3.3), which covers the general strategy (curriculum learning, dynamic budget allocation, self-verification), agentic-specific context management, and multi-domain environment training with robust noise injection. This is the algorithmic core that determines what the model learns.
• Fifth, the Heavy Thinking Mode (Section 4), which is the test-time inference strategy for scaling reasoning through parallel exploration and summary synthesis. This is the deployment counterpart to the training pipeline.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily a systems and engineering paper whose core idea is that general-purpose agentic reasoning capability does not emerge from any single algorithmic innovation but from the end-to-end co-design of data construction, environment design, training infrastructure, and inference strategies. The paper's central claim is that this holistic integration achieves state-of-the-art open-source agentic performance by systematically addressing each bottleneck in the pipeline.

---

Mid-Training: Bridging Language Models to Agentic Interaction

The paper identifies a fundamental mismatch between standard language model pretraining and the demands of agentic reasoning. Standard pretraining data consists primarily of natural language text—articles, books, code, conversations—where information flows in linear sequences. Agentic reasoning, in contrast, involves multi-turn trajectories where the model interleaves internal reasoning with explicit tool invocations, receives environmental feedback, and adjusts its behavior accordingly. This interaction pattern is "extremely scarce in real-world corpora" (Section 2), meaning that a raw pretrained model has essentially never seen anything like it. The result is inefficient exploration during reinforcement learning: the model must simultaneously learn what the reward signal means and how to even engage in agentic behaviors.

The mid-training stage addresses this by exposing the model to moderate-scale synthesized structured agentic trajectories before RL begins. This provides a strong initialization—the model learns the basic format and dynamics of tool interaction in a supervised setting, so that RL can focus on optimizing the quality of interactions rather than discovering the interaction format from scratch.

Context Length Staging. Because agentic trajectories can be extremely long (multi-turn interactions with tool outputs, each potentially containing thousands of tokens), the model must be trained to handle extended context windows. The paper adopts a staged procedure: 500B tokens at 32K context length, followed by 500B tokens at 128K, then an additional 40B tokens at 256K. This progressive extension allows the model to adapt its positional encodings and attention patterns gradually rather than being abruptly exposed to extremely long sequences.

Hybrid Data Synthesis Framework. The core challenge is that "large-scale, high-quality agentic data—especially long-horizon trajectories involving reasoning, planning, and interaction—is extremely scarce" (Section 2). Real-world sources of such data (e.g., user interactions with assistants, software development logs) are either unavailable, proprietary, or too noisy to use directly. The paper constructs a synthesis framework that draws from two complementary sources:

Text-driven synthesis works backward from unstructured text to structured trajectories:

1. Text Filtering and Tool Extraction: The system identifies text segments (tutorials, instructions, multi-step workflow descriptions) that exhibit rich procedural structure. From these segments, it defines potential tool functions and extracts corresponding function-call lists, converting implicit procedures into explicit tool schemas. For example, a tutorial describing how to set up a web server might be decomposed into a sequence of structured tool calls (download package, configure file, start service).

2. Synthesis and Refinement: The extracted procedures are translated into concrete multi-turn user-agent interaction trajectories. The user receives a task description, the agent produces reasoning and tool calls, the environment returns results. To ensure diversity, the paper applies "extensive agentic pattern diversity enhancement and rigorous quality filtering" (Section 2), covering a diverse array of interaction scenarios and task domains.

3. Tool Decomposition Augmentation: Starting from simple tool invocation trajectories, parts of the tool parameters are progressively hidden into the environment state. The model must then produce additional interactions to extract these parameters. For instance, if a tool call originally contained send_email(recipient="john@example.com", subject="Meeting"), the decomposition might remove the recipient from the call and require the agent to first query a contacts database to retrieve it. This transformation converts simple linear trajectories into more complex multi-step interactions.

4. Reasoning Decomposition Augmentation: At each action step in the model's output, multiple alternative action candidates are generated. The original action is replaced with these alternatives, and the model's reasoning step is modified to include a comparison and selection among them. This transforms a linear trajectory into a decision-making process where the agent must explicitly reason about which action to take among several plausible options.

Environment-grounded synthesis works forward from executable tools to guaranteed-correct trajectories:

1. Environment Construction and Dependency Modeling: For existing tool definitions, the paper implements lightweight, verifiable Python environments. A directed dependency graph is constructed where nodes represent tools and edges represent parameter dependencies (e.g., searchFlights depends on getAirports to provide airport codes). This graph structure allows systematic sampling of tool invocation chains with varying complexity and depth.

2. Reverse-Synthesis and Execution Verification: Valid tool execution paths are sampled from the dependency graph, and a reverse-engineering approach synthesizes user prompts that align with the chosen tool chain. Critically, each trajectory's correctness is validated by executing the code and verifying the final state of the environment database. This ensures the synthesized data is "grounded in actual execution logic" (Section 2), not just plausible-looking text.

Planning-Oriented Data Augmentation. The paper identifies planning as a "core component of agentic reasoning that is difficult to acquire from existing data" (Section 2). Planning governs how the model decomposes complex goals, explores alternatives, and commits to intermediate decisions—behaviors that are poorly represented in standard data. Two augmentation strategies are introduced:

1. Problem decomposition trajectories: Data is synthesized to show effective decomposition of complex goals into sub-goals, paired with correct initial action selections. This provides supervision for coarse-to-fine planning and early-stage decision making.

2. Multi-step decision-making enrichment: Starting from complete interaction trajectories, multiple alternative candidates are generated at each decision step. The model is then trained to reason over and select among these candidates, transforming originally linear trajectories into structured decision-making processes that demonstrate exploration and comparison.

Figure 2 shows the effect: compared to the old mid-training recipe (baseline), the enhanced recipe with planning-oriented augmentation produces higher pass@k on τ²-Bench across all k values, demonstrating that the model's agentic capability boundary has been expanded.

---

Environment Construction: The Automated Scaling Pipeline

The paper makes a strong architectural claim: transferable agentic reasoning capability emerges from exposure to diverse tool sets and interaction patterns, not from clever algorithm design or larger models. This claim has a concrete engineering implication: the training pipeline must be able to produce a very large number of distinct, executable, and verifiable environments across many domains, without prohibitive human effort. Section 3.1.1 describes the automated pipeline that achieves this.

Domain Graph Construction. The pipeline starts from a high-level domain specification—essentially a description of what kind of environment this is (e.g., "airline reservation system" or "project management platform"). From this specification, the pipeline automatically synthesizes:

1. A domain-specific tool set: the set of functions an agent can call in this domain (e.g., search flights, book ticket, cancel reservation, check baggage policy).

2. Unified database schemas: structured representations of the state that the tools operate on (e.g., a flights table, a bookings table, a passengers table).

3. Explicit tool-database mappings: for each tool, a clear specification of which database tables it reads from and writes to.

The generated code is validated through unit testing and an auxiliary debugging agent that tries to identify and fix execution errors. The paper reports that in practice, this pipeline achieves "a success rate exceeding 95% in transforming schema-level designs into fully executable tool implementations" (Section 3.1.1).

Domain Scale and Complexity. The pipeline constructs tool graphs across "over 20 domains." Each tool graph contains "more than 60 tools organized in a dense dependency graph" (Section 3.1.1), paired with a corresponding executable database schema. The density of the dependency graph provides structural complexity: when tools depend on each other's outputs, the agent must plan invocation sequences that respect these constraints. A simple linear chain of independent tools is easy to navigate; a dense graph with many interdependencies requires sophisticated planning.

Verifiability-Preserving Environment Expansion. This is the most technically subtle part of the pipeline, and it solves a critical problem. Given a domain graph, the natural way to construct a training environment is to:

1. Sample a "seed" tool chain—a sequence of tool calls that forms a valid solution to some task.
2. Instantiate the database states along this chain to ensure all tool dependencies are satisfied.
3. Generate a task description grounded in this tool chain.

The sampled tool chain serves as a guaranteed-correct solution path (the "golden" path), which provides the ground-truth reward signal during RL training.

However, this produces environments of limited complexity—they contain only the tools needed for the designated solution path. A more realistic environment would contain additional tools that are available but not needed for the task, creating distraction and requiring the agent to distinguish relevant from irrelevant tools. This is the expansion problem: how to add more tools to the environment while ensuring that (a) the golden path remains executable, and (b) new tools don't introduce database inconsistencies that would cause correct solutions to appear incorrect.

The paper's solution is controlled graph expansion:

• Starting from the seed tool chain $s_1$, the pipeline performs a BFS-style expansion on the tool graph.
• A new tool node is added only if all of its dependencies are already satisfied by tools that have been instantiated and whose database states have been fully constructed.
• This constraint ensures that adding the new tool does not trigger a cascade of unmet dependencies that would require extensive database augmentation.

The paper formalizes this process: given an initial seed chain $s_1$ sampled from the domain graph $G$, the pipeline constructs an expanded subgraph $\mathcal{R}(s_1)$ by adding dependent tools through the BFS expansion. The resulting environment $\mathcal{E}_1 = \mathcal{R}(s_1)$ contains the golden path plus additional tools with guaranteed database consistency.

Multi-Chain Environment Construction. To further increase complexity, the pipeline can incorporate additional seed chains. Given the current environment:

$\mathcal{E}_n = \bigcup_{i=1}^{n} \mathcal{R}(s_i)$

the remaining unused tool nodes are $\mathcal{D}_n = G \setminus \mathcal{E}_n$. A new seed chain $s_{n+1}$ is sampled from $\mathcal{D}_n$ with probability:

$p = f\big(c(\mathcal{E}_n), g(\mathcal{D}_n), |\mathcal{D}_n|\big)$

where:

• $c(\mathcal{E}_n)$ is the structural complexity of the current environment,
• $g(\mathcal{D}_n)$ is measured by "the number of attempts required by a strong solver to discover an alternative valid tool chain from $\mathcal{D}_n$",
• $|\mathcal{D}_n|$ is the number of remaining unused tool nodes,
• $f(\cdot)$ is a monotonic decision function controlling the environment growth process.

What this computes: For a given partially constructed environment, the pipeline decides whether to add another independent tool chain based on three factors: how complex the current environment already is (don't add too much), how hard it is to find new valid tool chains in the remaining graph (don't try if it's impossible or too expensive), and how many unused tools remain (don't keep going if resources are exhausted). The decision is probabilistic, controlled by a threshold $\tau$ where $p > \tau$ triggers the addition of a new seed chain and its expansion.

Why this form: A deterministic rule (e.g., "always add a new chain if $|\mathcal{D}_n| > 20$") would produce environments lacking diversity in their structural complexity. The probabilistic decision, parameterized by the monotonic function $f$, allows controlled variation: some environments will have one seed chain, others will have two or three, producing a distribution of complexities that prevents the agent from overfitting to a single environment structure.

Fallback Mechanism. The paper introduces a minimum complexity guarantee: "if the resulting expansion $\mathcal{E}_n$ contains only a small number of tool nodes, we randomly sample an additional moderate-size tool chain from $G$ and incorporate it into the environment, while ensuring the database consistency with current tool chains." This ensures each constructed environment contains "at least 20 tools, providing sufficient structural complexity for meaningful agentic interaction and exploration."

Difficulty Sources. The paper distinguishes two complementary sources of task difficulty:

1. Interaction complexity: Ensured by synthesizing diverse user prompts that "require varying degrees of clarification, planning, and multi-step interaction." Some users ask straightforward questions requiring one tool call; others ask ambiguous questions requiring the agent to seek clarification; others request complex multi-step workflows.

2. Environment complexity: Quantified using structural properties of the tool graph, including "the number of involved tool nodes and the connectivity density among them." More tools and denser dependencies create more opportunities for the agent to make poor tool selection or sequencing decisions.

Task Generation. Each generated task consists of three components:

1. Task description: What the user wants to accomplish (e.g., "Book a round-trip flight from Boston to San Francisco for next Tuesday, returning Friday, with a vegetarian meal preference").

2. User profile: Background information that constrains the solution (e.g., the user's frequent flyer number, seat preferences, budget constraints).

3. Evaluation rubrics: Validated through "multiple rounds of consistency checking, guaranteeing that any executable tool chain can be accepted as a correct solution and that incorrect or incomplete trajectories are consistently rejected." This is the critical component for RL: it ensures that the reward signal is reliable and that the correct solution path (the golden chain) is recognized as such, while incorrect paths are flagged.

An important design choice: "the task generator was restricted to utilizing the full tool chain exclusively, without any deliberate task design." This constraint mitigates human prior bias—the generator cannot inadvertently design tasks that favor certain interaction patterns over others, because it must use exactly the sampled tool chain as the solution basis.

---

Cold-Start Policy Initialization

Before large-scale RL begins, the model needs a cold-start policy—an initial version that exhibits basic task-relevant behaviors. Without this, RL exploration would be wildly inefficient: the model would spend most of its budget generating random or malformed outputs that provide no useful learning signal.

The paper's cold-start goal is explicitly not benchmark performance: "instead of prioritizing immediate gains on standard benchmarks, our primary goal is to prime the model for effective large-scale exploration" (Section 3.1.2). The evaluation criteria are (1) proficiency on the specific tasks designated for the RL stage, and (2) diversity of reasoning paths, assessed through qualitative human inspection.

General Thinking Data Selection. For general reasoning capability, the paper constructs a high-quality data subset using a sliding-window perplexity K-Center-Greedy (KCG) selection algorithm. Standard perplexity-based filtering has a known weakness: by averaging perplexity over entire sequences, it "masks localized hard tokens and discards informative samples" (Section 3.1.2). A sequence might have low average perplexity because most tokens are easy, but contain a critical reasoning step that the model handles poorly. Average-perplexity filtering discards such sequences.

The paper introduces sliding-window perplexity: compute the average perplexity over all 512-token windows in a sequence, and take the maximum as the sequence's representative score. This captures "peak model uncertainty without dilution from global averaging." A sequence with even one difficult window gets a high score.

During KCG selection, the distance between a candidate sample and the currently selected set is weighted by this sliding-window perplexity score. KCG preserves coverage over the original data distribution (diverse examples get selected), while the perplexity weighting emphasizes samples that expose gaps in the model's current reasoning capability.

The pipeline downsamples to 210K general thinking samples from a large-scale corpus. The paper reports that models trained on this subset "outperform those trained on the full corpus on multiple reasoning benchmarks"—a counterintuitive result demonstrating that aggressive quality filtering can improve over quantity.

Agentic Coding Data Curation. For agentic coding, raw trajectories from software development platforms are abundant but noisy. The paper's curation pipeline enforces:

1. Full executability and verifiability: All retained trajectories must be "fully executable and verifiable within reproducible environments."
2. Correct resolution with functionality preservation: Trajectories must correctly resolve the target issue while preserving existing functionality (i.e., not breaking other parts of the codebase).
3. Fine-grained action-level filtering: Erroneous, redundant, or speculative operations that do not contribute to correct problem solving are removed.
4. Long-horizon preservation: Trajectories involving long and iterative debugging are retained by compressing earlier steps, "allowing long-horizon code reasoning to be maintained without length constraints."

Agentic Search Data Synthesis. For search capability, high-quality real-world trajectories are largely unavailable. The paper synthesizes trajectories with three explicit requirements:

1. Correctness: The trajectory must arrive at the correct answer.
2. Reasoning completeness: The trajectory must explicitly verify all conditions specified in the query. This prevents "shortcut learning such as lucky guesses based on partial evidence."
3. Consistent reasoning and tool-use format: The trajectory maintains a structured format amenable to supervised training.

Long-horizon search trajectories are preserved through step compression, and behavioral diversity is increased by reusing rollout trajectories from subsequent RL stages (creating a feedback loop where better RL policies generate better cold-start data).

Agentic Tool-Use Data Synthesis. For general tool use across diverse environments, the data synthesis pipeline builds on top of the environment scaling pipeline. It models "realistic tool-use environments covering 33 representative domains" by jointly defining domains, tool schemas, database states, and task objectives, and generating multi-step tasks grounded in structured tool dependencies.

Diversity is explicitly promoted along three axes:

• Domain coverage: Tasks are generated across all 33 domains.
• Trajectory structure: Each task admits multiple distinct correct tool-call trajectories.
• Interaction length: Horizons range from short dialogues to long, multi-turn executions.

Quality control uses rubric-based outcome validation and turn-level quality control. Only trajectories that correctly reach the target final state are retained. Within retained trajectories, turn-level loss masking excludes low-quality turns (failed tool calls, format violations) from loss computation, "ensuring the model learns only from correct actions while preserving the full interaction context."

---

RL Task Set Construction

The task set determines what the agent is trained to do, complementing the environments that determine what the agent can do. The paper identifies that task availability varies dramatically across domains: coding has abundant high-quality tasks, but search and tool use require custom synthesis.

Graph-based QA Synthesis for Search. The paper models multi-hop reasoning difficulty through relational entity graphs constructed from Wikipedia. The pipeline:

1. Seed extraction: Extracts low-frequency entities from Wikipedia as initial seed nodes. Low-frequency entities are chosen because high-frequency entities (e.g., "United States") would produce trivial tasks with easily memorized answers.

2. Graph expansion: Iteratively expands the graph by sampling from the existing entity set, retrieving their Wikipedia pages, and incorporating related entities along with their corresponding relations. Expansion continues until reaching a predefined size threshold.

3. Subgraph sampling: Samples multiple fixed-size connected subgraphs from the constructed graph. Each subgraph defines a reasoning problem: to answer a question, the agent must traverse the relationships in the subgraph.

4. Question generation: Uses large language models to create questions corresponding to the subgraph information, then "deliberately obfuscates explicit details such as numerical values, entity names, geographical locations, and temporal markers to maximize reasoning complexity." For example, "What year did Person A die?" becomes "In what year did the founder of Organization B's predecessor pass away?"—requiring multi-hop traversal from Organization B → its predecessor → its founder → their death year.

5. Quality assurance: Employs LLM-as-a-judge at critical steps (entity relation extraction, question generation, obfuscation) to maintain baseline accuracy.

6. Answer uniqueness verification: For each generated question-answer pair, an agent-based methodology identifies other potential correct answers and assesses their validity. Only pairs where the original answer is correct and all other identified potential answers are incorrect are retained, ensuring unambiguous ground truth.

Agent-based QA Synthesis. For ambiguity-driven difficulty, the paper presents a multi-agent pipeline orchestrated by a Finite State Machine (FSM):

1. Entity Extraction Agent identifies representative long-tail entities and extracts their salient attributes as ground truth.

2. Question Synthesis Agent randomly samples attributes to formulate tailored questions. A question about multiple attributes (e.g., "Which person born in City X, graduated from University Y, and won Award Z?") creates ambiguity because multiple entities might partially match.

3. Verification Agent uses search and browse tools to validate that the ground truth satisfies all constraints, mitigating entity-question mismatches.

4. Answer Generation Agent produces candidate answers using search tools.

5. Judgment Agent evaluates alignment between candidates and ground truth. When a non-ground-truth answer satisfies verification criteria, it signals a multi-answer conflict. The system resolves this by "randomly incorporating additional attributes of the ground truth entity and triggering a re-synthesis of the question to ensure its uniqueness."

The pipeline also enables "automated difficulty grading based on the accuracy metrics of the Answer Generation Agent"—questions that the answer generation agent struggles with are classified as harder.

---

The DORA Asynchronous RL Framework

The core technical challenge in agentic RL training is that multi-turn interactions with variable environments break the assumptions of synchronous training systems. In a standard synchronous system, all workers generate a batch of trajectories, all trajectories are complete before training begins, and training proceeds in lockstep. In an agentic setting, this breaks in two ways:

1. Tail latency: Trajectories vary wildly in length and complexity. Some agents solve a task in 3 turns with short tool outputs; others take 30 turns with long search results. A synchronous system must wait for the slowest trajectory, leaving accelerators idle.

2. Environment unpredictability: Tool execution introduces variable latency from external services, network delays, and computation. This latency is unpredictable and often heavily skewed (most calls are fast, a few are slow).

The DORA system (Dynamic ORchestration for Asynchronous Rollout) addresses these challenges through three key design decisions. Note: the paper references LongCat-Flash-Thinking (Team et al., 2025b) for the initial DORA description and describes extensions here for agentic scenarios.

Fully Streaming Asynchronous Pipeline. The system eliminates all batch barriers:

• Within the rollout process, LLM generation, environment execution, and reward computation are dispatched to remote workers at the granularity of individual samples, not batches.
• The RolloutManager does not wait for a full batch of trajectories to complete before sending them to training. As each trajectory finishes, it is immediately enqueued into the SampleQueue.
• The Trainer can initiate a training step "as soon as its conditions are met"—it does not need to wait for all rollouts in progress to finish.

To handle the staleness problem (trajectories generated by older model versions being used to train a newer model version), DORA supports multi-version asynchronous training: "trajectories generated by different model versions are immediately enqueued upon completion." The system limits new requests to older model versions to control average staleness "at the expense of efficiency."

Scaling to Large-Scale Agentic Training. The paper's setting requires up to 32,000 environments running across approximately 400 physical machines with thousands of accelerators. A monolithic RolloutManager would become a bottleneck because "each interaction typically involves a few CPU operations," and at this scale, even small per-interaction overhead accumulates.

The solution decomposes the original controller into:

1. Lightweight-RolloutManager: Manages global control metadata (which environments are active, overall training progress, global coordination).

2. Multiple RolloutControllers: Each manages the lifecycle of a "virtual rollout group" in a data-parallel manner. A virtual rollout group consists of multiple trajectories and associated physical machines (generation instances and environment instances). This decomposition allows scaling out by adding more RolloutControllers without central coordination overhead.

Additionally, the PyTorch RPC framework is extended to provide "CPU-idleness-aware remote function invocation and object instantiation." This means that when scheduling environments onto physical machines, the system can identify machines with idle CPU cores and preferentially place new environment instances there, enabling efficient deployment of massive numbers of environments across a heterogeneous cluster.

PD Disaggregation with CPU Swapping. For the 560B MoE model, decoding is expensive. The standard approach—interleaving prefill (processing new input) and decode (generating tokens) on the same devices—suffers from a specific inefficiency in multi-turn agentic settings: "frequent incoming requests with long contexts lead to workload imbalance within an expert parallelism group." Ranks assigned longer contexts consume disproportionately more computation and communication bandwidth.

PD Disaggregation separates prefill and decode onto different device groups:

• Prefill nodes process incoming requests, compute input representations, and produce KV-caches.
• Decode nodes receive KV-caches and perform token generation without being interrupted by new request processing.

This separation introduces two new challenges:

1. KV-cache transfer overhead: Moving KV-caches between prefill and decode nodes adds latency. The paper mitigates this by aggregating KV-cache blocks at chunk level and enabling asynchronous transmission. Transfers of previous chunks overlap with computation of subsequent chunks.

2. Recomputation when on-device KV-cache is insufficient: With limited device memory (~60GB in the paper's cluster), long agentic trajectories may exhaust the on-device KV-cache, requiring recomputation of cached values. To avoid this, the paper introduces "a CPU-resident KV-cache, which dynamically swaps KV-cache blocks in and out as needed." When on-device memory approaches capacity, less-recently-used blocks are offloaded to CPU memory and fetched back when needed, "eliminating recomputation overhead due to insufficient on-device KV-cache capacity."

Runtime Performance. The paper reports that the "request load ratio" (a continuous value from 0 to 1 aggregated over all generation devices across the entire rollout period) is approximately 63%. A value of 100% would mean devices are never idle; 63% reflects the tradeoff made for staleness control. The paper notes that within a single training step, a two-phase strategy is employed: before the first load-balancing operation (when there are no long-tailed generations yet), a higher number of requests per device is allowed (e.g., 8); after load-balancing, requests are limited to an optimal level (e.g., 4) to avoid recomputation. Overall, DORA is reported to be "2 to 4 times faster than synchronous training across our production jobs spanning different scenarios."

---

RL Training Strategy: General Components

The paper uses a unified training strategy applied throughout all RL recipes, with domain-specific extensions for agentic settings (context management) and scaled environment training (multi-domain balancing, noise injection).

Training Objective: Group Sequence Policy Optimization (GSPO). The paper adopts GSPO as the training objective, citing "empirical effectiveness on MoE models" and more stable sequence-level optimization for long-horizon agentic trajectories. The objective is:

$\mathcal{J}_{\text{GSPO}}(\theta) = \mathbb{E}_{x\sim\mathcal{D},\,\{y_i\}_{i=1}^{G}\sim\pi_{\theta_{\text{old}}}(\cdot|x)}\left[\frac{1}{G}\sum_{i=1}^{G}\min\!\left(s_i(\theta)\,\hat{A}_i,\;\mathrm{clip}\!\left(s_i(\theta),1-\epsilon,1+\epsilon\right)\hat{A}_i\right)\right]$

where:

• $x$ is the input (task description, user profile, environment state),
• $\mathcal{D}$ is the training distribution,
• $\{y_i\}_{i=1}^{G}$ is a group of $G$ trajectories sampled from the old policy $\pi_{\theta_{\text{old}}}$,
• $s_i(\theta)$ is the importance ratio computed at the sequence level based on normalized likelihoods (how much more or less likely the current policy makes trajectory $i$ compared to the old policy),
• $\hat{A}_i$ is the group-based advantage estimate for trajectory $i$ (how much better or worse this trajectory is compared to the average in the group),
• $\epsilon$ is the clipping threshold (controls how far the policy can change in a single update).

What it computes: For each training example $x$, the system generates $G$ complete trajectories from the current policy. Each trajectory gets an advantage score based on its outcome (reward relative to the group average). The policy update increases the probability of good trajectories and decreases the probability of bad ones, but the clipping prevents any single update from changing the policy too drastically. The objective is computed as an expected value over the training distribution.

Why this form: Standard PPO clips at the token level, which is appropriate for token-level generation tasks. In contrast, GSPO operates at the sequence level by normalizing likelihoods across the group. This matters for agentic trajectories because a good trajectory might need to be somewhat longer than a bad one (more searching, more tool calls) and token-level clipping could unfairly penalize length. The group-based advantage estimation compares trajectories against each other rather than against an absolute value function, which provides more stable training signals when reward scales vary dramatically across environments. The paper notes it "relaxes penalties on long trajectories, allowing effective strategies to emerge naturally during training."

Curriculum Learning. The training curriculum is organized along two axes:

1. Task difficulty: Quantified by the model's pass rate estimated prior to optimization. Lower pass rates indicate more challenging tasks.

2. Capability requirement: Characterized by the agentic capabilities primarily exercised—basic tool invocation, multi-step planning, autonomous decision making.

During early training, the curriculum prioritizes tasks that are "either easier to learn or expose capabilities that are expected to be autonomously reused by the agent when solving harder tasks." As training progresses, the distribution shifts toward tasks that are both more difficult and require advanced combinations of capabilities. This two-dimensional curriculum allows the model to "first acquire reusable agentic skills and then compose them to solve increasingly complex problems."

The paper reports three specific improvements from curriculum learning in agentic settings:

• Tool-use generalization: Skills from simpler tasks (tool selection, constraint handling) transfer effectively to complex scenarios, reducing tool-call failures.
• Interaction efficiency: Better instruction understanding enables more thorough internal reasoning and reduces redundant clarifications, decreasing interaction rounds.
• Planning capability: Enhanced joint reasoning over multiple constraints (time, location, entities) enables more direct task completion with fewer corrective iterations.

Dynamic Budget Allocation. The paper observes that "tasks whose difficulty is well matched to the model's current capability yield substantially higher learning gains under a fixed rollout budget." Standard RL pipelines assign uniform rollout budgets to all tasks, which is wasteful: easy tasks get more samples than needed, hard tasks get fewer than useful.

The paper proposes a dynamic budget allocation strategy that adapts to the model's real-time training state:

$v_{i,t} = V(\tau_i \mid \pi_{\theta_t}, \mathbf{m}_t)$

where:

• $v_{i,t}$ is the estimated learning value of task $\tau_i$ at training step $t$,
• $\pi_{\theta_t}$ is the current policy,
• $\mathbf{m}_t$ is a vector of real-time training metrics (e.g., current pass rate),
• $V(\cdot)$ is a dynamic value function that maps the task and current model state to estimated learning value.

What it computes: At each training step, the system evaluates how valuable each task is for the current model. Tasks where the model has recently improved but hasn't saturated are assigned higher value; tasks the model already solves perfectly or never solves correctly are assigned lower value.

Why this form: A static value function (e.g., "always prioritize tasks with 40-60% pass rate") would fail because the set of tasks in this sweet spot changes as the model improves. The dynamic formulation $V(\tau_i \mid \pi_{\theta_t}, \mathbf{m}_t)$ allows the allocation to track the model's evolving capabilities.

Based on value estimation, a "heap-based greedy algorithm computes the rollout allocation that maximizes the aggregate learning value of the current training batch." Tasks with higher estimated value get more rollout budget; tasks with lower value get less.

Self-Verification. The paper identifies a notable asymmetry: "even advanced reasoning models that are capable of generating high-quality trajectories often struggle to reliably assess the correctness of those trajectories in the absence of explicit ground-truth signals." In other words, the model can produce correct solutions but cannot reliably distinguish its own correct solutions from its incorrect ones.

Self-verification is introduced as a "dynamically activated training phase" triggered "when the generator exhibits signs of stagnation or convergence to local optima." During verification training:

• The model evaluates its own rollout trajectories (a binary judgment: correct or incorrect).
• Verification is emphasized on challenging cases (where the model's generation is uncertain).
• The influence of verification is coupled with the quality of corresponding generated trajectories, so the auxiliary signal "encourages faithful improvement of generation rather than degenerate shortcut behaviors."

The paper reports that introducing on-policy self-verification as an auxiliary task "accelerates model convergence, leading to improved generation performance."

---

Context Management for Agentic Training

Agentic trajectories grow over multiple turns, accumulating tool calls, tool outputs, and reasoning text. Under limited context windows, this eventually causes truncation. The paper designs a hybrid context management strategy combining two approaches:

Summary-based Management (based on ReSum). When cumulative context length exceeds 80K tokens (the "optimal threshold" identified through experiments in Appendix B), historical tool call results are distilled into a concise summary. The model itself is used as the summarizer—it reads the long history and produces a compressed version that preserves critical information while fitting within the context budget.

The paper reports:

• Figure 15 (Appendix B) shows that summary-based management peaks at 66.58% Pass@1 on BrowseComp at 80K token threshold, declining to 65.9% at 100K. This identifies 80K as the optimal trigger point.
• A cold-start summarization dataset of 15K samples was synthesized specifically for this purpose.
• The summarization training yields "approximately 3% gains in accuracy."

Discard-based Management. Following DeepSeek-V3.2's approach, when the interaction exceeds the maximum number of turns, the model triggers a "discard-all" reset: the entire historical context is discarded, and generation restarts with an initialized system and user prompt derived from the original question.

Hybrid Strategy. The paper combines these into a hybrid approach: "first apply summary-based compression whenever the context window exceeds our predefined limit of 80K tokens. When the interaction exceeds the maximum number of turns, we trigger a discard-all reset and restart generation." The progressive discard schedule gradually increases the discard threshold, allowing "a gradual increase in the number of reasoning steps for more challenging samples."

Figure 7 demonstrates the effectiveness: under heterogeneous computational budgets, the hybrid strategy starts from 55.8% and reaches 73.1%, outperforming both summary-only and discard-only strategies. The paper attributes this to "dynamic switching between compression and reset, governed by context window and interaction turn constraints, which achieves a favorable trade-off between critical reasoning context retention and computational overhead control."

---

Multi-Domain Environment Training

Training across thousands of heterogeneous environments introduces a new challenge beyond training on a single environment type: maintaining stability and efficiency when environments have vastly different throughput, difficulty, and interaction patterns.

Cross-Domain Balancing. The algorithmic constraint is that "all domains contribute comparably to the overall training process, while preventing any single training batch from being dominated by a small subset of domains." However, this constraint conflicts with the DORA system's asynchronous design: if the trainer must wait for slow or rare long-tailed domains to produce enough samples, "faster domains accumulate excessive rollout trajectories, leading to scheduling bubbles and device underutilization."

The solution is configurable oversampling ratios: different data types and domains are assigned different sampling rates. More challenging or low-throughput domains receive higher oversampling (more rollout quota per unit time), allowing them to contribute sufficient samples without blocking the pipeline, while faster domains are sampled at lower effective rates. This "relaxes the strict per-batch balancing constraint and maintains the high-throughput property of asynchronous training using DORA, while still maintaining a roughly balanced data mixture at the training stage."

Dynamic Budget Allocation in the Asynchronous Setting. The general dynamic budget allocation strategy (Section 3.3.1) requires centralized coordination to compute $v_{i,t}$ values, which is complex to implement in a fully asynchronous system. The paper approximates this by introducing "an oversampling coefficient for each task based on its historical pass rate." Tasks with lower success rates are assigned higher oversampling coefficients. Each task is duplicated into multiple groups according to its coefficient, and each group independently computes advantages during training. This "approximates dynamic budget allocation while preserving the simple and fully asynchronous scheduling behavior of DORA."

Training Results. Figure 8 shows the training reward curves: "a stable and consistent increasing trend throughout training," indicating that the algorithm-infrastructure co-design ensures training stability at scale. Figure 9 shows performance on agentic benchmarks at different training steps, demonstrating "strong generalization across multiple benchmarks, which validates the effectiveness of our environment synthesis pipeline." The model also achieves strong performance on "randomly generated environments, demonstrating strong generalization."

---

Robust RL: Training with Environmental Noise

The paper makes a systematic departure from the standard assumption that training environments should be clean and well-controlled. Instead, it argues that "in contrast, real-world environments are inherently imperfect," and that training exclusively on clean environments produces brittle agents.

Noise Modeling. Two major sources of interaction noise are modeled:

1. Instruction noise: Captures "ambiguity and variability in user interaction patterns." This includes ambiguous queries, underspecified requests, inconsistent terminology, and implicit assumptions that the agent must discover through clarification.

2. Tool noise: Simulates "execution failures, inconsistent responses, and partial results from external tools." This includes API timeouts, malformed responses, missing fields, and stochastic failures.

Noise Injection Constraint. The paper introduces a critical safeguard: "to avoid introducing unreliable or misleading reward signals, we ensure that the injected imperfections do not invalidate task solvability." In other words, the noise makes tasks harder but not impossible. A task that becomes genuinely unsolvable due to noise injection would provide a misleading negative signal—the agent would be punished for failing an impossible task, potentially learning to avoid useful behaviors.

Curriculum-Based Noise Strategy. Noise is introduced progressively: "starting from mild perturbations, we gradually increase noise difficulty and diversity as the model demonstrates sufficient robustness at the current level. This adaptive process ensures that training remains informative rather than overwhelming, and avoids inefficient exploration of excessively noisy regimes."

The paper measures robustness as "the performance gap between perfect and imperfect environments on the same task." A smaller gap indicates greater robustness.

Results (Table 1). The ablation study demonstrates the effectiveness:

Several patterns emerge:

• Training with noise achieves comparable or slightly better performance on standard benchmarks (29.3 vs 28.6 on VitaBench, 88.2 vs 87.1 on τ²-Bench), suggesting noise injection does not harm and may slightly help even in clean evaluation settings.

• Training with noise yields substantial improvements under noisy conditions (20.5 vs 13.3 on VitaBench-Noise, 67.1 vs 62.2 on τ²-Bench-Noise), confirming that noise-aware training produces more robust agents.

• The cold-start model shows the largest robustness gap (10.0 → 6.3 on VitaBench vs 29.3 → 20.5 for the noise-trained model), indicating that basic agentic capability without noise exposure is extremely brittle.

---

Heavy Thinking Mode: Test-Time Scaling

The paper introduces a test-time inference strategy that decomposes complex problem-solving into two stages. The key design principle is that scaling reasoning width (exploring multiple solution paths) and scaling reasoning depth (iteratively refining a single path) are complementary, and that jointly scaling both yields better performance than scaling either alone.

Stage 1: Parallel Reasoning. A "thinking model" generates multiple candidate reasoning trajectories for the same problem in parallel. Each trajectory is a complete reasoning chain—a sequence of internal deliberation and tool interactions that leads to an answer. The parallel generation expands the breadth of exploration: different trajectories may explore different approaches, make different assumptions, or discover different relevant information through tool use.

Stage 2: Heavy Thinking (Summary Synthesis). A "summary model" receives all the parallel trajectories from Stage 1 and performs reflective reasoning over them. Its task is to synthesize the intermediate reasoning and outcomes from all trajectories to produce a final decision. The summary model can identify consensus across trajectories (multiple paths arriving at the same answer), resolve conflicts (trajectories arriving at different answers with different reasoning), and identify reasoning gaps (aspects of the problem that no trajectory adequately addressed).

The paper does not specify whether the thinking model and summary model share parameters or are distinct models—it states that "the thinking and the summary module can either share the same model parameters or be instantiated as distinct models."

Context Memory for Multi-Turn Support. For tool-use and multi-turn conversation scenarios, the system includes a context memory module that stores message history. As shown in Figure 11, in each turn:

• The summary model receives history messages from the parallel reasoning stage to perceive context.
• A specific prompt template organizes the permutations of parallel trajectories at the current turn, retaining only answer content (not full reasoning traces).
• The summary model generates the final response, "which aims to aggregate or refine the answers derived from the parallel reasoning stage."
• The response format is constrained to match the parallel reasoning stage's output style, enabling direct concatenation with message history for subsequent turns.

RL for the Summary Phase. An additional RL stage is introduced "specifically tailored to the summary phase." The paper does not detail the training procedure for this stage, but states that it "strengthens the model's ability to aggregate and refine intermediate reasoning outcomes."

Performance Characteristics. The paper reports that Heavy Thinking "consistently outperforms self-consistency, with its performance advantage becoming increasingly pronounced as the test-time computational budget grows." Self-consistency (majority voting over parallel trajectories) uses only the width dimension—it identifies the most common answer but does not synthesize reasoning across trajectories. Heavy Thinking's summary stage can identify when consensus is spurious (many trajectories agree but all share a common reasoning error) and when a minority trajectory is correct (a single trajectory with particularly thorough reasoning that others missed).

4. Key Insights and Innovations

Innovation 1: Environment Diversity as the Primary Driver of Generalizable Agentic Reasoning

The paper's most intellectually distinctive contribution is not any specific algorithm or architecture, but a causal claim about what produces agentic generalization: exposure to diverse, executable, and verifiable environments during reinforcement learning. This is a fundamental reframing of the agentic training problem.

Prior to this work, the dominant assumption—visible across agentic coding models, early tool-use models like Kimi-K2, and reasoning models like DeepSeek-R1—was that agentic capability emerges from scaling model size or RL compute, with the environment serving primarily as a reward source. Environments were constructed ad hoc, often as a handful of curated benchmarks that the model was directly optimized against. The implicit theory was: better models learn better agentic behaviors, and better behaviors are measured by benchmark scores.

LongCat-Flash-Thinking-2601 inverts this logic. The paper's central architectural claim in Section 3.1.1 is explicit: "we posit that transferable agentic reasoning capability should emerge from exposure to diverse tool sets and interaction patterns." The environment is not merely a testing ground or reward generator—it is the primary learning substrate. The model's ability to generalize to unseen tools, novel task structures, and noisy conditions stems from the diversity of its training environments, not from architectural innovations or optimization tricks.

What makes this claim novel is its empirical operationalization. Prior work gestured at environment diversity (e.g., training on multiple domains), but typically relied on a handful of hand-crafted environments that were never disclosed in detail. The paper's automated domain graph pipeline (Figure 3) and controlled expansion procedure (Figure 4) constitute the first disclosed, reproducible methodology for scaling environment diversity at an industrial level. The claim is backed by concrete evidence: the Random Complex Tasks evaluation protocol (Section 5.1), which randomly generates novel environments that were not seen during training, shows that LongCat-Flash-Thinking-2601 achieves 35.8% vs. 25.3–32.6% for prior open-source models (Table 2). This 3–10 percentage point gap is the cleanest evidence that diverse training environments—not model scale or RL compute alone—produce generalizable agentic skills.

The significance of this reframing extends beyond this paper. It establishes a scaling law analog for agentic training: just as diverse pretraining data produces general language understanding, diverse interaction environments produce general agentic reasoning. The implication is that future progress in agentic capability will depend more on environment construction methodology than on model architecture improvements. This is a non-obvious shift in research prioritization that the paper supports with concrete evidence, not just assertion.

Innovation 2: Training on Imperfect Environments as a Robustness Paradigm, Not a Post-Hoc Fix

The paper makes a systematic departure from a deeply embedded assumption in the agentic training literature: that training environments should be clean, stable, and well-controlled. Prior work—from SWE-bench agents to τ²-Bench models—operated on the implicit principle that training data should be as clean as possible, with noise treated as contamination to be removed. The consequence was well-documented but underexamined: models that performed well on curated benchmarks but degraded catastrophically when deployed in the real world where tools fail, users are ambiguous, and environments are inconsistent.

LongCat-Flash-Thinking-2601 treats environmental imperfection not as a nuisance but as a first-class training signal. The paper's contribution here is threefold:

First, it quantifies the robustness gap that prior work left implicit. Table 1 provides concrete measurements: a cold-start model drops from 10.0 to 6.3 on VitaBench when noise is injected (a 37% relative degradation); on τ²-Bench, the drop is from 78.8 to 58.8 (a 25% relative degradation). These numbers make the brittleness problem tangible and measurable, whereas prior work discussed it in qualitative terms.

Second, it categorizes noise into two principled dimensions: instruction noise (user ambiguity, underspecification) and tool noise (execution failures, inconsistent responses). This decomposition enables targeted training interventions rather than generic data augmentation. The paper's automated noise injection pipeline applies specific perturbation types at controlled levels, rather than simply adding random perturbations.

Third, it demonstrates that noise-aware training is not a tradeoff between robustness and capability—a finding that contradicts the intuitive expectation that training on noisy data degrades peak performance. In Table 1, training with noise achieves slightly better performance on standard benchmarks (29.3 vs. 28.6 on VitaBench, 88.2 vs. 87.1 on τ²-Bench) while substantially improving performance under noisy conditions (20.5 vs. 13.3 on VitaBench-Noise, 67.1 vs. 62.2 on τ²-Bench-Noise). This is a Pareto improvement: noise-aware training produces models that are both more capable and more robust.

The intellectual significance is that this reframes robustness from a separate evaluation concern (something you measure after training) into a training design principle (something you optimize during training). The paper's curriculum-based noise strategy—progressively increasing noise difficulty as the model demonstrates robustness at each level—operationalizes this principle. It is analogous to the role of data augmentation in computer vision, where training on augmented (noisy, transformed) images became a standard technique that improved both robustness and accuracy. For the agentic training literature, this paper makes the analogous case and provides the first systematic evidence.

Innovation 3: Heavy Thinking as a General Test-Time Scaling Framework with Disclosed Design

Test-time scaling—using additional computation during inference to improve performance—has become a central technique in the reasoning literature. OpenAI's o1 and DeepSeek-R1 scale reasoning depth by generating long chains of thought. Self-consistency and MCTS-based approaches scale reasoning width by exploring multiple trajectories. More recently, several frontier models (Gemma 3, GPT-5, Kimi-K2, PaCoRe) have introduced "heavy thinking" modes that aim to scale both dimensions simultaneously.

The paper's contribution here is not the concept of heavy thinking itself—it acknowledges prior work explicitly—but rather the transparency and generality of the disclosed framework. The paper states that prior heavy thinking implementations "remain largely undisclosed, limiting their reproducibility and systematic study" (Section 4). By describing the two-stage architecture (parallel reasoning → summary synthesis), the context memory module, and the RL training of the summary phase, the paper makes heavy thinking a reproducible technique rather than a proprietary capability.

What makes this more than just documentation is the generalizability claim: Heavy Thinking is demonstrated to work "across a wide range of settings, including long chain-of-thought reasoning, tool-integrated reasoning, and fully agentic tool-use scenarios" (Section 4). This is substantively different from prior heavy thinking demonstrations, which were typically shown only on pure text-based reasoning. The paper provides evidence across mathematical reasoning (AIME-2025: 99.6% → 100.0% with heavy mode), Olympiad-level math (IMO-AnswerBench: 78.6% → 86.8%), and general QA (GPQA-Diamond: 80.5% → 85.2%). This breadth of evidence demonstrates that the two-stage framework is not tied to a specific reasoning modality.

The conceptual insight is that reasoning width and depth are complementary scaling axes with different failure modes. Parallel reasoning (width) protects against the risk that a single reasoning chain gets stuck in a local error—if one trajectory makes a mistake, another might avoid it. Summary synthesis (depth) protects against the risk that majority voting selects a consensus answer that is wrong for systematic reasons—the summary model can identify when all trajectories share a common error and can privilege a minority trajectory with stronger evidence. The performance advantage over self-consistency (majority voting over parallel trajectories) demonstrates that summary synthesis adds value beyond simple aggregation, and the paper reports that this advantage "becomes increasingly pronounced as the test-time computational budget grows" (Section 4)—a critical scaling property that suggests the framework is robust to increased compute investment.

Innovation 4: Asynchrony as an Architectural Principle for Agentic RL, Not Just an Optimization

The DORA system's extension to agentic training (Section 3.2) might initially appear to be purely an engineering contribution—an infrastructure optimization that makes training faster. This would be a misreading of its significance. The paper's treatment of asynchrony reveals a fundamental tension between the algorithmic requirements of multi-domain training and the physical constraints of distributed computation, and the resolution of this tension requires reconsidering what "fairness" means in RL training.

The tension arises because standard multi-domain training requires that all domains contribute balanced representation to each training batch. This is algorithmically sensible: if some domains dominate, the model overfits to their patterns and fails to generalize. However, this constraint is physically impossible to satisfy in a purely asynchronous system where different domains have different throughput characteristics. The paper's insight is that the batch-balancing constraint can be relaxed without sacrificing training quality, using configurable oversampling ratios that maintain statistical balance at the training stage while allowing physical asynchrony at the rollout stage.

This is more than an optimization trick. It represents a re-characterization of what constitutes a valid training signal in reinforcement learning. The standard view is that each training batch should be a representative microcosm of the overall training distribution. The paper demonstrates—through the stable training reward curves in Figure 8 and the strong generalization performance in Figure 9—that statistical balance across a training stage is sufficient; strict per-batch balance is an unnecessary constraint that imposes severe throughput penalties. This finding has implications for any large-scale RL system training on heterogeneous data sources: the tension between batch balance and throughput is a false choice created by overly restrictive algorithmic assumptions.

The dynamic budget allocation approximation further reinforces this insight. The general strategy requires centralized coordination to compute per-task learning values, which would break the asynchronous architecture. The paper's approximation—using historical pass rates as static oversampling coefficients—shows that a simple, decoupled signal can substitute for a complex, coupled one without meaningful performance degradation. This is a concrete demonstration that the statistical requirements of RL are more forgiving than the algorithmic literature typically assumes, enabling much simpler and more scalable implementations.

5. Experimental Analysis

Evaluation Methodology

• Dataset. The paper evaluates on a broad suite of benchmarks covering five capability dimensions: mathematical reasoning (AIME 2025, HMMT 2025, IMO-AnswerBench, AMO-Bench), agentic search (BrowseComp, BrowseComp-ZH, RWSearch), agentic tool use (τ²-Bench, VitaBench, and noise-augmented variants of both, plus Random Complex Tasks), general QA (HLE text-only subset, GPQA-Diamond), and coding (LiveCodeBench, OJBench, OIBench, SWE-bench Verified). For mathematical reasoning, the paper introduces AMO-Bench, a 50-problem dataset designed by human experts in both English and Chinese versions. For agentic search, the paper introduces RWSearch, a private benchmark with 200 real-world queries requiring complex multi-step information retrieval. For agentic tool use, the paper constructs τ²-Bench-Noise and VitaBench-Noise through an automated noise injection pipeline and introduces Random Complex Tasks, a protocol that randomly generates 100 novel executable agentic tasks spanning 4+ domains per evaluation run, averaged over three independent runs. All models on HLE are evaluated on the text-only subset using the official o3-mini scoring model and prompt template to ensure fair comparison.

• Base model(s). The primary model is LongCat-Flash-Thinking-2601, a 560B-parameter Mixture-of-Experts model with 27B activated parameters per token on average, built on the LongCat-Flash-Chat pretraining recipe. The paper also releases LongCat-Flash-Thinking-ZigZag, a variant using Zigzag Attention for long-context efficiency. Open-weight comparison models include DeepSeek-V3.2-Thinking (671B total, 37B activated), Kimi-K2-Thinking (1T total, 32B activated), Qwen3-235B-A22B-Thinking-2507 (235B total, 22B activated), and GLM-4.7-Thinking (355B total, 32B activated). Closed-weight comparison models include Claude-Opus-4.5-Thinking, Gemini-3-Pro, and GPT-5.2-Thinking-xhigh. The model scale is chosen to be competitive with frontier open-weight models while using fewer activated parameters (27B vs. 32–37B for comparable models), enabling efficiency comparisons.

• Metrics. The primary metrics are Pass@1 (fraction of problems solved with one attempt) and Avg@k (average accuracy over k independent samples, used for smaller benchmarks to reduce sampling variance). For mathematical reasoning, scores are determined by exact answer matching with tool-integrated reasoning (code execution) where supported. For agentic search, correctness is determined by whether the model's final answer matches the ground truth after multi-step information retrieval. For agentic tool use on τ²-Bench and VitaBench, correctness is determined by rubric-based evaluation of whether the agent successfully completed the specified task in the simulated environment. For coding, correctness on LiveCodeBench, OJBench, and OIBench is determined by test case execution; for SWE-bench Verified, correctness is determined by whether the agent's patch resolves the issue while passing existing tests. For Random Complex Tasks, the Avg@4 score is computed across 100 randomly generated tasks, averaged over three independent runs to ensure reliability.

• Baselines. The paper compares against both open-weight models (DeepSeek-V3.2-Thinking, Kimi-K2-Thinking, Qwen3-235B-A22B-Thinking-2507, GLM-4.7-Thinking) and closed-weight models (Claude-Opus-4.5-Thinking, Gemini-3-Pro, GPT-5.2-Thinking-xhigh). For the Heavy Thinking mode evaluation (indicated by ‡ in Table 2), the baseline is the same model without heavy mode (standard single-trajectory inference). For the context management ablation (Figure 7), baselines include summary-based management, discard-based management, and no context management. For robust RL ablation (Table 1), baselines include the cold-start model (post-supervised fine-tuning, pre-RL) and a model trained without noise injection. For mid-training ablation (Figure 2), the baseline is the model undergoing the old mid-training recipe without agentic enhancements.

• Generation budget / compute accounting. The paper measures generation budget implicitly through k in Avg@k (e.g., k=4 for IMO-AnswerBench, VitaBench, τ²-Bench; k=16 for AIME-25, HMMT-25, AMO-Bench, GPQA-Diamond; k=5 for SWE-bench Verified). For Heavy Thinking mode, the computational budget is expanded by running multiple parallel reasoning trajectories (width scaling) followed by a summary synthesis step (depth scaling), though the paper does not specify exact trajectory counts. The performance comparison relative to cost for Zigzag Attention is shown in Figure 13, with percentage reductions in cost annotated for each benchmark. For context management experiments (Figure 7), computational budgets are heterogeneous and represented as Pass@1 accuracy at varying compute levels, with the hybrid strategy achieving the highest efficiency. For inference, the paper uses temperature=1.0, top-k=-1, and top-p=1.0 unless otherwise specified. The paper reports token efficiency for coding: LongCat-Flash-Thinking-2601 requires approximately 45K tokens per problem on OIBench compared to 57K for GLM-4.7, demonstrating lower inference cost for similar performance.

• Cross-validation / statistical protocol. The paper modifies several evaluation protocols to ensure reliability. For τ²-Bench, the original user simulator is replaced with GPT-4.1 with adjusted prompting due to "occasional abnormal behaviors that introduce uncontrolled noise" (Section 5.1). For the airline subset specifically, 19 problematic cases are corrected due to "annotation and environment issues that can lead to spurious failures." For BrowseComp-ZH, the paper manually revised answers for 24 cases due to errors in original annotations. For VitaBench, the verifier model is upgraded to "the strongest publicly available version" with stricter evaluation criteria. For Random Complex Tasks, three independent evaluation runs of 100 randomly generated tasks each are averaged. All modifications are publicly released to support reproducibility. The paper does not report confidence intervals or statistical significance tests for any benchmark comparisons.

Main Quantitative Results

Mathematical Reasoning Results

LongCat-Flash-Thinking-2601 achieves first-tier performance on mathematical reasoning, with Heavy Thinking mode enabling results competitive with leading closed-source models (Table 2). On AIME-2025 (Avg@16), the model achieves 99.6% without heavy mode and a perfect 100.0% with heavy mode, matching GPT-5.2-Thinking-xhigh (100.0%) and Claude-Opus-4.5-Thinking (100.0%), and surpassing DeepSeek-V3.2-Thinking (93.5%). On HMMT-2025 (Avg@16), the model achieves 93.4% without heavy mode and 97.5% with heavy mode, trailing GPT-5.2 (99.6%) and Claude (99.8%) but outperforming DeepSeek-V3.2 (93.5%). On IMO-AnswerBench (Avg@4), the model achieves 78.6% without heavy mode and 86.8% with heavy mode—the highest score among all open-weight models and surpassing both Claude-Opus-4.5 (82.8%) and Gemini-3-Pro (86.7%, though this score is reported without tools per the table notation).

On AMO-Bench, positioned as "the most challenging dataset among existing Olympiad-level benchmarks" (Section 5.1), LongCat-Flash-Thinking-2601 achieves 61.6% (English) and 56.8% (Chinese) without heavy mode, rising to 66.0% and 67.5% with heavy mode. These represent the best open-source results, though trailing GPT-5.2-Thinking-xhigh (72.5% EN, 74.9% CH). Notably, the model exhibits "comparable performances on both the English and Chinese version of AMO-Bench, indicating advanced mathematical reasoning and tool-use capability in non-English settings" (Section 5.2), whereas Qwen3-235B-A22B-Thinking shows a dramatic gap (47.8% EN vs. 28.8% CH), suggesting language-specific reasoning limitations that LongCat-Flash-Thinking-2601 avoids.

A critical observation from Table 2 is that several models report mathematical reasoning results without tools (indicated by * and the note that "the w/ tools result is unavailable, and thus the corresponding w/o tools result is reported instead"). DeepSeek-V3.2-Thinking's scores of 93.5%, 93.5%, and 77.7% on AIME, HMMT, and IMO-AnswerBench respectively are all tool-free results, while LongCat-Flash-Thinking-2601's scores are tool-integrated. This makes direct comparison misleading—the paper does not isolate how much of the performance gap is due to tool use versus base reasoning capability.

Agentic Search Results

LongCat-Flash-Thinking-2601 achieves state-of-the-art open-source performance on agentic search benchmarks (Table 2). On BrowseComp (Pass@1) with context management enabled, the model achieves 73.1%, surpassing DeepSeek-V3.2-Thinking (67.6% with context management), GPT-5.2-Thinking-xhigh (65.8%), and all other compared models. Without context management, the model achieves 56.6%, significantly below the with-context-management result and behind several closed-weight models, demonstrating that context management is critical for this benchmark. On BrowseComp-ZH, context management enables 77.7%, the highest score among all models. On RWSearch (Pass@1, without context management to ensure fair comparison), the model achieves 79.5%, second only to GPT-5.2-Thinking-xhigh (82.0%) and substantially ahead of Claude-Opus-4.5-Thinking (75.5%), Gemini-3-Pro (74.5%), and DeepSeek-V3.2-Thinking (74.0%).

The context management ablation (Figure 7) provides detailed scaling behavior. The hybrid strategy (summary-based compression at 80K tokens + discard-all reset at max turns) starts at 55.8% and scales to 73.1% as computational budget increases. The discard-only strategy begins at lower performance and scales less efficiently. The summary-only strategy begins highest but plateaus. The hybrid strategy's advantage is attributed to "dynamic switching between compression and reset, governed by context window and interaction turn constraints, which achieves a favorable trade-off between critical reasoning context retention and computational overhead control" (Section 3.3.2). The optimal token threshold for summary-based management is identified as 80K (Appendix B, Figure 15), where Pass@1 peaks at 66.58% before declining to 65.9% at 100K—shorter summaries lose critical information, longer summaries waste context budget.

The paper attempted to reproduce external model results under its own agentic search framework but "observed consistently lower performance than the reported numbers" (Section 5.1), so it uses official reports for external models. This is an important methodological note: the evaluation framework significantly affects results, and the paper's internal comparisons on RWSearch (where all models are evaluated under the same framework) are more controlled than the cross-framework comparisons on BrowseComp.

Agentic Tool-Use Results

LongCat-Flash-Thinking-2601 achieves state-of-the-art open-source performance across agentic tool-use benchmarks (Table 2). On τ²-Bench (Avg@4), the model achieves 88.2% overall, outperforming DeepSeek-V3.2-Thinking (80.6%), Kimi-K2-Thinking (74.3%), and GLM-4.7-Thinking (87.4%), and approaching GPT-5.2 (90.7%, though this score is from a different evaluation configuration). The breakdown by subdomain reveals strong domain-specific performance: 88.6% on Retail (behind GPT-5.2's 88.9% but ahead of all open-weight models), 76.5% on Airline (substantially behind the modified evaluation, where results for many models are unavailable due to the annotation fixes), and 99.3% on Telecom. On τ²-Bench-Noise (Avg@4, Table 1), the model achieves 67.1%, representing the highest noise-augmented performance across all compared models (trained with noise) and substantially ahead of models trained without noise (62.2%). The robustness gap (standard → noise) is 88.2% → 67.1% = 21.1 percentage points, compared to DeepSeek-V3.2's 80.6% → 64.1% = 16.5 points. While the absolute noisy score is higher, the relative drop is larger, suggesting there may be a ceiling effect where higher clean performance is harder to maintain under noise.

On VitaBench (Avg@4), the model achieves 29.3%, second only to Gemini-3-Pro (31.5%) and ahead of GPT-5.2-Thinking-xhigh (24.3%), Claude-Opus-4.5-Thinking (28.5%), and DeepSeek-V3.2-Thinking (24.0%). On VitaBench-Noise (Avg@4, Table 1), the model achieves 20.5%, matching Claude (20.3%) and Gemini (20.8%) despite these closed-weight models having higher clean performance (28.5% and 31.5% respectively), indicating superior noise robustness. The cold-start model drops from 10.0% to 6.3% on VitaBench-Noise, a 37% relative degradation, while the noise-trained model drops from 29.3% to 20.5%, a 30% relative degradation. This suggests noise training reduces but does not eliminate brittleness.

On Random Complex Tasks (Avg@4), the model achieves 35.8%, the highest score among all models compared (Table 2). The next best models are Claude-Opus-4.5-Thinking and Gemini-3-Pro at 32.6% and 32.5% respectively, with DeepSeek-V3.2-Thinking at 32.5%. The 3.3 percentage point gap over the strongest baselines on a benchmark specifically designed to test generalization to unseen environments is the paper's strongest evidence for the central claim that diverse environment training produces generalizable agentic skills. Notably, GPT-5.2-Thinking-xhigh scores only 17.2%—substantially below all other models—which the paper does not discuss. This anomalous result for a model that leads on most other benchmarks could suggest that Random Complex Tasks penalizes certain architectural or training choices that benefit standard benchmarks.

General QA Results

On HLE (text-only subset), LongCat-Flash-Thinking-2601 achieves 25.2% (Table 2), within the range of other open-weight models: GLM-4.7-Thinking (26.9%), DeepSeek-V3.2-Thinking (24.1%), Kimi-K2-Thinking (24.4%). Closed-weight models lead substantially: GPT-5.2-Thinking-xhigh (34.5%, though this score is from external reports) and Gemini-3-Pro (40.3%). On GPQA-Diamond (Avg@16), the model achieves 80.5% without heavy mode and 85.2% with heavy mode, approaching but not matching the best models: GPT-5.2 (92.9%) and Gemini-3-Pro (91.9%). The heavy mode improvement of 4.7 percentage points on GPQA-Diamond demonstrates that Heavy Thinking benefits general knowledge-intensive reasoning beyond mathematical and agentic domains.

Coding Results

LongCat-Flash-Thinking-2601 demonstrates competitive coding performance (Table 2). On LiveCodeBench 24.08–25.05 (Avg@4), the model achieves 82.8%, ranking third among open-weight models behind GLM-4.7-Thinking (84.8%) and matching Claude-Opus-4.5-Thinking (82.8%) and DeepSeek-V3.2-Thinking (82.4%). On OJBench (Pass@1), the model achieves 42.2%, behind GLM-4.7 (44.6%) and Kimi-K2 (42.3%) but ahead of Qwen3-Thinking (35.6%). On OIBench EN (Pass@1), the model achieves 47.7%, the highest among all open-weight models and ahead of all closed-weight models except Gemini-3-Pro (58.2%) and GPT-5.2-Thinking-xhigh (58.2%, though not reported in this table). The paper notes a token efficiency advantage: LongCat-Flash-Thinking-2601 generates approximately 45K tokens per problem on OIBench versus 57K for GLM-4.7, meaning it achieves open-source best performance with ~21% less inference compute.

On SWE-bench Verified (Avg@5), the model achieves 70.0%, within the competitive range but behind several models: GPT-5.2 (80.0%), Claude-Opus-4.5-Thinking (80.9%), GLM-4.7-Thinking (73.8%), and DeepSeek-V3.2-Thinking (73.1%). This is the weakest relative performance across all coding benchmarks and the only benchmark where the model trails multiple open-weight competitors by more than a marginal amount. The paper does not discuss this relative weakness, which could indicate that the model's agentic training emphasis on diverse tool-use environments transfers less effectively to the specific challenges of software engineering (large codebase navigation, patch generation, test-driven debugging) compared to models with coding-specific training pipelines.

Heavy Thinking Ablation

The Heavy Thinking mode's contribution is annotated with ‡ marks in Table 2. The improvements are: AIME-2025: 99.6% → 100.0% (+0.4pp, already near ceiling), HMMT-2025: 93.4% → 97.5% (+4.1pp), IMO-AnswerBench: 78.6% → 86.8% (+8.2pp), AMO-Bench EN: 61.6% → 66.0% (+4.4pp), AMO-Bench CH: 56.8% → 67.5% (+10.7pp), GPQA-Diamond: 80.5% → 85.2% (+4.7pp). The largest gains appear on benchmarks where the base performance is well below ceiling, particularly IMO-AnswerBench and AMO-Bench CH, consistent with the idea that test-time scaling provides diminishing returns as performance approaches saturation. The paper does not report heavy mode results for agentic search, agentic tool use, or coding benchmarks in Table 2, which is a notable omission given that Heavy Thinking is claimed to work "across a wide range of settings, including long chain-of-thought reasoning, tool-integrated reasoning, and fully agentic tool-use scenarios" (Section 4). The absence of heavy mode agentic results limits the evidence for this cross-domain generalizability claim.

Ablation Studies and Robustness Checks

Mid-training agentic data augmentation (Figure 2): Enhanced mid-training with planning-oriented data and agentic trajectories produces higher pass@k on τ²-Bench across all k values compared to the old mid-training recipe. The gap is present at k=1 and widens at higher k values, indicating that the enhanced recipe not only improves the model's best-case performance (k=1) but also expands the model's capability boundary (higher k values represent more attempts needed to find a correct solution).

Cold-start data selection: sliding-window perplexity KCG (Section 3.1.2): The sliding-window perplexity variant of K-Center-Greedy, applied to downselect 210K general thinking samples from a large-scale corpus, outperforms models trained on the full corpus on multiple reasoning benchmarks. This is a non-obvious result: aggressive quality filtering (removing over 50% of data) improves performance, suggesting that standard data quality signals (average perplexity) may actively remove valuable samples by masking localized difficult regions. The paper does not report exact benchmark scores for this ablation or compare against alternative data selection methods (e.g., standard KCG without perplexity weighting, random subsampling).

Context management strategies (Figure 7): The hybrid strategy (summary at 80K + discard) consistently outperforms summary-only and discard-only strategies across heterogeneous computational budgets, scaling from 55.8% to 73.1%. Summary-only begins highest at low budgets but saturates; discard-only underperforms at all budgets. The summary token threshold sweep (Appendix B, Figure 15) identifies 80K as optimal (66.58% Pass@1), with monotonic improvement from 20K (63.86%) to 80K and decline at 100K (65.9%). The cold-start summarization dataset of 15K samples yields "approximately 3% gains in accuracy" compared to no summarization training.

Multi-domain environment training vs. single-domain (Figures 8 and 9): The training reward curve (Figure 8) exhibits "a stable and consistent increasing trend throughout training," which the paper attributes to the algorithm-infrastructure co-design. Agentic benchmark performance at different training steps (Figure 9) demonstrates improvement across multiple benchmarks simultaneously, with the model achieving "strong performance in randomly generated environments, demonstrating strong generalization." However, the paper does not include an explicit single-domain training ablation (e.g., training on only one domain's environments and testing on others) that would isolate the multi-domain contribution. The generalization evidence is correlational (training on diverse domains → good random environment performance) rather than causal (comparing identical training pipelines with single vs. multiple domains).

Robust RL noise training (Table 1): Training with noise achieves comparable or slightly better clean performance (29.3 vs. 28.6 on VitaBench, 88.2 vs. 87.1 on τ²-Bench) while substantially improving noisy performance (20.5 vs. 13.3 on VitaBench-Noise, 67.1 vs. 62.2 on τ²-Bench-Noise). The cold-start model shows the largest robustness gap (37% relative drop on VitaBench vs. 30% for noise-trained), confirming that basic agentic capability without noise exposure is extremely brittle. The paper does not ablate the curriculum-based noise strategy against uniform noise injection (same noise level throughout training) or report performance at intermediate noise levels, making it unclear whether the curriculum specifically or noise exposure in general drives the improvement.

Self-verification auxiliary task (Section 3.3.1): Self-verification is introduced as a dynamically activated auxiliary training phase when the generator shows signs of stagnation. The paper reports that it "accelerates model convergence, leading to improved generation performance." However, no quantitative ablation is provided that compares training with vs. without self-verification. The mechanism is described in detail (verification focused on challenging cases, influence coupled with trajectory quality), but its contribution cannot be isolated from other training components.

RL training objective: GSPO vs. alternatives (Section 3.3.1): The paper adopts GSPO citing "empirical effectiveness on MoE models" and more stable sequence-level optimization for long-horizon trajectories. No comparison against standard PPO or other RL objectives is reported for this model. The choice is justified by reference to prior work (Zheng et al., 2025) rather than by ablations within this paper's training pipeline.

Curriculum learning (Section 3.3.1): The two-dimensional curriculum (task difficulty × capability requirement) is reported to yield improvements in tool-use generalization, interaction efficiency, and planning capability. However, these are described qualitatively based on analysis of agentic behavior rather than through a controlled ablation comparing curriculum vs. uniform difficulty sampling. The paper reports three specific behavioral improvements but does not quantify them (e.g., "tool-call failures reduced by X%, interaction rounds decreased by Y").

Zigzag Attention efficiency vs. performance tradeoff (Figure 13): LongCat-Flash-Thinking-ZigZag achieves approximately 1.5× end-to-end inference speedup (Figure 12) with percentage cost reductions annotated per benchmark in Figure 13. The paper claims the variant "preserves reasoning performance and agentic capabilities across benchmarks" (Section 6), but does not report absolute performance numbers for ZigZag on any benchmark, making it impossible to assess the performance cost of the efficiency gain. The statement that it "yields a good trade-off between performance and speed" is supported by the relative cost reduction percentages in Figure 13 but not by direct performance comparisons.

Critical Assessment

Claim: "LongCat-Flash-Thinking-2601 achieves state-of-the-art performance among open-source models on a wide range of agentic benchmarks" (Abstract, Section 5.2). The evidence for this claim is strong but requires qualification. On agentic search (BrowseComp: 73.1% with context management, RWSearch: 79.5%), agentic tool use (τ²-Bench: 88.2%, VitaBench: 29.3%, Random Complex Tasks: 35.8%), and their noise-augmented variants, the model indeed achieves the highest scores among all open-weight models in Table 2. The margins are substantial in several cases: +7.6pp over DeepSeek-V3.2 on τ²-Bench, +10.5pp on BrowseComp-ZH with context management, +5.3pp over the next best open-weight model on VitaBench. However, the paper's evaluation framework modifications (revised τ²-Bench user simulator, fixed airline subset, updated VitaBench verifier) mean that not all comparison scores were collected under identical conditions—some are from external reports using different evaluation configurations. The paper acknowledges this for BrowseComp ("we use results from their official reports" after failing to reproduce reported numbers) but the extent of cross-framework variance is not quantified. On Random Complex Tasks, the 3.3pp gap over the strongest baseline is meaningful but would benefit from confidence intervals given the 3-run averaging protocol.

Claim: "Training with diverse environments produces generalizable agentic reasoning that transfers to previously unseen settings" (Section 3.1.1, Section 5.2). The Random Complex Tasks result (35.8% vs. 25.3–32.6% for baselines) provides the most direct evidence for this claim. However, the claim is stronger than the experiment can fully verify. The experiment shows correlation (diverse environment training + strong random task performance) but does not establish a causal link through controlled ablation. An experiment comparing identical training pipelines with 1 domain vs. 5 domains vs. 20+ domains, measuring performance on held-out domains, would provide more direct evidence. Additionally, it is unclear whether the generalization is to genuinely unseen task structures or to tasks that are novel combinations of seen patterns—the 20+ training domains plus 33 cold-start domains provide broad coverage, and Random Complex Tasks may sample from within this distribution rather than outside it. The paper does not characterize the relationship between training domain distribution and random task distribution.

Claim: "Training with environmental noise substantially improves robustness with no degradation of clean performance" (Section 3.3.3, Table 1). This claim is well-supported by the Table 1 ablation. The noise-trained model achieves 29.3% vs. 28.6% on clean VitaBench (+0.7pp, likely within noise) and 88.2% vs. 87.1% on clean τ²-Bench (+1.1pp), while achieving 20.5% vs. 13.3% on noisy VitaBench (+7.2pp) and 67.1% vs. 62.2% on noisy τ²-Bench (+4.9pp). The Pareto improvement is clear. However, the ablation compares only two conditions: training without noise and training with noise using a curriculum-based strategy. It does not isolate the contribution of the curriculum specifically—would uniform noise injection (same noise level throughout) produce similar results? Would training only on noisy data without clean data also work? The paper's claim implies that noise injection is the causal factor, but the experiment is too coarse to rule out that the specific curriculum strategy (progressive difficulty increase, adaptive triggering based on robustness thresholds) is doing the work.

Claim: "Heavy Thinking Mode enables effective test-time scaling that outperforms self-consistency" (Section 4). The heavy mode results (‡ annotations in Table 2) demonstrate consistent improvements: +8.2pp on IMO-AnswerBench, +10.7pp on AMO-Bench CH, +4.7pp on GPQA-Diamond. The paper claims superiority over self-consistency and that the advantage "becomes increasingly pronounced as the test-time computational budget grows" (Section 4). However, the experiments do not directly compare Heavy Thinking against self-consistency at matched computational budgets—there is no Table or Figure showing Heavy Thinking vs. majority voting vs. best-of-N at varying trajectory counts. The self-consistency comparison is asserted but not empirically demonstrated. More critically, the paper does not report heavy mode results for the agentic benchmarks (BrowseComp, τ²-Bench, VitaBench), which is where the claim of cross-domain generalizability would be tested. The heavy mode evidence is confined to mathematical reasoning and general QA, which are the domains where deep chain-of-thought reasoning (depth scaling) is already known to be effective—it is unclear whether the width+ depth combination provides benefits in interaction-heavy settings where parallel exploration may generate conflicting tool calls.

Weaknesses in experimental design:

• No statistical significance reporting. For a paper that introduces multiple evaluation protocol modifications (revised τ²-Bench, cleaned airline subset, updated VitaBench verifier, corrected BrowseComp-ZH annotations), the absence of confidence intervals or significance tests makes it difficult to assess whether observed differences (e.g., 88.2% vs. 87.4% on τ²-Bench) are reliable. The Random Complex Tasks protocol (3 runs of 100 tasks) would naturally produce variance estimates, but none are reported.

• Inconsistent comparison conditions. As noted, some comparison scores are from external reports using different evaluation frameworks, some are from the paper's own reproduction attempts, and some benchmarks (BrowseComp, BrowseComp-ZH) are reported with and without context management while others are not. The paper's internal evaluation on RWSearch (all models under the same framework) is more controlled, but this covers only one search benchmark.

• Missing agentic heavy mode results. The paper's strongest algorithmic contribution is the Heavy Thinking framework's claimed cross-domain applicability. The absence of heavy mode results for agentic search and tool use in Table 2 is a significant gap. Either these experiments were not run (suggesting the framework may not translate well to interactive settings), or they were run but not reported (raises questions about result selection).

• Coding performance is weaker relative to peers. On SWE-bench Verified (70.0%), the model trails GLM-4.7 (73.8%), DeepSeek-V3.2 (73.1%), and Claude (80.9%). This is the only benchmark category where the model is not competitive for the top position among open-weight models. The paper does not analyze this weakness or explain why the diverse environment training approach might transfer less effectively to software engineering tasks.

• Ablation reporting is selective. Several claimed techniques (self-verification, curriculum learning, dynamic budget allocation) lack quantitative ablations that would isolate their contributions. The GSPO objective choice is justified by prior work rather than through within-paper comparison. The multi-domain training benefit is demonstrated correlationally (Figure 9 shows benchmark improvement over training steps) but not causally (no single-domain comparison). This makes it difficult to attribute the model's performance to specific design choices rather than to scale of compute and data.

• No analysis of computational cost for training. The paper describes infrastructure (32,000 environments, 400+ machines, thousands of accelerators) but does not report total training FLOPs, GPU-hours, or wall-clock time. The DORA system's 2–4× speedup over synchronous training is reported without the baseline synchronous throughput, making the absolute training cost opaque. This is important context for interpreting the model's performance: if it requires substantially more training compute than DeepSeek-V3.2-Thinking or Kimi-K2-Thinking, the performance comparisons are not on equal footing.

• Single evaluation temperature setting. All inference uses temperature=1.0, top-p=1.0 (Section 5.2), which is the standard for benchmarking but does not explore whether the model's agentic capabilities are sensitive to sampling hyperparameters. Some models may benefit from lower temperature in tool-use settings where deterministic behavior is advantageous.

6. Limitations and Trade-offs

6.1 The Difficulty Estimation and Environment Construction Cost Is Unaccounted for in Training Budget

The automated environment scaling pipeline described in Section 3.1.1 is the foundation of the paper's central claim—that diverse, executable, verifiable environments produce generalizable agentic skills. However, the paper reports the output of this pipeline (tens of thousands of environments across 20+ domains, tool graphs with 60+ tools each) without reporting the cost of producing it.

The cost is substantial but opaque. The domain graph construction pipeline involves automated tool synthesis from domain specifications, database schema generation, unit testing, and an auxiliary debugging agent that fixes execution errors. The paper reports a success rate "exceeding 95% in transforming schema-level designs into fully executable tool implementations" (Section 3.1.1, Environment-grounded synthesis), which implies that approximately 5% of generated environments fail validation and require re-generation or manual intervention. The controlled graph expansion procedure involves BFS-style traversal of tool dependency graphs, multiple rounds of database consistency checking, and probabilistic decisions about whether to incorporate additional seed chains—each step requiring computational resources and human oversight.

The consequence: the paper's contribution is not a fully automated, zero-cost pipeline for constructing training environments. It is a methodology that likely requires significant engineering investment to instantiate for new domains, involving the design of domain specifications, implementation of domain-specific database schemas, and debugging of edge cases that the automated validation misses. A practitioner attempting to replicate this pipeline would face substantial upfront costs that the paper does not quantify or bound. This matters because the paper's core thesis—that environment diversity drives generalization—implies that the cost of constructing diverse environments should be amortized over the training gains. Without cost estimates, no such amortization analysis is possible.

Additionally, the RL task set construction for agentic search (Section 3.1.3) involves graph-based QA synthesis from Wikipedia (entity extraction, graph expansion, subgraph sampling, question generation with deliberate obfuscation, LLM-as-judge verification, and answer uniqueness checking) and agent-based QA synthesis (Entity Extraction Agent, Question Synthesis Agent, Verification Agent, Answer Generation Agent, Judgment Agent, all orchestrated by an FSM). Each of these stages involves multiple large language model calls. The paper provides no estimate of how many GPU-hours or dollars this synthesis costs per question-answer pair, making it impossible for practitioners to assess whether the approach is cost-effective for their domains.

Mitigation status: Not addressed. The paper does not report environment construction cost, does not discuss scaling properties of the construction pipeline (e.g., does cost per environment decrease as more environments are built?), and does not provide guidance on what level of investment in environment diversity is cost-effective. This is a significant gap for a paper whose central contribution is the environment scaling methodology.

6.2 Hard Problems in Agentic Domains Remain Unsolved—the Method Has a Hard Capability Ceiling

The paper demonstrates impressive performance on standard agentic benchmarks, but a careful reading of the results reveals a persistent failure mode: on the most challenging tasks, the model's performance remains low and shows no clear trajectory toward improvement. This is the agentic analog of the "hardest problems" limitation in pure reasoning—test-time and training-time compute can amplify existing capability but cannot create capability that the model fundamentally lacks.

The evidence appears in several places:

• VitaBench (29.3%) and VitaBench-Noise (20.5%): These are the only benchmarks in the agentic tool-use category where the model scores well below 80%. VitaBench measures "versatile interactive tasks in real-world applications" (Section 5.1), representing the most open-ended and varied agentic evaluation. That the best open-source model achieves only 29.3%—and even the best closed-weight model (Gemini-3-Pro, 31.5%) barely exceeds this—suggests a fundamental difficulty ceiling that scaling alone does not overcome. The noise-augmented variant at 20.5% indicates that real-world imperfection further degrades already-limited capability.

• Random Complex Tasks (35.8%): This benchmark is specifically designed to test generalization to unseen task distributions, making it the most direct test of the paper's central claim. The score of 35.8%—while leading all models—still means the model fails on approximately 64% of randomly generated agentic tasks. This is the generalization ceiling: exposure to 20+ domains and tens of thousands of environments produces a model that succeeds on roughly one-third of novel tasks in new domains. The gap between this result and the 88.2% on τ²-Bench (where the model has seen similar domain structures during training) indicates significant overfitting to training environment distributions despite the diversity of the training data.

• SWE-bench Verified (70.0%): Among coding benchmarks, this is where the model trails most significantly—behind GLM-4.7 (73.8%), DeepSeek-V3.2 (73.1%), and Claude (80.9%). SWE-bench requires navigating large codebases, generating targeted patches, and understanding software engineering conventions—capabilities that the paper's diverse environment training approach does not seem to transfer to as effectively as coding-specialized training pipelines.

The consequence: the paper demonstrates that environment scaling produces strong generalization within the capability range that the base model can support, but it does not extend that range. On tasks where the base model's fundamental reasoning or interaction capabilities are insufficient, no amount of environment diversity, noise training, or Heavy Thinking closes the gap. This bounds the applicability of the approach: it is effective for complex-but-solvable tasks (τ²-Bench, BrowseComp) but offers diminishing returns as task complexity increases beyond the model's intrinsic capability boundary.

Mitigation status: The paper does not explicitly acknowledge this ceiling or analyze it. The strong results on τ²-Bench (88.2%) and BrowseComp (73.1%) are presented as evidence of the approach's effectiveness without discussing what the much lower scores on VitaBench (29.3%) and Random Complex Tasks (35.8%) imply about its limitations. The introduction frames environment interaction as the mechanism for "further progress" after intrinsic reasoning "approaches its limits" (Section 1), but the evidence suggests that even with environment interaction, progress on the hardest tasks is limited.

6.3 Heavy Thinking Mode Is Not Demonstrated on the Benchmarks Where It Matters Most

The paper presents Heavy Thinking Mode (Section 4) as a general test-time scaling framework that works "across a wide range of settings, including long chain-of-thought reasoning, tool-integrated reasoning, and fully agentic tool-use scenarios." However, the empirical evidence for this claim is restricted almost entirely to mathematical reasoning and general QA benchmarks (Table 2, results marked with ‡):

• AIME-2025: 99.6% → 100.0%
• HMMT-2025: 93.4% → 97.5%
• IMO-AnswerBench: 78.6% → 86.8%
• AMO-Bench EN: 61.6% → 66.0%
• AMO-Bench CH: 56.8% → 67.5%
• GPQA-Diamond: 80.5% → 85.2%

No Heavy Thinking results are reported for agentic search (BrowseComp, BrowseComp-ZH, RWSearch), agentic tool use (τ²-Bench, VitaBench, Random Complex Tasks), or coding (LiveCodeBench, OJBench, OIBench, SWE-bench Verified). This is a conspicuous omission. The Heavy Thinking architecture (parallel reasoning → summary synthesis) is described in a way that should be applicable to agentic tasks—the parallel reasoning stage could generate multiple tool-use trajectories, and the summary stage could synthesize them. But the fact that no results are reported for these benchmarks raises the possibility that the approach does not work well, or works but with unacceptable computational cost, or was not attempted.

The potential failure modes in agentic settings are significant. Parallel reasoning with tool interactions could generate conflicting tool calls (different trajectories calling different tools with different parameters, making the environment state inconsistent if executed). The summary model, which receives only "answer content" (not full reasoning traces) from parallel trajectories (Section 4, context memory description), may lack the information needed to resolve conflicts between trajectories that took different tool interaction paths. Multi-turn interactions compound these issues: the summary model's output becomes the context for the next turn's parallel reasoning, potentially propagating synthesis errors.

The consequence: the paper's claim of cross-domain Heavy Thinking effectiveness is supported only for the domain where test-time scaling is already well-established (mathematical reasoning). The extension to agentic settings—which would be the novel contribution—is asserted but not demonstrated. A practitioner deciding whether to implement Heavy Thinking for an agentic deployment has no evidence to work with.

Mitigation status: Not addressed. The paper states the applicability claim without qualifying it as a hypothesis or noting the absence of agentic results. Section 4 describes the architecture in general terms, but the evaluation section provides no connection between this architecture and the agentic benchmarks that form the paper's primary contribution.

6.4 Training Cost and Infrastructure Requirements Are Prohibitive for Most Practitioners

The paper describes an industrial-scale training operation whose cost and complexity put replication beyond the reach of most research groups and all but the largest companies. Several specific details in Section 3.2 and Section 3.3.3 quantify this:

• 32,000 environments executing concurrently across "roughly 400 physical machines with thousands of accelerators" (Section 3.2, Scaling to Large-scale Agentic Training).
• A 560B-parameter MoE model requiring expert parallelism with graph-level compilation for decode, PD disaggregation across separate device groups, and CPU-resident KV-cache swapping (Section 3.2, PD Disaggregation with CPU Swapping).
• Custom extensions to PyTorch RPC for "CPU-idleness-aware remote function invocation and object instantiation" to support flexible environment scheduling.
• A training system (DORA) that is "2 to 4 times faster than synchronous training across our production jobs" (Section 3.2), implying that a synchronous baseline would require 2–4× the already-substantial resources.

The paper does not report total training cost (GPU-hours, wall-clock time, or estimated dollar cost). This omission makes it impossible to assess whether the performance gains are worth the investment, or to compare cost-effectiveness against alternative approaches like scaling model size, using more pretraining data, or leveraging commercial API-based agentic systems.

The consequence: the paper's contributions are most valuable to organizations that already have industrial-scale training infrastructure. For academic researchers, smaller companies, or practitioners working with budget constraints, the methodology provides design principles (diverse environments are good, noise training helps robustness, Heavy Thinking improves test-time performance) but no cost-effective path to implementation. The automated environment scaling pipeline, while reducing human effort, still requires running large language models for synthesis and verification, and the resulting environments require the same large-scale RL infrastructure to be useful for training.

Mitigation status: The paper does not acknowledge this as a limitation or discuss how the approach might be scaled down. The separate release of LongCat-Flash-Thinking-ZigZag with Zigzag Attention (Section 6) addresses inference efficiency (1.5× speedup) but not training cost. The open-weight release enables inference-only use of the trained model, but the training methodology itself is not accessible to most potential users.

6.5 Evaluation Framework Modifications Undermine Cross-Model Comparability

The paper introduces several modifications to standard evaluation protocols, some of which make direct comparison with other models' reported scores unreliable:

• τ²-Bench: The user simulator is replaced with GPT-4.1 and prompting is adjusted because the original simulator "occasionally exhibits abnormal behaviors" (Section 5.1). The airline subset has 19 problematic cases corrected. Some comparison scores in Table 2 are marked with † ("score is from external reports"), meaning they were collected under the original evaluation protocol with a different simulator. The paper's own scores (88.2%) and DeepSeek-V3.2's score (80.6%, not marked with †) appear to use the modified protocol, while others (Kimi-K2 at 74.3% with †, GLM-4.7 at 87.4% with †) use the original.

• VitaBench: The verifier model is upgraded to the "strongest publicly available version" with "stricter evaluation criteria" (Section 5.1). This means the paper's VitaBench scores are not directly comparable to previously reported scores using the original verifier and criteria.

• BrowseComp and BrowseComp-ZH: The paper compares scores with and without context management (e.g., 56.6 vs. 73.1 on BrowseComp). For external models on BrowseComp, the paper uses official reports after failing to reproduce reported numbers under its own framework: "we observed consistently lower performance than the reported numbers" (Section 5.1). This means the BrowseComp comparison in Table 2 pools results from different evaluation frameworks with different search capabilities, tool access, and context management strategies.

• HLE: The paper reports that "results of HLE are sensitive to prompt templates and scoring models" (Section 5.1) and standardizes to the official o3-mini scoring model. Some comparison scores are from external reports (GPT-5.2 at 34.5% with †), making template sensitivity an uncontrolled variable.

The consequence: while these modifications are individually justified (noisy simulators, annotation errors, and weak verifiers genuinely degrade evaluation reliability), their cumulative effect is that the comparison table (Table 2) is not a controlled experiment. Scores are not all collected under identical conditions. The paper's improvements over prior models on τ²-Bench and VitaBench may partially reflect differences in evaluation protocol rather than genuine capability differences. This is particularly concerning for the central agentic tool-use results, which are the paper's main contribution.

The paper partially addresses this for agentic search by introducing RWSearch as a clean-slate benchmark where all models are evaluated under the same framework. The RWSearch results (79.5% vs. 74.0–82.0%) are the most credible head-to-head comparisons. But for agentic tool use, no equivalent clean-slate benchmark exists—Random Complex Tasks is a new benchmark but is not evaluated on most comparison models beyond the subset shown in Table 2 (GPT-5.2 scores 17.2%, which is anomalously low and raises questions about whether the evaluation protocol disadvantages certain model architectures or inference strategies).

Mitigation status: Partial. The paper publicly releases all its evaluation modifications for reproducibility. It acknowledges that BrowseComp external model results use official reports rather than its own reproduction. However, it does not provide a table or analysis showing how much the evaluation modifications affect scores (e.g., what does the paper's model score under the original τ²-Bench protocol vs. the modified one?), which would allow readers to calibrate the magnitude of protocol-induced variance. The anomalous GPT-5.2 score on Random Complex Tasks is not discussed, despite it being the largest model in the comparison and the strongest on most other benchmarks.

6.6 The Generalization Claims Lack Causal Evidence—Correlation Confused with Causation

The paper's central thesis is that diverse environment training causes generalizable agentic reasoning. This causal claim is stated explicitly: "we posit that transferable agentic reasoning capability should emerge from exposure to diverse tool sets and interaction patterns" (Section 3.1.1). The evidence for this claim is the Random Complex Tasks result (35.8% vs. 25.3–32.6% for baselines) and the training curves showing simultaneous improvement across multiple benchmarks (Figure 9).

However, this evidence is correlational, not causal. The model was trained on diverse environments and performs well on novel environments, but there is no controlled experiment that isolates the diversity variable:

• There is no comparison of identical training pipelines with varying numbers of training domains (e.g., 1 domain, 5 domains, 20 domains), measuring held-out domain performance.
• There is no ablation that trains on the same total number of environment interactions but from fewer, more homogeneous environments—which would control for the total amount of agentic interaction data versus its diversity.
• The model also differs from baselines in model architecture (560B MoE with 27B activated), training infrastructure (DORA with multi-version asynchrony), training strategies (GSPO, curriculum learning, self-verification, noise injection), and data quality (sliding-window perplexity KCG selection, hybrid data synthesis). Any of these factors could contribute to the generalization performance.

The consequence: the paper's most intellectually significant claim—that environment diversity is the primary driver of agentic generalization—is supported by an existence proof (diverse training + good generalization) but not by a controlled experiment that isolates the causal factor. A skeptical reader could argue that the model's strong Random Complex Tasks performance is due to its model scale, its carefully curated cold-start data, its noise training, or its RL training strategy—any of which might produce generalization without the environment scaling pipeline. The paper provides no evidence to rule out these alternative explanations.

Mitigation status: Not addressed. The paper does not acknowledge this as a limitation or propose follow-up experiments that would establish causality. The environment scaling contribution is presented as validated by the generalization results, but the logical gap between "we built diverse environments and got good generalization" and "diverse environments cause generalization" remains unexamined. This is a significant methodological weakness for a paper that positions environment scaling as its core innovation.

7. Implications and Future Directions

How This Work Changes the Landscape

This paper does not introduce a single algorithmic breakthrough that renders prior work obsolete. Rather, it performs a more subtle but potentially more durable operation: it redefines what the agentic training problem is about, shifting the field's focus from model architecture and RL algorithms toward environment design and data diversity as the primary levers for producing generalizable agentic behavior.

The magnitude of this shift is significant but not revolutionary. It does not overturn the fundamental paradigm of reinforcement learning for language models—the model still uses GSPO as the training objective, still relies on outcome-based reward signals, and still follows a cold-start → RL pipeline. What changes is the relative importance of components within that paradigm. Prior work implicitly treated the environment as a fixed, exogenous input: you have some benchmarks, you train against them, and you measure generalization as a separate property. LongCat-Flash-Thinking-2601 treats the environment as an endogenously designed, actively scaled resource that causes generalization. This reframing has second-order effects: it makes environment construction methodology a first-class research contribution rather than an engineering detail, it elevates environment diversity to a status comparable to model size in the scaling conversation, and it creates a new axis of investment for organizations building agentic systems—how much to spend on building better training environments versus scaling model parameters or RL compute.

The paper also reconciles a latent contradiction in the agentic training literature. On one hand, models like DeepSeek-V3.2-Thinking and Kimi-K2-Thinking demonstrated that open-weight models could achieve non-trivial agentic performance, but their results on benchmarks like τ²-Bench (80.6% and 74.3%, respectively) and their performance degradation under noise (64.1% and 63.1% on τ²-Bench-Noise) suggested a ceiling driven by environment-specific overfitting and brittleness. On the other hand, the closed-weight frontier (Claude, Gemini, GPT-5.2) demonstrated stronger generalization and robustness but disclosed nothing about their training methodology, creating an unproductive asymmetry where the open-source community knew that agentic capability was achievable but not how. LongCat-Flash-Thinking-2601 bridges this gap by providing a disclosed methodology whose results (88.2% on τ²-Bench, 67.1% on τ²-Bench-Noise, 35.8% on Random Complex Tasks) narrow the gap with closed-weight models on key metrics. The paper does not fully close this gap—Gemini-3-Pro still leads on VitaBench (31.5% vs. 29.3%) and GPT-5.2-Thinking-xhigh leads on AIME-2025 and HMMT-2025—but it establishes that the methodological ingredients for strong open-weight agentic capability are environment diversity, noise-aware training, and test-time scaling, not proprietary architecture or data.

The paper makes several research directions more attractive:

• Environment design as a research discipline. The paper demonstrates that automated environment construction with verifiability guarantees is both possible and performance-impactful. This opens the door to treating environment design as a scientific problem with its own methodology, evaluation criteria, and scaling properties—analogous to how dataset curation became a recognized research contribution in the pretraining era.
• Robustness-by-training rather than robustness-by-architecture. The paper's noise injection results (Table 1) suggest that training on imperfect environments is a more effective robustness strategy than architectural modifications or post-hoc filtering. This makes robustness research more empirical and less theoretical, with the key question becoming "how should noise be introduced during training?" rather than "what architecture is noise-resistant?"
• Test-time scaling beyond reasoning. The Heavy Thinking framework, while not fully demonstrated on agentic benchmarks, proposes a general architecture (parallel exploration + summary synthesis) that could be applied to any task with a verifiable correctness signal. This opens test-time scaling research beyond the mathematics and code domains where it has been concentrated.

The paper makes several directions less attractive:

• Hand-crafted environment design. The automated pipeline's success makes manual environment construction for agentic training look increasingly inefficient. For researchers, the return on investment shifts from building a few high-quality environments to building systems that can generate many environments.
• Architecture-centric approaches to agentic capability. The paper achieves state-of-the-art agentic performance with a relatively standard MoE architecture (27B activated parameters, no novel attention mechanism for agentic tasks beyond the separate Zigzag experiment). This suggests that architecture innovation is not the primary bottleneck for agentic capability—environment design and training strategy are.
• Benchmark-specific optimization. The paper's Random Complex Tasks evaluation (35.8% vs. 32.5% for baselines) shows that training on diverse environments produces generalization that cannot be achieved by optimizing against a fixed set of benchmarks. For research groups pursuing agentic capability, investing in benchmark-specific training data becomes less attractive than investing in diverse environment generation.

Follow-Up Research This Work Enables

1. Measuring the causal effect of environment diversity on generalization. The paper's central claim—that diverse environments cause generalizable agentic reasoning—is supported correlationally but not causally. A clean follow-up experiment would train identical model architectures with identical RL budgets on varying numbers of training domains (1, 2, 5, 10, 20) from the environment scaling pipeline, keeping total environment interactions constant by oversampling within fewer domains. The dependent variable is performance on the Random Complex Tasks benchmark and on held-out domains not used in any training condition. If the causal claim holds, performance should increase monotonically with domain count and plateau only when coverage saturates. If performance plateaus at 5 domains, the diversity claim is weakened; if it continues improving to 20+, the claim is strengthened and the "diversity scaling law" becomes a productive object of study. The paper's automated environment pipeline makes this experiment newly tractable by providing a reproducible source of diverse, verifiable environments with controlled complexity.

2. Characterizing the failure modes of Heavy Thinking on agentic tasks. The paper claims Heavy Thinking works across agentic settings but reports results only for mathematical reasoning and general QA. A targeted follow-up would run Heavy Thinking on BrowseComp, τ²-Bench, and VitaBench, measuring not just Pass@1 but also qualitative failure categories: (a) parallel trajectories produce conflicting tool calls that the summary model cannot resolve, (b) the summary model incorrectly privileges a minority trajectory with flawed reasoning, (c) heavy thinking's computational cost provides no benefit over best-of-N at matched budget, and (d) heavy thinking provides substantial gains. The key measurement is at what computational budget (number of parallel trajectories) heavy thinking's advantage over self-consistency emerges or disappears. If heavy thinking provides no benefit on interactive benchmarks, the framework's claimed generality is falsified and future work should focus on interaction-aware summary synthesis. If it provides benefit but at prohibitive cost, the research question shifts to efficiency.

3. Isolating the contribution of curriculum-based noise injection versus uniform noise training. The paper's robust RL results (Table 1) compare only two conditions: no noise and curriculum-based noise. This conflates two independent interventions: (a) exposure to noise, and (b) the curriculum strategy (progressive difficulty increase, adaptive triggering). A follow-up experiment would compare curriculum-based noise against uniform noise injection at fixed noise levels (mild only, moderate only, severe only) and against a naive "noise from the start" strategy with no progression. The measurement is performance on both clean and noisy benchmarks. If uniform noise at moderate levels matches curriculum performance, the curriculum strategy is unnecessary complexity. If curriculum outperforms all uniform conditions, the paper's specific strategy is validated. This experiment is newly tractable because the paper's noise injection pipeline is described in sufficient detail (automated, multi-type, controllable levels) to be replicated.

4. Transfer of agentic skills between domains with structural similarity. The paper trains on 20+ diverse domains but does not analyze whether generalization is uniform or structured. A fine-grained follow-up would categorize training environments by structural properties (e.g., tool graph density, number of tool nodes, presence of particular dependency motifs like sequential chains vs. branching dependencies) and measure held-out performance on novel environments grouped by these properties. The hypothesis: generalization is stronger between structurally similar domains (e.g., two domains with dense, highly interconnected tool graphs) than between structurally dissimilar ones (dense vs. sparse graph). Finding would provide design guidance for environment scaling—invest in diversity along structural axes, not arbitrary domain coverage. The paper's tool dependency graph methodology (Section 3.1.1) makes this structural analysis feasible by providing a formal representation of environment complexity.

5. Difficulty estimation without the 2048-sample oracle. The paper's environment scaling pipeline produces tasks with ground-truth solution chains, enabling reliable reward signals during training. However, the pipeline's task generator is "restricted to utilizing the full tool chain exclusively" to avoid bias—it produces tasks that are matched to specific solution chains. A natural extension is to estimate task difficulty from structural properties of the environment (graph density, chain length, number of alternative paths) without requiring a strong solver to attempt the task. This would enable dynamic curriculum design where training task distribution is adjusted based on computed complexity rather than pass-rate feedback. The paper's formalization of environment complexity through $c(\mathcal{E}_n)$ and $g(\mathcal{D}_n)$ (the structural complexity and search difficulty metrics in the expansion decision function) provides a starting point for such estimators. The experiment would compare a pass-rate-based curriculum against a structural-complexity-based curriculum, measuring final performance and training efficiency.

6. Testing the robustness limits of noise injection. The paper models two noise types (instruction noise, tool noise) and demonstrates improved robustness at modest noise levels (Table 1). A stress-test follow-up would escalate noise to extreme levels—tool failure rates exceeding 50%, instructions with deliberately contradictory constraints, environments that change state between interactions—and measure at what point the noise-trained model's advantage over the clean-trained model disappears. This establishes the "robustness frontier" of the approach and identifies whether there is a noise regime where training on noise becomes counterproductive (e.g., the model learns to be overly cautious, refusing to take any action because tools might fail). The experiment would also test whether the curriculum strategy can be extended by adding a "noise annealing" phase late in training where noise is reduced to fine-tune clean performance while preserving robustness.

Practical Applications and Downstream Use Cases

1. Customer-facing conversational agents with tool access. The paper's strongest results are on τ²-Bench (88.2%), which simulates conversational agents interacting with business tools across retail, airline, and telecom domains. The 88.2% score—representing successful task completion across diverse customer service scenarios—suggests the model is production-ready for deployment as a customer service agent backed by internal business tools (reservation systems, order management databases, support ticket systems). The noise-augmented performance of 67.1% on τ²-Bench-Noise is particularly relevant: real-world customer interactions involve ambiguous queries, partial information, and occasional tool failures, and the model demonstrates meaningful robustness to these conditions. A deployment would use the Heavy Thinking mode for complex customer requests that require comparing multiple options (parallel reasoning) and synthesizing a recommendation (summary synthesis), while defaulting to standard single-trajectory inference for simpler queries to control cost. The Zigzag Attention variant's 1.5× inference speedup (Figure 12) enables higher throughput for latency-sensitive customer interactions.

2. Automated software engineering with diverse toolchains. The model's agentic coding performance is competitive (82.8% on LiveCodeBench, 70.0% on SWE-bench Verified) but not best-in-class among open-weight models. The unique value proposition for software engineering is the model's demonstrated ability to generalize across diverse tool environments—the same model that books flights and queries databases can also navigate a codebase, run tests, and edit files. This makes it suitable for "full-stack" agentic tasks that cross tool boundaries: a single agent that can search documentation (browser tool), query the codebase (code search tool), run tests (terminal tool), and file a pull request (API tool). The Random Complex Tasks result (35.8%, leading all models) suggests that this cross-tool generalization is stronger than for models with narrower agentic training. A practical deployment would configure the agent with access to the organization's specific tool ecosystem (internal build systems, deployment pipelines, monitoring dashboards) and use the environment scaling methodology to construct training environments that mirror the organization's actual tool dependency graphs, producing a customized agent that generalizes across the organization's specific tools rather than generic benchmarks.

3. Data generation for self-improving agentic systems. The paper's environment scaling pipeline and RL training framework together constitute a system for continuously generating new training tasks and improving the model against them. This can be operated as a self-improvement loop: (1) the environment pipeline generates novel environments and tasks, (2) the current model is evaluated on these tasks to estimate difficulty and identify capability gaps, (3) tasks in the model's "zone of proximal development" (the dynamic budget allocation sweet spot) are selected for the next RL training phase, (4) the improved model generates higher-quality trajectories on previous tasks, which become cold-start data for the next iteration. The paper's report that "behavioral diversity is increased by reusing rollout trajectories from subsequent reinforcement learning stages" (Section 3.1.2, Agentic Search) suggests this loop is already partially implemented. For organizations with evolving tool ecosystems (new APIs, deprecating old tools, changing business logic), this loop enables the agent to continuously adapt without manual retraining effort. The key practical requirement is the upfront investment in environment construction infrastructure—once built, the marginal cost of generating new training tasks is low.

4. Open-source agentic research infrastructure. The paper's combination of open-weight model release, disclosed environment scaling methodology, and released evaluation modifications (revised τ²-Bench, updated VitaBench verifier, RWSearch benchmark, Random Complex Tasks protocol) creates a reproducible foundation for open-source agentic research that previously did not exist. Prior to this work, agentic benchmarks either had reliability issues (the original τ²-Bench simulator) or opaque evaluation (closed-weight models with undisclosed frameworks). The paper's modifications are publicly released, its model weights are available, and its environment construction method is described in sufficient detail for replication. For academic groups or smaller companies, this means: (a) they can evaluate their own agentic models against a known-strong open-weight baseline using consistent evaluation protocols, (b) they can extend the environment scaling pipeline to new domains without starting from scratch, and (c) they can study agentic capability emergence using a fully transparent training pipeline rather than reverse-engineering closed-weight behavior. The Zigzag Attention variant's open release provides an additional resource for long-context agentic inference research.