Using Kimi K2.6 on Chutes

Kimi K2.6 is Moonshot AI's 1T-parameter, natively multimodal agentic model, built for long-horizon coding, agent swarms, and autonomous orchestration. On Chutes it is served inside a Trusted Execution Environment (TEE) through the OpenAI-compatible gateway, so existing OpenAI SDK code works with a base URL change.

Overview

Released in April 2026 under a Modified MIT license, Kimi K2.6 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, and the upstream release ships with native INT4 quantization (the same method as Kimi-K2-Thinking).

The model card highlights four capability areas: long-horizon coding that generalizes across languages (Rust, Go, Python) and domains from front-end to DevOps; coding-driven design, turning prompts and visual inputs into production-ready interfaces; agent swarms that scale to 300 sub-agents executing 4,000 coordinated steps; and proactive orchestration for persistent 24/7 background agents. It accepts image and video input alongside text, and runs in two modes: Thinking (default, emits reasoning content) and Instant.

Reported benchmarks include 80.2 on SWE-Bench Verified, 58.6 on SWE-Bench Pro, 66.7 on Terminal-Bench 2.0 (Terminus-2), 83.2 on BrowseComp (86.3 with agent swarm), 54.0 on HLE-Full with tools, 90.5 on GPQA-Diamond, and 79.4 on MMMU-Pro. These are Moonshot's own numbers with thinking mode enabled; see the model card for methodology.

Model specifications

Quick start

Authenticate with Authorization: Bearer $CHUTES_API_KEY. The model name is moonshotai/Kimi-K2.6-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.6-TEE",
  "messages": [{"role": "user", "content": "Refactor this function to be iterative: def fib(n): return n if n < 2 else fib(n-1) + fib(n-2)"}],
  "stream": true,
  "max_tokens": 2048,
  "temperature": 1.0
}'

import os
from openai import OpenAI

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

# Thinking mode (default): reasoning content precedes the answer
response = client.chat.completions.create(
    model="moonshotai/Kimi-K2.6-TEE",
    messages=[{"role": "user", "content": "Plan and implement a rate limiter in Go."}],
    max_tokens=2048,
    temperature=1.0,  # Moonshot recommends 1.0 for Thinking mode
)
print(response.choices[0].message.content)

# Instant mode (skip reasoning) on vLLM-based serving:
instant = client.chat.completions.create(
    model="moonshotai/Kimi-K2.6-TEE",
    messages=[{"role": "user", "content": "One-line summary of MLA attention."}],
    max_tokens=512,
    temperature=0.6,  # recommended for Instant mode
    extra_body={"chat_template_kwargs": {"thinking": False}},
)
print(instant.choices[0].message.content)

import { readFile } from "node:fs/promises";

const imageBase64 = (await readFile("input.png")).toString("base64");
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.6-TEE",
    messages: [
      {
        role: "user",
        content: [
          { type: "text", text: "Describe this UI and generate matching HTML." },
          { type: "image_url", image_url: { url: `data:image/png;base64,${imageBase64}` } },
        ],
      },
    ],
    max_tokens: 2048,
    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 additionally exposes the vLLM sampling surface: top_p, top_k, min_p, presence_penalty, frequency_penalty, repetition_penalty, logprobs, and more.

Moonshot's recommendations: temperature 1.0 in Thinking mode, 0.6 in Instant mode, and top_p 0.95 for both. Since the chute default is 0.7, pass these explicitly. Two mode toggles matter on vLLM-style serving:

• Instant mode: extra_body={"chat_template_kwargs": {"thinking": false}}
• Preserve thinking (keeps reasoning across turns, recommended for coding agents): extra_body={"chat_template_kwargs": {"thinking": true, "preserve_thinking": true}}

Budget max_tokens generously in Thinking mode; reasoning content counts against the output limit, and Moonshot's own evaluations run with very large generation budgets.

What it's best at

• Long-horizon coding. End-to-end tasks across languages and stacks; 80.2 SWE-Bench Verified and 66.7 Terminal-Bench 2.0 put it at the front of open-weights coding models on the card's comparison table.
• Coding-driven design. Turning prompts and screenshots into production-ready interfaces with structured layouts, interactive elements, and animations.
• Agent swarms and orchestration. Decomposing tasks into parallel domain-specialized subtasks (up to 300 sub-agents, 4,000 steps per the card), and powering persistent background agents.
• Agentic search. 83.2 BrowseComp and 92.5 DeepSearchQA f1 with search, code-interpreter, and browsing tools.
• Vision-grounded work. Reasoning over images, charts (80.4 CharXiv RQ), and video input.

Less ideal: strict-license environments where Modified MIT terms need legal review before redistribution; cheap short-form Q&A where a 1T-parameter agentic model is overkill; and anything requiring image or video output, since generation is text-only.

How Chutes serves this model

This chute runs K2.6 inside a Trusted Execution Environment: inference executes on attested confidential-compute hardware, so prompts and outputs are processed inside the enclave. This is a serving-level guarantee and does not alter model outputs.

Serving is vLLM-based on the shared OpenAI-compatible gateway with streaming /v1/chat/completions and /v1/completions, plus /tokenize, /detokenize, and 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.6 support?

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

Does Kimi K2.6 accept images and video?

Yes. It is natively multimodal with a 400M-parameter MoonViT vision encoder, and the model card shows image and video input via OpenAI-style image_url and video_url content parts. Note the card marks video chat as experimental outside Moonshot's official API. Output is text only.

How do I switch between Thinking and Instant modes?

Thinking mode is the default and returns reasoning content. For Instant mode on vLLM-based deployments like this chute, pass extra_body={"chat_template_kwargs": {"thinking": false}} in your request. Moonshot recommends temperature 1.0 for Thinking and 0.6 for Instant.

Can I use Kimi K2.6 commercially?

The weights and code are released under a Modified MIT license. It is broadly permissive, but it is 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.6-TEE. Streaming is supported on chat and text completions.

How good is it at coding, really?

The model card reports 80.2 on SWE-Bench Verified, 58.6 on SWE-Bench Pro (above the GPT-5.4 and Claude Opus 4.6 numbers it cites), 76.7 on SWE-Bench Multilingual, and 66.7 on Terminal-Bench 2.0. Moonshot positions it for long-horizon, end-to-end coding tasks rather than single-file snippets.

What is preserve_thinking mode?

An option that retains the model's full reasoning content across multi-turn interactions instead of dropping it, which the card says improves coding-agent performance. On vLLM deployments enable it with extra_body={"chat_template_kwargs": {"thinking": true, "preserve_thinking": true}}.

Sources

• moonshotai/Kimi-K2.6 on Hugging Face
• Upstream config.json
• Kimi-K2.6-TEE model page on Chutes
• Live llms.txt for this chute