Kimi acaba de lanzar K2.6, disponible en código abierto en HuggingFace y evaluado frente a GPT-5.4, Claude Opus 4.6 y Gemini 3.1 Pro. Supera a los tres en Humanity's Last Exam, DeepSearchQA y SWE-Bench Pro, con una capacidad de programación casi un 20 % mayor que K2.5, una reducción del 35 % en los pasos promedio de tareas y un precio que es 1/8 del de Claude Opus 4.6 para cargas de trabajo de agentes.

Si ejecutas agentes de IA y quieres integrar K2.6 en tu cadena de herramientas actual, esta guía cubre los cuatro marcos principales —Claude Code, OpenCode, OpenClaw y Hermes Agent— utilizando un endpoint de API compartido a través de atlascloud.ai. La segunda parte muestra qué hace realmente K2.6 una vez que está en funcionamiento.

Referencia rápida

Todos los tutoriales de este artículo se realizaron en Windows usando WSL2.

Parte 1 — Configuración

1. Claude Code (La más sencilla)

Descarga la documentación oficial de Claude Code: https://github.com/anthropics/claude-code

Claude Code utiliza de forma nativa el formato de Anthropic. Define tres variables de entorno y listo:

plaintextCopy
1# Añadir a ~/.bashrc o ~/.zshrc
2export ANTHROPIC_BASE_URL="https://api.atlascloud.ai"
3export ANTHROPIC_AUTH_TOKEN="apikey-xxx"
4export ANTHROPIC_MODEL="moonshot/kimi-k2.6"
5export ANTHROPIC_SMALL_FAST_MODEL="moonshot/kimi-k2.6"

Tras ejecutar

1source ~/.bashrc

1/model

2. OpenCode (Archivo de configuración)

Descarga la documentación oficial de OpenCode: https://github.com/anomalyco/opencode

OpenCode tiene un proveedor de openai integrado, pero elimina silenciosamente el prefijo openai/ de los IDs de los modelos, lo que rompe el enrutamiento en endpoints de terceros. Debes declarar un proveedor personalizado usando @ai-sdk/openai-compatible en su lugar.

1~/.config/opencode/config.json

json

plaintextCopy
1{
2  "$schema": "https://opencode.ai/config.json",
3  "provider": {
4    "atlascloud": {
5      "npm": "@ai-sdk/openai-compatible",
6      "name": "AtlasCloud",
7      "options": {
8        "baseURL": "https://api.atlascloud.ai/v1",
9        "apiKey": "apikey-xxx"
10      },
11      "models": {
12        "moonshot/kimi-k2.6": { "name": "Kimi K2.6" }
13      }
14    }
15  },
16  "model": "atlascloud/moonshot/kimi-k2.6"
17}

El campo model sigue el formato nombreProveedor/claveModelo. Para cambiar de modelo, edita la última línea.

3. OpenClaw (Archivo de configuración + dos terminales)

OpenClaw se ejecuta como dos procesos separados: un gateway y una TUI. Ambos deben estar activos antes de usarla.

~/.openclaw/openclaw.json:

json

plaintextCopy
1{
2  "agents": {
3    "defaults": {
4      "model": {
5        "primary": "custom-api-atlascloud-ai/moonshot/kimi-k2.6"
6      }
7    }
8  },
9  "models": {
10    "providers": {
11      "custom-api-atlascloud-ai": {
12        "baseUrl": "https://api.atlascloud.ai/v1",
13        "api": "openai-completions",
14        "apiKey": "apikey-xxx",
15        "models": [
16          {
17            "id": "moonshot/kimi-k2.6",
18            "name": "Kimi K2.6",
19            "api": "openai-completions"
20          }
21        ]
22      }
23    }
24  }
25}

Orden de inicio:

bash

plaintextCopy
1# Terminal 1
2openclaw gateway
3
4# Terminal 2
5openclaw tui

Para reconfiguración interactiva:

1openclaw configure

Para cambiar de modelo, edita el campo

1primary

4. Hermes Agent (Configuración interactiva)

Hermes utiliza un asistente en lugar de un archivo de configuración:

bash

plaintextCopy
1hermes setup

Rellena las indicaciones:

• Provider: custom
• Endpoint: https://api.atlascloud.ai/v1
• API Key: apikey-xxx
• Model: moonshot/kimi-k2.6

Importante: El ID del modelo debe incluir el prefijo moonshot/. Introducir solo kimi-k2.6 devolverá un error 404.

Para cambiar de modelo más tarde, vuelve a ejecutar hermes setup.

Parte 2 — ¿Qué hace realmente K2.6?

