Kimi K2.5: Visual Agentic Intelligence

Today, we are introducing Kimi K2.5, the most powerful open-source model to date.

Kimi K2.5 builds on Kimi K2 with continued pretraining over approximately 15T mixed visual and text tokens. Built as a native multimodal model, K2.5 delivers state-of-the-art coding and vision capabilities and a self-directed agent swarm paradigm.

For complex tasks, Kimi K2.5 can self-direct an agent swarm with up to 100 sub-agents, executing parallel workflows across up to 1,500 tool calls. Compared with a single-agent setup, this reduces execution time by up to 4.5x. The agent swarm is automatically created and orchestrated by Kimi K2.5 without any predefined subagents or workflow.

Kimi K2.5 is available via Kimi.com, the Kimi App, the API, and Kimi Code. Kimi.com & Kimi App now supports 4 modes: K2.5 Instant, K2.5 Thinking, K2.5 Agent, and K2.5 Agent Swarm (Beta). Agent Swarm is currently in beta on Kimi.com, with free credits available for high-tier paid users.

“

Across three agentic benchmarks—HLE, BrowseComp, and SWE-Verified—Kimi K2.5 delivers strong performance at a fraction of the cost.

1. Coding with Vision

Kimi K2.5 is the strongest open-source model to date for coding, with particularly strong capabilities in front-end development.

K2.5 can turn simple conversations into complete front-end interfaces, implementing interactive layouts and rich animations such as scroll-triggered effects. Below are examples generated by K2.5 from a single prompt with image-gen tool:

Beyond text prompts, K2.5 excels at coding with vision. By reasoning over images and video, K2.5 improves image/video-to-code generation and visual debugging, lowering the barrier for users to express intent visually.

Here is an example of K2.5 reconstructing a website from video:

This capability stems from massive-scale vision-text joint pre-training. At scale, the trade-off between vision and text capabilities disappears — they improve in unison.

Below is an example of K2.5 reasoning over a puzzle and marking the shortest path using code:

Chat

Find the shortest path from the top-left corner (green dot) to the bottom-right corner (red dot), where black represents the road.

Find Shortest Path in Image Using BFS or A*

The user wants me to find the shortest path through a maze from the top-left corner (green dot) to the bottom-right corner (red dot). Black represents the road (passable), and presumably white represents walls.

Let me analyze the image:

• It's a complex maze pattern with black and white pixels

• The green dot should be at the top-left corner

• The red dot should be at the bottom-right corner

• I need to find the shortest path through the black areas

This is essentially a pathfinding problem on a grid. I can treat this as a graph where:

• Each black pixel is a node

• Edges connect adjacent black pixels (up, down, left, right, or possibly diagonally depending on interpretation)

• The goal is to find the shortest path from start to end

The standard algorithm for this is A* (A-star) or Dijkstra's algorithm. Given the grid nature, BFS (Breadth-First Search) would also work since all edges have equal weight.

Approach:

1. Load the image using Python (PIL/Pillow or OpenCV)

2. Convert to binary/black and white to identify passable areas

3. Find the start (green) and end (red) points, or assume they are at top-left and bottom-right corners

4. Implement BFS or A* to find the shortest path

5. Visualize the path on the image

Let me start by loading and analyzing the image.

I'll help you find the shortest path through this maze. Let me analyze the image and implement a pathfinding algorithm.

tools.default.title

Locate green and red corner dots in image

The corners appear to be white. The problem statement mentions a green dot at top-left and red dot at bottom-right. Let me search for green and red pixels in the image. Green is typically [0, 255, 0] or close to it, and red is [255, 0, 0] or close.

I need to scan the image for green and red pixels. Since the image is large (1503x3003), I should look specifically around the corners first, or check for non-black and non-white colors.

Let me convert to grayscale first and threshold to see the maze structure, then look for colored pixels.

Let me search for the green (start) and red (end) dots in the image:

tools.default.title

