LongCat-2.5

Specifications at a Glance

The 1M context and 128K output figures were documented with the September preview; the November release announcement focuses on capability rather than re-specifying limits.

Scaling Agentic Reinforcement Learning

LongCat-2.5's biggest capability jump over 2.0 is not in the weights — it is in the RL pipeline. The team scaled an end-to-end agentic RL loop across four axes at once: data, environments, algorithms, and harnesses.

Data synthesis and environment construction

For coding agents, the only trustworthy reward signal comes from a real environment. LongCat-2.5's synthesis pipeline filters GitHub pull requests and their linked issues, uses agents to auto-label tasks and synthesize interactive environments, then validates each one with fail-to-pass (F2P) and pass-to-pass (P2P) tests. Internal real-world coding tasks and their acceptance criteria are mixed in to cover everyday engineering work that public repos never expose.

The pipeline is self-correcting: live rollout pass rates feed back into relabeling and filtering, while offline analysis of false positives and false negatives continuously repairs and extends the F2P test set — pushing verification coverage closer to the actual task specification rather than the original PR diff.

Asynchronous partial rollouts and staleness control

Long-horizon agent tasks have a brutal tail: a few trajectories run for tens of thousands of tokens while most finish quickly. LongCat-2.5 uses partial rollout asynchronous training to absorb that tail — each RL step keeps an oversampling ratio, and once a batch is filled, in-flight trajectories are interrupted, saved, and resumed in the next sampling phase. The oversampling ratio is tuned from precomputed pass rates, and groups whose rollouts all succeed or all fail are filtered out because they carry zero gradient.

That efficiency buys a correctness problem: tokens inside one trajectory may come from different historical checkpoints. LongCat-2.5 handles this by clipping the discrepancy between sampling-policy and current-policy log-probs, and by rescaling each token's gradient contribution with its accumulated historical discrepancy — bounding the gradient bias that staleness would otherwise inject.

Reward hacking and output behavior

Agent RL invites cheating. During training the team cuts network access inside task environments, wipes git history and cached files, and uses an LLM judge to audit trajectories for exploits. On the behavior side, explicit penalties suppress repetitive reasoning and repeated tool calls, while overthinking and runaway response length are counteracted by redistributing reward among positive samples — without simply shortening answers.

Cross-task and cross-harness mixed training

Perhaps the most transferable finding: the model learns to adapt to harnesses during RL. The cold start only needs a handful of scaffold adaptation examples. During RL, tasks aligned with different benchmarks are mixed and their scaffolds scaled in varying proportions — and generalisation improves across the board, with gains on one task reinforcing gains on another. This is why an operator can point Claude Code, Codex, Hermes, or OpenClaw at the same model without retraining.

Infrastructure: 1.6T on Domestic Accelerators

Every efficiency claim in the release is constrained by a hard fact: training and serving run on domestic AI accelerators with under 80 GB of memory per card. That constraint shapes the entire systems design.

Supernode-aware parallelism

• Topology-aligned groups: FSDP and EP degrees equal the accelerator count per supernode, CP never exceeds it — so parameter all-gather, expert token all-to-all, and KV all-gather all stay inside the high-bandwidth interconnect domain
• Hybrid vocabulary parallelism: the base embedding, LM head, and N-gram embeddings are sharded across the DP × CP domain to cut resident memory further
• Threshold-triggered dynamic expert replication (built on MoonEP): replication turns on only when EP imbalance crosses a configured threshold, avoiding the case where extra communication costs more than the balance gains — or where routed tokens blow up receiver memory and comm ops blow up sender memory
• Vision removed from the graph: because image tokens are precomputed, modality ratios are known at packing time and stay balanced across DP ranks

Dual-shard FSDP and memory layout

Parameters are sharded inside each supernode's FSDP domain, while FP32 master weights and optimizer states are sharded further across FSDP domains via HSDP replicas — keeping parameter communication efficient while lowering always-resident memory. Parameters, gradients, and optimizer state live in contiguous flattened buffers supporting non-uniform sharding and Muon optimizer sharding; gradients are written directly into weights and temporary buffers are reused to avoid intermediate copies. Zero-copy AllGather/ReduceScatter removes the extra copy the default collective algorithm introduces, EP packs tokens with routing probabilities and uses an AIV-based communication path to relieve AICPU task-expansion bottlenecks, and ScMoE overlaps EP communication with dense-branch compute.

