Cómo construir tu primer bucle de agente de IA con Kimi K3 (configuración exacta incluida)

Un bucle de agente es la diferencia entre pedirle ayuda a la IA y despertarte con el trabajo terminado. La mayoría nunca construye uno porque cien iteraciones en un modelo de frontera cuestan dinero real.

Dentro: el patrón del bucle explicado en un diagrama, dos configuraciones exactas (Claude Code y API cruda) y las matemáticas de caché que convierten a K3 en la máquina de bucles.

Tu primer bucle corre esta noche por unos $0.39 por turno.

Aquí está la configuración completa 👇

Antes de sumergirnos, comparto notas diarias sobre IA y vibe coding en mi canal de Telegram: https://t.me/zodchixquant 🧠

Qué es realmente un bucle

Quítale el hype y un bucle son cuatro pasos que se repiten:

1OBJETIVO → INTENTO → VERIFICAR → (¿mejor? mantener : reintentar)
2        ↑__________________________|

• Objetivo: una línea de meta medible, no una vibra. "Todas las pruebas pasan", "la página carga en menos de 1s", "puntuación superior a 90"
• Intento: el modelo hace una unidad de trabajo hacia ese objetivo
• Verificar: algo comprueba el resultado contra el objetivo. Un conjunto de pruebas, un linter, un segundo modelo
• Repetir: retroalimenta el resultado de la verificación, vuelve a intentar, detente cuando se cumpla el objetivo o se acabe el presupuesto

Eso es todo. Todo lo demás (memoria, subagentes, ejecuciones nocturnas) es decoración sobre este ciclo.

Por qué K3 específicamente: la economía del bucle

Los bucles releen el mismo contexto en cada turno: la base de código, el objetivo, el historial. En la mayoría de los modelos pagas el precio completo por esa repetición. En K3 no:

1Costo por turno = fresh_tokens × $3/M + cached_tokens × $0.30/M
2
3Forma real (800K contexto estable + 50K fresco por turno):
4K3:       $0.24 + $0.15 = $0.39/turno
5Fable 5:  850K × $10/M  = $8.50/turno

Un bucle nocturno de 50 turnos: unos $20 en K3, unos $425 en Fable 5. Eso no es un descuento, es la diferencia entre "déjalo correr" y "vigílalo como un halcón".

La única regla: mantén tu contexto estable como un prefijo idéntico cada turno, la tarea al final, para que el caché realmente acierte.

Configuración A: Claude Code (el camino de 5 minutos)

Si vives en Claude Code, los bucles están integrados y K3 se coloca debajo a través de la configuración oficial de Moonshot:

1export ANTHROPIC_BASE_URL=https://api.moonshot.ai/anthropic
2export ANTHROPIC_AUTH_TOKEN=${YOUR_MOONSHOT_API_KEY}
3export ANTHROPIC_MODEL=kimi-k3
4export ANTHROPIC_DEFAULT_OPUS_MODEL=kimi-k3
5export ANTHROPIC_DEFAULT_SONNET_MODEL=kimi-k3
6export ANTHROPIC_DEFAULT_HAIKU_MODEL=kimi-k3
7export CLAUDE_CODE_SUBAGENT_MODEL=kimi-k3
8export ENABLE_TOOL_SEARCH=false
9export CLAUDE_CODE_AUTO_COMPACT_WINDOW=1048576
10claude

Luego el bucle son dos comandos:

• /goal establece la línea de meta: "todas las pruebas en tests/ pasan y la cobertura se mantiene por encima del 80%". Claude Code sigue trabajando hacia ello en lugar de detenerse en la primera respuesta
• /loop lo hace recurrente: la sesión se re-ejecuta en un horario o hasta que el objetivo se cumple

Confirma que estás en K3 con /status (el menú /model no lo mostrará). La ventana de auto-compactación de 1M en la configuración significa que los bucles largos se compactan raramente, lo que mantiene vivo el historial de iteraciones.

Configuración B: el bucle de API cruda (control total)

Para bucles fuera de Claude Code, aquí tienes un bucle mínimo completo, compatible con OpenAI:

1from openai import OpenAI
2
3client = OpenAI(
4    api_key=MOONSHOT_API_KEY,
5    base_url="https://api.moonshot.ai/v1",
6)
7
8# Prefijo estable: idéntico cada turno = aciertos de caché a $0.30/M
9STABLE = f"""Eres un agente de codificación en un bucle.
10OBJETIVO: haz que todas las pruebas pasen en el proyecto siguiente.
11PROYECTO:
12{project_dump}
13REGLAS:
14- Un cambio enfocado por turno
15- Explica qué cambiaste y por qué en 2 líneas
16- Si las pruebas pasan, responde exactamente: GOAL_REACHED
17"""
18
19history = []
20MAX_TURNS = 30
21
22for turn in range(MAX_TURNS):
23    result = run_tests()          # tu verificación: pytest, npm test, etc.
24    if result.passed:
25        print(f"Hecho en {turn} turnos")
26        break
27
28    response = client.chat.completions.create(
29        model="kimi-k3",
30        messages=[
31            {"role": "system", "content": STABLE},
32            *history[-6:],        # últimos 3 intercambios, limitados
33            {"role": "user", "content":
34                f"Turno {turn}. Salida de pruebas:\n{result.output}\n"
35                f"Arregla el siguiente fallo."},
36        ],
37    )
38    change = response.choices[0].message.content
39    apply_change(change)          # escribe la edición, haz commit en una rama
40    history += [
41        {"role": "user", "content": f"Salida de pruebas del turno {turn} proporcionada"},
42        {"role": "assistant", "content": change},
43    ]

Tres detalles importantes:

• La verificación es código, no vibraciones. run_tests() decide el progreso, el modelo nunca se califica a sí mismo
• El historial está limitado. Solo los últimos 3 intercambios; el prefijo estable lleva el contexto duradero y se mantiene amigable con el caché
• Cada cambio va a una rama. El bucle puede equivocarse 10 veces mientras main nunca lo vea

Protecciones antes de irte

• Límite de presupuesto: cuenta los tokens por turno, mata el bucle al alcanzar un tope de dólares. MAX_TURNS no es suficiente, un turno inflado puede consumir más que diez normales
• Límite de progreso: si la misma prueba falla 3 turnos seguidos, detente y marca. Los bucles que no convergen queman dinero educadamente
• Un detalle de K3: el razonamiento se ejecuta solo al máximo por ahora, así que cada turno lleva la salida completa de pensamiento a $15/M. Mantén los turnos enfocados, un fallo por turno, y el lado de salida se mantiene sensato

Errores comunes

• Objetivos vagos. "Mejora el código" se repite para siempre. Un bucle es tan bueno como su línea de meta sea verificable
• Dejar que el modelo se autoevalúe. "Se ve correcto para mí" es cómo los bucles envían basura. El verificador debe ser externo: pruebas, linter o un segundo modelo con una rúbrica
• Romper el caché. Marcas de tiempo, IDs aleatorios o archivos reordenados en tu prefijo significan que cada turno se cobra a $3/M en lugar de $0.30. Idéntico significa idéntico
• Sin disciplina de ramas. Un bucle sin supervisión con acceso de escritura a main es una historia de terror con pasos adicionales
• Empezar con ejecuciones nocturnas. Ejecuta tus primeros bucles mientras observas, 10-15 turnos. Gánate la confianza antes de dormir sobre ello

La configuración de 15 minutos

1. Consigue una clave API de Moonshot, recarga dentro de la ventana de bonificación del 10-30%, vigente hasta el 11 de agosto (3 min)
2. Elige la Configuración A o B y conéctala (5 min)
3. Escribe un objetivo verificable para una tarea pequeña real: una prueba fallida, una pasada de lint (2 min)
4. Ejecuta 10 turnos supervisados, observa cómo la verificación impulsa el trabajo (4 min)
5. Anota el costo. Luego decide qué tan grande será el siguiente bucle (1 min)

El bucle es la idea más antigua de la programación aplicada a la herramienta más nueva. K3 simplemente lo hizo lo suficientemente barato como para usarlo realmente.

¡Gracias por leer!

Comparto notas diarias sobre IA y vibe coding en mi canal de Telegram: https://t.me/zodchixquant 🧠