Kimi K2.6: The Complete Developer Guide (2026)

Last updated: May 14, 2026.

Moonshot AI shipped Kimi K2.6 on April 20, 2026 and reset what "open weights" can mean. On the headline benchmark every frontier lab now leans on — Artificial Analysis Intelligence Index — K2.6 scores 54, the highest of any open-weights model and only three points behind Anthropic, Google, and OpenAI's closed flagships. On SWE-bench Pro it ties GPT-5.5. On Code Arena's WebDev leaderboard it sits sixth out of 67 models at 1,529 Elo, ahead of every other open-weights model and within striking distance of Claude Opus 4.7. And it runs at roughly one-fifth the per-token cost of Opus 4.7.

The release also introduces a genuinely new primitive: Agent Swarms. K2.6 has been post-trained — not just prompted — to decompose long-horizon work into up to 300 parallel sub-agents and reconcile their results across as many as 4,000 coordinated steps. Moonshot's reference run shows the model sustaining a continuous 12-hour autonomous coding session that made 4,000+ tool calls and raised the throughput of a Qwen 3.5-0.8B inference engine in Zig on a Mac from 15 to 193 tokens per second.

This guide is for engineering leaders, founders, and developers deciding where K2.6 fits in a 2026 stack alongside Claude Opus 4.7, GPT-5.5, and DeepSeek V4 Pro. We cover what is genuinely new, the benchmark picture without the hype, the API and self-hosting paths, where K2.6 wins and where it still loses, and the practical decision tree for routing tasks across models.

Also in this series

What is Kimi K2.6?

Kimi K2.6 is the third K2-class model from Moonshot AI, the Beijing-based lab founded by Yang Zhilin in 2023. The K2 line is Moonshot's open-weights flagship; the closed Kimi consumer product (kimi.com) runs on the same family. K2 launched in August 2025, K2.5 ("K2-Thinking") followed in November 2025, and K2.6 shipped on April 20, 2026 — a nine-month cadence faster than any closed-weights lab.

The architecture is a 1-trillion-parameter sparse Mixture-of-Experts with 32 billion active parameters per token. It uses Multi-head Latent Attention (MLA), 384 routed experts plus 1 shared, 8 experts selected per token, 61 transformer layers, 64 attention heads, and SwiGLU activation. The context window is 262,144 tokens. The MoonViT vision encoder (400M params) handles native image and video input. Weights are released under a Modified MIT license that imposes no commercial restriction below ~100M MAU or $20M/month revenue.

Why K2.6 matters in one sentence: it is the first open-weights model that competes with the closed frontier on every dimension that matters for agentic coding — long-context stability, tool-call reliability, sub-agent orchestration, and unit economics — without an asterisk. Where K2.5 was "open weights, but with caveats," K2.6 is "open weights, no caveats."

What's new versus Kimi K2.5?

Three changes do most of the work. Everything else is delta on existing capability.

1. Agent Swarms. K2.5 capped concurrent sub-agents at 100 and coordinated steps at 1,500. K2.6 raises both — 300 sub-agents and 4,000 steps — and, more importantly, post-trains the model to decide on its own when to fan out, how many agents to spawn, and how to reconcile results. The native primitive is what differentiates K2.6 from "K2.5 with a bigger context." On BrowseComp, plain K2.6 scores 83.2%; with swarms enabled, 86.3%. The lift is bigger on naturally parallel work (multi-repo refactors, batch validation, large literature reviews) and smaller on linear tasks.

2. Native INT4 quantisation. Moonshot used Quantisation-Aware Training during post-training, so the model learned representations compatible with 4-bit weights rather than being compressed afterwards. The practical result: roughly 2x inference speed and 50% less GPU memory versus FP16, with Moonshot claiming negligible quality loss. The INT4 weights on Hugging Face are ~594 GB.

3. Hard benchmark lift across coding and reasoning. SWE-bench Verified rises from 76.8% (K2.5) to 80.2%. SWE-bench Pro rises from 50.7% to 58.6%. Terminal-Bench 2.0 rises from 50.8% to 66.7%. LiveCodeBench v6 rises from 85.0% to 89.6%. AIME 2026 lands at 96.4%, HMMT 2026 at 92.7%, GPQA-Diamond at 90.5%. Hallucination rate on AA-Omniscience drops from 65% (K2.5) to 39% (K2.6), close to Claude Opus 4.7.

