O Kimi K2.7 Code é o modelo agêntico focado em código da Moonshot AI construído sobre o Kimi K2.6, ajustado para engenharia de software do mundo real e descrito pela Moonshot como seu modelo dedicado a código, que segue instruções de forma mais confiável em contextos longos e completa tarefas de código com taxas de sucesso mais altas.
- Entrada
- texto imagem vídeo $0.95/M
- Saída
- texto $4/M
- Leitura de cache
- $0.19/M
- Contexto
- 256K
- vs GPT-4o
- ~81% mais barato
Benchmarks
Publicado pelos fornecedores: Alibaba (Qwen) Moonshot OpenAI Z.ai
O preço em contexto
Posição do preço entre 60 modelos comparáveis
A barra mostra onde fica o preço deste modelo entre todos os modelos do mesmo tipo na Synthorai. Em cada extremidade está o mais barato e o mais caro. São tarifas base; os descontos de lote, região e escrita em cache estão na página de preços.
Especificações e limites
Tokens
| Janela de contexto (especificação do fornecedor) | 256.000 |
|---|---|
| Saída máxima (especificação do fornecedor) | 32.768 |
Cache de prompts
| Modo | automático |
|---|
Raciocínio
| Parâmetro do fornecedor | thinking.type + thinking.keep |
|---|---|
| Valores aceites | type accepts only enabled; keep accepts only all |
| Valor predefinido | raciocínio ativado, com Preserved Thinking ativado aplicado quando o pedido nada indica |
| Pode ser desativado | Não |
| Comportamento do raciocínio | Passar type disabled retorna erro; como o Preserved Thinking é forçado no servidor, o reasoning_content de toda mensagem de assistente do histórico precisa ser devolvido como está. |
| Parâmetro | reasoning_effort |
| Valores | minimal · low · medium · high a superfície de parâmetros do gateway - aplica-se o mapeamento do fornecedor acima |
Modelo
| Modalidades | texto + imagem + vídeo → texto |
|---|---|
| Parâmetros | 1T no total · 32B ativos MoE |
| Licença | Modified-MIT |
- Modelo agêntico focado em código, construído sobre o K2.6: MoE de 1T com 32B ativos, contexto de 256K
- raciocínio sempre ativo, com raciocínio preservado entre turnos
- cerca de 30% menos tokens de raciocínio que o K2.6
conforme documentação oficial da Moonshot ↗
Um prompt, medido pelo gateway
Kimi K2.7 Code passou · 3 sentences
Enabling reasoning mode causes the model to generate an internal chain-of-thought before producing each answer, and that hidden reasoning text is billed like any other output. Those extra reasoning tokens typically add up to much more than the final response itself, so every API call now costs significantly more than before. Because our overall usage volume did not change, the doubled bill reflects that each query consumes roughly twice as many billable tokens.
saída 259 tok (+174 pensamento) latência 5.4 s
Cumprimento da instrução (exatamente três frases - contáveis), ajuste ao público (registro de CFO), e a lacuna de cobrança do pensamento oculto que os medidores de tokens abaixo expõem.
Kimi K2.7 Code passou · 8/8 cases
```python def longest_run(xs): if not xs: return 0 best = 1 cur = 1 for i in range(1, len(xs)): if xs[i] == xs[i - 1]: cur += 1 best = max(best, cur) else: cur = 1 return best ``` The bug is that the function counts *transitions* between equal neighbors instead of counting the items themselves, so a single-element list never enters the loop and returns `0` instead of `1`. Likewise, resetting `cur` to `0` on a mismatch forgets the current item that starts a new run, which causes runs that end at the last index to be undercounted. Initializing both `best` and `cur` to `1` and resetting `cur` to `1` fixes both issues.
saída 410 tok (+222 pensamento) latência 9.4 s
Se a correção é de fato certa (executável), a densidade da explicação, e a eficiência em tokens numa tarefa delimitada.
Kimi K2.7 Code passou · 5/5 fields, guidance "withheld pending the Q4 close"
```json { "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": 412, "growth_pct": 11, "guidance": "withheld pending the Q4 close" } ```
saída 721 tok (+663 pensamento) latência 13.2 s
Obediência ao esquema (sem campos inventados), pressão de alucinação (guidance é explicitamente retida), e diferenças no caminho de saída estruturada.
Kimi K2.7 Code passou · 120 words, 0 banned, 1 question
We're introducing Prompt Cache for our API Gateway, a new capability that stores prompt responses across multiple AI providers. By caching replies, you reduce redundant calls, lower latency, and cut costs without changing how you build. Teams using several model providers can now reuse identical prompt results instantly, keeping traffic consistent and budgets predictable. Responses are keyed by provider, model, and exact prompt, so you always get the right result. Configure TTL, hit thresholds, and eviction rules from a single dashboard. It fits into your existing routing and requires no code changes. Setup takes minutes and works with your current endpoints. Want to see how much latency and spend you can trim? Check the docs to enable Prompt Cache today.
saída 2375 tok (+2235 pensamento) latência 38.6 s
Obediência às restrições (orçamento de palavras, lista de palavras proibidas, a única pergunta), impressão digital de estilo, e controle de comprimento.
Use o Kimi K2.7 Code em 30 segundos
Compatível com OpenAI: troque a base_url, mantenha seu SDK. POST /v1/chat/completions
from openai import OpenAI
client = OpenAI(
base_url="https://synthorai.io/v1",
api_key="sk-syn-...",
)
resp = client.chat.completions.create(
model="kimi-k2.7-code",
messages=[{"role": "user", "content": "Summarize this diff"}],
reasoning_effort="medium",
)
print(resp.choices[0].message.content)import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://synthorai.io/v1",
apiKey: "sk-syn-...",
});
const resp = await client.chat.completions.create({
model: "kimi-k2.7-code",
messages: [{ role: "user", content: "Summarize this diff" }],
reasoning_effort: "medium",
});
console.log(resp.choices[0].message.content);curl https://synthorai.io/v1/chat/completions \
-H "Authorization: Bearer sk-syn-..." \
-H "Content-Type: application/json" \
-d '{
"model": "kimi-k2.7-code",
"messages": [{"role": "user", "content": "Hello"}],
"reasoning_effort": "medium"
}'package main
import (
"context"
"fmt"
"github.com/openai/openai-go/v3"
"github.com/openai/openai-go/v3/option"
)
func main() {
client := openai.NewClient(
option.WithBaseURL("https://synthorai.io/v1"),
option.WithAPIKey("sk-syn-..."),
)
resp, _ := client.Chat.Completions.New(context.TODO(), openai.ChatCompletionNewParams{
Model: "kimi-k2.7-code",
Messages: []openai.ChatCompletionMessageParamUnion{
openai.UserMessage("Summarize this diff"),
},
ReasoningEffort: openai.ReasoningEffortMedium,
})
fmt.Println(resp.Choices[0].Message.Content)
}import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.*;
import com.openai.models.ReasoningEffort;
OpenAIClient client = OpenAIOkHttpClient.builder()
.baseUrl("https://synthorai.io/v1")
.apiKey("sk-syn-...")
.build();
ChatCompletion resp = client.chat().completions().create(
ChatCompletionCreateParams.builder()
.model("kimi-k2.7-code")
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));Sobre o Kimi K2.7 Code
- Ele mantém a arquitetura Mixture-of-Experts de 1T de parâmetros com 32B ativados por token (384 especialistas, oito por token mais um compartilhado) e um contexto de 256K, aceita entrada de imagem junto ao texto e roda sempre em modo thinking, com o conteúdo de raciocínio preservado entre conversas de múltiplos turnos.
- O modo non-thinking não é apenas desaconselhado, mas rejeitado: a documentação afirma que o modelo não o suporta e que desativar o raciocínio retorna um erro, com o thinking preservado forçado no lado do servidor.
- O raciocínio chega em reasoning_content antes da resposta, e o guia é explícito de que você precisa devolver esse campo junto à mensagem do assistente nos turnos de chamada de ferramentas, ou a requisição dá erro, que é o erro de integração mais comum com este modelo.
- Oficialmente, ele fortalece a conclusão de tarefas de ponta a ponta em fluxos complexos de engenharia de software usando cerca de 30% menos tokens de raciocínio que o K2.6, e suporta uso agêntico de ferramentas pelo ecossistema MCP, com raciocínio intercalado ao longo de chamadas de ferramentas em múltiplas etapas.
- A Moonshot aconselha deixar folga generosa em max_tokens porque o raciocínio a consome.
- Os pesos são abertos sob uma licença Modified MIT.
- Acesse o Kimi K2.7 Code na Synthorai pelo endpoint compatível com OpenAI.
Perguntas frequentes
A API do Kimi K2.7 Code é gratuita para testar?
Sim. Contas novas recebem 10 chamadas de teste e até $1 em créditos gratuitos, sem precisar de cartão. A $0.95/M de tokens de entrada, só esse crédito já cobre cerca de 131 requisições de ~8K tokens ao Kimi K2.7 Code.
Em que o Kimi K2.7 Code é melhor?
Cerca de 30% menos tokens de raciocínio; raciocínio preservado ao longo de conversas de múltiplos turnos; ajustado para engenharia de software do mundo real. Veja a seção Sobre para o quadro completo, extraído das notas de lançamento do próprio fornecedor.
Quanto custa o Kimi K2.7 Code?
Na Synthorai, o Kimi K2.7 Code custa $0.95 por milhão de tokens de entrada e $4 por milhão de tokens de saída. É o preço de tabela do provedor, sem margem da plataforma. Tokens de entrada em cache são cobrados a $0.19/M.
O Kimi K2.7 Code suporta cache de prompts?
Sim, automaticamente: prompts servidos pela Moonshot entram em cache sem nenhuma mudança no código. Tokens de entrada em cache são cobrados a $0.19/M, contra $0.95/M sem cache. Guia de cache de prompts →
Como obtenho acesso ao Kimi K2.7 Code?
Aponte seu SDK da OpenAI existente para base_url="https://synthorai.io/v1", defina model="kimi-k2.7-code" e pronto. Uma única chave de API cobre todos os modelos do gateway.
O Kimi K2.7 Code é open source?
Sim, os pesos são publicados sob a Modified-MIT License. Ou dispense as GPUs: a versão hospedada aqui é pagamento por uso, sem infraestrutura para operar. Como rodar modelos de pesos abertos →
Modelos relacionados
Comparar
Cada valor desta página é transcrito da documentação do fornecedor, ligada acima, e traz a data em que foi verificado. Os preços são comparados em todo o catálogo; os valores de especificação que os fornecedores definem de forma diferente são apresentados com a diferença indicada em vez de representados num gráfico. Nada aqui é medido por nós, e nada é pontuado.