Qué son las reglas de Codex
Codex ejecuta comandos en un sandbox. Las reglas deciden qué sucede cuando un comando necesita ejecutarse fuera de él: ejecutarlo, preguntarte primero o rechazarlo.
La documentación de OpenAI añade una advertencia al principio: "Las reglas son experimentales y pueden cambiar".
Las reglas se escriben en un archivo .rules. La documentación indica que el formato utiliza Starlark, que tiene una sintaxis similar a Python pero está "diseñado para ser seguro de ejecutar: el motor de reglas puede ejecutarlo sin efectos secundarios (por ejemplo, tocar el sistema de archivos)".
Por lo tanto, un archivo de reglas es un pequeño programa de políticas de comandos. La prosa escrita en él no es una regla y no cambiará la forma en que Codex escribe código.
Dónde van tus convenciones en su lugar
Las convenciones de codificación, la estructura del proyecto y la guía del equipo pertenecen a AGENTS.md. La documentación de OpenAI sobre memories es directa al respecto: "Mantén la guía de equipo requerida en AGENTS.md o en documentación registrada (checked-in)".
La misma página advierte contra confiar en la memory para reglas que deben aplicarse siempre: "Trata las memories como una capa de recuerdo útil, no como la única fuente para reglas que deben aplicarse siempre".
Eso te da tres lugares diferentes con tres funciones distintas:
AGENTS.md: qué debe saber Codex y cómo debe trabajar en tu proyecto.- Memories: contexto útil que Codex arrastra de chats anteriores.
- Reglas: qué comandos pueden ejecutarse fuera del sandbox y cómo.
Si Codex no está siguiendo las instrucciones que has escrito en AGENTS.md, las reglas no son el lugar donde buscar. Comprueba qué archivos de instrucciones se cargaron. Cubrimos cómo comprobar eso en nuestra guía sobre cómo evitar que Codex ignore las reglas de AGENTS.md.
Dónde viven los archivos de reglas y cuándo se cargan
Creas un archivo .rules bajo una carpeta rules/ junto a una capa de configuración activa. El ejemplo de la documentación es ~/.codex/rules/default.rules.
Luego: "Codex escanea rules/ bajo cada capa de configuración activa al inicio". Esto incluye las ubicaciones de Team Config y tu capa de usuario en ~/.codex/rules/.
Dos detalles deciden si una regla surte efecto:
- Reiniciar después de editar. Los pasos de la documentación terminan con el reinicio de Codex, porque las reglas se escanean al inicio.
- Las reglas de proyecto necesitan confianza. "Las reglas locales del proyecto bajo
<repo>/.codex/rules/se cargan solo cuando la capa.codex/del proyecto es de confianza (trusted)".
Por lo tanto, una regla subida a un repositorio no se aplicará en la máquina de un compañero hasta que este haya marcado ese proyecto como confiable.
Dónde se guardan las aprobaciones permanentes
Esta parte es fácil de pasar por alto, y es un tipo de memory.
La documentación dice: "Cuando añades un comando a la lista de permitidos en la TUI, Codex escribe en la capa de usuario en ~/.codex/rules/default.rules para que las ejecuciones futuras puedan omitir el aviso".
De esa frase se deducen tres cosas:
- Tus aprobaciones se registran por escrito. Son reglas en un archivo, no un ajuste oculto en una sesión.
- Están en la capa de usuario. Se guardan en tu directorio personal, no en el proyecto en el que estabas trabajando cuando aprobaste.
- Puedes leerlas y editarlas. Abre
~/.codex/rules/default.rulespara ver cada comando que has permitido de esta manera.
Hay una segunda forma en que se añaden reglas. "Cuando las aprobaciones inteligentes (Smart approvals) están habilitadas (por defecto), Codex puede proponerte una prefix_rule durante las solicitudes de escalada". La documentación añade una precaución: "Revisa cuidadosamente el prefijo sugerido antes de aceptarlo".
La razón es el prefijo. Una regla sugerida coincide con cada comando que comienza con ese prefijo, por lo que un prefijo corto puede permitir mucho más que el único comando que pretendías aprobar.
Cómo se escribe una regla
Cada regla es una prefix_rule() con algunos campos. La documentación los describe:
patternes obligatorio. Es una lista que define el prefijo del comando a coincidir, como las tres palabrasgh,pryview. Cada elemento puede ser un literal o un conjunto de alternativas en esa posición.decisionpor defecto es allow. Las opciones son allow, prompt y forbidden.justificationes opcional: "Una razón legible por humanos y no vacía para la regla". La documentación dice que Codex puede mostrarla en los avisos de aprobación o mensajes de rechazo.matchynot_matchson ejemplos opcionales "que Codex valida cuando carga tus reglas". La documentación los llama pruebas unitarias integradas.
Vale la pena seguir la guía de la documentación sobre reglas prohibidas: "Cuando uses forbidden, incluye una alternativa recomendada en la justificación cuando sea apropiado". De esa manera, cuando Codex choca con la regla, aprende qué hacer en su lugar.
El campo de justificación es también lo más parecido que tiene una regla a un motivo. Un año después, es lo que te dirá por qué se bloqueó un comando.
Qué hace la regla de ejemplo de la documentación
El ejemplo de OpenAI es una plantilla útil. Es una regla única para ver pull requests con la CLI de GitHub.
- El patrón es el prefijo compuesto por
gh,pryview. - La decisión es prompt, por lo que Codex pregunta antes de que cada comando coincidente se ejecute fuera del sandbox.
- La justificación dice "Ver PRs está permitido con aprobación", que es lo que verías en el aviso.
- Los ejemplos de match incluyen ver una PR por número y con flags adicionales, para que Codex verifique que la regla los cubre.
- El ejemplo de not_match coloca el flag del repositorio antes de la palabra view, y el comentario explica por qué no debería coincidir: "No coincide porque el
patterndebe ser un prefijo exacto".
Ese último ejemplo muestra cuán literal es la coincidencia. Un comando con las mismas palabras en un orden diferente es un prefijo distinto, por lo que necesita su propia regla.
Qué decisión prevalece cuando las reglas se solapan
Reglas de varias capas pueden coincidir con el mismo comando. La documentación es explícita sobre el resultado: "Codex aplica la decisión más restrictiva cuando coincide más de una regla (forbidden > prompt > allow)".
Por lo tanto, un allow en tu capa de usuario no puede suavizar una regla forbidden de otra capa. Se aplica la decisión coincidente más restrictiva.
Los administradores pueden usar esto deliberadamente. La documentación dice que los administradores "también pueden imponer entradas prefix_rule restrictivas" desde el archivo gestionado requirements.toml.
Cómo se revisan los scripts de shell
Algunas herramientas envuelven varios comandos en una sola invocación, como una llamada bash -lc que ejecuta un script corto. La documentación explica por qué esto importa: tal comando "puede ocultar más de una acción dentro de una cadena".
Codex maneja esto de dos maneras.
Cuando puede dividir el script de forma segura. Si el script es una cadena simple de comandos planos unidos por operadores como &&, ||, ; o |, Codex lo analiza y lo divide en comandos separados. "Codex luego evalúa cada comando contra tus reglas, y el resultado más restrictivo prevalece". El ejemplo de la documentación: permitir git add no permite un rm -rf encadenado oculto después, porque esa parte se evalúa por separado.
Cuando no puede. Si el script utiliza redirecciones, sustituciones, variables de entorno, comodines o flujo de control, Codex no intenta interpretarlo. Toda la invocación se trata como un solo comando, y tus reglas se aplican a eso.
La documentación resume el diseño: "obtienes la seguridad de la evaluación por comando cuando es seguro hacerlo, y un comportamiento conservador cuando no lo es".
Cómo probar una regla
Antes de confiar en una regla, compruébala. La documentación dice que uses codex execpolicy check, apuntando a un archivo de reglas y dándole un comando. "El comando emite un JSON que muestra la decisión más estricta y cualquier regla coincidente, incluyendo cualquier valor de justification de las reglas coincidentes". Puedes pasar más de un archivo de reglas para ver cómo se combinan.
Los ejemplos match y not_match dentro de una regla hacen un trabajo similar automáticamente, ya que Codex los valida cuando carga tus reglas.
Las reglas y la política untrusted retirada
Si usaste la antigua política de aprobación untrusted, las reglas importan más ahora. La documentación de aprobaciones de OpenAI dice que Codex ya no admite ese ajuste y explica cómo mantener un proyecto estricto. Añades una entrada de proyecto con un nivel de confianza untrusted a tu configuración de nivel de usuario, y luego: "Los comandos requieren aprobación a menos que una regla de política de ejecución los permita".
En esa configuración, tus reglas allow son la única forma en que un comando se ejecuta sin preguntar. Esa es otra razón para mantener default.rules ordenado.
Codex tiene un paso de confianza similar para los hooks, que necesitan revisión antes de ejecutarse. Lo cubrimos en nuestra guía sobre por qué los hooks de Codex necesitan revisión.
Lo que la gente intenta primero
Escribir convenciones en un archivo de reglas. Las reglas controlan comandos. Las convenciones van en AGENTS.md.
Editar una regla y esperar que se aplique de inmediato. Las reglas se escanean al inicio.
Subir reglas de proyecto y esperar que funcionen en todas partes. Las reglas de proyecto se cargan solo cuando la capa del proyecto es de confianza.
Aceptar un prefijo sugerido sin leerlo. Un prefijo corto puede permitir más de lo que pretendías.
Permitir un comando para anular un bloqueo. La decisión más restrictiva prevalece.
La solución: Pon cada tipo de instrucción donde corresponde
Paso 1: Mueve las convenciones a AGENTS.md
Saca cualquier cosa que describa cómo escribir código de los archivos de reglas y llévala a AGENTS.md.
Paso 2: Revisa tus aprobaciones guardadas
Abre ~/.codex/rules/default.rules y elimina las reglas allow que ya no necesites.
Paso 3: Añade justificaciones y ejemplos
Dale a cada regla una justificación y añade ejemplos de match y not_match para que los errores aparezcan cuando Codex la cargue.
Paso 4: Registra por qué existe cada política de comando
Escribe las decisiones detrás de tus reglas, como por qué un comando está bloqueado o qué alternativa usar.
Configurando esto en MemoryLake
Un archivo de reglas registra lo que Codex puede ejecutar. Las decisiones detrás de él, como por qué los comandos de despliegue están bloqueados localmente o qué comando de prueba reemplazó a uno antiguo, son conocimiento del proyecto que cada asistente en el proyecto debería tener.
MemoryLake es una capa de memory para ese tipo de contexto de proyecto, como decisiones, convenciones y las razones detrás de tus salvaguardas, mantenidas en un solo lugar que tú controlas y disponibles para los asistentes que conectes, como ChatGPT, Claude Code y Codex.
Tú mismo escribes las entradas, con tus propias palabras. No se lee nada de, ni se escribe en, ni se borra de tus archivos .rules, tus archivos AGENTS.md, tu configuración o memories de Codex, tus sesiones o el almacenamiento de cualquier proveedor. Las reglas y aprobaciones de Codex funcionan de la manera que describe OpenAI.
Paso 1: Crea una clave API
Inicia sesión y genera una clave desde el panel de control. Guárdala fuera de tus repositorios, como cualquier otra credencial.

