LongCat-Flash-Thinking-2601 Technical Report

🍞 Hook: Imagine you’re learning to bake cookies. Reading a recipe (thinking in your head) is helpful, but to really bake great cookies you must use tools (oven, mixer), follow steps, fix mistakes, and taste as you go. That’s the difference between just thinking and acting in the world.

🥬 The Concept (Agentic Reasoning – what changes in the world): Agentic reasoning is when an AI doesn’t just think but also decides when and how to use tools, checks results, and adapts across many steps. How it works (in the field before this paper):

1. Models got very good at single-shot reasoning like math problems and coding puzzles by thinking internally.
2. But real-life tasks are messy: you search websites, call tools, handle errors, and change plans over many turns.
3. Data about these long, tool-using interactions is rare, and training can be unstable and slow. Why it matters: Without agentic skills, an AI that aces a test might still fail at booking travel, fixing software, or doing real research. 🍞 Anchor: Planning a trip needs browsing, comparing flights, checking hotel rules, and rebooking if something breaks. That’s agentic, not just a one-time answer.

The World Before:

• Models excelled at internal, step-by-step thinking (like solving a math problem) but struggled to operate in external environments where they must click, run tools, read outputs, and try again.
• Training pipelines focused on static text and single-turn answers, not on multi-turn, long-horizon interactions.
• Real-world agent logs are scarce, messy, and often not executable or verifiable.

The Problem:

• How do we teach a model to use tools, survive noisy environments, and stay stable over many turns?
• How do we scale reinforcement learning (RL) when each sample is a long conversation with unpredictable tool delays?
• How do we make the model generalize to brand-new tools and unfamiliar domains?

Failed Attempts (and why):

• Pure offline imitation from logs: too noisy/inconsistent; often lacks step-by-step executability and verification.
• Small, hand-crafted environments: not diverse enough; models overfit to a few patterns and don’t generalize.
• Synchronous RL with batches: stalls on long, slow rollouts; devices sit idle, training crawls.

The Gap:

• We need an end-to-end pipeline that: (1) builds many reliable, executable environments across domains, (2) scales RL asynchronously over long, variable interactions, (3) injects realistic noise to build robustness, and (4) adds test-time compute strategies to push reasoning further.

Real Stakes (in daily life):

• Web research: cross-check multiple sources, verify claims, and handle paywalls or broken links.
• Customer support: follow complicated troubleshooting trees, handle flaky tools, and keep context across many turns.
• Software debugging: read logs, edit code, run tests, and roll back safely.
• Scheduling/booking: juggle constraints, compare options, and recover from failures.
• Data chores: fetch from APIs, clean tables, and reconcile inconsistencies.

New Concepts (sandwich explanations introduced here):

🍞 Hook: You know how a coach helps a team improve by trying plays and giving feedback? 🥬 The Concept: Reinforcement Learning (RL) is training by trial, feedback, and improvement. How it works:

1. The model tries an action.
2. The environment reacts and gives a score (reward).
3. The model updates to do better next time. Why it matters: Without RL, the model can’t learn from doing; it stays stuck reading recipes instead of cooking. 🍞 Anchor: The AI tries a search query, gets a poor result, learns to refine the query next time.

🍞 Hook: When you chat with a friend, one message isn’t enough—you go back and forth. 🥬 The Concept: Multi-turn Interaction means the AI and environment exchange many messages over time. How it works:

1. User asks → model plans.
2. Model calls a tool → gets output.
3. Model updates plan → repeats until done. Why it matters: Without multi-turn support, complex tasks get cut off or confused. 🍞 Anchor: Fixing a bug often needs many rounds: read error, change code, run tests, tweak again.

🍞 Hook: Imagine a hospital with many specialists: a heart doctor, a bone doctor, and more. 🥬 The Concept: Mixture-of-Experts (MoE) is a model with many specialist sub-models (experts) where only a few wake up per token. How it works:

1. A router decides which experts to activate.
2. Selected experts process the token.
3. Their outputs combine into the final result. Why it matters: You get big-brain capacity with small-brain cost per step. 🍞 Anchor: For a coding question, the ‘programmer’ expert helps more than the ‘poetry’ expert.