Convert image to binary maze and locate nearest black start/end points

It seems there are no pure green or red pixels. The image appears to be grayscale or nearly so, with very dark colors (near black) being the paths. Let me look more carefully at the extreme corners to see if there's a specific pattern, or perhaps I need to look for the darkest/brightest pixels.

Actually, looking at the description again: "Find the shortest path from the top-left corner (green dot) to the bottom-right corner (red dot), where black represents the road."

The user mentioned green and red dots, but they might not be visible in the image provided, or they might be so small they're hard to detect. The statement says "where black represents the road" - so black pixels are passable.

Let me check if the corners have distinct values. I should look for:

• Start: Top-left corner (0,0)

• End: Bottom-right corner (height-1, width-1)

But I need to check if these are actually on the road (black). Looking at the previous output, the top-left pixel is [255, 255, 255] (white), which is not black. The bottom-right is [255, 254, 255] (almost white). So the actual start and end points might be nearby.

Let me convert to grayscale and threshold to create a binary maze, then find the nearest black pixel to each corner as the actual start/end points.

Let me convert the image to a binary maze and find the nearest road (black) pixels to the corners:

tools.default.title

BFS Shortest Path with Parent Tracking and Reconstruction

Good! I found the start point at (7, 3) - which is near the top-left corner, and the end point at (1495, 2999) - near the bottom-right corner.

Now I need to implement BFS (Breadth-First Search) to find the shortest path. The maze is quite large (1503x3003 ≈ 4.5 million pixels), but BFS should be able to handle it efficiently if I use deque.

The maze appears to be a perfect maze (no cycles, single path), but I should implement BFS anyway to guarantee the shortest path.

Steps:

1. BFS from start to end

2. Track the path using a parent dictionary

3. Reconstruct the path

4. Visualize the result

Now I'll implement BFS to find the shortest path through this maze:

tools.default.title

Overlay Maze Path on Image with Matplotlib for Visualization

Excellent! BFS found a path of 113,557 steps. Now I need to visualize this path on the maze. Given the maze is very large and the path is long, I'll create a visualization where I overlay the path in red on the original image.

I should:

1. Create a copy of the original image or the binary maze

2. Draw the path in a distinct color (red or bright green)

3. Display it

Given the size, I might want to either:

• Show the full maze with the path (might be hard to see details)

• Or show a zoomed portion

