HomeAI models
MoonshotAI: Kimi K2.7 Code
Moonshot AI
•
0
•
Released 
June 2026

Moonshot AI
0

Open-weight, coding-focused agentic model tuned for long-horizon software engineering with roughly 30% leaner reasoning-token usage.

Modality:
Text
Image
PDF
model ID
moonshotai/kimi-k2.7-code
Start for free
arrow black icon
View API Docs
arrow white icon

Output Speed *

0.00
tok/s

Intelligence Index *

0
/ 100

Context Window *

0
tokens

Input price

4
Anytoken

Output price

20.4
Anytoken
Kimi K2.7 Code: Long-Horizon Coding Agents With Leaner Reasoning Kimi K2.7 Code is an open-weight, coding-focused agentic model from MoonshotAI, built on Kimi K2.6 within the trillion-parameter Kimi K2 family. It is a specialist rather than a generalist: fine-tuned for multi-step software engineering — planning, editing, running tools, and debugging across extended sessions. Its defining trait is efficiency. MoonshotAI reports it cuts thinking-token usage by roughly 30% versus K2.6 while posting double-digit gains on every coding benchmark it published. Teams running autonomous coding agents at scale, where output tokens dominate the bill, benefit most from this combination of higher task success and lower per-task cost. Integrate Kimi K2.7 Code via the AnyAPI.ai API and route your coding-agent traffic today.

Performance

Where Kimi K2.7 Code Earns Its Place: Long-Horizon Task Completion

Kimi K2.7 Code is tuned for end-to-end software engineering across many steps rather than single-shot generation. MoonshotAI reports it lifts Kimi Code Bench v2 from 50.9 to 62.0 (+21.8%) over K2.6 while cutting thinking-token usage roughly 30%. These are first-party numbers, but they point at a consistent story: higher task success with less deliberation overhead. Because agentic coding runs hundreds of plan-edit-verify steps, and reasoning tokens bill as output, a 30% reduction compounds across a long run. The production consequence is lower effective cost per accepted change and faster interactive CLI turns.

Benchmarks

Reading Kimi K2.7 Code Benchmarks: Vendor-Reported Only

All published Kimi K2.7 Code scores are first-party. On MoonshotAI's own coding suites, it improves on K2.6 by +21.8% on Kimi Code Bench v2 (62.0 vs 50.9), +11.0% on Program Bench (53.6 vs 48.3), and +31.5% on MLS Bench Lite (35.1 vs 26.7). On agentic suites (Kimi Claw 24/7 Bench, MCP Atlas, MCP Mark Verified) it improves roughly 10% over K2.6, scoring 81.1 on MCP Mark Verified. As of mid-2026 no independent SWE-bench, Terminal-Bench, or LiveCodeBench results exist under identical conditions, so treat these figures as vendor claims and run your own bake-off.

Output Speed

*
0.00
tok/s

Intelligence Index

*
0
/ 100

MMLU *

Broad world knowledge and problem-solving
0
%

GPQA *

PhD-level scientific reasoning across physics, biology, chemistry.
0
%

HLE *

Adherence to multi-step structured instructions.
0
%

LiveCodeBench *

Tool-calling reliability in long agentic loops.
0
%

Technical Specifications

What the model supports

Kimi K2.7 Code is a Mixture-of-Experts model with roughly 1T total parameters and 32B active per token, sharing K2.6's architecture (61 layers, 384 experts, MLA attention, MoonViT vision encoder). It accepts text and image input and returns text. The two most consequential characteristics for production: a 262,144-token context window that supports large-repo and multi-file sessions, and a forced thinking mode — the model always reasons and preserves reasoning across turns, which cannot be disabled. Weights ship openly under a Modified MIT License, enabling self-hosting for data-residency needs.
Verified Specifications — 
0
*
Input modalities
Text
Image
PDF
output modalities
Text
Context window
0
 tokens
Maximum output tokens
0
Reasoning
No
Knowledge cutoff
June 2026
Pricing (standard)
4
 AnyTokens in
 / 
20.4
 AnyTokens out

Limitations & Trade-offs

Where 0 falls short

1
Vendor-only benchmarks. Every published Kimi K2.7 Code score comes from MoonshotAI's proprietary suites (Kimi Code Bench v2, Program Bench, MLS Bench Lite, MCP Mark Verified). As of mid-2026 no independent SWE-bench Verified, SWE-bench Pro, LiveCodeBench, or Terminal-Bench results run all models under identical conditions. This matters most for teams configuring model-routing systems, who need discriminating neutral signals. Until third-party numbers appear, treat the deltas as directional and run a controlled bake-off with pinned versions and cost-per-accepted-change metrics.
2
Forced thinking mode. Kimi K2.7 Code always operates in thinking mode with preserved reasoning; it cannot be disabled. For genuinely simple, latency-sensitive, or single-turn requests, this adds unavoidable reasoning overhead and output-token spend even after the ~30% reduction. A non-reasoning or toggleable model is preferable for high-volume trivial completions where deliberation adds no value.
3
Coding specialist, not a generalist. K2.7 Code was fine-tuned for long-horizon software engineering and trades breadth for depth. For general-purpose chat, creative writing, or broader multimodal reasoning, the sibling Kimi K2.6 or another generalist model is a better fit. Do not deploy it as an all-purpose assistant.
4
Trails closed frontier on raw quality. Independent reviewers note that on most listed comparisons K2.7 Code trails both closed leaders like GPT-5.5 and Claude Opus 4.8 on absolute capability; its advantage is price and openness rather than topping the leaderboard. Teams whose sole priority is maximum coding accuracy regardless of cost may prefer a closed frontier model.