Smaller deltas worth knowing before you migrate K2.5 client code:

• New thinking field. The chat template now exposes thinking: {type: "enabled" | "disabled", keep: "all"}. K2.5 client code that does not parse response.choices[0].message.reasoning will silently lose the reasoning trace.
• Default temperature is 1.0. K2.5 defaulted to 0.6. Copying K2.5 prompts forward without re-tuning yields more creative variance in thinking mode.
• Transformers version pin. Native INT4 inference needs transformers>=4.57.1, <5.0.0. Older inference stacks silently fall back to FP16 and OOM on single-node setups.
• Vocabulary 160K. Up from K2.5's 152K. Modest reduction in tokens-per-request for code and non-English text.
• Vision encoder doubled. MoonViT scaled from 200M to 400M params. Dense documents, IDE screenshots, and dense data tables are now competitive with Opus 4.7 (MMMU-Pro 79.4%, MathVision-with-python 93.2%).

How does the Agent Swarm architecture work?

Most agent frameworks today — LangGraph, CrewAI, AutoGen — bolt orchestration on top of the model in user space. The model is a black-box generator; the framework owns spawning, scheduling, and reconciliation. K2.6 internalises that primitive. The model is trained to decide when to fan out, how many sub-agents to spawn, what each one does, and how to combine their results.

There are two related primitives. Agent Swarms let the model spawn up to 300 homogeneous sub-agents for parallelisable work — for example, 200 sub-agents each reading a single file in a large monorepo to localise a regression, then a reconciliation step that proposes a fix. Claw Groups extend this to heterogeneous agents with persistent memory: a planner-agent, a researcher-agent, a coder-agent, and a verifier-agent each maintain their own scratchpad across the full session, share intermediate state through a structured memory protocol, and pick up where they left off after a tool failure.

What this buys you in practice:

• Quality lift on parallelisable work. BrowseComp jumps from 83.2% (plain) to 86.3% (with swarms). The lift is bigger on tasks with naturally parallel structure and smaller on linear tasks.
• Latency reduction at fixed quality. A 20-minute single-agent run can drop to 3–5 minutes when the work decomposes into 20 parallel sub-tasks. The token bill is roughly the same; wall-clock is dramatically lower.
• Cost discipline. Sub-agents inherit the parent's task budget. They cannot silently spawn an exponential tree of grandchildren. Moonshot's reference scheduler caps each task at 300 active agents and 4,000 total steps; you can lower these in your client.
• Recovery from tool failures. A failed sub-agent does not halt the parent. The parent receives a structured failure report and decides whether to retry, replan, or proceed without that result. K2.6's 96.6% tool-invocation success rate matters here — the remaining 3.4% is handled by the swarm, not by the human.

The honest caveat: swarms shine on parallelisable work and add overhead on inherently sequential work. A bug fix that requires reading file A, then file B, then file C, then writing a patch is not a swarm problem. A bug fix that requires reading 80 files in a monorepo to understand a regression — that is a swarm problem. Disable swarms with an extra-body flag when you know the task is linear.

What benchmarks does Kimi K2.6 score on?

Benchmarks narrow your shortlist; they do not pick a winner. The numbers below are the ones to remember.

Artificial Analysis Intelligence Index (composite, all categories): 54. Highest of any open-weights model. Ranked #4 overall behind Anthropic, Google, and OpenAI (all 57). Median open-weights model: 30. Xiaomi's MiMo V2.5 Pro recently tied at 54 with weights expected shortly.

SWE-bench Pro: 58.6%. Tied with GPT-5.5 (57.7%). Ahead of Gemini 3.1 Pro (54.2%) and Claude Opus 4.6 (53.4%). Behind Claude Opus 4.7 (64.3%).

SWE-bench Verified: 80.2%. Within a tight band of every top-tier model. DeepSeek V4 Pro ties at 80.6%; Opus 4.7 leads at 87.6%.