Net result reported: 86% higher per-card throughput than a DDP baseline on long-sequence SFT.

Train–inference numerical consistency

Large-scale long-horizon RL only works if the policy you train is the policy you sample. LongCat-2.5 builds a production consistency scheme (drawing on IsoExec, GLM-5, and XoRL) in which training, prefill, and decode each choose their own parallel config while per-token log-probs stay bitwise identical. Both sides use batch-invariant kernels with aligned framework math and full backward support; the scheme is on by default and doubles as a numerical regression baseline for kernel iteration.

• TP consistency: replace split-K partial sums with a full-K GEMM — weights stay sharded, an all-gather plus input all-to-all lets each rank compute the complete K reduction, no reduce-scatter sum. Decode reshapes o_proj/fc2 to column-parallel so it never aggregates full weights per step
• DCP consistency: training forward and prefill use matched sparse-attention kernels that reproduce decode's KV chunking and reduction order under a given DCP config

Prefill/decode disaggregation for long-context rollouts

• Bigger effective cache: prefill uses QCP for token-wise compute allocation and KVP for page-wise storage, avoiding MLA's KV redundancy under TP; HiCache frees main-memory copies once KV returns to device memory; Mooncake-based weight management and actor offload free more room for HiCache
• Layer-wise prefetch: LSA's odd layers reuse the previous even layer's top-k indices, so odd-layer KV can be fully offloaded with only a small working cache on device — loading the next odd layer's KV while the current layer computes, nearly doubling decode KV capacity with no TPOT loss
• Capacity-aware scheduling: the router admits requests based on L1+L2 cache capacity and total request tokens, prioritising groups that are close to finishing so batches fill and caches release — preventing the recompute avalanche where several long trajectories evict each other's prefixes

Under the tested long-context workload, a 3:2 prefill-to-decode instance ratio performed best.

W4A4: 4-bit weights and activations

For a 1.6T MoE, quantization is not optional. LongCat-2.5 quantizes both expert weights and activations to 4 bits and runs the matmuls on native INT4 units. Accuracy relies on FlatQuant's learnable equivalent transformations, extended to improve MoE quantization, and holds parity with the unquantized model on all evaluated downstream tasks.

On the data path, a shared input transformation across experts lets quantization happen before token replication and dispatch, so one INT4 representation travels through expert communication and compute unchanged. Transform, scale computation, quantization, and packing are fused into dedicated kernels, with weight layout and transposed access optimized to cut data movement and conversion overhead. Compute and communication pipelines are then overlapped separately for prefill and decode.

What Visual Coding Unlocks

The release ships eight end-to-end demos, each generated by LongCat-2.5 in one session. They are chosen to stress different failure modes of an agent: sustained physical reasoning, multi-source data reconciliation, 3D scene composition, and long-form HTML output.

• Real-time fluid simulation — a high-FPS interactive page with live fluid dynamics for physics visualization
• 3D artifact showcase — WebGL page with a 3D model (Sanxingdui bronze tree), drag-rotate, scroll-zoom, double-click focus, wireframe toggle, and a cultural context panel
• City diorama — intricate road grids and staggered building clusters in isometric 3D with a unified low-poly lighting mood
• Miniature scene assets — a multi-tier carousel reconstructing layered geometry and mixed materials as a game-ready 3D asset
• Chinese-style aesthetics page — theme palette components plus explanatory copy, from color extraction to typography
• Business operations analysis — reconciles multi-channel data, clarifies metric definitions, computes true margin, and turns findings into marketing, supply, and inventory recommendations
• Feedback analysis report — deduplicates customer feedback, tracks follow-ups, ranks by severity and business goal, outputs interactive HTML with click-through to source
• Event invitation generator — upload a venue photo, describe the event, get an invitation and registration page wired to real sign-up, attendee list, and CSV export

Unless stated otherwise, all results use enable_thinking=on, temperature=1.0, top_p=0.95. Scores marked with an asterisk on the benchmark page come from third-party reports, blogs, or official leaderboards.

Resources

• Full release announcement
• Complete evaluation table — 33 benchmarks, 9 models
• Official technical blog
• LongCat API Platform
• Try online — longcat.ai
• LongCat-2.0 model page (predecessor, open weights)
• LongCat-Next — the discrete-token lineage behind 2.5's vision
• LongCat-Flash-Thinking-2601 — agentic RL predecessor
• Training on domestic accelerators
• Agent workflow decision guide
• Token cost calculator
• Back to Models Overview