Abstract “We introduce Kimi K2.5, an open-source multimodal agentic model designed to advance general agentic intelligence. K2.5 emphasizes the joint optimization of text and vision so that two modalities enhance each other. This includes a series of techniques such as joint text-vision pre-training, zero-vision SFT, and joint text-vision einforcement learning. Building on this multimodal foundation, K2.5 introduces Agent Swarm, a self-directed parallel agent orchestration framework that dynamically decomposes complex tasks into heterogeneous sub-problems and executes them concurrently. Extensive evaluations show that Kimi K2.5 achieves state-of-the-art results across various domains including coding, vision, reasoning, and agentic tasks. Agent Swarm also reduces latency by up to 4.5×oversingle-agent baselines. We release the post-trained Kimi K2.5 model checkpoint1 to facilitate future research and real-world applications of agentic intelligence.”
Let’s break them down one by one: r_parallel — Instantiation Reward (Speed/Efficiency); r_finish — Sub-Agent Finish Rate (Reliability); r_perf(x,y) — Task-Level Outcome (Quality). The λ weights aren’t hand-tuned forever. They’re typically found through:
Method A: Pareto Frontier Search
Run training with different (λ₁, λ₂) combinations:- (1.0, 0.0): Pure speed → fast but unreliable- (0.0, 1.0): Pure reliability → slow but steady- (0.5, 0.5): BalancedPlot the Pareto frontier, select the point that maximizes r_perf while meeting latency/reliability constraints.
Method B: Constraint Formulation
Instead of weighted sum, treat as constrained optimization:Maximize: r_perf(x,y)Subject to: r_finish ≥ 0.95 (at least 95% finish rate) r_parallel ≥ 0.7 (at least 70% parallel utilization)This avoids manual λ tuning entirely.
Method C: Learned Adaptive Weights
λ₁, λ₂ are themselves outputs of a small meta-network:"Given the current task complexity, how much should I prioritize speed vs. reliability?"Simple task → high λ₁ (parallelize aggressively)Complex task → high λ₂ (be careful, ensure completion)
End to end
User Query: "Analyze Q3 sales data and forecast Q4"┌─────────────────────────────────────────────────────────────┐│ ORCHESTRATOR DECIDES: ││ Spawn Agent A (data loader) ││ Spawn Agent B (trend analyzer) ← parallel ││ Spawn Agent C (forecast model) ← parallel │└─────────────────────────────────────────────────────────────┘ │ ┌─────────────────────┼─────────────────────┐ ▼ ▼ ▼ [Agent A] [Agent B] [Agent C] Load CSV Calculate Run ARIMA Validate data moving averages model Return df Return trends Return forecast ─────────── ─────────── ─────────── Status: SUCCESS Status: SUCCESS Status: TIMEOUT Time: 3s Time: 5s Time: 10s (killed) │ │ │ └─────────────────────┼─────────────────────┘ ▼┌─────────────────────────────────────────────────────────────┐│ SCORING: ││ r_parallel = overlap(A,B,C active) = 0.67 ││ r_finish = (1.0 + 1.0 + 0.0) / 3 = 0.67 ││ r_perf = check_forecast_accuracy(forecast, actual_Q4) ││ = 0.0 (no forecast produced due to timeout) ││ ││ r_PARL = 0.4*0.67 + 0.3*0.67 + 0.3*0.0 = 0.47 ││ (Low score! Orchestrator learns to give C more time ││ or split C's task into smaller subtasks) │└─────────────────────────────────────────────────────────────┘
Let’s look into a scenario to learn intuitively about r_parallel computation:
3 independent subtasks, each takes ~10 seconds of actual workSequential execution: Task 1 → Task 2 → Task 3 = 10 + 10 + 10 = 30 secondsParallel execution: Task 1 + Task 2 + Task 3 (simultaneously) = 12 seconds totalso span_reduction is 1-12/30=0.6overlap = (time_with_multiple_agents_active) / (total_parallel_time) = 10/12=0.83redundancy_score = (useful_unique_tasks) / (total_agents_spawned)=3/3=1.0r_parallel = 0.6 × (span_reduction) + 0.3 × (overlap) + 0.1 × (no_redundancy) = 0.6 × 0.6 + 0.3 × 0.83 + 0.1 × 1.0 = 0.36 + 0.25 + 0.10 = 0.71 (0.6, 0.3, 0.1) weights are hyperparameters tuned empirically. If your use case values reliability over speed, you might flip them: 0.2, 0.5, 0.3
The key insight is that span reduction rewards the outcome (was it faster?), while overlap rewards the process (were agents actually working simultaneously?). You can have good span reduction with bad overlap if there’s massive overhead, or good overlap with bad span reduction if the baseline was already fast.
About RL(reinforcement learning) frameworks:
| Goal | Recommended Framework |
|---|---|
| General LLM alignment | PPO + learned reward model |
| Math/reasoning models | GRPO (no critic overhead) |
| Fast, stable training | DPO or Online DPO |
| Maximum performance | PPO with heavy compute |
| Limited compute | RFT or DPO |
| Process supervision | PPO/GRPO with PRM |
the agent’s goal is always to maximize the cumulative reward, so all these RL frameworks aim to solve this optimization problem.
Environment → Observation (s) → Agent → Action (a) → Environment → Reward (r) → ...∇J = E[ reward × ∇log(policy(action)) ]Translation: - If reward was HIGH → amplify the probability of that action- If reward was LOW → suppress the probability of that action# Introduce an advantage functionA(s,a) = Q(s,a) - V(s)Where:- Q(s,a) = actual return from taking action a in state s- V(s) = expected return from state s (average over all actions)- A(s,a) > 0 → this action was better than average → do MORE- A(s,a) < 0 → this action was worse than average → do LESSA2C vs A3C| Variant | Mechanism | Use Case || -------------------------------- | ---------------------------------------- | ------------------------------------- || **A2C** (Advantage Actor-Critic) | Synchronous, one environment | Stable, simpler || **A3C** (Asynchronous) | Multiple agents in parallel environments | Faster exploration, more diverse data |
PPO: Proximal Policy Optimization; The most popular RL algorithm for LLMs. Prevents the policy from changing too drastically in one update.
L^CLIP(θ) = E[ min( r_t × A_t, clip(r_t, 1-ε, 1+ε) × A_t ) ]Where:- r_t = π_new(a) / π_old(a) (probability ratio)- ε = small number (typically 0.1 or 0.2)- A_t = advantage estimate
GRPO: Group Relative Policy Optimization: Used in DeepSeek-R1 and similar reasoning models. Specifically designed for LLM reasoning tasks where there’s no single correct answer. Instead of training a separate critic network, use multiple samples from the same prompt as a baseline. The mechanism is:
For a given math problem prompt: Generate G = 4 (or 8, 16) different reasoning traces Score each with reward function (e.g., did it get the right answer?) Group mean reward = baseline Each sample's advantage = its reward - group mean Update policy to favor above-average traces, disfavor below-average# The GRPO objectiveJ_GRPO(θ) = E[ (1/G) Σ ( min( r_i × A_i, clip(r_i) × A_i ) ) - β × D_KL(π_θ || π_ref) ]Where:- G = group size- r_i = π_new(response_i) / π_old(response_i)- A_i = r_i - mean(group_rewards)- β = KL penalty coefficient- π_ref = reference model (pretrained/SFT model, frozen)# KL PenaltyD_KL(π_θ || π_ref) = "How much did the policy drift from the original model?"This prevents:- Reward hacking (gaming the reward function)- Catastrophic forgetting (losing general language ability)- Mode collapse (only generating one type of answer)
DPO: Direct Preference Optimization
Token Efficient Reinforcement Learning Token efficiency is central to LLMs with test-time scaling. While test
time scaling inherently trades computation for reasoning quality, practical gains require algorithmic innovations that
actively navigate this trade-off. Our previous findings indicate that imposing a problem-dependent budget effectively
constrains inference-time compute, incentivizing the model to generate more concise chain of thought reasoning pat
terns without unnecessary token expansion. they propose Toggle, a training heuristic that alternates between inference-time scaling and budget constrained optimization: for learning iteration t, the reward function is defined by
This is quite clever, he key insight is that brevity should be rewarded only after competence is established. By alternating between unrestricted reasoning (to preserve and improve problem-solving ability) and budget-constrained reasoning (to encourage concise solutions), the model learns to think deeply when necessary but avoid unnecessary reasoning. This is one way Kimi achieves better token-efficient reinforcement learning without sacrificing reasoning quality.
SWE Bench(SWE is software engineering) Public and Verified are among the most important benchmarks for evaluating whether an LLM can function as a real software engineer. They go far beyond “write a Python function” and instead test whether the model can fix bugs in large, real-world GitHub repositories. Claude 4 / GPT-5 / Kimi K3 / Gemini 2.5 Pro (with agentic workflows) can achieve 70-90%, solid performance!
Conclusion: Kimi K2.5 shows that scalable and general agentic intelligence can be achieved through joint optimization of text and vision together with parallel agent execution. By unifying language and vision across pre-training and reinforcement learning, the model achieves strong cross-modal alignment and visual–text reasoning. Agent Swarm enables concurrent execution of heterogeneous sub-tasks, reducing inference latency while improving performance on complex agentic workloads. Grounded in vision–text intelligence and agent swarms, Kimi K2.5 demonstrates strong performance on benchmarks and real-world tasks. By open-sourcing the post-trained checkpoints, we aim to support the open-source community in building scalable and general-purpose agentic systems and to accelerate progress toward General Agentic Intelligence.