Code Arena WebDev (Elo, blind pairwise): 1,529. Sixth of 67 models as of April 26, 2026. Behind Claude Opus 4.7 (1,565), Claude Opus 4.6 (1,548), and Z.ai's open-weights GLM-5.1 (1,534).

Terminal-Bench 2.0 (Terminus-2 harness): 66.7%. Ahead of GPT-5.4 and Claude Opus 4.6 (both 65.4%). Behind Gemini 3.1 Pro (68.5%) and GPT-5.5 (~82.7%).

LiveCodeBench v6: 89.6%. Up from K2.5's 85.0%. DeepSeek V4 Pro leads at 93.5%.

BrowseComp (web research): 86.3% in Agent Swarm mode. Up from K2.5's 78.4%. Plain mode: 83.2%.

DeepSearchQA (F1): 92.5. Leads GPT-5.4 (78.6).

Humanity's Last Exam (HLE-Full, with tools): 54.0. Leads every model in the comparison, including GPT-5.4 (52.1), Claude Opus 4.6 (53.0), and Gemini 3.1 Pro (51.4).

AIME 2026: 96.4%. HMMT 2026: 92.7%. GPQA-Diamond: 90.5%. Highest of any open-weights model on competition math and graduate-level science.

Tool-invocation success: 96.6%. Highest of any model with public weights. Remaining 3.4% is largely malformed third-party MCP server schemas, not model errors.

Hallucination rate (AA-Omniscience): 39%. Down from K2.5's 65%, closing on Claude Opus 4.7's ~31%.

The honest read: K2.6 is the best model in the world right now for the specific shape of work that is "run unsupervised for hours, fan out into sub-agents, finish a real coding task" — and the best open-weights model on almost every coding benchmark in the suite. Opus 4.7 still wins SWE-bench Verified and graduate-science questions. GPT-5.5 still wins terminal-style breadth. DeepSeek V4 Pro is still cheaper on raw output cost and leads competitive programming.

How does Kimi K2.6 compare to Claude Opus 4.7, GPT-5.5, and DeepSeek V4 Pro?

The 2026 frontier is now a four-way race rather than a three-way one. The way to think about routing:

vs Claude Opus 4.7. Opus 4.7 wins SWE-bench Verified (87.6% vs 80.2%), MCP-Atlas (~77% vs ~74%), and graduate-level science (GPQA Diamond 94.2% vs 90.5%). K2.6 wins on cost (5–6x cheaper), open weights, agent swarms, web research, multilingual coding, and competitive programming. Pick Opus 4.7 when the bottleneck is "can it ship this single PR." Pick K2.6 when the bottleneck is "can it run unsupervised for hours, coordinate sub-agents, and finish a multi-task." For the deep comparison, see our Claude Opus 4.7 complete guide.

vs GPT-5.5. GPT-5.5 wins on the AAII composite (60 vs 54), Terminal-Bench 2.0 (~82.7% vs 66.7%), and time-to-first-token latency (~0.8s vs 3.0s in thinking mode). K2.6 ties on SWE-bench Pro, leads on web research (DeepSearchQA 92.5 vs ~80) and competition math, and is roughly 3x cheaper. Pick GPT-5.5 when terminal/agent breadth dominates. Pick K2.6 when the workload is structured, parallelisable, and cost-sensitive. See the GPT-5.5 complete guide for the inverse perspective.

vs DeepSeek V4 Pro. V4 Pro shipped four days after K2.6 (April 24, 2026) and is the closest peer. The two trade wins: K2.6 leads on agentic tooling (HLE-with-tools, BrowseComp with swarms, DeepSearchQA, multilingual SWE), V4 Pro leads on competitive programming (LiveCodeBench 93.5 vs 89.6) and ties on SWE-bench Verified (80.6 vs 80.2). On the GDPval-AA agentic real-world benchmark, V4 Pro currently leads (1554 vs 1484). On raw output cost, V4 Pro is ~17% cheaper at base pricing and 4–5x cheaper during its 75%-off promo through May 31, 2026. The differentiation is concentrated in long-horizon agentic work: K2.6's post-training specifically targets it; V4's does not. For 12+ hour autonomous coding sessions, K2.6 is the clear win; for everything else, it comes down to license, context length (V4 has 1M, K2.6 has 256K), and price-window. See the DeepSeek V4 complete guide for the V4-side argument.