Best-Fit Workloads

Where this model earns its place

01

Long-horizon autonomous coding agents

‍
K2.7 Code is explicitly tuned to plan, edit across files, run tools, and debug over extended agent sessions. MoonshotAI reports higher end-to-end task success and more reliable long-context instruction following than K2.6. Because thinking is preserved across turns and reasoning tokens are ~30% leaner, cost per accepted change drops on runs spanning hundreds of steps. Ideal for repo-scale refactors and multi-file feature implementation. Validate with your own acceptance tests, since scores are vendor-reported.

02

MCP tool-use and CI loops

‍
The model supports multi-turn function calling and scored 81.1 on MoonshotAI's MCP Mark Verified, which tests correct tool invocation via the Model Context Protocol. This fits agentic loops that run CI checks, update tickets, edit files, and fix failing migrations through MCP servers such as GitHub and Postgres in one session. Structured outputs and OpenAI/Anthropic-compatible APIs simplify wiring into existing agent harnesses.

03

High-volume, cost-sensitive coding at scale

‍
For teams where output tokens dominate the bill, K2.7 Code benefits twice: roughly 30% fewer reasoning tokens per task, layered on lower per-token pricing than closed flagships. Long autonomous runs get cheaper at both the token-count and per-token level, making it well suited to high-throughput agentic coding where economics decide viability. Best when cost or data control is a priority over topping absolute benchmarks.

04

Self-hosted, data-residency-constrained deployments

‍
Open weights under a Modified MIT License let privacy-sensitive organizations run K2.7 Code entirely in-house — on 8× H200-class hardware with vLLM, SGLang, or KTransformers — and drive it with Kimi Code CLI pointed at a local endpoint. This suits regulated codebases that cannot leave the perimeter, and enables fine-tuning a frontier-class coding model on proprietary code. Note the attribution clause applies at very large scale.

Pricing in anytokens via AnyAPI
Input
4
₳
Output
20.4
₳
Cache write
—
₳
Cache read
0.9
₳
Get API access
arrow black icon
Read Docs

on this page

PerformanceBenchmarksTechnical SpecificationsLimitations & Trade-offsBest-Fit WorkloadsIntegrationFAQ

Integration

Access 0 via AnyAPI.ai

Access 0 through AnyAPI.ai using a unified API built for multi-model AI applications. Integrate 0 without maintaining a separate provider-specific connection, and keep the flexibility to test, switch, or combine models as your application requirements evolve.

01

One API integration

Access 0 and other AI models through the same API workflow instead of maintaining separate integrations for every provider.

02

Easy model switching

Test 0 against alternative models or switch models as your performance, capability, or cost requirements change without rebuilding your application around another provider API.

03

Flexible for production

Use 0 from experimentation through production while keeping your AI stack flexible as workloads, traffic, and model requirements evolve.

04

Multi-model applications

Use 0 for the workloads where it performs best and combine it with other models for tasks that require different capabilities, performance, or efficiency.

Start free
arrow black icon
Read Docs

Frequently Asked Questions

Answers to common questions about integrating and using this AI model via AnyAPI.ai

Kimi K2.7 Code is a coding-focused agentic model built for long-horizon software engineering — planning, editing across files, running tools, and debugging over extended sessions. It is not designed for general chat. MoonshotAI reports higher end-to-end coding task success than K2.6 while cutting reasoning-token usage by roughly 30%, making it well suited to autonomous coding agents and MCP tool loops.

Kimi K2.7 Code supports a 262,144-token context window (roughly 256K), the same as Kimi K2.6. It also supports up to 262,144 completion tokens. This large window is designed for large-repository and multi-file coding sessions where the model must track source, logs, and prior reasoning across many steps.

Yes. Kimi K2.7 Code supports function calling via tools and tool_choice, multi-turn tool use, MCP workflows, and structured outputs. It accepts text and image input and returns text. Its MoonViT vision encoder handles image input, so a UI screenshot plus a stack trace can be diagnosed in a single prompt.

No. As of mid-2026, all published Kimi K2.7 Code scores come from MoonshotAI's own suites (Kimi Code Bench v2, Program Bench, MLS Bench Lite, MCP Mark Verified). No independent SWE-bench, LiveCodeBench, or Terminal-Bench results run all models under identical conditions exist yet. Treat the figures as vendor claims and run a controlled evaluation on your own tasks.

Yes. Kimi K2.7 Code ships open weights on Hugging Face under a Modified MIT License, so it can be self-hosted with vLLM, SGLang, or KTransformers and fine-tuned on proprietary code. It is also available through MoonshotAI's OpenAI/Anthropic-compatible API. The Modified MIT attribution clause primarily affects operators at very large scale.

* Benchmark data source: Artificial Analysis artificialanalysis.ai