Kimi K2.7 Code is available on Novita AI for teams building coding agents, tool-using assistants, and long-context engineering workflows. Use the model ID moonshotai/kimi-k2.7-code with Novita AI’s OpenAI-compatible chat API when you need a coding-focused model with a 262,144-token context window, multimodal inputs, tool calling, structured outputs, and clear token pricing.
Key Takeaways
- Kimi K2.7 Code is a MoonshotAI coding and agentic model available through the Kimi K2.7 Code API and Playground on Novita AI.
- The Novita AI model ID is
moonshotai/kimi-k2.7-code, withchat/completionsandanthropicendpoint families listed on the model page. - The model page lists a 262,144-token context window and 262,144 max output tokens, making it suitable for long repository context, multi-file reasoning, and extended agent traces.
- As of June 16, 2026, pricing is $0.95 per 1M input tokens, $0.19 per 1M cache-read input tokens, and $4.00 per 1M output tokens.
What Is Kimi K2.7 Code?
Kimi K2.7 Code is MoonshotAI’s coding-focused Kimi model for agentic software development workflows. The Novita AI Kimi K2.7 Code model page describes it as a 1T-parameter Mixture-of-Experts model with 32B activated parameters, a 256K context window, interleaved thinking, and multi-step tool calling.
For developers, the value is practical: Kimi K2.7 Code is built for prompts that include more than a small snippet. It can work with larger repository context, reason through multi-step implementation plans, use tools, and return code or structured outputs through an API. That makes it a natural fit for coding assistants, repository-aware agents, code review copilots, and internal automation where context length and tool-use behavior matter.
It also supports text, image, and video inputs with text output. In practice, that means you can evaluate it for UI inspection, design-to-code prompts, screenshot-based bug reports, and multimodal debugging workflows while keeping the response format text-based.
Kimi K2.7 Code API Access on Novita AI
Kimi K2.7 Code is available through Novita AI under the exact model ID moonshotai/kimi-k2.7-code. The model page lists two endpoint families:
| Endpoint family | What it means for developers |
|---|---|
chat/completions | Use Kimi K2.7 Code through an OpenAI-compatible chat completion interface. |
anthropic | Use the model through Novita AI’s Anthropic-compatible endpoint path where supported by your tooling. |
Endpoint details above are based on the Novita AI model page as of June 16, 2026.
For most application teams, the OpenAI-compatible route is the simplest place to start. Keep the familiar chat messages pattern, configure the Novita AI base URL, and set the model to moonshotai/kimi-k2.7-code. For runnable code examples and a step-by-step walkthrough, see the Kimi K2.7 Code API quick start.
from openai import OpenAI
client = OpenAI(
api_key="YOUR_NOVITA_API_KEY",
base_url="https://api.novita.ai/v3/openai",
)
response = client.chat.completions.create(
model="moonshotai/kimi-k2.7-code",
messages=[
{"role": "system", "content": "You are a careful coding assistant."},
{"role": "user", "content": "Review this function for correctness and edge cases."},
],
max_tokens=4096,
temperature=0.2,
)
print(response.choices[0].message.content)Create and manage API keys through Novita AI Key Management. For account setup, see the Novita AI quickstart guide.
Kimi K2.7 Code Specs and Pricing Summary
| Field | Details |
|---|---|
| Display name | Kimi K2.7 Code |
| Model ID | moonshotai/kimi-k2.7-code |
| Model type | Chat |
| Series | MoonshotAI |
| Architecture label | MoE |
| Parameter summary | 1T total parameters, 32B activated |
| Base URL | https://api.novita.ai/v3/openai for OpenAI-compatible calls |
| Endpoint family | chat/completions, anthropic |
| Input modalities | Text, image, video |
| Output modality | Text |
| Context window | 262,144 tokens |
| Max output tokens | 262,144 tokens |
| Features listed | Serverless, function calling, structured outputs, reasoning |
| Pricing | $0.95 / 1M input tokens, $0.19 / 1M cache-read input tokens, $4.00 / 1M output tokens |
| Rate limits shown | T1: 30 RPM / 50,000,000 TPM; T2: 100 RPM / 50,000,000 TPM; T3: 1,000 RPM / 50,000,000 TPM; T4: 3,000 RPM / 50,000,000 TPM; T5: 6,000 RPM / 50,000,000 TPM |
| Best fit | Coding agents, code review, repository analysis, structured engineering assistants, multimodal development workflows |
Specs and pricing above are based on the Novita AI model page as of June 16, 2026.
Key Capabilities for Developers
Tool Calling: Build Agents That Need Function Use
Function calling and structured outputs matter when your application needs the model to do more than answer in prose. Typical examples include repository search, test execution, retrieval, ticket triage, structured code review, and workflow routing.
Use tool calling for bounded actions with clear schemas. Keep high-risk operations behind explicit application checks, especially when a coding agent can modify files, run commands, or open pull requests.
Long Context: Keep More Repository State in View
The 262,144-token context window gives teams room for larger code snippets, issue descriptions, logs, dependency notes, and architectural constraints. You still need retrieval and context selection, but your agent has more room to preserve facts that often get dropped in short-context coding sessions.
For best results, organize context by priority: task goal, relevant files, failing test output, API contracts, constraints, and only then lower-priority background. Long context helps most when the input is curated.
Multimodal Input: Support Vision-Driven Development Workflows
Text, image, and video inputs open evaluation paths for UI review, screenshot-based bug reports, design-to-code prompts, and video-assisted debugging notes. Since output is text, the model can describe issues, produce implementation plans, or generate code changes from multimodal evidence.
Structured Outputs: Make Responses Easier to Automate
Structured output support is useful when the model response feeds downstream automation. A code review assistant can return severity, file path, line reference, confidence, and suggested patch. A triage agent can return component, likely owner, reproduction risk, and next action. Structured output turns the model from a chat interface into a predictable service component.
When to Use Kimi K2.7 Code
Coding Agents and Developer Tools
Use Kimi K2.7 Code when your product needs an LLM that can reason over code, call tools, and return structured results. Good candidates include IDE assistants, terminal coding agents, pull-request reviewers, test-failure explainers, internal platform bots, and CI triage tools.
If your team already uses OpenAI-compatible tooling, the chat/completions endpoint listed on the model page keeps integration work contained.
Repository Analysis With Long Context
Use Kimi K2.7 Code when the model needs to hold more than a small prompt in view: multi-file changes, migration notes, logs, architecture docs, API contracts, or long issue threads. Its long context window gives your application room to send enough context for serious analysis.
For very large repositories, long context works best with retrieval. Sending only the files, logs, and notes that directly affect the task usually produces better answers than sending an entire repository at once.
Multimodal Engineering Review
Use Kimi K2.7 Code when an engineering workflow includes screenshots, UI videos, or visual bug reports. Its text, image, and video inputs make it worth testing for front-end QA, design implementation review, and visual regression explanation.
Cost-Aware Long-Running Agents
Because Novita AI lists cache-read pricing for this model, Kimi K2.7 Code can fit repeated-context workflows where a stable system prompt, tool schema, repository summary, or design document appears across many calls. In practice, the best fit depends on cache reuse, output length, and total token cost for your workload.
When Not to Use Kimi K2.7 Code
Choose a smaller model for simple FAQ bots, short extraction tasks, or low-stakes classification where long context, multimodal input, and coding-agent features do not affect the result.
For coding-agent workflows, keep standard safety controls in place: validate tool arguments, sandbox command execution, require approvals for destructive actions, and log model decisions for audit.
How Kimi K2.7 Code Fits Your API Workflow
Kimi K2.7 Code fits into a Novita AI API workflow as a chat model. Keep these integration values handy:
- Model ID:
moonshotai/kimi-k2.7-code - OpenAI-compatible base URL:
https://api.novita.ai/v3/openai - Endpoint family:
chat/completions - Optional compatibility path:
anthropic - Primary use: coding, tool calling, structured outputs, long-context reasoning, multimodal engineering inputs
A practical rollout path is to start in the Kimi K2.7 Code Playground, move the same prompts into an API harness, and compare the results on the coding tasks your team already handles. Outcome quality and total token usage usually matter more than per-token pricing alone.
For coding agents, the most useful comparison points are:
| Evaluation area | What to measure |
|---|---|
| Correctness | Did the generated fix pass tests and preserve expected behavior? |
| Tool use | Did the model call the right tool with valid arguments? |
| Context use | Did it use provided repository facts instead of guessing? |
| Cost | What were input, cache-read, and output tokens per completed task? |
| Safety | Did it avoid destructive changes and flag uncertain assumptions? |
Final Recommendation
Use Kimi K2.7 Code on Novita AI if you are building coding agents, repository-aware assistants, multimodal engineering review tools, or long-context developer workflows that need OpenAI-compatible API access. Start with moonshotai/kimi-k2.7-code, test it in the Kimi K2.7 Code API and Playground, and compare it against your current model using real tickets, failing tests, and code review examples.
Choose another model when your workload is short, generic, or cost-sensitive enough that long context and coding-agent features are unnecessary.
FAQ
What is Kimi K2.7 Code?
Kimi K2.7 Code is a MoonshotAI chat model for coding and agentic workflows. The Novita AI model page describes it as a 1T-parameter MoE model with 32B activated parameters, a 256K context window, interleaved thinking, and multi-step tool calling.
Is Kimi K2.7 Code available on Novita AI?
Yes. The Kimi K2.7 Code model page on Novita AI lists the model as available as of June 16, 2026.
What is the model ID for Kimi K2.7 Code on Novita AI?
The model ID is moonshotai/kimi-k2.7-code.
How much does Kimi K2.7 Code cost on Novita AI?
As of June 16, 2026, Novita AI lists pricing at $0.95 per 1M input tokens, $0.19 per 1M cache-read input tokens, and $4.00 per 1M output tokens.
What endpoints does Kimi K2.7 Code support?
The Novita AI model page lists chat/completions and anthropic endpoint families for Kimi K2.7 Code.
What is Kimi K2.7 Code best used for?
It is best suited for coding agents, tool-using assistants, repository analysis, structured code review, and multimodal development workflows where long context and tool calling matter.