How much does Kimi K2.6 cost via API?

Moonshot publishes hosted-API pricing at https://api.moonshot.ai/v1. The API is OpenAI-compatible, so existing OpenAI SDKs work without modification. Pricing is the same on the .ai and .cn endpoints; OpenRouter and Cloudflare Workers AI re-sell the model at small markups.

Headline rates as of May 2026:

• Moonshot direct: $0.95 / $4.00 per million input/output tokens. Cache reads $0.16/M (83% off input).
• OpenRouter: $0.74 / $3.50 per million input/output tokens.
• Cloudflare Workers AI, NVIDIA NIM, DeepInfra, GMI Cloud: blended $1.15–$2.15 per million, depending on provider.

The cache discount is the unusual part. Repeated prefixes are cached and billed at $0.16/M on read, applied automatically — no explicit cache-control markers like Anthropic's API requires. The blended rate at a 3:1 input:output ratio works out to roughly $1.71 per million tokens, 5–6x cheaper than Claude Opus 4.7 and ~3x cheaper than GPT-5.5.

To make this concrete: take an autonomous coding agent fixing 100 medium-complexity bugs per day, with 50,000 cached context tokens, 5,000 fresh input tokens per task, and 8,000 output tokens per task.

• K2.6 first task (cold cache): ~$0.085.
• K2.6 subsequent task (warm cache): ~$0.045.
• K2.6 daily total (100 tasks): ~$4.50/day, or ~$135/month.
• Same workload on Opus 4.7: ~$750/month — about 5.5x more.
• Same workload on DeepSeek V4 Pro (base): ~$113/month — about 17% cheaper than K2.6.
• Same workload on DeepSeek V4 Pro (75% promo, through May 31, 2026): ~$28/month — roughly 5x cheaper than K2.6 while the promo lasts.
• Self-hosted K2.6 on 8x H200 at on-demand cloud rates: ~$580/month at 60% utilisation, before storage and egress. Pays off vs hosted API only at very high throughput or when data residency / open-weights are hard requirements.

The economic case for K2.6 is strongest in two scenarios: high-volume coding agents where Opus is too expensive and DeepSeek's specialty does not match the workload, and regulated or air-gapped environments where you need open weights you can audit and self-host. For most teams, start on the hosted API and port to self-hosted only if economics or compliance demand it.

How do you run Kimi K2.6 locally?

K2.6 weights are on Hugging Face at moonshotai/Kimi-K2.6. The native INT4 quant is published directly by Moonshot — no community conversion needed. Community quants for llama.cpp, LM Studio, Jan, and Ollama landed within 48 hours of release. MLX builds for Apple Silicon followed about a week later.

Hardware budget

• INT4, full 256K context: 8x H200 141GB or equivalent ~640 GB aggregate VRAM. Verified target.
• INT4, reduced context (~32K): 4x H100 80GB, or even a single H100 80GB for tight context windows.
• INT4 on 8x RTX 4090 (24GB each): roughly 500 GB of VRAM with tensor parallel — works but tight.
• Storage: INT4 weights are ~594 GB; budget at least 700 GB of fast SSD for the weights plus scratch.
• FP16 / BF16 full: 1.5 TB system RAM plus one H100 via KTransformers CPU+GPU hybrid for offline / single-machine inference.

vLLM path (production default)

Pin transformers>=4.57.1, <5.0.0 and use vLLM 0.19.1 (manually verified). Minimal command:

vllm serve moonshotai/Kimi-K2.6 \
  --tensor-parallel-size 8 \
  --max-model-len 262144 \
  --enable-prefix-caching \
  --quantization compressed-tensors

Prefix caching is required for any agent workload — without it you re-tokenise the system prompt every call and lose the price advantage. The official deploy guide on the Hugging Face model card has the full set of recommended flags for SGLang and KTransformers as well.

llama.cpp path (local development)

Community GGUFs are available within hours of any K2-class release; for K2.6 the UD-Q2_K_XL quant at ~350 GB is the recommended size/quality balance, and UD-Q8_K_XL is effectively lossless because Moonshot already uses INT4 for MoE weights and BF16 for everything else. Real but slow on a workstation; useful for development and offline tasks, not for serving production traffic.

