Kimi K2.6: What Moonshot AI's New Model Actually Scores on the Benchmarks

HLE is a 3,000-question benchmark assembled by domain experts to be the hardest single test for general AI knowledge. It mixes graduate-level math, frontier physics, novel chemistry, and obscure language tasks. A model can score well on MMLU and still bomb HLE; that is the point.

| Model | HLE-Full (with tools) | Source |

|---|---|---|

| Kimi K2.6 | 54.0 | Moonshot blog |

| Claude Opus 4.6 | 53.0 | BuildFastWithAI comparison |

| GPT-5.4 | 52.1 | BuildFastWithAI comparison |

| Gemini 3.1 Pro | 51.4 | BuildFastWithAI comparison |

The "with tools" qualifier matters. K2.6 leads in the variant where the model is allowed to call external tools (search, code execution, calculators) during the exam. Without tools, K2.6 scores 36.4% — still strong, but no longer the leader. Source: Lorka AI K2.6 review.

What this tells you: K2.6 is not just smarter in raw weights. It is better at orchestrating tool calls under pressure, which is exactly the capability that matters for autonomous coding agents.

HLE is interesting, but most readers care about coding throughput. K2.6 leads or ties on:

• SWE-bench Verified (real-world bug fixes against GitHub issues)
• LiveCodeBench Pro (competitive programming)
• Aider polyglot (multi-file refactoring across languages)

Source: Moonshot K2.6 tech blog and Office Chai benchmark coverage.

The number that matters most for daily use is on long-horizon tasks. K2.6 sustains coding work for 12+ hours and 4,000+ tool calls in a single session without losing track of state. That is roughly 4× what Claude Code holds and 2× what Codex sustains. If you have ever watched a Claude session forget the file structure 3 hours in, you know why this is the headline feature.

K2.6 is not strictly better. Three areas where Claude Opus 4.6 or GPT-5.4 still lead:

• Creative writing — Claude's prose voice is materially better, especially for long-form
• Multi-modal vision — GPT-5.4 + Images 2.0 still outperforms K2.6 on dense visual reasoning
• Voice + agentic UI — Anthropic's ecosystem (Claude Cowork, MCP, Skills) is ahead of Moonshot's developer surface

If your work is visual or voice-first, K2.6 is a sidegrade. If it is code or research, K2.6 is a possible upgrade.

Most agentic coding sessions are a single context window with tool calls. Open Anthropic's Skills, Claude Code's /agents feature, or OpenAI's Codex agent — all of those run one primary agent at a time, with the option to spawn focused sub-agents for narrow tasks.

K2.6 ships with native orchestration for up to 300 concurrent sub-agents coordinated through a parent planner. The planner decomposes a project into independent work units, dispatches each to a specialist sub-agent (frontend, backend, tests, docs, infra), and reconciles the outputs. Source: MarkTechPost K2.6 release coverage.

The previous version capped at 100. The jump to 300 sub-agents is what enables single-prompt full-stack delivery (website + database + slides + spreadsheets in one session).

Swarm scaling helps for tasks with independent subproblems:

• Building a multi-page site where each page is largely independent
• Refactoring a monorepo where each package can be touched in parallel
• Generating a documentation set where each doc is self-contained
• Producing a deliverable bundle (slides + spreadsheet + report) from one brief

It does not help for tightly-coupled work — debugging a race condition in a single file, designing a schema, optimizing a single algorithm. For those, a tighter single-context loop is faster.

The honest framing: swarms are a parallelism trick. If your problem is parallel, K2.6 finishes faster than any single-context model. If it is not, the overhead of coordination is wasted.

Most AI products you have used so far are assistants: you ask a question, you get text back, you copy-paste it into a real document yourself. The model is one expert sitting next to you.

K2.6 with file output flips this. The model becomes a department: a project manager who decomposes your brief into work units, dispatches them to specialist sub-agents, and hands you back finished deliverables — Word documents, PDFs, slide decks, spreadsheets. You do not transcribe. You do not reformat. You receive the bundle.

Moonshot's own framing in the K2.6 launch blog: "Outputs are real files, not chat — one run delivers 100+ files, 100,000-word literature reviews, or 20,000-row datasets." Source: Moonshot K2.6 tech blog and AlphaSignal swarm coverage.

What changes when the unit of work is a deliverable, not a message:

• Brief, don't iterate. You write a one-paragraph project brief, not a back-and-forth chat. The model's planner asks clarifying questions if the brief is ambiguous, then disappears for 30–90 minutes.
• Review the bundle, not the prose. You audit the 100-page report, the 20K-row dataset, and the slide deck as a whole — the same way you would review a junior analyst's deliverable.
• Reuse via Skills. K2.6 can ingest a high-quality reference document (a sample McKinsey deck, a published paper, a polished resume) and turn it into a Skill that captures the document's "structural and stylistic DNA." The next run reproduces that style. Source: Moonshot K2.6 tech blog.

This is a workflow shift, not a feature shift. If you keep treating it like a chat tool, you are using 5% of the model. If you treat it like a department, you are running projects that previously required three to five people for a week.

This is the demo Moonshot uses to anchor the swarm-as-department story. The exact reported result, quoted from the K2.6 blog: "Based on the uploaded CV, K2.6 spawned 100 sub-agents to match 100 relevant roles in California, delivering a structured dataset of opportunities and 100 fully customized resumes." Source: Moonshot K2.6 tech blog.

You can reproduce this on the free Kimi Chat tier with a single conversation. Steps:

1. Open kimi.com and start a new chat. Confirm K2.6 is the active model in the model selector.
2. Upload your CV (PDF or Word). The file becomes part of the working context.
3. Brief the project in one paragraph, for example:

> "Read my attached CV. Find 100 currently-open roles in California that match my background — biased toward senior IC and staff-level positions, mix of remote and Bay Area in-person. For each role, produce: (a) a row in a master Excel sheet with company, title, location, comp range, source URL, and a 1-sentence fit rationale; (b) a tailored one-page resume in Word format that emphasizes the parts of my background most relevant to that specific role. Deliver the Excel and a zip of all 100 resumes."

1. Wait. The planner will spawn sub-agents (one per role search, then one per resume tailoring). Long-horizon runs at this scale typically take 30–90 minutes.
2. Download the bundle when complete. You will receive an Excel spreadsheet plus 100 individual .docx files, each tailored to a specific posting.

Acceptance check before you trust the output:

• Spot-check 5 of the 100 resumes against the master sheet. Does each resume actually emphasize the keywords in its target job description?
• Verify 3 source URLs are still live postings, not stale cache hits. If many are dead, your sub-agents pulled from a non-fresh search index — re-run with a "search results from the last 30 days only" constraint in the brief.
• Confirm the Excel sheet has all 100 rows with no truncation. Long-horizon runs occasionally lose state on row 80+ if the planner under-budgets the dataset task.

Why this matters: a single brief replaces what would otherwise be 100 manual tailoring sessions. Even if 20 of the 100 resumes need human polish, the leverage ratio is roughly 5:1 versus doing it yourself.

The literature-review demo is the second canonical anchor. The reported result: "a 104-page, 10,000-word literature review, ready to download in Word, PDF, PPT, or Excel." Source: AlphaSignal — How Kimi K2.6 Deploys 300 Sub-Agents.

Reproduce the pattern for any research topic where you currently spend a week reading and summarizing papers:

1. Pick a research question narrow enough that the answer fits in 60–120 pages, for example: "What does the 2024–2026 literature say about reinforcement learning from human feedback alternatives — DPO, KTO, ORPO, IPO — and where is each method's empirical evidence strongest?"
2. Open Kimi Chat at kimi.com, confirm K2.6 is selected, and write a brief that specifies (a) the question, (b) source quality bars (peer-reviewed only, last 24 months, etc.), (c) the target deliverable shape, and (d) the file format. Example:

> "Produce a literature review on RLHF alternatives (DPO, KTO, ORPO, IPO). Constraints: peer-reviewed papers and arxiv preprints from 2024-01 onwards; 100+ citations; structured by method, then by experimental domain. Deliver: (1) a Word document with the full review, (2) a PowerPoint executive summary, (3) an Excel table of all citations with method, year, headline result, and dataset. 80–120 pages."

1. Let the swarm decompose. K2.6's planner will split the work into source search, citation extraction, topic grouping, outline creation, section writing, table creation, and final formatting (per Moonshot's described decomposition pattern). Source: AlphaSignal swarm coverage.
2. Download all three artifacts when the run completes.

Quality gates before you cite anything:

• Open the Excel citation table. Pick 10 random rows and verify the source actually exists and supports the claim attributed to it. Multi-agent literature reviews still hallucinate citations — the rate has dropped versus single-context runs but is not zero.
• Read the Word executive summary section first. If the framing matches your question, the structural decomposition worked. If it drifted, kill the run and re-brief with tighter constraints.
• Verify the PowerPoint deck is consistent with the Word document. Cross-document inconsistency is the failure mode that exposes a swarm coordination breakdown.