Claude Code × K2.6 — ¿Qué ocurre cuando ejecutas 23 agentes a la vez?

¿Qué es lo primero que falla cuando llevas un sistema de IA al límite?

Un desarrollador decidió ponerlo a prueba ejecutando 23 agentes simultáneamente a través de Claude Code durante todo un día. A lo largo de 26 sesiones, el sistema gestionó llamadas a herramientas de alta frecuencia, tuberías de pasos múltiples y tareas de cadena larga, como la redacción de PRDs y planificación SEO. Es decir, una carga de trabajo realista "tipo producción" donde las cosas suelen fallar.

Pero esta vez, ocurrió algo inusual.

Hubo cero errores de límite de tasa 429.

Para cualquiera que haya intentado escalar flujos de trabajo de agentes, esto es lo más destacable. Bajo condiciones similares, modelos como GLM 5.1 suelen alcanzar límites de tasa con frecuencia, forzando reintentos, rompiendo tuberías e introduciendo inestabilidad. K2.6, en cambio, se mantuvo estable; no por ser el más rápido, sino por ser consistentemente fiable bajo presión.

Y esa distinción importa más de lo que parece.

Porque una vez que vas más allá de los prompts individuales hacia sistemas multi-agente, el desafío real ya no es "¿puede el modelo responder bien?", sino:

¿Puede seguir respondiendo bien —en docenas de tareas paralelas— sin romper el sistema?

Calidad que se siente como planificación, no solo generación

La diferencia no solo fue la estabilidad. También se notó en cómo K2.6 gestionaba tareas complejas.

Al pedirle que redactara un PRD, el modelo no solo respondió: estructuró el espacio del problema por sí mismo. Análisis competitivo, historias de usuario, priorización de funciones... no se solicitaron explícitamente, pero aparecieron como si el sistema entendiera cómo debería verse un PRD "completo".

En tareas de SEO, el comportamiento fue similar. En lugar de saltar directamente a sugerencias de palabras clave, K2.6 infirió primero la intención de búsqueda y luego alineó la dirección del contenido en consecuencia. La salida se sintió menos como una generación bruta y más como una planificación estratégica inicial.

Es un cambio sutil, pero importante:

Ya no solo obtienes respuestas, obtienes pensamiento organizado.

Y en entornos multi-agente, eso se multiplica. Cuando cada agente produce resultados estructurados y de alta calidad, la capa de coordinación tiene mucho menos trabajo de limpieza que hacer.

El compromiso: La estabilidad tiene un coste

Dicho esto, este rendimiento no es gratuito.

K2.6 es notablemente más lento que GLM 5.1, especialmente en términos de latencia del primer token. El retraso no es marginal: es aproximadamente un orden de magnitud mayor. En una interacción única, esto podría ser tolerable. Pero en un sistema donde 23 agentes corren en paralelo, cada paso introduce una pequeña pausa, y esas pausas se acumulan.

Parte de esto proviene de su arquitectura. K2.6 utiliza un diseño de Mezcla de Expertos (MoE), con cerca de 1 billón de parámetros totales y 32 mil millones activados por inferencia. Esa escala aporta capacidad, pero también sobrecarga de programación. Y dado que sigue siendo una versión preliminar, es probable que la optimización de la inferencia aún no se haya llevado al límite.

Por lo tanto, el compromiso es claro:

• Si te importa el rendimiento y la velocidad, esto importa.
• Si te importa la estabilidad y las salidas estructuradas a escala, puede merecer la pena.

OpenCode × K2.6 — De un prompt a nueve flujos de trabajo paralelos

Si el experimento de Claude Code muestra cómo se comporta K2.6 bajo presión, OpenCode revela otra cosa: cómo organiza el trabajo.

K2.6 introduce una capa de coordinación llamada AgentSwarm, donde un único agente "Coordinador" puede generar docenas de subagentes especializados, cada uno con un rol específico. En lugar de gestionar una tarea paso a paso en un solo hilo, el sistema la descompone y ejecuta múltiples procesos en paralelo.

Para ver cómo es eso en la práctica, considera este ejemplo.

Un investigador pidió a K2.6 que elaborara un perfil profundo de Dario Amodei, trazando su camino desde su doctorado en física en Princeton hasta la fundación de Anthropic. En lugar de abordar esto como una única tarea de generación de formato largo, K2.6 lo descompuso en nueve pistas paralelas.

Cada pista tenía una responsabilidad distinta. Un agente se centró puramente en la investigación, recopilando información pública. Otro se encargó del diseño, formateando el material en un PDF estructurado. Un agente separado construyó un conjunto de datos de puntos clave en la toma de decisiones profesionales. Mientras tanto, un agente de escritura produjo una narrativa en primera persona titulada "Dear 2008".