MLX path (Apple Silicon)

The mlx-community has published Kimi-K2.6-MoE-Smart-Quant with per-component bit allocation tuned for the MoE + MLA architecture — effective ~4.5 bpw, near-6-bit quality at near-4-bit size. On a single Mac Studio M3 Ultra with 192 GB+, the model fits in roughly 150 GB. For full 256K context, two M3 Ultras over JACCL/RDMA provide the headroom. Throughput is ~5–15 tokens/sec depending on prompt length — fine for interactive development, not for production serving.

SGLang and KTransformers

SGLang is faster than vLLM on agentic workloads with shared-prefix patterns; the Claw Groups primitive specifically benefits from SGLang's RadixAttention. Same 8x H100 hardware target. KTransformers is the CPU+GPU hybrid path for offline / single-machine inference on a workstation with 1.5 TB RAM and one H100.

For a wider walk-through of the open-weights operations side — model serving, evals, observability, autoscaling — see our self-hosting LLMs complete guide.

What use cases is Kimi K2.6 best at?

K2.6 was post-trained specifically for long-horizon agentic coding. The benchmark suite reflects that. The shape of work where K2.6 outperforms everything else is also the shape of work it was trained for.

Autonomous coding agents. Multi-hour runs with many tool calls, branching plans, and recovery from failures. Moonshot's published reference run is a 12+ hour port of a Qwen 3.5-0.8B inference engine to Zig on a Mac, with 4,000+ tool calls across 14 iterations — throughput climbed from 15 to 193 tokens/sec end-to-end. This is the workload K2.6 is built for; no other open-weights model holds coherence past ~1,500 tool calls.

This is the segment where K2.6's tool-invocation success rate (96.6%) and Claw Groups primitive both pay off. If you are building an agent that runs unsupervised overnight or across a weekend, K2.6 is the model to evaluate first.

Coding-driven UI/UX generation. K2.6's 1,529 Elo on Code Arena WebDev sits #6 of 67 — ahead of every other open-weights model. The model ships front-end animations end-to-end from a prompt or a screenshot; the design mode specifically targets coding-driven UI flows rather than image-first design.

Long-context retrieval and synthesis. 262,144-token window with MLA attention keeps KV memory tractable. Practical use: ingest an entire 200-file repo, ingest a multi-hundred-page RFC bundle, ingest a full year of meeting notes. Holds coherence at depths where K2.5 drifted.

Web research and multi-hop reasoning. 92.5 F1 on DeepSearchQA and 86.3% on BrowseComp with swarms enabled are both leaderboard leaders. Combined with the 300-agent fan-out, K2.6 is the right model for "review every paper on this topic and produce a synthesis."

Multilingual and competitive coding. SWE-bench Multilingual 76.7%, AIME 2026 96.4%, HMMT 2026 92.7%. Strong fits for international engineering teams and for any pipeline that includes competition-style algorithmic work.

Open-weights compliance environments. Regulated industries that need weights they can audit, host on-prem, and freeze on a specific version. The Modified MIT license has effectively no commercial restriction below ~100M MAU.

What are Kimi K2.6's limitations?

Moonshot's launch post is, by frontier-lab standards, candid. The third-party picture matches:

1. Output speed is mid-pack. 34.4 tokens per second on the Moonshot API, ranked #46 of 83 models tracked by Artificial Analysis. Time-to-first-token is 3.04 seconds in thinking mode — meaningfully slower than Opus 4.7 (~1.2s) or GPT-5.5 (~0.8s). Instant mode roughly doubles throughput.
2. Terminal-Bench gap is real. 66.7% on Terminal-Bench 2.0 is a clear loss to GPT-5.5 (~82.7%). If your agents live in a shell rather than in code, K2.6 is not the right model.
3. SWE-bench Verified still trails Opus 4.7 by ~7 points. 80.2% vs 87.6%. On the hardest single-file bug fixes, Opus 4.7 still wins. K2.6 closes the gap on multi-file and multi-language work, but Verified is still Anthropic's home turf.
4. Self-hosted INT4 has a transformers version pin. transformers>=4.57.1, <5.0.0. Older inference stacks silently fall back to FP16 and OOM on single-node setups. This will catch a team off-guard the first time.
5. Verbosity is high. 170M output tokens during the Artificial Analysis Intelligence Index evaluation — among the chattiest models tested. Use instant mode or aggressive max_tokens caps for cost-sensitive workloads.
6. Agent Swarms add overhead on sequential work. Tasks that do not parallelise see 10–25% latency overhead from the swarm scheduler. Disable swarms (one extra_body flag) when you know the task is linear.
7. Vision encoder is good, not great on stylised content. MoonViT matches Opus 4.7 on dense documents and screenshots but lags on artistic / illustrative imagery. Not a typical agentic-coding concern, but worth knowing for design-tooling use cases.
8. Hosted-API rate limits are conservative for now. Default tier is 50 RPM; bumping to production tiers requires a request to support@moonshot.ai. Plan ahead if you intend to ship K2.6 to production traffic on day one.
9. License has a scale clause. Modified MIT, no restriction below ~100M MAU or $20M/month revenue; above that, you must display "Kimi K2" branding on the user interface. Most teams will never hit either threshold; for hyperscalers planning to embed K2.6 in user-facing products, it is a legal-review item before launch.
10. Hosting region. Moonshot's primary infrastructure is in Beijing; the .ai endpoint terminates in a US/EU edge but data eventually flows to Chinese-controlled infrastructure. For regulated workloads where data residency matters, self-host or use a Western re-seller (Cloudflare Workers AI, NVIDIA NIM, DeepInfra).

How do you call the Kimi K2.6 API?

You call K2.6 with the model id kimi-k2.6 against the Moonshot platform API at https://api.moonshot.ai/v1. The API is OpenAI-compatible, which means existing OpenAI SDKs work out of the box.

Key knobs:

• Thinking mode (default): The model emits a hidden reasoning trace before the user-visible answer. Reasoning is returned in response.choices[0].message.reasoning; the visible answer is in .content as usual. Recommended temperature: 1.0, top-p: 0.95, max_tokens: up to 98,304 for hard reasoning.
• Instant mode: Disable thinking with extra_body={"thinking": {"type": "disabled"}} for low-latency chat. Recommended temperature drops to 0.6.
• Preserve thinking across turns: Set thinking: {type: "enabled", keep: "all"} to retain the full reasoning trace in multi-turn conversations. Useful for agentic loops; doubles the output-token bill.
• Multimodal: Pass images as base64 PNG/JPG via image_url; pass MP4 video via video_url (official API only — vLLM and SGLang do not yet support video).
• Tool use: Standard OpenAI tool-call schema. 96.6% tool-invocation success across the Moonshot tool benchmark.
• Agent Swarms: Enable via extra_body={"swarm": {"enabled": true, "max_agents": 300, "max_steps": 4000}}. Set enabled: false on tasks you know are linear.

A minimal Python example:

from openai import OpenAI

client = OpenAI(
    api_key="sk-...",
    base_url="https://api.moonshot.ai/v1",
)

response = client.chat.completions.create(
    model="kimi-k2.6",
    messages=[{"role": "user", "content": "Port this Python function to Rust."}],
    temperature=1.0,
    extra_body={"thinking": {"type": "enabled", "keep": "all"}},
)
print(response.choices[0].message.content)

Building with Kimi K2.6? Hire the engineers who know open-weights operations.

K2.6 closes the gap between open weights and closed-frontier quality — but only if the team running it understands inference operations, agent design, and routing economics. Most teams that try to adopt open-weights models stall at the same three places: serving infrastructure (vLLM, SGLang, KTransformers, prefix caching), agent harnesses (MCP tools, evals, swarm scheduling), and the routing layer that sends the right task to the right model.

Hire a Codersera-vetted AI or platform engineer to stand up K2.6 in your stack: tensor-parallel deployments on H200 / H100, prefix caching, agent-swarm integration, eval pipelines, and a router that knows when to fall back to Opus 4.7 or GPT-5.5. Vetted, remote-ready, and available in days — not months.

FAQ

When was Kimi K2.6 released?

