Can Kimi K2.5’s Visual Agent Swarm Make It the New Open‑Source AI King?

Introduction

Kimi K2.5 is the newest open‑source model released by Moonshot. It builds on Kimi K2 and is further trained on 15 trillion image‑text tokens, positioning it as a native multimodal model with a novel "agent swarm" capability.

Core Highlights

Vision Programming (Coding with Vision) : The model can interpret UI design images and even video streams to generate or refactor code. The official demo recreates a Matisse‑style artwork directly onto an app interface.

Agent Swarm : Up to 100 sub‑agents can be recruited and run in parallel, performing up to 1 500 tool calls and delivering a 4.5× speedup over single‑agent execution.

Productivity : Handles long documents, Excel modeling, LaTeX formulas, and can process 100‑page documents or 10 000‑word papers end‑to‑end.

Deep Dive into Agent Swarm

The traditional agent approach treats a single agent as an all‑rounder that works serially, leading to long latency on complex tasks. Kimi K2.5 introduces an "Agent Swarm" trained with PARL (Parallel‑Agent Reinforcement Learning) that acts as a "foreman".

When a complex task arrives, K2.5 automatically:

Task Decomposition : Breaks the large task into many parallel subtasks.

Recruit Sub‑agents : Dynamically creates specialized agents such as "physics researcher" or "fact checker".

Parallel Execution : Directs up to 100 sub‑agents to work concurrently.

This workflow yields a 4.5× efficiency gain, especially valuable for large‑scale search or complex codebases.

Figure: Architecture of the Agent Swarm.

Figure: Parallel execution brings a massive performance boost.

Vision Programming (Coding with Vision)

For front‑end developers, this feature is a game‑changer. The model can understand video streams and dynamic interactions, extracting animation logic and navigation flows to generate code automatically.

Benchmark results:

SWE‑Verified: 76.8% (top tier among open‑source models).

HLE (Humanity's Last Exam) with tool support: Text score 51.8, Image score 39.8.

Installation & Usage

Kimi K2.5’s weights and code are hosted on Hugging Face under a Modified MIT License.

vLLM added Day‑0 support, enabling fast inference deployment. The model also uses Native INT4 quantization to reduce VRAM while preserving performance. Recommended deployment stacks include vLLM, SGLang, and KTransformers.

Because the relevant PR is still merging, the current recommendation is to install vLLM from source:

# Temporary solution: install vLLM development version with Kimi support
uv pip install git+https://github.com/vllm-project/vllm.git

Launch command (example for an 8‑GPU H200 node):

vllm serve moonshotai/Kimi-K2.5 -tp 8 \
  --mm-encoder-tp-mode data \
  --tool-call-parser kimi_k2 \
  --reasoning-parser kimi_k2 \
  --trust-remote-code

Specify --tool-call-parser kimi_k2 and --reasoning-parser kimi_k2 to enable the model’s unique tool‑calling and reasoning modes.

Remember to add --trust-remote-code.

Official API – Thinking Mode

K2.5 supports a "Thinking Mode" similar to o1’s slow‑thinking approach, allowing detailed reasoning.

Example Python snippet that sends a video to K2.5 and receives a description:

import openai
import base64
import requests

def chat_with_video(client: openai.OpenAI, model_name: str):
    # Official demo video
    url = 'https://huggingface.co/moonshotai/Kimi-K2.5/resolve/main/figures/demo_video.mp4'
    video_base64 = base64.b64encode(requests.get(url).content).decode()
    messages = [
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Describe the video in detail."},
                {"type": "video_url", "video_url": {"url": f"data:video/mp4;base64,{video_base64}"}}
            ]
        }
    ]
    response = client.chat.completions.create(model=model_name, messages=messages)
    print('===== Thinking Process =====')
    print(f'reasoning content: {response.choices[0].message.reasoning_content}')
    print('===== Response =====')
    print(f'response: {response.choices[0].message.content}')
    # Configure your API key and base URL before calling
    # client = openai.OpenAI(api_key="YOUR_KEY", base_url="https://api.moonshot.cn/v1")
    # chat_with_video(client, "kimi-k2.5")

Kimi Code

Moonshot also released Kimi Code (https://kimi.com/code), a CLI tool that integrates directly into terminals or VSCode. It leverages K2.5 to automatically discover and migrate existing skills, debug code, and, thanks to visual capabilities, validate UI code via screenshots.

Pros and Cons

Pros

Agent swarm parallelism solves the efficiency bottleneck of slow reasoning.

Extremely strong visual understanding beyond simple OCR.

Maintains T0‑level command in Chinese contexts.

Cons

High token consumption when the swarm (100 agents) is active, leading to significant cost.

Local deployment requires substantial hardware, raising the entry barrier for individual developers.

Overall, Kimi K2.5 demonstrates the next evolution of agents—from a single intelligence to a coordinated group intelligence.