Todo esto ocurrió al mismo tiempo.

El resultado no fue solo una salida única, sino un paquete coordinado: una presentación de 80 diapositivas, respaldada por datos estructurados y documentos formateados. Lo que normalmente requeriría múltiples herramientas, sesiones y ensamblaje manual se produjo como un entregable unificado.

Por qué esto cambia cómo usas la IA

El facilitador clave aquí es el sistema de Habilidades (Skill system).

En lugar de tratar cada tarea como un prompt nuevo, K2.6 te permite cargar conocimiento estructurado —como un informe de Goldman Sachs, un análisis de la competencia o una especificación de producto bien redactada— y convertirlo en una "Habilidad" reutilizable. Cuando un subagente se ejecuta, hereda ese marco: el estilo analítico, el tono, incluso la estructura.

Con el tiempo, esto convierte tu sistema en algo muy diferente a un flujo de trabajo basado en prompts.

Se convierte en una tubería de producción repetible.

Y eso lleva a un cambio en cómo piensas sobre el uso de la IA:

Ya no estás indicando a un modelo, estás gestionando un equipo.

Si estás creando flujos de trabajo basados en agentes, esa diferencia es difícil de ignorar.

Las cuatro herramientas se conectan a través de https://api.atlascloud.ai/v1. ID del modelo: moonshot/kimi-k2.6.

Preguntas frecuentes

1. ¿Cuál es la diferencia entre usar Hermes Agent y llamar directamente a la API de Kimi K2.6?

La diferencia fundamental radica en la ejecución frente a la respuesta.

Cuando llamas directamente a la API de Kimi K2.6, esencialmente obtienes una sola respuesta por solicitud. Incluso para tareas complejas, todavía necesitas desglosarlas manualmente, iterar sobre múltiples prompts y combinar las salidas tú mismo. Esto funciona bien para casos de uso simples o interactivos, pero se vuelve ineficiente rápidamente para flujos de trabajo estructurados.

Hermes cambia esto mediante la orquestación de flujos de trabajo. En lugar de un solo prompt, defines una tubería con múltiples pasos —investigación, planificación, ejecución, etc.— y Hermes asigna cada paso a un agente. Estos agentes pueden pasarse resultados entre sí, validar resultados intermedios e incluso reintentar pasos cuando algo sale mal.

En la práctica, esto significa que pasas de la "ingeniería de prompts" a la orquestación de tareas. La API se convierte en un componente dentro de un sistema, en lugar de ser el sistema en sí mismo.

1. ¿Es Kimi K2.6 bueno para flujos de trabajo multi-agente y automatización?

Sí, aquí es donde tiene un desempeño notablemente bueno.

En configuraciones multi-agente, los mayores desafíos suelen ser:

• coherencia entre pasos
• estabilidad durante ejecuciones largas
• capacidad para seguir tareas estructuradas

Kimi K2.6 muestra un fuerte desempeño en las tres áreas. Cuando se usa dentro de Hermes, puede mantener salidas estructuradas en múltiples etapas y manejar cadenas de tareas complejas sin romper el formato o perder la dirección.

Otro aspecto importante es la autocorrección. Si un resultado intermedio se desvía del objetivo, el sistema puede regenerar ese paso en lugar de continuar con datos erróneos. Esto lo hace mucho más adecuado para escenarios de automatización donde no deseas supervisar manualmente cada paso.

En general, se siente más cerca de una capa de ejecución fiable que de un simple generador de texto.

1. ¿Por qué Kimi K2.6 es más lento en flujos de trabajo de agentes en comparación con otros modelos?

La menor velocidad se debe principalmente a cómo se está utilizando, no solo al modelo en sí.

En un escenario de chat estándar, solo esperas una respuesta. En un flujo de trabajo de agentes, una sola tarea puede involucrar múltiples pasos, cada uno de los cuales requiere una llamada al modelo por separado, además de la sobrecarga de coordinación entre agentes. Esto introduce latencia de forma natural en cada etapa.

Además, Kimi K2.6 está diseñado con una arquitectura más compleja (ej. enrutamiento estilo MoE), lo que puede aumentar la sobrecarga de inferencia en comparación con modelos más pequeños o más optimizados. Cuando se combina con la orquestación multi-agente, el retraso se vuelve más notorio.

Sin embargo, el compromiso es que cada paso produce salidas de mayor calidad y más estructuradas, reduciendo la necesidad de reintentos o correcciones manuales. Así que, aunque es más lento en tiempo de respuesta bruto, puede ser más eficiente a nivel de flujo de trabajo.