Moonshot AI shipped Kimi K2.6 on April 20, 2026, nine months after the original K2 (August 2025) and five months after K2.5 / K2-Thinking (November 2025).

What is the model id for Kimi K2.6 in the API?

kimi-k2.6. Use it as the model parameter against https://api.moonshot.ai/v1. The API is OpenAI-compatible.

What license is Kimi K2.6 released under?

A Modified MIT license. Commercial use is permitted with no royalty. Above ~100M monthly active users or $20M/month revenue, you must display "Kimi K2" branding on the product UI; below those thresholds the license behaves as standard MIT.

What hardware do I need to self-host Kimi K2.6?

Full 256K context at INT4 needs 8x H200 141GB (or equivalent ~640 GB aggregate VRAM). Reduced context fits on 4x H100 80GB. Single H100 80GB serves INT4 at ~32K context. KTransformers CPU+GPU hybrid runs the FP16 weights with 1.5 TB RAM and one H100. Apple Silicon via MLX smart-quant fits in ~150 GB on a single Mac Studio M3 Ultra.

How much does the Moonshot hosted API cost?

$0.95 / $4.00 per million tokens (input / output) on Moonshot direct. Cache reads $0.16/M — an 83% input-side discount, applied automatically. OpenRouter is slightly cheaper at $0.74 / $3.50/M. Blended at a 3:1 input:output ratio: roughly $1.71 per million tokens.

Does Kimi K2.6 support prompt caching?

Yes, automatically. Repeated prefixes are cached and billed at $0.16/M on read. Unlike Anthropic's API, you do not need to mark cache-control points explicitly.

Is Kimi K2.6 better than Claude Opus 4.7?

For long-horizon autonomous coding, web research, multilingual coding, and competition math — yes. For SWE-bench Verified single-file bug fixes, graduate-level science, and dense MCP-tool workflows — Opus 4.7 still leads. On cost, K2.6 wins by 5–6x.

Is Kimi K2.6 better than GPT-5.5?

For SWE-bench Pro (tied at 58.6%), web research (DeepSearchQA 92.5 vs ~80), and competition math (AIME 2026 96.4% vs ~94%), yes. For the AAII composite (54 vs 60) and Terminal-Bench 2.0 (66.7% vs ~82.7%), GPT-5.5 still leads. K2.6 is roughly 3x cheaper.

Is Kimi K2.6 better than DeepSeek V4 Pro?

On long-horizon agentic work, agent swarms, multilingual SWE, and tool-use success rate — yes, decisively. On competitive programming (LiveCodeBench), V4 Pro leads (93.5 vs 89.6). SWE-bench Verified is a tie (80.6 vs 80.2). On raw cost, V4 Pro is ~17% cheaper at base pricing and 4–5x cheaper during its 75%-off promo through May 31, 2026.

What are Agent Swarms and when should I use them?

A native K2.6 primitive that lets the model spawn up to 300 sub-agents and coordinate up to 4,000 steps per task. Use them on parallelisable work — large literature reviews, multi-repo refactors, batch validation. Disable them on linear tasks where they add 10–25% latency overhead with no quality gain.

Does Kimi K2.6 support vision and video?

Yes. Images via base64 PNG/JPG (image_url) and MP4 video via base64 (video_url). Video input is currently official-API-only; vLLM and SGLang do not yet support it.

Does Kimi K2.6 work with Cursor and Windsurf?

Partly. As of early May 2026, Cursor has an open community request to add K2.6 to its model picker but no first-class integration — you can use it via OpenRouter or a custom OpenAI-compatible endpoint. Windsurf supports the K2 family in its picker; K2.6 specifically is rolling out. The wiring is identical to any other OpenAI-compatible endpoint either way. See our Cursor IDE guide for setup patterns.

How do I disable the thinking trace for low-latency chat?

Pass extra_body={"thinking": {"type": "disabled"}} on the official API, or extra_body={"chat_template_kwargs": {"thinking": false}} on vLLM / SGLang. Drop temperature to 0.6 in instant mode for best results.

Where does Kimi K2.6 host its weights?

Hugging Face at moonshotai/Kimi-K2.6. The native INT4 weights are ~594 GB. Community quants for llama.cpp, LM Studio, Jan, Ollama, and MLX are all available.