🍞 Hook: Before searching a messy attic, you draw a map of where to look. 🥬 The Concept: Attention Mechanism lets the model focus on the most relevant pieces of context. How it works:

1. Compare current word to all previous words.
2. Give higher weights to more relevant bits.
3. Use weighted info to decide next token. Why it matters: Without attention, the model treats “the” and “capital” as equally important. 🍞 Anchor: In “What’s the capital of France?” attention locks onto “capital” and “France,” not “what’s.”

The Aha! Moment in one sentence: Treat agentic reasoning as a full-stack problem—co-design data, executable environments, RL algorithms, and systems so a thinking model can act, adapt, and generalize, then supercharge it with Heavy Thinking at test time.

Multiple Analogies:

1. Theme park training: Build many safe rides (environments), let the trainee practice with varying difficulty (curriculum), sometimes drop fake rain or wind (noise), measure performance, and upgrade the rides and rules together (co-design).
2. Sports academy: Recruit specialists (MoE), run scrimmages across many fields (domains), use video review (self-verification), and hold drills in storms (noise). On game day, put multiple strategists in parallel and let a head coach summarize (Heavy Thinking).
3. Kitchen lab: Stock many tools and recipes (tools + environments), try experiments (RL), keep tidy notes (context management), and when stuck, invite several chefs to propose dishes and a head chef to blend ideas (Heavy Thinking).

Before vs After:

• Before: Models were smart in their heads but clumsy using tools, brittle to noise, and slow to train over long interactions.
• After: LongCat-Flash-Thinking-2601 learns in large, executable, multi-domain worlds, stays steady with asynchronous RL, handles noise, and gets test-time boosts from parallel-and-summarize Heavy Thinking.

Why It Works (intuition, no equations):

• Practice where it counts: Training inside verified, scalable tool worlds teaches the model the real patterns of using tools.
• Many small wins: Asynchronous RL keeps devices busy despite slow, uneven tool calls, so learning never stalls.
• Tough-love training: Injecting realistic instruction and tool noise builds habits for recovery and verification.
• Think wider and deeper: Heavy Thinking explores many solution paths and then refines them, raising the chance of a correct, robust answer.
• MoE efficiency: Specialists add capacity without paying full cost every token, so the model can be big yet fast enough.

Building Blocks (with sandwich explainers):

🍞 Hook: Learning to ride different bikes on many terrains makes you a better cyclist. 🥬 The Concept: Environment Scaling means automatically building many executable tool worlds across domains. How it works:

1. Start from a domain definition (like a file system or retail tools).
2. Auto-generate tool code and a database schema; verify with tests.
3. Expand tool graphs carefully so everything stays runnable and consistent. Why it matters: Without lots of reliable worlds, the model memorizes a few tricks and fails elsewhere. 🍞 Anchor: From a small path (a few tools) to a big map (many tools), always keeping the roads connected and drivable.

🍞 Hook: Sometimes directions are vague and machines glitch—real life is like that. 🥬 The Concept: Noise Injection adds controlled confusion during training. How it works:

1. Mix in instruction noise (ambiguous prompts) and tool noise (partial results, failures).
2. Use a curriculum: start mild, increase as the model toughens.
3. Keep tasks solvable; don’t break the ground truth. Why it matters: Without practicing in noise, agents crumble when reality is messy. 🍞 Anchor: A search tool times out; the agent retries, clarifies, or switches strategy rather than giving up.

🍞 Hook: Imagine a classroom where students hand in work at different times; the teacher keeps grading as it comes in. 🥬 The Concept: Asynchronous RL with DORA is a training loop that never waits for the slowest sample. How it works:

1. Many rollouts run in parallel; results stream in.
2. Trainer updates continuously (multi-version to control staleness).
3. Prefill/Decode disaggregation and KV-cache swapping keep GPUs busy. Why it matters: Without asynchrony, long, tool-laggy tasks waste compute and slow learning. 🍞 Anchor: While one sandbox compiles, others are already improving the model.

🍞 Hook: For hard puzzles, it helps to try many ideas and then compare notes. 🥬 The Concept: Heavy Thinking Mode scales test-time compute by exploring multiple reasoning paths and then summarizing. How it works:

1. Parallel thinkers propose answers (width).
2. A summarizer compares, merges, and refines (depth).
3. Extra RL helps the summarizer pick and polish the best parts. Why it matters: Without Heavy Thinking, the model might stick to a single, wrong path. 🍞 Anchor: Three detectives share clues; a head detective writes the final, strongest case.

🍞 Hook: Scanning a long book, your eyes hop between the latest paragraph and important earlier pages. 🥬 The Concept: Zigzag Attention sparsifies attention so it’s fast on long contexts while keeping global anchors. How it works:

1. Some layers use local + prefix attention (sparse), others keep full attention.
2. Alternating layers let information hop across the sequence like a zigzag path.
3. YaRN extends positions to 1M tokens; overall speedup about 1.5×. Why it matters: Without efficient attention, long-context agent work and Heavy Thinking become too slow. 🍞 Anchor: You skim nearby text but can still peek at the intro summary to stay grounded.

High-level recipe: Input (a task that needs tools) → Pretraining + Mid-training (prime agentic skills) → RL Preparation (build executable environments + tasks) → Scalable Asynchronous RL (DORA) with smart strategies → Robustness via noise curriculum → Test-time Heavy Thinking → Output (a reliable, tool-using solution).

1. Pretraining and Mid-training (priming agentic behaviors) What happens:

• Start with strong language and reasoning abilities from LongCat-Flash-Chat.
• Extend context lengths in stages (32K → 128K → 256K), allocating most tokens to mid-lengths and extra to ultra-long.
• Inject moderate, structured agentic trajectories so the model learns basic planning and tool-use formats before RL. Why this step exists:
• RL is inefficient if the model doesn’t know the basic ‘dance moves’ of tool use. Example data:
• Text-driven synthesis: mine multi-step tutorials, extract tool schemas and calls; diversify tool and reasoning patterns.
• Environment-grounded synthesis: generate real tool chains from verified Python tool graphs; check by executing and validating final database states.
• Planning-oriented augmentation: transform linear traces into decision points with candidate actions and selections.

1. RL Preparation: Environments and Tasks What happens:

• Automated environment construction from domain definitions to verified tool graphs with databases and tests.
• Carefully expands tool chains via BFS-like growth to maintain executability and consistency.
• Task sets:
  • Agentic search: graph-based QA (multi-hop over Wikipedia relations) + agent-based QA (ambiguity via FSM and multi-agent verification).
  • Agentic tool-use: tasks directly from the environment scaling pipeline (each environment defines its own goal, user profile, and verifiable rubric). Why this step exists:
• The model must practice in many reliable worlds with measurable goals to learn transferable agent behavior. Example:
• A retail domain with inventory, orders, and returns tools; tasks require calling a sequence like check_stock → create_order → update_shipping, verified by database state.

1. Scalable Asynchronous RL Framework (DORA) What happens:

• Fully streaming pipeline: rollout, environment execution, and reward happen without batch barriers.
• Multi-version async training: use slightly older models for generation while the trainer updates a newer version; control staleness.
• Prefill–Decode disaggregation + CPU KV-cache swapping: separate long-input prefill from fast decode; move KV blocks between CPU and GPU to avoid recompute and keep throughput high.
• Massive scale: up to 32,000 environments across thousands of accelerators via RPC extensions and virtual rollout groups. Why this step exists:
• Agentic rollouts are long, uneven, and tool-latency heavy. Asynchrony is the secret to keeping hardware busy and training stable. Example with data:
• While one coding sandbox runs tests, other conversations continue decoding; finished trajectories are queued instantly for training.

1. RL Training Strategy What happens:

• Objective: Group Sequence Policy Optimization (GSPO) for sequence-level stability with MoE.
• Curriculum learning: start with easier or foundational capabilities; gradually raise difficulty and capability mix.
• Dynamic budget allocation: monitor pass rates in real time; oversample tasks at the right difficulty sweet spot.
• Self-verification: the model periodically judges its own rollouts, especially hard cases, to accelerate learning without shortcuts. Why this step exists:
• Heterogeneous tasks have very different learning value; the strategy ensures compute goes where it helps most. Example:
• If the model often fails on multi-constraint scheduling tasks, those tasks are oversampled until success rises.

1. Agentic-Specific Context Management What happens:

• Hybrid policy: summarize when context exceeds ~80K tokens; if turns get too many, do a clean reset (discard-all) with a concise restart prompt.
• Progressive discard thresholds allow more steps for tougher problems. Why this step exists:
• Long tool outputs and many turns can overflow context; careful management retains key info without breaking the task. Example:
• On BrowseComp, hybrid management improved Pass@1 up to 73.1% under certain budgets by balancing retention and efficiency.

1. Multi-Domain Environment Training What happens:

• Train across many heterogeneous domains in each batch for generalization.
• Use domain-wise oversampling to avoid stalling on slow domains and to keep mixture roughly balanced without sacrificing asynchrony.
• Approximate dynamic budget allocation with task-specific oversampling, computed from historical pass rates. Why this step exists:
• True generalization requires varied practice without letting one domain dominate or block the pipeline. Example:
• Airline, telecom, and retail tasks appear together; harder or underrepresented domains receive higher rollout quotas.

1. Robust RL with Noise Curriculum What happens:

• Inject instruction noise (ambiguous or chatty users) and tool noise (timeouts, partial or inconsistent outputs) progressively.
• Ensure solvability and reliable rewards even under noise. Why this step exists:
• Real deployments are messy; training the model to recover gracefully reduces brittle failures. Example with numbers:
• On noisy variants, training with noise greatly narrows the clean→noisy performance gap (e.g., τ-Noise 67.1% vs much lower without noise training).

1. Test-time Scaling: Heavy Thinking Mode What happens:

• Parallel Reasoning: K thinkers generate independent candidates.
• Heavy Thinking: a summarizer reads the candidates (and the history) and produces a final, refined answer.
• Extra RL tunes the summarizer to aggregate faithfully and robustly. Why this step exists:
• Hard problems benefit from exploring multiple paths and then combining the best insights. Example:
• For a tricky math or multi-hop search, several chains are explored; the summarizer aligns on the most consistent evidence and final answer.

Secret Sauce (what’s clever):

• A full-stack co-design: executable environments + asynchronous RL + curriculum + noise + context management + Heavy Thinking + MoE efficiency.
• Verified environment graphs prevent silent training bugs from broken tool dependencies.
• DORA’s PD disaggregation and CPU KV swapping tame long-context, multi-turn workloads on mid-range accelerators.
• Noise curriculum builds real-world grit without corrupting rewards.

The Test (what and why):

• Five areas: mathematical reasoning, agentic search, agentic tool use, general QA, and coding.
• Focus is agentic ability: using tools, browsing, coding in sandboxes, and handling long, noisy, multi-turn tasks.
• Heavy Thinking and hybrid context management are tested to see how scaling test-time compute boosts outcomes.

The Competition (who we compared to):

• Open-weight reasoning leaders like DeepSeek-V3.2-Thinking, Kimi-K2-Thinking, Qwen3-235B-A22B-Thinking, GLM-4.7-Thinking.
• Closed-weight leaders like Claude-Opus-4.5, Gemini-3-Pro, GPT-5.2-Thinking.

The Scoreboard (with context):

• Agentic Search:
  • BrowseComp: 73.1% with context management. Think of this as an A when many others are at B levels; it shows strong browsing-and-verifying ability.
  • RWSearch: 79.5% without context management, second only to a top closed system, indicating strong real-world multi-step search.
• Agentic Tool Use:
  • τ-Bench Avg@4: 88.2%. This is like consistently winning across airline, retail, telecom; shows robust tool orchestration.
  • VitaBench Avg@4: 29.3% under a strict verifier—competitive for an open-weight model given task diversity and difficulty.
  • Noisy variants: τ-Noise 67.1%, Vita-Noise 20.5%. Training with noise shrinks the clean→noisy drop a lot, proving improved toughness.
• Mathematical Reasoning (with tools, heavy mode helps):
  • AIME-2025 up to perfect scores in heavy mode; IMO-AnswerBench 86.8 in heavy mode; AMO-Bench top open-weight results.
• General QA:
  • GPQA-Diamond 85.2 (heavy mode): near open-source top-tier.
  • HLE text-only: 25.2 under strict, consistent evaluation.
• Coding:
  • LiveCodeBench Avg@4: 82.8 (strong among open models) with fewer tokens than some peers.
  • OJBench Pass@1: 42.2 and OIBench Pass@1: 47.7 (open-source best/near-best).
  • SWE-bench Verified Avg@5: 70.0–competitive top tier among open models.

