Kimi K2.5: Visual Agentic Intelligence

TL;DR

Moonshot releases Kimi K2.5, positioned as the most capable open-source model to date — a native multimodal model built on K2 with ~15T tokens of continued vision+text pretraining, four product modes (Instant, Thinking, Agent, Agent Swarm), and a new training recipe called Parallel-Agent Reinforcement Learning (PARL) that lets a single orchestrator model self-direct up to 100 sub-agents across up to 1,500 tool calls. The headline numbers: 60.6 / 74.9 / 78.4 BrowseComp (base / w/ context mgmt / Agent Swarm), 76.8 SWE-Bench Verified, 50.2 HLE-with-tools, 63.3 OSWorld-Verified. The work is the most concrete public datapoint for “agent swarms as an inference-time scaling axis” — a wall-clock 4.5× speedup over single-agent execution via learned parallelism on the same model — and stakes out coding-with-vision (image/video → code, visual debugging) as the open-source frontier.

Key claims

K2.5 is built on K2 via continued pretraining over ~15T mixed visual+text tokens, as a native multimodal model rather than a vision adapter bolted onto a text LLM [§Overview].
The “Agent Swarm” mode lets K2.5 self-direct up to 100 sub-agents executing parallel workflows across up to 1,500 coordinated tool-call steps; the orchestrator and decomposition are learned rather than hand-crafted [§Agent Swarm].
Wall-clock execution time on complex tasks drops by up to 4.5× vs single-agent execution; internal evaluations report up to 80% end-to-end runtime reduction on long-horizon workloads [§Agent Swarm].
Training the orchestrator uses Parallel-Agent Reinforcement Learning (PARL): a trainable orchestrator agent decomposes tasks into parallelizable subtasks, each executed by dynamically instantiated sub-agents [§PARL].
PARL identifies two failure modes specific to parallel-agent training and shapes the reward to defeat each: (a) serial collapse, where the orchestrator defaults to single-agent execution despite parallel capacity — countered by an incentive term for sub-agent instantiation; (b) spurious parallelism, where the orchestrator inflates parallel metrics by spawning subagents without meaningful task decomposition — countered by rewarding completed subtasks [§PARL].
PARL evaluates parallelism via Critical Steps, a latency-oriented metric inspired by the critical path in parallel computation, instead of total step count; this makes sequential execution structurally non-optimal under the reward [§PARL].
Agent Swarm reduces the minimum Critical Steps required to hit a target performance by 3×–4.5× vs single-agent execution in wide-search scenarios, with savings scaling as target performance rises [§Agent Swarm].
K2.5 reports 60.6 BrowseComp single-agent, 74.9 with context management, and 78.4 with Agent Swarm — i.e. the swarm contributes ~+3.5 absolute points on top of single-agent context-managed inference [Benchmark table].
On agentic coding, K2.5 reports 76.8 SWE-Bench Verified, 50.7 SWE-Bench Pro, 73.0 SWE-Bench Multilingual, 50.8 Terminal-Bench 2.0, 63.5 PaperBench, 85.0 LiveCodeBench v6 [Benchmark table].
On vision benchmarks, K2.5 reports 92.3 OCRBench, 88.8 OmniDocBench 1.5, 92.6 InfoVQA, 78.5 MMMU-Pro, 84.2 MathVision, 90.1 MathVista-mini, 86.6 VideoMMMU, 87.4 VideoMME — competitive with or ahead of GPT-5.2, Claude 4.5 Opus, and Gemini 3 Pro on most vision tasks [Benchmark table].
On computer-use, K2.5 reports 63.3 OSWorld-Verified vs 8.6 for GPT-5.2 and 20.7 for Gemini 3 Pro — a large gap that the post does not contextualize but is implicitly the strongest result on the page [Benchmark table].
Vision–text joint pretraining at sufficient scale removes the modality trade-off: K2.5 claims that “the trade-off between vision and text capabilities disappears — they improve in unison” at the 15T-token scale [§Coding with vision].
The release ships through four surfaces — Kimi.com, the Kimi App, the API (via platform.kimi.ai), and Kimi Code (an open-sourced terminal coding agent integrable with VSCode/Cursor/Zed) — and Agent Swarm is exposed as a research preview on Kimi.com with free credits for high-tier paid users [§Overview, §Kimi Code].

Method

K2.5 is a continued-pretraining-then-RL recipe over K2: ~15T tokens of mixed vision and text, then product/post-training that produces four modes (Instant / Thinking / Agent / Agent Swarm). The interesting methodology is concentrated in the Agent Swarm path.

