Modo YOLO de OpenCode: ¿existe? Los permisos explicados
Por CodeAgentSwarm · Actualizado el 31 de octubre de 2026
--yolo ni ningún flag dangerously-skip-permissions, pero opencode sí trae --auto, que aprueba cualquier petición de permiso que una regla no deniegue de forma explícita. Para lo permanente, opencode lee cuánta libertad le diste desde su configuración de permisos: en un archivo de config decides qué tipos de acciones se ejecutan solas, cuáles preguntan primero y cuáles se bloquean. --auto o una config todo-en-allow es lo más parecido al "modo YOLO", y los dos conllevan los mismos riesgos que cualquier flag de bypass.
Esta guía explica cómo funcionan juntos el flag y la config, qué se rompe en serio cuando permites todo y cómo conseguir la velocidad del full-auto sin perder el control. Esa última parte es donde entra CodeAgentSwarm: no añade un interruptor de Turbo Mode para opencode, porque opencode gestiona su autonomía con su propio flag y su config, pero sí mantiene supervisada una sesión permisiva de opencode con diffs en vivo, notificaciones de escritorio e historial buscable.Qué significa "modo YOLO" y la respuesta corta para opencode
opencode bypass permissions: ¿existe una bandera?
Sí: --auto. Arranca opencode --auto, o opencode run --auto para una tarea suelta, y opencode aprueba cualquier petición de permiso que no esté denegada de forma explícita. No hay --yolo ni ninguna opción dangerously-skip-permissions. Para un ajuste duradero, usa opencode.json: pon cada tipo de acción en allow, ask o deny, o pon "permission": "allow" para permitirlo todo de una vez.
# Sesión interactiva
opencode --auto
# Tarea suelta
opencode run --auto "Ejecuta los tests y arregla los fallos"
"Modo YOLO" es el apodo de la comunidad para ejecutar un agente de código con las aprobaciones desactivadas, para que trabaje sin pararse a preguntarte. El nombre viene de herramientas como Claude Code y Codex, donde un único flag apaga las peticiones. La idea cuajó porque capta la sensación: solo se vive una vez, así que apaga las peticiones y deja que el agente corra.
La respuesta corta para opencode es el flag --auto, descrito en la documentación oficial de permisos de opencode (revisada el 31 de octubre de 2026). Solo cambia las peticiones que de otro modo pedirían aprobación, así que las reglas deny explícitas se siguen aplicando. En la TUI también puedes elegir Enable auto-approve permissions o Disable auto-approve permissions para cambiar de modo durante una sesión.
Para un ajuste que valga en todas las sesiones, la respuesta es un archivo de config. Le dices a opencode qué tipos de acciones se autoejecutan, cuáles preguntan primero y cuáles se deniegan, y se comporta así en cada sesión.
Antes de tirar de --auto, mira qué sigue preguntando. Según la documentación oficial, la mayoría de los permisos de opencode ya vienen en allow por defecto. doom_loop y external_directory vienen en ask, y leer archivos .env pide aprobación. Así que --auto sobre todo quita esas peticiones y las reglas ask que hayas añadido tú.
Si lo que de verdad buscas es ejecutar varios agentes de opencode a la vez y no solo uno en full auto, la guía del enjambre de agentes opencode cubre ese lado, y la visión general del enjambre de agentes CLI de IA lo compara en todas las CLI.
Cómo funcionan en realidad los permisos de opencode
La autonomía duradera de opencode vive en la configuración; --auto solo cambia la sesión que arrancas con él. Los permisos se definen en opencode.json. Hay una config global en ~/.config/opencode/opencode.json, además de config por proyecto y config por agente, así que distintos agentes pueden ejecutarse con distinta cantidad de libertad. Un agente de refactor de confianza puede correr más suelto que uno general, y tu repo del trabajo puede quedarse más estricto que un proyecto paralelo.
Los valores siguen un patrón de allow, ask, deny por tipo de acción. Decides, por ejemplo, que las ediciones de archivos se ejecutan solas mientras los comandos de shell se paran a preguntar primero. Una config mínima tiene esta pinta:
{
"permission": {
"edit": "allow",
"bash": "ask"
}
}Tómalo como ilustrativo. Las claves y los valores exactos evolucionan entre versiones de opencode, y el esquema crece con el tiempo, así que la documentación oficial de opencode es la fuente de verdad para lo que admite tu versión instalada. No copies una config que viste en un post antiguo sin contrastarla con la documentación actual.
Poner todo en allow, con "permission": "allow", es la versión en config de --auto. Hace que opencode lea, escriba y ejecute comandos por su cuenta, sin ninguna petición de por medio. La velocidad es real, y el riesgo también: una config todo-en-allow conlleva exactamente el mismo peligro que cualquier flag de bypass, porque no queda nada que frene un comando destructivo.
En qué se diferencia de Claude Code y Codex
Claude Code tiene --dangerously-skip-permissions y Codex tiene --yolo, que además quita el sandbox de Codex. --auto en opencode es más acotado: las reglas deny explícitas siguen bloqueando. La guía de Turbo Mode YOLO de Claude Code explica en detalle el modelo de Claude.
El enfoque por configuración de opencode es, siendo justos, más sensato. El estado permisivo es explícito, versionable y acotado: vive en un archivo que puedes leer, commitear y compartir, en lugar de un flag que alguien teclea con prisa y olvida. Ves de un vistazo qué acciones autoaprueba tu proyecto, y mantienes esa política consistente en cada sesión en vez de depender de acordarte de añadir o quitar un flag cada vez.
Los riesgos reales de permitir todo
Esto no son hipótesis. Con todo puesto en allow, opencode se ejecuta sobre un repo en uso con un historial de Git de verdad y datos de verdad, y cualquiera de estas cosas puede pasar dentro de una sola sesión, sin ninguna petición que la frene antes.
- Push de Git a la rama equivocada - opencode decide hacer commit y push de trabajo a medias a main, o hace force-push y machaca a un compañero.
- Borrado de archivos o directorios - Una instrucción malinterpretada se convierte en
rm -rfsobre una ruta que no querías eliminar. - Comandos de shell irreversibles -
DROP TABLE,docker system pruneo cualquier cosa que no se pueda deshacer una vez se ejecuta. - Instalar la dependencia equivocada -
npm installsobre un paquete con typosquatting o comprometido que a simple vista parecía correcto. - Llamadas de red no deseadas - Golpear endpoints de producción, enviar datos a servicios externos o disparar webhooks que no esperabas.
- Sobrescribir trabajo sin commitear - opencode edita archivos que estabas tocando y tu trabajo sin commitear desaparece antes de que te des cuenta.
Una config todo-en-allow, o --auto sin reglas deny, es exactamente igual de peligrosa que cualquier flag YOLO. La ventaja de opencode es que las reglas deny sobreviven a --auto: puedes dejar que las ediciones de archivos corran mientras git push o rm siguen denegados, así que el trabajo seguro pasa de largo mientras los comandos peligrosos siguen parándose.
El full auto no es malo en sí. Es el ajuste correcto para mucho trabajo. El riesgo viene de poner todo en allow sin mantener frenadas las operaciones de verdad peligrosas. La siguiente sección va justo sobre eso.
Cómo ejecutar opencode en full auto con seguridad
Hay varios enfoques, del menos controlado al más. El objetivo es el mismo en todos: mantener la velocidad del full auto en las operaciones seguras sin dejar nunca que un comando destructivo se ejecute sin supervisión.
Método 1: permitir todo en trabajo desechable
Arranca opencode --auto o pon todos los permisos en allow, y deja que opencode corra sin supervisión. Esto va bien para proyectos de pruebas y ramas desechables, donde confías en que nada destructivo puede importar y puedes tirarlo todo a la basura. En un repo real con historial de verdad, correr del todo abierto es una apuesta, porque una sola instrucción malinterpretada alcanza Git, borrados y la red sin ninguna petición de por medio.
Método 2: una config de permisos selectiva (el punto dulce)
Un punto de partida mejor es una config selectiva. Permite las ediciones y lecturas de archivos para que el trabajo rutinario pase de largo, pero mantén los comandos de shell, o al menos los destructivos, en ask. Ponlo por proyecto o por agente, para que un agente de refactor de confianza corra más suelto que uno general, y tu repo principal se quede más estricto que un proyecto de pruebas. Luego mete tus normas de la casa en AGENTS.md, el archivo de instrucciones común entre herramientas, para que cada sesión herede la misma guía sin que la repitas.
Este es el punto dulce porque conserva las partes del full auto que de verdad ahorran tiempo mientras frena el puñado de acciones que causan daño real. A diferencia de un solo flag de bypass, no te obliga a elegir entre preguntar por todo y no preguntar por nada.
Método 3: ejecutar la config permisiva dentro de CodeAgentSwarm (recomendado para enjambres)
Que quede claro: CodeAgentSwarm no ofrece Turbo Mode para las sesiones de opencode. opencode controla su autonomía con su propio flag --auto y su config de permisos, así que ahí es donde decides qué se autoejecuta. Lo que CodeAgentSwarm añade en su lugar es supervisión alrededor de tu configuración permisiva de opencode, para que el trabajo en full auto nunca sea una caja negra.
Esto es lo que te da esa supervisión por encima de opencode:
- Varios terminales de opencode en una ventana - Ejecuta todo un enjambre de opencode en paralelo en lugar de hacer malabares con ventanas sueltas.
- Diffs de archivos en vivo por terminal - Observa exactamente qué está cambiando cada agente de opencode en tiempo real, para que una config permisiva nunca corra sin verse.
- Notificaciones de escritorio - Recibe un aviso cuando un agente termina o se atasca esperando input, en vez de vigilar cada terminal.
- Títulos dinámicos - Cada terminal muestra en qué está trabajando su agente, para que distingas el enjambre de un vistazo.
- Historial buscable y reanudable - Audita qué hizo un agente después de los hechos y retoma una sesión con el propio soporte de reanudación de opencode.
La combinación de una config selectiva más supervisión en tiempo real es lo que hace viable un enjambre permisivo de opencode. La config decide qué se autoejecuta; CodeAgentSwarm se asegura de que puedas ver y auditar cada una de esas tiradas. Para ejecutar muchos agentes de opencode a la vez, la guía de ejecutar múltiples sesiones de opencode cubre el montaje de principio a fin.
La config por proyecto significa que tu repo del trabajo puede quedarse estricto mientras un proyecto paralelo corre abierto de par en par, y CodeAgentSwarm muestra ambos tipos de terminal lado a lado en la misma ventana, cada uno con su propio diff en vivo.
Buenas prácticas para tiradas de opencode en full auto
Sea cual sea el método que uses, estos hábitos mantienen fuera de la mesa los peores accidentes del full auto:
- Trabaja siempre en una rama de feature, nunca en main. Si opencode la lía, tiras la rama. Si la lía en main, lo nota todo el equipo.
- Haz commit antes de empezar una tirada permisiva. Un punto de restauración limpio significa que
git checkout .te devuelve al instante si algo sale mal. - Mantén en ask las acciones destructivas de Git y de shell. Aunque todo lo demás esté en allow, push, force-push, merge, borrado de ramas y los comandos de shell irreversibles deberían seguir parándose a pedir confirmación. Si arrancas con
--auto, las reglas ask se aprueban solas, así que ponlas en deny. Son las acciones de mayor impacto y más difíciles de deshacer. - Mete las instrucciones permanentes en AGENTS.md. Las normas de la casa en el archivo de instrucciones común hacen que cada sesión de opencode herede los mismos guardarraíles sin que los repitas.
- Vigila el diff en vivo. Una vista de cambios de archivos por terminal convierte una config permisiva de caja negra en algo que de verdad puedes supervisar.
- Mantén los prompts acotados. "Refactoriza el middleware de auth para usar JWT" es mucho más seguro en full auto que "mejora el código". Cuanto más estrecho el alcance, menos margen tiene opencode para irse por las ramas.
Una config selectiva más una rama de feature más un diff en vivo te dan casi toda la velocidad del full auto con casi nada del riesgo. La mayoría de quien monta esto no vuelve a permitir todo sobre un repo real.
Preguntas frecuentes
¿Tiene opencode un modo YOLO?
Casi. El flag --auto aprueba cualquier petición de permiso que no esté denegada de forma explícita, y poner "permission": "allow" en opencode.json hace lo mismo en todas las sesiones. No hay flag --yolo ni dangerously-skip-permissions, y las reglas deny siguen aplicándose con --auto.
¿Existe un flag opencode --yolo o --full-auto?
No. opencode no tiene --yolo, ni --full-auto, ni ningún flag dangerously-skip-permissions. Su equivalente es --auto: opencode --auto, u opencode run --auto, aprueba cualquier petición de permiso que una regla no deniegue de forma explícita. Para un ajuste permanente, usa los permisos de opencode.json.
¿Cómo hago que opencode se ejecute sin pedir aprobación?
Arráncalo con opencode --auto, u opencode run --auto para una tarea suelta. Para todas las sesiones, pon los permisos en allow en opencode.json: "permission": "allow" lo permite todo, mientras que { "permission": { "edit": "allow", "bash": "ask" } } mantiene en ask los comandos de shell. Revisa la documentación oficial de opencode para el esquema que admite tu versión instalada.
¿Cómo hago bypass permissions en opencode?
Usa el flag --auto, que aprueba cualquier petición que no esté denegada de forma explícita, o pon los permisos en allow en opencode.json. Con --auto las reglas deny explícitas siguen bloqueando, y esa es la diferencia principal con --dangerously-skip-permissions de Claude Code. Revisa la documentación oficial de opencode para el esquema que admite tu versión instalada.
¿Tiene opencode una bandera --dangerously-skip-permissions?
No. Esa bandera es de Claude Code, y Codex usa --yolo. Lo más parecido en opencode es --auto, que mantiene en vigor las reglas deny explícitas. El comportamiento duradero de allow, ask y deny vive en opencode.json.
¿Cómo hago que opencode se salte las confirmaciones de permisos?
Arranca opencode con --auto, o pon en allow los tipos de acción que quieras sin supervisión en opencode.json, de forma global en ~/.config/opencode/opencode.json o por proyecto y por agente. Una config selectiva es la versión más segura: permite las ediciones de archivos para que el trabajo rutinario vuele, y mantén en ask las acciones de shell y las destructivas de Git, o en deny si usas --auto.
¿Es seguro poner todos los permisos de opencode en allow?
Una config todo-en-allow, o --auto sin reglas deny, es rápida pero exactamente igual de peligrosa que cualquier flag YOLO: opencode puede ejecutar git push, rm -rf o DROP TABLE sin ninguna petición. Es razonable en una rama desechable. En un repo real, permite las ediciones de archivos y deja en ask (o en deny con --auto) las acciones peligrosas de shell y de Git, y supervisa la tirada con diffs en vivo.
¿Dónde vive la config de permisos de opencode?
La config global está en ~/.config/opencode/opencode.json, siguiendo el layout XDG. También hay config por proyecto y config por agente, así que distintos agentes y distintos repos pueden ejecutarse con distinta cantidad de libertad. Las instrucciones permanentes van en AGENTS.md, el archivo de instrucciones común entre herramientas que hereda cada sesión.
¿En qué se diferencia opencode --auto de Codex --yolo o de Claude Code --dangerously-skip-permissions?
--dangerously-skip-permissions de Claude Code y --yolo de Codex se saltan sus controles en esa tirada, y --yolo además quita el sandbox de Codex. opencode --auto solo aprueba las peticiones que de otro modo preguntarían, así que las reglas deny explícitas siguen bloqueando. Su política duradera vive en opencode.json, un archivo que puedes leer y commitear, en lugar de un flag que alguien teclea con prisa y olvida.
¿Tiene CodeAgentSwarm Turbo Mode para opencode?
No. CodeAgentSwarm no ofrece Turbo Mode para las sesiones de opencode; opencode gestiona su autonomía con su propio flag --auto y su config de permisos. Lo que CodeAgentSwarm añade para opencode es supervisión: diffs en vivo por terminal, notificaciones de escritorio cuando un agente termina o se atasca, títulos dinámicos e historial buscable y reanudable.
¿Puede opencode borrar archivos o hacer push a la rama equivocada en full auto?
Sí, si se lo permites. Con las acciones de shell y de Git en allow, o con --auto y sin reglas deny, opencode puede ejecutar rm -rf, sobrescribir trabajo sin commitear y hacer commit o force-push a la rama equivocada, todo sin preguntar. Mantener en ask (en deny con --auto) las acciones destructivas de Git y de shell, trabajar en una rama de feature y hacer commit antes de una tirada son los guardarraíles que evitan los accidentes más comunes.