Surprising/Notable Findings:

• Hybrid context management wins: summarizing at ~80K tokens and resetting when turns explode yields the best efficiency and accuracy on BrowseComp, peaking at 73.1%.
• Noise helps even on clean tests: training with realistic noise doesn’t just harden the model under chaos; it can slightly lift standard scores too, likely by encouraging verification and recovery habits.
• Heavy Thinking scales well: As test-time compute increases, parallel+summarize overtakes single-path reasoning by a growing margin, especially on tricky math and multi-hop tasks.
• Multi-domain training generalizes: The model performs strongly on randomly generated complex tasks with unseen tool combinations, showing it learned transferrable patterns rather than memorizing.

What these numbers mean in everyday terms:

• The system isn’t just book-smart; it handles web messiness, tool quirks, and long tasks better than prior open models.
• It recovers when tools hiccup, keeps track of long conversations, and chooses better strategies when allowed to think more at test time.
• Across many domains, it behaves reliably like a careful helper rather than a brittle answer machine.

Limitations (honest notes):

• Coverage is not infinity: Even with 20+ domains and tens of thousands of environments, real-world tools and edge cases are endless; some unseen quirks will still surprise the model.
• Cost and complexity: Building, verifying, and running huge environment sets plus asynchronous RL at scale requires serious engineering and compute.
• Long-horizon memory still hard: Hybrid context management helps, but very long, branching dialogues can still exceed practical limits.
• Summarizer bias: Heavy Thinking’s summarizer could over-favor majority answers; RL mitigations help but don’t eliminate all risks.

Required Resources:

• Compute: many accelerators (the paper notes training on thousands of devices) and robust CPU fleets for environments.
• Engineering: reliable sandboxes, RPC frameworks, storage for KV-cache swapping, and pipeline orchestration.
• Data: domain definitions, schema generation, and verification rubrics; curated/synthesized traces for mid-training and RL.

When NOT to Use:

• Tiny, on-device scenarios with strict latency and memory budgets where Heavy Thinking and long-context attention are impractical.
• Highly specialized, proprietary tools/environments that cannot be emulated or verified without major integration work.
• Tasks needing strict determinism and auditability if summarization or randomness (sampling) is not allowed.

Open Questions:

• Adaptive test-time compute: How to automatically choose the right number of thinkers and summary depth per task to balance cost and accuracy?
• Continual environment scaling: Can we auto-learn new tool graphs safely from logs while preserving verifiability?
• Robustness beyond noise: How to handle adversarial tool outputs or security constraints without overfitting to synthetic attacks?
• Transparent reasoning: How to make the parallel-and-summarize decisions more interpretable for auditing and compliance?
• Energy/efficiency trade-offs: What are the best knobs to lower cost while maintaining agentic robustness?

3-Sentence Summary:

• LongCat-Flash-Thinking-2601 is a 560B-parameter MoE reasoning model trained end-to-end to act like a capable agent that can plan, use tools, and adapt in long, noisy, real-world-style tasks.
• Its strength comes from co-designing executable multi-domain environments, scalable asynchronous RL, noise-robust training, smart context management, and a Heavy Thinking mode that widens and deepens test-time reasoning.
• The result is state-of-the-art open-weight performance on agentic search and tool use, with strong generalization to new environments and tougher tasks.

Main Achievement:

• Turning agentic reasoning into a full-stack, verifiable practice ground—then proving at scale that this recipe yields robust, transferable tool-using behavior.

Future Directions:

• Smarter test-time scaling that auto-tunes the number of parallel thinkers and summary depth per task.
• Expanding environment coverage and automatic tool graph construction from real-world logs with strong verification.
• Even more efficient long-context inference (e.g., refined sparse attention patterns) and better memory tools.
• Richer robustness curricula (e.g., adversarial noise, security constraints) with formal guarantees.

Why Remember This:

• It shows that agentic ability isn’t a single trick; it’s a carefully engineered ecosystem—data, environments, RL, systems, and inference strategies working together.
• The paper demonstrates that with the right practice grounds and training discipline, an AI can become a steadier, more helpful doer, not just a talker.