Using Kimi K2.5 on Chutes

Kimi K2.5 is Moonshot AI's 1T-parameter, natively multimodal agentic model, built by continual pretraining on roughly 15 trillion mixed visual and text tokens atop Kimi-K2-Base. On Chutes it runs inside a Trusted Execution Environment (TEE) with DFlash speculative decoding, behind the standard OpenAI-compatible gateway.

Overview

Released in January 2026 under a Modified MIT license, Kimi K2.5 is a Mixture-of-Experts transformer with 1T total parameters and 32B activated per token: 61 layers (one dense), 384 routed experts with 8 selected per token plus one shared expert, Multi-head Latent Attention (MLA) with 64 heads, SwiGLU activations, and a 400M-parameter MoonViT vision encoder. Context length is 262,144 tokens; the upstream release ships with native INT4 quantization.

The model card highlights native multimodality (vision-language pretraining rather than a bolted-on adapter), coding with vision (generating code from UI designs and video workflows, orchestrating tools for visual data processing), and an agent-swarm execution scheme that decomposes complex tasks into parallel sub-tasks run by dynamically instantiated, domain-specific agents. Like K2.6, it operates in a default Thinking mode that emits reasoning content, with an Instant mode toggle.

Card-reported results (Thinking mode): 76.8 on SWE-Bench Verified, 50.7 on SWE-Bench Pro, 73.0 on SWE-Bench Multilingual, 78.5 on MMMU-Pro, 77.5 on CharXiv (RQ), 50.2 on HLE-Full with tools, and 60.6 on BrowseComp (74.9 with context management, 78.4 with agent swarm).

Model specifications

Quick start

Authenticate with Authorization: Bearer $CHUTES_API_KEY. The model name is moonshotai/Kimi-K2.5-TEE on the shared gateway https://llm.chutes.ai/v1.

curl -X POST "https://llm.chutes.ai/v1/chat/completions" \
  -H "Authorization: Bearer $CHUTES_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "model": "moonshotai/Kimi-K2.5-TEE",
  "messages": [{"role": "user", "content": "Write a Python script that dedupes a CSV by email column."}],
  "stream": true,
  "max_tokens": 2048,
  "temperature": 1.0
}'

import base64
import os
from openai import OpenAI

image_base64 = base64.b64encode(open("input.png", "rb").read()).decode()

client = OpenAI(
    base_url="https://llm.chutes.ai/v1",
    api_key=os.environ["CHUTES_API_KEY"],
)

response = client.chat.completions.create(
    model="moonshotai/Kimi-K2.5-TEE",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Turn this mockup into a responsive HTML/CSS page."},
                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_base64}"}},
            ],
        }
    ],
    max_tokens=2048,
    temperature=1.0,  # Moonshot recommends 1.0 for Thinking mode, 0.6 for Instant
)
print(response.choices[0].message.content)

const res = await fetch("https://llm.chutes.ai/v1/chat/completions", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.CHUTES_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "moonshotai/Kimi-K2.5-TEE",
    messages: [{ role: "user", content: "Summarize the trade-offs of MoE vs dense models." }],
    stream: false,
    max_tokens: 1024,
    temperature: 1.0,
  }),
});
const data = await res.json();
console.log(data.choices[0].message.content);

Parameters and tuning

Chute defaults (from the live endpoint definition): temperature 0.7, max_tokens 1024, seed 42. The /v1/completions endpoint also exposes the vLLM sampling surface: top_p, top_k, min_p, presence_penalty, frequency_penalty, repetition_penalty, logprobs, and more.

Moonshot recommends temperature 1.0 in Thinking mode, 0.6 in Instant mode, and top_p 0.95 for both; the chute default of 0.7 sits between the two modes, so set values explicitly. Enable Instant mode with extra_body={"chat_template_kwargs": {"thinking": false}}. In Thinking mode, raise max_tokens well above the 1024 default since reasoning content consumes the output budget.

What it's best at

• Coding from visual specifications. Generating working code from UI designs and screenshots is a headline capability, backed by native vision-language pretraining.
• Software engineering. 76.8 SWE-Bench Verified and 73.0 SWE-Bench Multilingual make it a strong open-weights coding agent.
• Vision-language reasoning. 78.5 MMMU-Pro and 77.5 CharXiv (RQ) for chart, document, and image understanding.
• Agentic search. 74.9 BrowseComp with context management; 78.4 with agent-swarm execution.
• Multi-agent workloads. The swarm-like execution scheme decomposes tasks into parallel, domain-specific sub-agents.

Less ideal: if you want the strongest current Kimi coder, K2.6 posts better numbers on the same gateway; Modified MIT licensing needs review for redistribution-heavy products; and there is no image or video generation, only text output.

How Chutes serves this model

Two serving-level features distinguish this chute. First, TEE: inference runs inside a Trusted Execution Environment on attested confidential-compute hardware, so prompts and outputs are processed inside the enclave. Second, DFlash speculative decoding: a draft mechanism proposes tokens the full model verifies, accelerating generation. Neither changes what the model outputs.

Serving is vLLM-based on the shared OpenAI-compatible gateway with streaming /v1/chat/completions and /v1/completions plus GET /v1/models. Billing follows Chutes' standard per-token LLM pricing. See the model page, the machine-readable llms.txt, and the callable OpenAPI spec.

FAQ

What context window does Kimi K2.5 support?

262,144 tokens (256K), per the upstream config's max_position_embeddings. Moonshot's benchmark runs use the full 256K context.

Does Kimi K2.5 accept images?

Yes. It is natively multimodal with a 400M-parameter MoonViT vision encoder, pretrained on roughly 15T mixed visual and text tokens. Send images as OpenAI-style image_url content parts. Output is text only.

What is DFlash speculative decoding?

A serving-side acceleration this chute uses: a fast draft process proposes tokens that the full model verifies, speeding up generation. It is transparent to callers and does not change model outputs or the API.

How do I switch between Thinking and Instant modes?

Thinking is the default and returns reasoning content. On this vLLM-based deployment, enable Instant mode with extra_body={"chat_template_kwargs": {"thinking": false}}. Moonshot recommends temperature 1.0 for Thinking and 0.6 for Instant, with top_p 0.95.

Can I use Kimi K2.5 commercially?

The weights and code are released under a Modified MIT license. It is broadly permissive but not identical to plain MIT, so review the LICENSE file in the Hugging Face repo before redistribution or large-scale commercial deployment.

What does the TEE suffix mean?

The chute runs inference inside a Trusted Execution Environment, i.e. attested confidential-compute hardware. Prompts and outputs are processed inside the enclave. It is a serving-level property and does not change model outputs.

How do I call it from the OpenAI SDK?

Point the client at base_url https://llm.chutes.ai/v1 with your Chutes API key and set model to moonshotai/Kimi-K2.5-TEE. Streaming is supported on chat and text completions.

How does K2.5 compare to K2.6?

Same architecture and context length. K2.6 (April 2026) improves on K2.5 across the shared benchmark table, e.g. SWE-Bench Verified 80.2 vs 76.8 and BrowseComp 83.2 vs 74.9 per Moonshot's cards. K2.5 remains a capable multimodal agentic model, and on Chutes it is served with DFlash speculative decoding.

Sources

• moonshotai/Kimi-K2.5 on Hugging Face
• Upstream config.json
• Kimi K2.5 technical report (arXiv)
• Kimi-K2.5-TEE model page on Chutes
• Live llms.txt for this chute