If the artifacts pass these gates, you have replaced a one-week solo lit-review pass with a 60–90 minute autonomous run plus a half-day human verification. That is the AI-department leverage in concrete numbers.

What this is not: a substitute for domain judgment. K2.6 will produce a structurally clean literature review on a topic where the field's actual consensus is contested, and the contested-ness will not always show up in the prose. Use it to compress the mechanical work, not the interpretive work.

The lowest-friction way to try K2.6 is kimi.com. Sign in with email; the free tier exposes K2.6 with reasonable daily limits. No API key required. Useful for spot tests, comparing one prompt against Claude or GPT, or short coding sessions.

The free chat does NOT give you the 12-hour autonomous agent runs. For that you need the API.

K2.6 is available via Moonshot's API. Pricing (as of April 2026):

• Roughly 30–50% of Claude Opus 4.6 per token for input
• Roughly 40–60% of Claude Opus 4.6 per token for output
• Long-context surcharge applies above 128K tokens

Source: Testing Catalog launch coverage. Pricing is in USD even though Moonshot is a Chinese company.

Set up: register at platform.moonshot.cn, create an API key, and point any OpenAI-compatible client at the Moonshot endpoint. The API speaks the OpenAI Chat Completions schema, so most existing code (LangChain, Aider, Open Interpreter) works with a single base-URL swap.

K2.6 weights are open and pullable from huggingface.co/moonshotai/Kimi-K2.6. The full model is 1 trillion parameters with a Mixture-of-Experts architecture; 32B parameters are active per token, and the context window is 256K tokens. Source: Hugging Face model card.

That activation footprint is what makes it borderline self-hostable: 32B active is in the same ballpark as Llama 3 70B at FP8, so a single 8×H100 node or a dual-RTX-5090 workstation with aggressive quantization can run it. The full weights at FP16 require around 2TB of GPU memory, which is data-center scale.

License: open-weight, with commercial use permitted under Moonshot's modified MIT-style license. Read the actual LICENSE file in the Hugging Face repo before deploying — there are clauses around attribution and downstream model derivation.

Stay with Claude or GPT if:

• Your work is creative writing, design, or dense visual analysis
• You are deeply integrated with Claude Skills, Cowork, or OpenAI's Workspace Agents
• Your team needs SOC 2 + DPA from a US-based vendor (Moonshot operates from China; check your compliance posture)

Switch to (or add) K2.6 if:

• You run long autonomous coding sessions and Claude or Codex is forgetting context after 3–4 hours
• Your bills are dominated by token cost and a 30–50% reduction is meaningful
• Your work is parallelizable across sub-agents (multi-page builds, monorepo refactors, documentation sets)
• You want open weights for self-hosting or air-gapped environments

The fastest test: take your hardest coding session from the last week and run it once against K2.6 via the free chat. If it finishes the task, switching is real. If it stalls where Claude or GPT also stalled, the bottleneck is not the model.

A free open-weight model from a Chinese lab leading a closed US benchmark is not new — DeepSeek did it in early 2025, Qwen has been doing it for a year. What is new is scale of the parallelism feature (300 sub-agents) and the price aggression (40–50% of Claude). The gap that closed-lab API pricing exploited is shrinking by the quarter.

Practical implication: design your stack around model swappability. If your code calls anthropic.messages.create directly, you are coupled to a single vendor. If it calls a generic chat.completions endpoint with a configurable base URL (the OpenAI shape), you can A/B Claude vs. K2.6 vs. GPT vs. Gemini on the same workload and switch on price-performance. Tools like Claude Code Router and OpenRouter make this routing trivial; see the companion guide on Claude Desktop model swapping for the full setup.

Sources

• Moonshot AI Kimi K2.6 tech blog
• Hugging Face Kimi-K2.6 model card
• MarkTechPost — Moonshot AI Releases Kimi K2.6
• Office Chai — K2.6 Benchmarks
• BuildFastWithAI — Kimi K2.6 vs GPT-5.4 vs Claude Opus
• Lorka AI — Kimi K2.6 Review
• Testing Catalog — Moonshot Launches K2.6
• AlphaSignal — How Kimi K2.6 Deploys 300 Sub-Agents and One-Shots a 104-Page Literature Review
• Source video (file-output module): Stop Using ChatGPT. Kimi K2.6 Just Replaced Your Whole Team
• Source video (original guide): China's Free AI Just Embarrassed Claude And ChatGPT (+12 AI Updates)