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 fornitori: Alibaba (Qwen) Moonshot OpenAI Z.ai
Il prezzo nel contesto
Posizione del prezzo tra 60 modelli comparabili
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 fornitore) | 256.000 |
|---|---|
| Output massimo (specifica del vendor) | 32.768 |
Caching prompt
| Modalità | automatico |
|---|
Ragionamento
| Parametro del fornitore | thinking.type + thinking.keep |
|---|---|
| Valori accettati | type accepts only enabled; keep accepts only all |
| Valore predefinito | 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 la superficie parametri del gateway - vale la mappatura del fornitore 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 dell'istruzione (esattamente tre frasi - contabili), adattamento al pubblico (registro da CFO), e il divario di fatturazione del pensiero nascosto che i contatori di token qui sotto rivelano.
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 (eseguibile), la densità della spiegazione, e l'efficienza in token su un compito delimitato.
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), pressione di allucinazione (guidance è esplicitamente sospesa), e differenze nel percorso 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 OpenAI: cambia la base_url, 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 carta richiesta. A $0.95/M token in input, quel credito da solo copre circa 131 richieste da ~8K token verso 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», tratto dalle note di rilascio ufficiali del vendor.
Quanto costa Kimi K2.7 Code?
Su Synthorai, Kimi K2.7 Code costa $0.95 per milione di token in input e $4 per milione di token in output: il prezzo di listino del provider, senza ricarico della piattaforma. I token di input in cache si fatturano a $0.19/M.
Kimi K2.7 Code supporta il caching dei prompt?
Sì, in automatico: i prompt serviti da Moonshot vanno in cache senza modifiche al codice. I token di input in cache si fatturano a $0.19/M contro $0.95/M senza cache. Guida al caching dei prompt →
Come ottengo l'accesso a Kimi K2.7 Code?
Punta il tuo SDK OpenAI esistente a base_url="https://synthorai.io/v1", imposta model="kimi-k2.7-code" e hai finito: una sola chiave API copre tutti i modelli del gateway.
Kimi K2.7 Code è open source?
Sì: i pesi sono pubblicati sotto Modified-MIT License. Oppure salta le GPU: la versione hosted qui è con pagamento a consumo, senza infrastruttura da gestire. Eseguire modelli open-weight →
Modelli correlati
Confronta
Ogni valore di questa pagina è trascritto dalla documentazione del fornitore, collegata sopra, e riporta la data in cui è stato verificato. I prezzi sono confrontati sull'intero catalogo; i valori di specifica che i fornitori definiscono in modo diverso sono mostrati indicando la differenza anziché messi a grafico. Nulla qui è misurato da noi e nulla è valutato con un punteggio.