• Or create an animation (but that's complex)

Let me first try to visualize the full path on the maze. Since the image is large, I'll plot it and overlay the path.

Now let me visualize the shortest path on the maze:

tools.default.title

Visualize Shortest Path with Thicker Lines and Gradient Color

The path is quite long (113,557 steps) and wiggles through the entire maze. The red line shows up but is a bit thin. Let me also create a zoomed-in view of the start and end to verify the path is correct, and perhaps create a cleaner visualization with thicker lines.

Also, I should verify the path is actually valid by checking that consecutive points are adjacent (distance 1) and all are on black pixels.

Actually, looking at the visualization, it's hard to see the path clearly because it's so dense. Let me create a better visualization by drawing lines between consecutive points with thicker linewidth, or by creating a gradient color effect to show the progression.

Let me also verify the path length and that it's indeed the shortest (which BFS guarantees for unweighted graphs like this).

Let me create a clearer visualization showing the path progression with color coding:

tools.default.title

Verify End Region for Path Validation and Save Final Result Image

Perfect! The path is valid (all consecutive steps are adjacent). Now let me also show the end region to verify, and save the final result image.

Let me also show the end region and save the final result:

tools.default.title

BFS finds shortest path of 113,557 steps in maze

Perfect! I have successfully found the shortest path through the maze. The results show:

1. Algorithm: BFS (Breadth-First Search) - guarantees the shortest path in unweighted grids

2. Path length: 113,557 steps (pixels)

3. Start point: (7, 3) - near top-left

4. End point: (1495, 2999) - near bottom-right

5. Verification: All 113,556 consecutive steps are valid (Manhattan distance = 1 between points)

The visualizations show:

• The full maze with the path colored in gradient (green → red → blue) showing progression

• Zoomed start region showing the green start point and initial path

• Zoomed end region showing the red path leading to the blue end point

• The solution has been saved to a file

I should provide the final answer to the user now with a summary and the path coordinates if they need them.

Solution Found!

I successfully found the shortest path through the maze using the BFS (Breadth-First Search) algorithm, which guarantees the optimal solution for unweighted grid mazes.

Results:

segment.table

common.copy

Metric	Value
Path Length	113,557 steps
Start Position	(7, 3) - near top-left corner
End Position	(1495, 2999) - near bottom-right corner
Algorithm	BFS (optimal for unweighted graphs)
Verification	All steps valid (4-directional movement)

Key Observations:

1. Path Visualization: The solution is visualized with a color gradient:

   • Green indicates the start region (top-left)

   • Red/Yellow indicates the middle progression

   • Blue indicates the end region (bottom-right)

2. Maze Structure: This is a dense "perfect maze" (essentially a spanning tree) with approximately 50% wall density, meaning the path winds through roughly half of the available space.

3. Complexity: With nearly 4.5 million pixels to search, the BFS algorithm efficiently explored all possible paths level-by-level to guarantee the shortest route.

Download:

The full solution image has been saved and can be viewed above. The path is highlighted in color against the original black (road) and white (wall) maze structure.

Note: The coordinates (row, column) are 0-indexed from the top-left. The actual path consists of 113,557 connected pixels forming a continuous route from start to finish without any shortcuts possible (as guaranteed by BFS optimality).

K2.5 excels in real-world software engineering tasks. We evaluate it using Kimi Code Bench, our internal coding benchmark covering diverse end-to-end tasks — from building to debugging, refactoring, testing, and scripting — across multiple programming languages. On this benchmark, K2.5 shows consistent and meaningful improvements over K2 across task types.

To try out K2.5's agentic coding capabilities, K2.5 Agent offers a set of preconfigured tools for immediate, hands-on experiences. For software engineering use cases, we recommend pairing Kimi K2.5 with our new coding product, Kimi Code.

Kimi Code works in your terminal and can be integrated with various IDEs including VSCode, Cursor, Zed, etc. Kimi Code is open-sourced and supports images and videos as inputs. It also automatically discovers and migrates existing skills and MCPs into your working environment in Kimi Code.

Here's an example using Kimi Code to translate the aesthetic of Matisse's La Danse into the Kimi App. This demo highlights a breakthrough in autonomous visual debugging. Using visual inputs and documentation lookup, K2.5 visually inspects its own output and iterates on it autonomously. It creates an art-inspired webpage created end to end:

2. Agent Swarm

Scaling Out, Not Just Up. We release K2.5 Agent Swarm as a research preview, marking a shift from single-agent scaling to self-directed, coordinated swarm-like execution.

Trained with Parallel-Agent Reinforcement Learning (PARL), K2.5 learns to self-direct an agent swarm of up to 100 sub-agents, executing parallel workflows across up to 1,500 coordinated steps, without predefined roles or hand-crafted workflows.

PARL uses a trainable orchestrator agent to decompose tasks into parallelizable subtasks, each executed by dynamically instantiated, frozen subagents. Running these subtasks concurrently significantly reduces end-to-end latency compared to sequential agent execution.

Training a reliable parallel orchestrator is challenging due to delayed, sparse, and non-stationary feedback from independently running subagents. A common failure mode is serial collapse, where the orchestrator defaults to single-agent execution despite having parallel capacity. To address this, PARL employs staged reward shaping that encourages parallelism early in training and gradually shifts focus toward task success.

We define the reward as

The performance reward $r_{\text{perf}}$ evaluates the overall success and quality of the solution $y$ for a given task $x$. This is augmented by two auxiliary rewards, each addressing a distinct challenge in learning parallel orchestration. The reward $r_{\text{parallel}}$ is introduced to mitigate serial collapse—a local optimum where the orchestrator defaults to single-agent execution. By incentivizing subagent instantiation, this term encourages the exploration of concurrent scheduling spaces. The $r_{\text{finish}}$ reward focuses on the successful completion of assigned subtasks. It is used to prevent spurious parallelism, a reward-hacking behavior in which the orchestrator increases parallel metrics dramatically by spawning many subagents without meaningful task decomposition. By rewarding completed subtasks, $r_{\text{finish}}$ enforces feasibility and guides the policy toward valid and effective decompositions. The hyperparameters $\lambda_1$ and $\lambda_2$ are annealed to zero over the course of training.

To further force parallel strategies to emerge, we introduce a computational bottleneck that makes sequential execution impractical. Instead of counting total steps, we evaluate performance using Critical Steps, a latency-oriented metric inspired by the critical path in parallel computation:

$\text{CriticalSteps} = \sum_{t=1}^{T} \left( S_{\text{main}}^{(t)} + \max_{i} S_{\text{sub},i}^{(t)} \right)$

$S_{\text{main}}^{(t)}$captures orchestration overhead, while $\max_{i} S_{\text{sub},i}^{(t)}$ reflects the slowest subagent at each stage. Under this metric, spawning more subtasks only helps if it shortens the critical path.

“

An agent swarm has an orchestrator that dynamically creates specialized subagents (e.g., AI Researcher, Physics Researcher, Fact Checker) and decomposes complex tasks into parallelizable subtasks for efficient distributed execution.

“

In our parallel-agent reinforcement learning environment, the reward increases smoothly as training progresses. At the same time, the level of parallelism during training also gradually increases.

K2.5 Agent Swarm improves performance on complex tasks through parallel, specialized execution. In our internal evaluations, it leads to an 80% reduction in end-to-end runtime while enabling more complex, long-horizon workloads, as shown below.

“

Agent Swarm reduces the minimum critical steps required to achieve target performance by 3×–4.5× compared to single-agent execution in wide search scenario, with savings scaling as targets rise—translating to up to 4.5× wall-clock time reduction via parallelization.

Here are representative trajectories demonstrating K2.5 Agent Swarm in action:

3. Office Productivity

Kimi K2.5 brings agentic intelligence into real-world knowledge work.

K2.5 Agent can handle high-density, large-scale office work end to end. It reasons over large, high-density inputs, coordinates multi-step tool use, and delivers expert-level outputs: documents, spreadsheets, PDFs, and slide decks—directly through conversation.

With a focus on real-world professional tasks, we design two internal expert productivity benchmarks. The AI Office Benchmark evaluates end-to-end Office output quality, while the General Agent Benchmark measures multi-step, production-grade workflows against human expert performance. Across both benchmarks, K2.5 shows 59.3% and 24.3% improvements over K2 Thinking, reflecting stronger end-to-end performance on real-world tasks.

K2.5 agent supports advanced tasks such as adding annotations in Word, constructing financial models with Pivot Tables, and writing LaTeX equations in PDFs, while scaling to long-form outputs like 10,000-word papers or 100-page documents.

Tasks that once took hours or days now complete in minutes. Here are some examples:

4. Conclusion

Grounded in advances in coding with vision, agent swarms, and office productivity, Kimi K2.5 represents a meaningful step toward AGI for the open-source community, demonstrating strong capability on real-world tasks under real-world constraints. Looking ahead, we will push further into the frontier of agentic intelligence, redefining the boundaries of AI in knowledge work.

Appendix

Benchmark table

To reproduce official Kimi-K2.5 benchmark results, we recommend using the official API. For third-party providers, refer to Kimi Vendor Verifier (KVV) to choose high-accuracy services. Details: https://kimi.com/blog/kimi-vendor-verifier

Footnotes

1. General Testing Details

• We report results for Kimi K2.5 and DeepSeek-V3.2 with thinking mode enabled, Claude Opus 4.5 with extended thinking mode, GPT-5.2 with xhigh reasoning effort, and Gemini 3 Pro with a high thinking level. For vision benchmarks, we additionally report results for Qwen3-VL-235B-A22B-Thinking.
• Unless otherwise specified, all Kimi K2.5 experiments were conducted with temperature = 1.0, top-p = 0.95, and a context length of 256k tokens.
• Benchmarks without publicly available scores were re-evaluated under the same conditions used for Kimi K2.5 and are marked with an asterisk (*).
• We could not evaluate GPT-5.2 xhigh on all benchmarks due to service stability issues. For benchmarks that were not tested, we mark them as "-".

2. Text and Reasoning

• HLE, AIME 2025, HMMT 2025 (Feb), GPQA-Diamond and IMO-AnswerBench were evaluated with a maximum completion budget of 96k tokens.
• Results for AIME and HMMT are averaged over 32 runs (avg@32); GPQA-Diamond over 8 runs (avg@8).
• For HLE, we report scores on the full set (text & image). Kimi K2.5 scores 31.5 (text) and 21.3 (image) without tools, and 51.8 (text) and 39.8 (image) with tools. The DeepSeek-V3.2 score corresponds to its text-only subset (marked with †) . Hugging Face access was blocked to prevent potential data leakage. HLE with tools uses simple context management: once the context exceeds a threshold, only the latest round of tool messages is retained.

3. Tool-Augmented / Agentic Search

• Kimi K2.5 was equipped with search, code-interpreter, and web-browsing tools for HLE with tools and all agentic search benchmarks.
• Except for BrowseComp (where K2.5 and DeepSeek-V3.2 used the discard-all strategy), no context management was applied, and tasks exceeding the supported context length were directly counted as failed.
• The test system prompts emphasize deep and proactive tool use, instructing models to reason carefully, leverage tools, and verify uncertain information. Full prompts will be provided in the technical report.
• Results for Seal-0 and WideSearch are averaged over four runs (avg@4).

4. Vision Benchmarks

• Max-tokens = 64k, averaged over three runs (avg@3).
• ZeroBench (w/ tools) uses max-tokens-per-step = 24k and max-steps = 30 for multi-step reasoning.
• MMMU-Pro follows the official protocol, preserving input order and prepending images.
• GPT-5.2-xhigh had ~10% failure rate (no output despite 3 retries), treated as incorrect; reported scores likely underestimate true performance.
• WorldVQA, a benchmark designed to evaluate atomic vision-centric world knowledge. Access WorldVQA at https://github.com/MoonshotAI/WorldVQA.
• OmniDocBench Score is computed as (1 − normalized Levenshtein distance) × 100, where a higher score denotes superior accuracy.

5. Coding Tasks

• Terminal-Bench 2.0 scores were obtained with the default agent framework (Terminus-2) and the provided JSON parser. In our implementation, we evaluated Terminal-Bench 2.0 under non-thinking mode. This choice was made because our current context management strategy for the thinking mode is incompatible with Terminus-2.
• For the SWE-Bench series of evaluations (including verified, multilingual, and pro), we used an internally developed evaluation framework. This framework includes a minimal set of tools—bash tool, createfile tool, insert tool, view tool, strreplace tool, and submit tool—along with tailored system prompts designed for the tasks. The highest scores were achieved under non-thinking mode.
• The score of Claude Opus 4.5 on CyberGym is reported under the non-thinking setting.
• All reported scores of coding tasks are averaged over 5 independent runs.

6. Long-Context Benchmarks

• AA-LCR: scores averaged over three runs (avg@3).
• LongBench-V2: identical prompts and input contexts standardized to ~128k tokens.

7. Agent Swarm

• BrowseComp (Swarm Mode): main agent max 15 steps; sub-agents max 100 steps.
• WideSearch (Swarm Mode): main and sub-agents max 100 steps.