Gemini 3.8 Flash vs Kimi K3
Cuál usar y cuándo
Ambos modelos comparten la misma ventana de contexto de 1048576 tokens, por lo que la decisión se reduce al precio, las modalidades y la longitud de salida: gemini-3.8-flash cuesta $0.75 de entrada y $3.75 de salida frente a $3 y $15 para kimi-k3, lo que hace que el modelo de Google sea 4x más barato en ambos aspectos, además de 4x más barato en lecturas de caché ($0.075 vs $0.3). Elige gemini-3.8-flash para trabajo de alto volumen sensible al costo o cuando necesites entrada de audio y video junto a texto e imágenes. Elige kimi-k3 cuando una sola respuesta deba ser larga, ya que su salida máxima de 1048576 tokens eclipsa el límite de 65536 de Flash; ten en cuenta que su razonamiento no se puede desactivar.
Benchmarks
5 medidos en ambos.
Publicado por los proveedores: Alibaba (Qwen) Anthropic ByteDance DeepSeek Google MiniMax Moonshot OpenAI Tencent Z.ai
Precios
| Gemini 3.8 Flash | Kimi K3 | Δ | |
|---|---|---|---|
| Entrada / 1M tokens | $0.75 | $3 | 0.25× |
| Salida / 1M tokens | $3.75 | $15 | 0.25× |
| Lectura de caché / 1M tokens | $0.075 | $0.3 | 0.25× |
Tarifas tomadas del catálogo en vivo al generar el sitio; la página de cada modelo tiene la ficha de precios actualizada.
Dónde queda cada uno: precio de entrada por 1M de tokens entre los 80 modelos de chat que se facturan en esta unidad (escala logarítmica)
Capacidades
| Gemini 3.8 Flash | Kimi K3 | |
|---|---|---|
| Uso de herramientas | sí | sí |
| Control del razonamiento | sí el proveedor no publica cómo ajustarlo | siempre activo |
| Salida estructurada | sí | sí |
| Caché de prompts | implícito + explícito | implícito (automático) |
| Duración de la caché | no publicado | no publicado |
| Prefijo mínimo en caché | 4,096 tokens | no publicado |
Especificaciones
| Gemini 3.8 Flash | Kimi K3 | |
|---|---|---|
| Modalidades de entrada | texto imagen audio vídeo | texto imagen vídeo |
| Modalidades de salida | texto | texto |
| Lanzamiento | 2026-09-02 | 2026-07-16 |
| Corte de conocimiento | 2026-03 | - |
| Ventana de contexto | 1M | 1M |
| Salida máxima | 66K | 1M |
| Parámetro de razonamiento | - | reasoning_effort (top-level; the thinking object is not accepted) |
| Valores aceptados | - | reasoning_effort
|
| Valor por defecto | - | max |
Las especificaciones se transcriben de la documentación de cada proveedor; si un proveedor no publica un dato, la fila se omite en vez de deducirlo. Fuentes completas: Gemini 3.8 Flash · Kimi K3
Un mismo prompt en los dos modelos, medido a través de la pasarela
Gemini 3.8 Flash superado · 3 sentences
When we enabled reasoning, the model began generating hidden "thinking tokens" to work through logic step-by-step before producing a final answer. Because AI vendors bill for every single token processed—visible or not—this internal deliberation dramatically inflated our billable volume per query. In short, while our total number of user requests remained flat, the cost per transaction doubled to buy higher accuracy on complex tasks.
salida 705 tok (+624 razonamiento) latencia 6.4 s
Kimi K3 superado · 3 sentences
Reasoning models don't just answer questions—they "think" first, generating long internal chains of step-by-step logic before producing a response. Those hidden thinking steps are billed as output tokens (the most expensive kind, typically 3–5x the price of input tokens), and a single query can generate thousands of them even when the visible answer is only a paragraph long. So you're paying for dramatically more compute per request: the bill doubled because the model does far more work behind the scenes, not because usage increased.
salida 755 tok (+637 razonamiento) latencia 20.8 s
Cumplimiento de la instrucción (exactamente tres frases, se pueden contar), adaptación al público (registro de CFO) y la diferencia de facturación por razonamiento oculto que dejan ver los contadores de tokens de abajo.
Gemini 3.8 Flash superado · 8/8 cases
Here is the corrected function: ```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 ``` ### Explanation of the Bug The original function counted equal-neighbor transitions rather than the actual items making up each run. Because `cur` started at `0` (and was reset to `0` on mismatches), every run was undercounted by one: single-element lists returned `0` because the loop never executed, and any subsequent run—including those ending at the last index—recorded a count of $N - 1$ instead of $N$. The fix handles empty input upfront, initializes both `cur` and `best` to `1` (since any single element forms a run of length 1), and resets `cur` to `1` whenever a new run begins.
salida 1393 tok (+1149 razonamiento) latencia 10.1 s
Kimi K3 superado · 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 a fencepost error: `cur` counts *matching adjacent pairs* rather than *items in the run*, because it starts at 0 and only increments when `xs[i] == xs[i - 1]`. A run of length L contains L−1 equal pairs, so every run was undercounted by exactly one. For a single-element list (a run of length 1) the loop never runs and the function returns 0 instead of 1; likewise any run ending at the last index — e.g. the two `2`s in `[1, 2, 2]` — reported 1 instead of 2, making it look like no run existed at all. […]
salida 1837 tok (+1547 razonamiento) latencia 47.2 s
Si la corrección funciona de verdad (se puede ejecutar), lo densa que es la explicación y la eficiencia en tokens en una tarea acotada.
Gemini 3.8 Flash superado · 5/5 fields, guidance null
```json { "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": 412, "growth_pct": null, "guidance": null } ```
salida 3989 tok (+3932 razonamiento) latencia 30.4 s
Kimi K3 superado · 5/5 fields, guidance null
{ "company": "Meridian Robotics", "quarter": "September quarter", "revenue_usd_m": 412, "growth_pct": 11, "guidance": null }
salida 924 tok (+863 razonamiento) latencia 25.9 s
Respeto del esquema (sin campos inventados), tentación de alucinar (la guidance se omite a propósito) y diferencias entre las vías de salida estructurada.
Gemini 3.8 Flash superado · 120 words, 0 banned, 1 question
Why pay multiple model providers for the exact same output? Introducing Universal Prompt Cache, our latest API gateway capability engineered to cut compute expenses and drop inference latency. When your application makes a call, the gateway inspects a central memory layer before routing traffic to external LLMs. If an identical query was previously processed by OpenAI, Anthropic, or Mistral, our gateway returns that response immediately. This shared cache eliminates duplicate token fees and insulates your production apps from vendor rate limits or unexpected downtime. Developers can easily customize expiration settings, enforce strict data privacy controls, and configure invalidation logic across every endpoint. Stop wasting your budget on repeated queries. Enable prompt caching in your dashboard to accelerate your pipeline today.
salida 3833 tok (+3688 razonamiento) latencia 21.8 s
Kimi K3 superado · 120 words, 0 banned, 1 question
Meet Prompt Cache, a new API gateway capability that stores prompt responses and serves them across OpenAI, Anthropic, Google, and Azure endpoints. It matches requests by model, prompt hash, tools, temperature, and tenant policy, so repeated work returns fast while sensitive contexts stay isolated. Teams set TTLs, stale rules, encryption scopes, and bypass flags per route. Analytics show hit rate, latency saved, token spend avoided, and drift risk by provider. What changes for developers? Keep one integration, add cache headers, and watch fallback logic respect consent, residency, and audit needs. During rollout, canary keys compare fresh answers with cached copies before promotion. Prompt Cache cuts vendor calls, steadies p95 latency, and gives platform owners controls for cost, quality, and compliance.
salida 1527 tok (+1354 razonamiento) latencia 37.9 s
Respeto de las restricciones (límite de palabras, lista de palabras prohibidas, una única pregunta), sello de estilo y control de la longitud.
Cambia de uno a otro con una sola línea
Los dos ids aparecen en todas las pestañas de abajo; lo único que cambia es el par de líneas resaltadas. El endpoint, la clave y la estructura de la solicitud son los mismos.
from openai import OpenAI
client = OpenAI(
base_url="https://synthorai.io/v1",
api_key="sk-syn-...",
)
resp = client.chat.completions.create(
model="gemini-3.8-flash",
# model="kimi-k3", # descomenta esta línea, comenta la de arriba
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: "gemini-3.8-flash",
// model: "kimi-k3", // descomenta esta línea, comenta la de arriba
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": "gemini-3.8-flash",
# "model": "kimi-k3", # descomenta esta línea, comenta la de arriba
"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: "gemini-3.8-flash",
// Model: "kimi-k3", // descomenta esta línea, comenta la de arriba
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("gemini-3.8-flash")
// .model("kimi-k3") // descomenta esta línea, comenta la de arriba
.addUserMessage("Summarize this diff")
.reasoningEffort(ReasoningEffort.MEDIUM)
.build());
System.out.println(resp.choices().get(0).message().content().orElse(""));Preguntas frecuentes
¿Cuál es más barato, Gemini 3.8 Flash o Kimi K3?
Gemini 3.8 Flash es más barato en Entrada / 1M tokens ($0.75 frente a $3, una diferencia de 4.0×). En otras filas puede ser al revés: la tabla de arriba recoge todas las tarifas, y el coste real depende de tu combinación de uso.
¿Puedo hacer pruebas A/B de Gemini 3.8 Flash frente a Kimi K3 sin dos integraciones?
Sí. Los dos se sirven desde el mismo endpoint compatible con OpenAI y con una sola clave API. Para cambiar de uno a otro basta con tocar una línea, el nombre del modelo, así que puedes mandar una parte del tráfico a cada uno y comparar directamente las facturas.
¿Admiten Gemini 3.8 Flash y Kimi K3 caché de prompts?
Sí. Los dos cobran las lecturas de caché por debajo de su tarifa de entrada, así que las cargas de trabajo que reutilizan un prefijo ya cacheado cuestan menos de lo que sugieren los precios de lista. Las tarifas exactas de lectura de caché están en la tabla de precios de arriba.