Paso 2: Sube tus primeras memories
Empieza con lo que escribiste en el Paso 4 de la solución: las razones detrás de tus políticas de comandos y las alternativas a los comandos bloqueados. Una decisión por entrada.

Paso 3: Conecta tu IA y agentes
Conecta Codex, Claude Code y los demás asistentes que utilices. Cada uno puede recurrir a las mismas decisiones, sea cual sea su propio sistema de permisos.

Qué cambia esto en la práctica
La primera diferencia es la claridad. Las reglas se limitan a los comandos, y los motivos viven donde la gente puede leerlos.
La segunda es la consistencia entre herramientas. Claude Code tiene sus propias reglas de permisos, y las decisiones detrás de ambas pueden vivir en un solo lugar.
La tercera es una revisión más fácil. Un compañero puede ver por qué existe una regla antes de cambiarla.
Mejores prácticas para las reglas de Codex
Usa reglas solo para comandos. Las convenciones pertenecen a AGENTS.md.
Revisa tu capa de usuario. Las aprobaciones permanentes se guardan en ~/.codex/rules/default.rules.
Lee los prefijos sugeridos. Pueden coincidir con más de un comando.
Escribe justificaciones. Incluye una alternativa para las reglas prohibidas.
Añade ejemplos de match. Codex los valida al cargar las reglas.
Prueba con codex execpolicy check. Mira la decisión más estricta antes de confiar en ella.
Reinicia tras editar. Las reglas se escanean al inicio.
Conclusión
Las reglas de Codex controlan qué comandos pueden ejecutarse fuera del sandbox: permitir, preguntar o prohibir. No son instrucciones, y las convenciones pertenecen a AGENTS.md. Los archivos de reglas viven en una carpeta rules/ junto a cada capa de configuración, se cargan al inicio, y las reglas de proyecto necesitan un proyecto de confianza. Cuando permites un comando en la TUI, Codex lo guarda en ~/.codex/rules/default.rules en tu capa de usuario.
Cuando las reglas se solapan, prevalece la decisión más restrictiva, y los scripts de shell simples se dividen para que cada comando se revise por separado. Revisa tus aprobaciones guardadas, añade justificaciones y mantén los motivos detrás de tus reglas en algún lugar que tú controles.