Modo YOLO de Kimi Code: el flag --yolo, modos y uso seguro

La respuesta corta: sí, Kimi Code tiene flag YOLO

"Modo YOLO" es el apodo que la comunidad le puso a ejecutar un agente de código con las aprobaciones desactivadas. Claude Code tiene --dangerously-skip-permissions, Codex tiene --full-auto, y Kimi Code tiene --yolo. La misma idea en los tres: el agente deja de pararse a preguntar si puede escribir un fichero o lanzar un comando, y lo hace sin más.

# Full auto: sin preguntas de aprobación
kimi --yolo

# Forma corta
kimi -y

Kimi Code es el agente de código en terminal de Moonshot AI, que corre sobre el modelo Kimi K3. Si aún no lo tienes instalado, la guía de cómo usar Kimi Code cubre la instalación y el login. Esta guía asume que ya lo tienes funcionando y quieres saber cuánto abrirle la mano.

Existen además dos alias ocultos, --yes y --auto-approve, que hacen exactamente lo mismo que --yolo. Están ahí para que los scripts y la memoria muscular de otras herramientas sigan funcionando. Uses la forma que uses, el comportamiento es idéntico: cada llamada a herramienta se aprueba sola.

YOLO vs auto vs plan: los tres modos de ejecución

El flag --yolo es uno de los tres interruptores de modo que Kimi Code acepta al arrancar, y conviene saber dónde cae en el espectro:

• Por defecto (sin flag). Aprobación interactiva. Kimi Code se para y pregunta antes de las acciones que requieren permiso, y tú apruebas o rechazas cada una.
• --plan. Modo plan. El agente piensa qué haría y te presenta el plan en vez de lanzarse. Ideal para acotar un cambio antes de dejarle tocar nada.
• --auto. Modo auto. Más autonomía que el modo por defecto sin quitar todas las barreras.
• --yolo. Todo se aprueba automáticamente. Sin preguntas, sin pausas, máxima velocidad y máximo riesgo.

Un flujo sano combina varios. Acota un cambio arriesgado con --plan, haz el trabajo rutinario en modo por defecto, y reserva --yolo para tareas donde el radio de daño está contenido: una rama de usar y tirar, un repo desechable o un worktree aislado.

El gotcha al reanudar: los flags de modo pisan la sesión guardada

Las sesiones de Kimi Code recuerdan el modo en el que corrían. Cuando reanudas una con kimi --continue o kimi --session <id>, normalmente vuelve en ese modo guardado. Pero si pasas --yolo, --auto o --plan junto al flag de reanudar, gana el flag y el modo guardado queda pisado.

Reanudar sesiones tiene su propia mecánica (dónde viven en disco, cómo encontrar una antigua, cómo ponerles nombre). La guía del historial de conversaciones de Kimi Code lo cubre entero.

Qué puede hacerle --yolo a tu máquina

Con las aprobaciones apagadas, Kimi Code corre sobre un repo vivo, con historia de Git real y una shell real. Nada de esto es hipotético; son los modos de fallo estándar de cualquier agente en full auto, y basta una instrucción mal leída:

• Push a la rama equivocada. Trabajo a medias commiteado y pusheado a main, o un force-push encima de un compañero.
• Ficheros y directorios borrados. Un rm -rf sobre una ruta que no era, ejecutado sin ninguna pregunta que lo frene.
• Comandos irreversibles. Borrados de base de datos, docker system prune, cualquier cosa que no se pueda deshacer una vez corre.
• Dependencias equivocadas. Un paquete con typosquatting que parecía correcto de un vistazo, instalado e importado antes de que te des cuenta.
• Llamadas de red no buscadas. Endpoints de producción tocados, webhooks disparados, datos enviados donde no esperabas.
• Trabajo sin commitear sobrescrito. Tus ficheros a medio cambiar editados por debajo, sin ninguna pregunta de por medio.

Hay un modo de fallo más, específico de las ejecuciones desatendidas: Kimi Code tiene issues abiertas donde una petición limitada por rate limit o un stream parado pueden dejar la sesión colgada en silencio en vez de fallar con error. En una sesión interactiva lo ves. En una sesión YOLO que dejaste sola una hora, un agente colgado parece exactamente un agente trabajando. Es uno de los argumentos más fuertes para ejecutar el full auto en un sitio con visibilidad de verdad.

El camino intermedio: reglas de permisos en vez de YOLO total

La mayor parte del tiempo no quieres que se apruebe todo. Quieres que lo rutinario (editar ficheros, leer, tu runner de tests) pase volando, y que lo peligroso siga parándose. Kimi Code soporta exactamente eso con entradas [[permission.rules]] en su fichero de configuración, ~/.kimi-code/config.toml, que pre-aprueban herramientas concretas para que dejen de preguntar, sin tocar nada más.

