Kimi K2.7 Code è il modello agentico focalizzato sul coding di Moonshot AI costruito su Kimi K2.6, messo a punto per l'ingegneria del software del mondo reale e descritto da Moonshot come il suo modello dedicato al coding, capace di seguire le istruzioni in modo più affidabile nei contesti lunghi e di completare i compiti di coding con tassi di successo più alti.
- Input
- testo immagine video $0.95/M
- Output
- testo $4/M
- Lettura cache
- $0.19/M
- Contesto
- 256K
- vs GPT-4o
- ~81% più economico
Benchmark
Dati pubblicati dai provider: Alibaba (Qwen) Moonshot OpenAI Z.ai
Il prezzo a confronto
Dove si colloca il prezzo tra 68 modelli confrontabili
La barra mostra dove si colloca il prezzo di questo modello tra tutti i modelli dello stesso tipo su Synthorai. Alle due estremità sono indicati il più economico e il più caro. Sono tariffe base; gli sconti per batch, regione e scrittura in cache sono nella pagina dei prezzi.
Specifiche e limiti
Token
| Finestra di contesto (specifica del provider) | 256.000 |
|---|---|
| Output massimo (specifica del provider) | 32.768 |
Prompt caching
| Modalità | automatico |
|---|
Ragionamento
| Parametro del provider | thinking.type + thinking.keep |
|---|---|
| Valori accettati | type accepts only enabled; keep accepts only all |
| Valore di default | thinking attivo con Preserved Thinking attivo applicato se la richiesta non specifica nulla |
| Disattivabile | No |
| Comportamento del ragionamento | Passare type disabled restituisce un errore; poiché il Preserved Thinking è forzato lato server, il reasoning_content di ogni messaggio storico dell'assistente deve essere restituito così com'è. |
| Parametro | reasoning_effort |
| Valori | minimal · low · medium · high parametri esposti dal gateway: vale la mappatura del provider indicata sopra |
Modello
| Modalità | testo + immagine + video → testo |
|---|---|
| Parametri | 1T totali · 32B attivi MoE |
| Licenza | Modified-MIT |
- Modello agentico focalizzato sul coding costruito su K2.6: MoE da 1T con 32B attivi, contesto da 256K
- thinking sempre attivo con ragionamento conservato tra i turni
- ~30% di token di thinking in meno rispetto a K2.6
Un solo prompt, misurato attraverso il gateway
Kimi K2.7 Code superato · 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.
out 259 tok (+174 ragionamento) latenza 5.4 s
Rispetto delle istruzioni (esattamente tre frasi: si contano), adattamento al destinatario (registro da CFO) e lo scarto di fatturazione dovuto al ragionamento nascosto, che i contatori di token qui sotto mettono in luce.
Kimi K2.7 Code superato · 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.
out 410 tok (+222 ragionamento) latenza 9.4 s
Se la correzione è davvero giusta (si può eseguire), quanto è densa la spiegazione e quanti token servono per un compito circoscritto.
Kimi K2.7 Code superato · 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" } ```
out 721 tok (+663 ragionamento) latenza 13.2 s
Aderenza allo schema (nessun campo inventato), tentazione di allucinare (il testo dice espressamente che la guidance non viene comunicata) e differenze tra i percorsi di output strutturato.
Kimi K2.7 Code superato · 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.
out 2375 tok (+2235 ragionamento) latenza 38.6 s
Rispetto dei vincoli (budget di parole, elenco di parole vietate, l'unica domanda), impronta stilistica e controllo della lunghezza.
Usa Kimi K2.7 Code in 30 secondi
Compatibile con OpenAI: cambi base_url e tieni il tuo 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(""));Informazioni su Kimi K2.7 Code
- Mantiene l'architettura Mixture-of-Experts da 1T di parametri con 32B attivati per token (384 esperti, otto per token più uno condiviso) e un contesto da 256K, accetta input di immagini accanto al testo e gira sempre in modalità thinking, con il contenuto di ragionamento preservato nelle conversazioni multi-turno.
- La modalità non-thinking non è semplicemente sconsigliata ma rifiutata: la documentazione afferma che il modello non la supporta e che disattivare il thinking restituisce un errore, con il thinking preservato forzato lato server.
- Il ragionamento arriva in reasoning_content prima della risposta, e la guida è esplicita sul fatto che quel campo va restituito insieme al messaggio assistant nei turni di tool calling, altrimenti la richiesta va in errore: è l'errore di integrazione più comune con questo modello.
- Ufficialmente rafforza il completamento end-to-end dei compiti attraverso flussi di lavoro complessi di ingegneria del software usando circa il 30% di token di thinking in meno rispetto a K2.6, e supporta l'uso agentico degli strumenti tramite l'ecosistema MCP con thinking interleaved lungo chiamate agli strumenti multi-step.
- Moonshot consiglia di lasciare un margine generoso su max_tokens perché il ragionamento lo consuma.
- I pesi sono aperti sotto una licenza Modified MIT.
- Su Synthorai si accede a Kimi K2.7 Code tramite l'endpoint compatibile OpenAI.
FAQ
L'API di Kimi K2.7 Code si può provare gratis?
Sì: i nuovi account ricevono 10 chiamate di prova e fino a $1 di credito gratuito, senza bisogno di carta. A $0.95/M per i token di input, quel credito basta da solo per circa 131 richieste da ~8K token a Kimi K2.7 Code.
In cosa eccelle Kimi K2.7 Code?
Circa il 30% in meno di token di thinking; ragionamento preservato attraverso le conversazioni multi-turno; tarato per l'ingegneria del software del mondo reale. Il quadro completo è nella sezione «Informazioni», ripreso dalle note di rilascio ufficiali del provider.
Quanto costa Kimi K2.7 Code?
Su Synthorai Kimi K2.7 Code costa $0.95 per milione di token di input e $4 per milione di token di output: è il prezzo di listino del provider, senza sovrapprezzo di piattaforma. I token di input letti dalla cache costano $0.19/M.
Qual è la finestra di contesto di Kimi K2.7 Code?
Kimi K2.7 Code ha una finestra di contesto di 256K token su Synthorai. Una singola risposta può arrivare a 32,768 token.
Kimi K2.7 Code supporta il prompt caching?
Sì, in automatico: i prompt serviti da Moonshot vanno in cache senza modifiche al codice. I token di input letti dalla cache costano $0.19/M, contro $0.95/M senza cache. Guida al prompt caching →
Come ottengo l'accesso a Kimi K2.7 Code?
Fai puntare l'SDK OpenAI che usi già a base_url="https://synthorai.io/v1", imposta model="kimi-k2.7-code" e hai finito: una sola chiave API vale per tutti i modelli del gateway.
Kimi K2.7 Code è open source?
Sì: i pesi sono pubblicati sotto licenza Modified-MIT. Oppure lascia perdere le GPU: qui la versione hosted si paga a consumo, senza infrastruttura da gestire. Eseguire modelli open-weight →
Modelli correlati
Confronta
Ogni valore di questa pagina è ripreso dalla documentazione del provider (il link è qui sopra) e riporta la data dell'ultima verifica. I prezzi sono confrontati sull'intero catalogo; per le specifiche che ogni provider definisce a modo suo indichiamo la differenza invece di metterle in un grafico. Qui non c'è nulla di misurato da noi e non assegniamo punteggi.