PARL (Parallel-Agent Reinforcement Learning). A trainable orchestrator agent learns to decompose a task into parallelizable sub-tasks and dynamically instantiate specialized sub-agents (e.g. AI Researcher / Physics Researcher / Fact Checker) to execute them concurrently. The training challenge the post highlights is non-stationary, delayed, sparse feedback from sub-agents that run independently of one another — a setting where vanilla RL produces two characteristic failure modes:

Serial collapse: the orchestrator defaults to single-agent execution. PARL counters this with a reward term that incentivizes sub-agent instantiation, opening exploration of the concurrent-scheduling space.
Spurious parallelism: the orchestrator games the parallelism metric by spawning many subagents without meaningful task decomposition. PARL counters this by rewarding completed subtasks, not subagent count.

The reward also uses staged reward shaping — early training is weighted toward parallelism, late training shifts toward task success — and replaces total-step counts with Critical Steps (the longest path through the orchestrator’s parallel execution graph) as the performance metric, structurally penalizing sequential strategies. The blog reports that during training the reward grows smoothly and the level of parallelism rises monotonically.

Coding with vision. K2.5 is pitched as turning conversations / images / video into front-end code with rich interactions (e.g. scroll-triggered animations, video → website reconstruction). The capability is attributed to the scale of vision-text joint pretraining rather than to a specialized post-training stage.

Distribution surfaces. Beyond the model API, the post launches Kimi Code (an open-source terminal coding agent with auto-discovery of existing skills and MCP servers) and a hosted Agent Swarm research preview at kimi.com/agent-swarm. The platform docs (platform.kimi.ai) provide the quickstart and API reference.

Results

Headline numbers from the released benchmark table, with the strongest cross-system comparisons:

Agentic search: BrowseComp 60.6 → 74.9 (context management) → 78.4 (Agent Swarm), vs 37.0 (Claude 4.5 Opus), 37.8 (Gemini 3 Pro), 51.4 (DeepSeek V3.2). WideSearch (item-F1) 79.0 with Agent Swarm, BrowseComp(Agent Swarm) is the strongest absolute number on the page.
Reasoning-with-tools: HLE-Full-with-tools 50.2 (vs 45.5 GPT-5.2, 43.2 Claude 4.5 Opus, 45.8 Gemini 3 Pro); HLE-Full no-tools 30.1 (vs 34.5 / 30.8 / 37.5). The tool-using delta is +20.1 points, larger than the closed-model competitors.
Coding: SWE-Bench Verified 76.8 (vs 80.0 GPT-5.2, 80.9 Claude 4.5 Opus). SWE-Bench Multilingual 73.0. Terminal-Bench 2.0 50.8 (vs 59.3 Claude 4.5 Opus, the strongest there). LiveCodeBench v6 85.0.
Vision: OCRBench 92.3 (the best on the page), OmniDocBench 1.5 88.8 (best), InfoVQA 92.6 (best, vs 57.2 Gemini 3 Pro), MathVista-mini 90.1 (best), VideoMMMU 86.6 (close to Gemini 3 Pro’s 87.6), VideoMME 87.4 (best).
Computer use: OSWorld-Verified 63.3 vs Claude 4.5 Opus 66.3 (closest); GPT-5.2 reports 8.6 and Gemini 3 Pro 20.7 — a very large gap that the post does not explain.
Long context: Longbench v2 61.0 (behind Gemini 3 Pro’s 68.2); AA-LCR 70.0 (close to GPT-5.2 and Claude 4.5 Opus, ahead of Gemini 3 Pro).
Internal evals: 59.3% improvement over K2 Thinking on the internal AI Office Benchmark; 24.3% improvement on the General Agent Benchmark.

Why it’s interesting

This is the first public production-scale datapoint for learned parallel-agent orchestration as an inference-time scaling axis distinct from chain-of-thought length and from interaction depth. MiroThinker (MiroThinker: Pushing the Performance Boundaries of Open-Source Research Agents via Model, Context, and Interactive Scaling) staked out “interaction depth” (up to ~600 sequential tool calls per task); Recursive Language Models (Recursive Language Models) staked out sub-LM orchestration via a REPL; PARL stakes out a third axis — learned parallelism — that compounds with both. The reward-shaping observations (serial collapse and spurious parallelism) are the cleanest articulation in the wiki of why naive RL on parallel agents collapses, and the Critical-Steps metric is a transferable idea for anyone trying to train parallel-tool-use policies. For Luma, the salient transfer is the same lesson re-stated for multimodal: vision-text joint pretraining at 15T tokens claims to remove the modality trade-off, which is a strong (if uncontrolled) version of the joint-training story that recurs in Luma’s generative-model work.