Eso te da una escalera con peldaños en vez de un interruptor binario: el modo por defecto con unas pocas herramientas pre-aprobadas molesta muchísimo menos que el modo por defecto a pelo, y es muchísimo más seguro que --yolo. La sintaxis exacta de las reglas está en la documentación oficial de Kimi Code, y evoluciona con las releases casi diarias, así que consulta la doc de tu versión instalada en vez de copiar un snippet de un post viejo.

Para un control más fino están los hooks: Kimi Code trae un sistema de hooks completo, configurado como bloques TOML [[hooks]] en el mismo config.toml, con 16 eventos de ciclo de vida. El que importa para seguridad es PreToolUse: un script de hook que sale con código 2 bloquea la llamada a la herramienta y devuelve su stderr como motivo. Con eso escribes tus propias barreras, como bloquear force-pushes o proteger un directorio, y aguantan incluso en modo YOLO.

Las instrucciones permanentes van en AGENTS.md, la convención de fichero de instrucciones multi-herramienta que sigue Kimi Code (no lee CLAUDE.md de forma nativa). Las reglas de la casa ahí, tipo "nunca hagas push sin preguntar", llegan a todas las sesiones sin re-escribirlas, aunque a diferencia de un hook PreToolUse son guía para el modelo, no un bloqueo impuesto.

Cómo ejecutar kimi --yolo con seguridad

El patrón que funciona es el mismo que funciona con Claude Code y Codex en full auto: contener el radio de daño, tener un punto de restauración y no perder de vista la ejecución.

• Trabaja en una rama, nunca en main. Si la ejecución sale mal, tiras la rama y ya.
• Commitea antes de empezar. Con el árbol limpio, git checkout . es un deshacer de una línea para todo lo que no sea un push.
• Usa un git worktree para aislar de verdad. Un worktree separado le da al agente su propia copia del repo, así que ni una ejecución agresiva puede tocar los ficheros que tú estás editando. La guía de git worktrees para agentes de IA explica el montaje.
• Acota los prompts. "Migra estos tres ficheros a la API nueva" es una tarea YOLO razonable. "Mejora el código" no lo es.
• Pon hooks PreToolUse en tus líneas rojas. Force-push, configs de producción, dotfiles: lo que no deba pasar nunca, imponlo con un hook de exit 2 en vez de confiar.

YOLO vigilado en CodeAgentSwarm

Queda el problema de la visibilidad. Una sesión YOLO en una ventana de terminal suelta es una caja negra: te enteras de lo que pasó cuando vuelves y lees el scrollback. CodeAgentSwarm corre Kimi Code como agente de primera clase (junto a Claude Code, Codex, Antigravity CLI y opencode) y envuelve cada terminal con la supervisión que el full auto necesita:

• Diffs en vivo por terminal. Ves qué ficheros está cambiando cada agente de Kimi Code mientras corre, no después.
• Notificaciones de escritorio. Te avisa cuando un agente termina o se queda parado, lo que además caza el fallo del cuelgue silencioso en vez de dejarle quemar una hora.
• Historial buscable. Audita qué hizo de verdad una sesión YOLO a posteriori, y reanúdala si se quedó a medias.
• Varios agentes lado a lado. Un terminal de Kimi Code interactivo y prudente y otro en YOLO sobre una rama desechable, en la misma ventana y de un vistazo.

Si lo tuyo va más hacia varios agentes de Kimi Code a la vez y no uno solo muy rápido, eso tiene guía propia: mira ejecutar múltiples sesiones de Kimi Code y el enjambre de agentes de Kimi Code.

Cómo se compara el YOLO de Kimi Code con los otros CLIs

Si usas más de un agente, los flags de bypass se mezclan fácil. Los modelos difieren más que los flags:

• Claude Code: --dangerously-skip-permissions, más reglas de allow granulares en settings. Lo cubre la guía del modo YOLO de Claude Code.
• Codex CLI: --full-auto y modos de aprobación. Explicado en modo YOLO de Codex.
• opencode: sin flag; la autonomía va por configuración. Mira modo YOLO de opencode.
• Kimi Code: --yolo / -y para el bypass total, reglas de permisos y hooks en config.toml para la versión gradual, y flags de modo que pisan el modo guardado de una sesión reanudada.

Kimi Code queda pegado a Claude Code, y no es casualidad: su set de herramientas y sus convenciones siguen de cerca a Claude Code, hasta el punto de leer el mismo directorio compartido de skills. La consecuencia práctica es que los hábitos se transfieren. Si ya tienes un flujo YOLO seguro para Claude Code, la misma higiene de ramas, el aislamiento con worktrees y la supervisión valen tal cual para kimi -y.