PTENES
MÓDULO 4.2 · Ruta 4 · Avanzado y entre entornos

🌐 Subagentes en Codex y otros entornos

El subagente no es un truco de Claude Code — es una idea: delegar trabajo a un contexto aislado y recibir solo el informe. Esta idea funciona en otros lugares. En este módulo vas a escribir una fuente .md que funciona en más de un entorno — Claude Code e el Codex CLI de OpenAI.

6
Temas
~30
Minutos
Avanzado
Nivel
Portable
Tipo

Piensa en una toma de corriente. El aparato es el mismo; cambia el adaptador según el país. El principio (110/220 V, un enchufe) no cambia — cambia el encaje. Un subagente funciona igual: el principio —«delegar en un contexto aislado y recibir un resumen»— es universal. Lo que cambia de un entorno a otro es el encaje: dónde está el archivo, cómo se llama el frontmatter, los nombres de las herramientas. El objetivo de este módulo es escribir un único .md y conectarlo a dos runtimes.

SKILL.md una fuente portátil adaptador.claude/agents adaptador~/.codex/prompts Claude Codeagente / skill en ejecución Codex CLIprompt / agente en ejecución

↑ Una fuente .md; cada runtime aplica su adaptador. La idea es la misma; el encaje cambia.

Contenido detallado

1

🧩 La idea es más grande que la herramienta

Todo lo que aprendiste hasta aquí — un director que delega, una ventana propia, un informe limpio — describe un estándar, no un producto. El patrón es: "una tarea grande se convierte en un subproceso con contexto propio; solo vuelve la conclusión". Cualquier herramienta seria de agentes necesita algo así, porque el problema (contexto que se llena, trabajo que se repite) es universal. Por eso el concepto es aplicable en otros contextos.

🔌 Principio × encaje

Separa dos cosas en tu mente. El principio es lo que delegas y por qué. El encaje es la documentación local: carpeta, nombre del campo, sintaxis. Cambiar de entorno solo modifica el encaje:

  • •Principio (no cambia): aislar el contexto · un papel por agente · devolver un resumen, no la conversación.
  • •Encaje (cambia): dónde vive el archivo · cómo se llama el frontmatter · nombre de las herramientas · quién invoca.
  • •Consecuencia: 80% del tuyo .md es reutilizable; solo hace falta adaptar la carcasa.
Qué es:

La constatación de que «subagente» es un patrón de arquitectura (delegar en un contexto aislado), y no una función exclusiva de una app.

Por qué aprender:

Te libera de depender de una sola herramienta. El conocimiento de todo el recorrido empieza a servir en cualquier runtime de agente, presente o futuro.

Conceptos clave:

Estándares × producto · principio (estable) × adaptación (local) · portabilidad del concepto.

2

🟢 Codex CLI: lo mismo, con otro nombre

O Codex CLI (el agente de terminal de OpenAI) tiene las mismas piezas, solo que con un vocabulario diferente. Donde Claude Code habla de «subagente» y «skill», Codex habla de prompts e agentes markdown que guardas en una carpeta e invocas. La estructura coincide: un archivo de instrucciones + un activador + un conjunto de herramientas permitidas.

Concepto Claude Code Codex CLI (equivalente)
Unidad de trabajo delegadasubagente (.md)prompt/agente markdown
Habilidad reutilizableskill (SKILL.md)prompt guardado + AGENTS.md
Dónde se encuentra (proyecto).claude/agents/.codex/prompts/
Dónde se encuentra (global)~/.claude/agents/~/.codex/prompts/
Memoria del proyectoCLAUDE.mdAGENTS.md
Cómo invocarloautomático por la description o @nomeexplícito por nombre del prompt (p. ej., /nome)

💡 La diferencia más importante

Claude Code enruta automáticamente: el director lee la description y decide por sí solo cuándo delegar. Codex tiende a ser más explícito — llamas al prompt por su nombre. La misma pieza, con un disparador diferente: ahí la description es un imán automático; aquí se convierte en una etiqueta más para que elijas.

Qué es: el mapa nombre por nombre entre las piezas de Claude Code y las de Codex CLI.
Por qué aprender: con el mapa, «portar» deja de ser traducir desde cero y pasa a ser completar una tabla de equivalencias.
Conceptos clave: prompt/agente Codex · AGENTS.md × CLAUDE.md · enrutamiento automático × invocación explícita.
3

♻️ Cross-runtime: la idea de "polyskill"

En vez de mantener dos copias (una para Claude y otra para Codex) que divergen con el tiempo, escribes una sola fuente y «emite» la versión de cada runtime a partir de ella. Esa es la idea de un polyskill: uno .md portable es el plantilla, y cada entorno es un build de ese molde. Una verdad, varios destinos — lo opuesto a copiar y pegar.

fuente portátil (la plantilla) rolquién es pasosqué hace salidalo que vuelve build → Claude Code+ estructura: name, description, tools build → Codex CLI+ estructura: prompt, AGENTS.md

📊 Por qué conviene tener una sola fuente

Dos copias divergen: corriges un bug en una, olvidas la otra y, en un mes, se contradicen. Con una fuente → varias compilaciones, la corrección se aplica una vez y ambos entornos la heredan. Ese es exactamente el motivo de "contexto limpio" de la Trilha 1 aplicado a tu repositorio de skills: menos duplicación, menos deriva.

Qué es: un único .md portable que sirve de molde; cada runtime se genera (build) a partir de él.
Por qué aprender: mantiene una sola verdad — corriges en un lugar y se aplica en todos — en vez de copias que divergen.
Conceptos clave: polyskill · molde × build · núcleo portable (rol/pasos/salida) × envoltura por runtime.
4

🛠️ Equivalencia de herramientas

Las herramientas tienen nombres diferentes, pero las capacidades son las mismas: leer archivos, buscar en texto, listar rutas, editar, ejecutar shell. En lugar de citar el nombre exacto de la herramienta en el cuerpo de tu .md, describe la capacidad ("lee los archivos", "busca por defecto") — así el mismo texto funciona en ambos, porque cada runtime determina qué herramienta concreta usar.

Capacidad Claude Code Codex / shell
Leer un archivoReadcat / lectura de archivo
Buscar en textoGreprg / grep
Listar rutas por defectoGlobfind / ls
Editar archivoEdit / Writepatch / escritura en el shell
Ejecutar comandoBashejecución de shell (nativa)
Investigar en la webWebFetch / WebSearchherramienta web (si está habilitada)

✓ Escribe el cuerpo así (portable)

  • ✓"Lee los archivos modificados y entiende la intención."
  • ✓"Busca llamadas inseguras en el código."
  • ✓"No modifiques nada: solo informa."

✗ Evita atarte a una herramienta

  • ✗"Usa la herramienta Grep con flag -n…" (solo Claude)
  • ✗"Llama WebFetch en…" (algunos en Codex)
  • ✗Mencionar nombres exactos en el cuerpo limita la portabilidad.
Qué es: el mapeo entre las herramientas con nombre de Claude Code (Read/Grep/Glob…) y sus equivalentes de shell/Codex.
Por qué aprender: describir la capacidad en lugar del nombre de la tool hace que el cuerpo del .md ejecutar igual en ambos runtimes.
Conceptos clave: capacidad × herramienta con nombre · Read↔cat, Grep↔rg, Glob↔find · cuerpo independiente de la herramienta.
5

⚖️ Qué cambia × qué no cambia

Antes de portar, fija el límite. El principio — delegar a un contexto aislado, un papel por agente, devolver un resumen — atraviesa cualquier entorno intacto. Lo que cambia es la carcasa: nombres de campos, carpetas, sintaxis de invocación, herramientas disponibles. Saber qué se mantiene estable evita reescribir lo que ya estaba bien.

✓ No cambia (el principio)

  • ✓Delegar a uno contexto aislado
  • ✓Devolver informe, no toda la conversación
  • ✓Uno rol por agente (sin hacer de todo)
  • ✓El núcleo: rol + pasos + salida + límites

✗ Cambia (la envoltura)

  • ✗Nombre de los campos del frontmatter
  • ✗Carpeta donde está el archivo
  • ✗Cómo es el agente invocado
  • ✗Nombres de las herramientas concretas

⚠️ El error de portabilidad más común

Reescribir el núcleo pensando que cada runtime necesita un cerebro diferente. No es así: el cerebro (rol, pasos, salida, límites) es el mismo. Quien hace bien la adaptación solo cambia la carcasa y deja intacto el núcleo; así, las dos compilaciones se comportan igual.

Qué es: la línea que separa lo invariable (principio/núcleo) de lo variable (envoltura/ajuste) al cambiar de entorno.
Por qué aprender: la adaptación es rápida cuando solo tocas la envoltura y nunca reescribes lo que ya funcionaba.
Conceptos clave: invariante × variable · núcleo intacto · envoltura adaptable · paridad de comportamiento.
6

🚚 Portar una skill — y dónde están los límites

Portar es un procedimiento de tres tiempos: extraer el núcleo, cambiar la carcasa, probar la paridad. Pero la portabilidad tiene un límite: no todo cruza la frontera. Las cosas muy ligadas a un runtime —una MCP exclusiva, un nombre de tool específico, un modelo de un solo proveedor— no se trasladan y se convierten en una nota de adaptación.

1

Extrae lo esencial

Qué es igual en ambos.

Separa el rol + los pasos + la salida + los límites del resto. Reescribe cualquier "usa la herramienta X" como una capacidad ("lee", "busca"). Ese texto se convierte en la fuente portable.

2

Cambia la cubierta

El encaje de cada runtime.

Configura el frontmatter del objetivo (Claude: name/description/tools; Codex: prompt + AGENTS.md) y coloca el archivo en la carpeta correcta del entorno.

3

Prueba la paridad

¿Misma entrada, mismo resultado?

Ejecuta la misma tarea en ambos y compara. Si Codex no se activa por sí solo, recuerda que allí la invocación suele ser explícita: eso es una capa adicional, no un error.

🚧 Los límites (lo que no cruza)

  • →Herramienta/MCP exclusiva de un runtime: deja una nota "en Codex, reemplázalo por el equivalente en shell".
  • →Modelo de un solo proveedor (p. ej., un Opus): en el otro entorno, elige el modelo del rol correspondiente.
  • →Enrutamiento automático: a description que se activa sola en Claude puede requerir una llamada explícita en Codex.
Qué es: el procedimiento extraer → cambiar la envoltura → probar la paridad, más la lista de lo que no es portable.
Por qué aprender: da un paso a paso repetible y crea el hábito de registrar la nota de adaptación donde termina la portabilidad.
Conceptos clave: extraer el núcleo · cambiar la envoltura · prueba de paridad · nota de adaptación · límites (MCP, modelo, enrutamiento).
📄

Ejemplo real: un agente portable (Claude → Codex)

Aquí hay un doc-summarizer.md escrito para ser portable: el frontmatter es la carcasa de Claude Code, y el cuerpo es el núcleo agnóstico de herramientas. Justo después, la nota de adaptación muestra qué cambiar para ejecutar el mismo archivo en Codex CLI.

.claude/agents/doc-summarizer.md Markdown + YAML
--- # CASCA (Claude Code) — troca por runtime
name: doc-summarizer
description: Lê documentos longos e devolve um resumo
  curto com os pontos-chave. Use para condensar
  arquivos grandes sem encher o contexto.
tools: Read, Grep, Glob   # só leitura
model: haiku             # barato p/ escanear
---

# MIOLO (portável) — NÃO cita ferramenta por nome
You are a precise document summarizer.

When invoked:
1. Read the target documents and grasp the intent.
2. Search for the key claims, numbers and decisions.
3. Write a summary: 5 bullets, then the source paths.

Output: only the summary. Do not paste raw
content. Do not modify any file.

📝 Nota de adaptación: ejecutar en Codex CLI

  • 1.Carpeta: mueve el archivo de .claude/agents/ para .codex/prompts/ (o el global ~/.codex/prompts/).
  • 2.Frontmatter: Codex no usa tools:/model: así — registra el papel y las reglas en el AGENTS.md del proyecto; el cuerpo (el contenido) queda igual.
  • 3.Herramientas: "Read/Grep/Glob" se convierten en cat/rg/find en el shell — el cuerpo ya habla de "read/search", así que no hay que cambiar nada ahí.
  • 4.Invocación: en vez de activación automática por description, llama al prompt por su nombre (/doc-summarizer).

🧠 El núcleo (viaja completo)

  • Papel — «un resumidor preciso de documentos».
  • Pasos — leer, buscar, resumir (sin nombre de tool).
  • Salida — 5 bullets + rutas.
  • Límites — no pegues el contenido en bruto ni lo edites.

🔌 La carcasa (cambio de runtime)

  • Carpeta — .claude/agents ↔ .codex/prompts.
  • Config — frontmatter ↔ AGENTS.md.
  • Tools — con nombre ↔ shell.
  • Disparador — auto ↔ llamada por nombre.
⌨️

Prompts listos (copia y pega)

Tres prompts para portar y ejecutar en distintos entornos. El patrón es siempre el mismo: pide que preserve el núcleo, adaptar a carcasa, y dejar una nota dónde termina la portabilidad.

Prompt 1 — adaptar un subagente para Codex cambio de carcasa
Pegue este subagente do Claude Code e adapte para o
Codex CLI. Mantenha o corpo (papel/passos/saída) intacto,
troque só a casca: pasta, frontmatter e invocação. No fim,
liste uma "nota de adaptação" com o que não é portável.
Prompt 2 — hacer que una skill sea portable (polyskill) una fuente → varias compilaciones
Reescreva esta skill como fonte portável: remova nomes
de ferramenta específicos do corpo e descreva a capacidade
("leia", "busque"). Depois emita dois builds — um para
Claude Code, um para Codex — a partir da mesma fonte.
Prompt 3 — mapear herramientas entre runtimes equivalencia de tools
Liste as ferramentas que este .md usa no Claude Code
(Read, Grep, Glob, Bash…) e me dê o equivalente de shell
para o Codex. Aponte quais não têm equivalente direto e
precisam virar nota de adaptação.
🖥️

Pantalla simulada: emitir la fuente para 2 runtimes

Así es como aparece en la terminal una compilación entre runtimes: ejecutas el emisor una vez sobre la fuente portátil, y genera los archivos de cada entorno, adaptando la envoltura y conservando el núcleo. Observa los dos destinos que salen del mismo SKILL.md.

polyskill build · doc-summarizer · 2 runtimes ⏱ 00:06
$ polyskill build doc-summarizer.md --all
→ fuente portable cargada · núcleo: rol + pasos + salida
● build claude-code
ok
→ .claude/agents/doc-summarizer.md (frontmatter: name, description, tools, model)
● build codex
ok
→ .codex/prompts/doc-summarizer.md + nota → AGENTS.md
! 1 nota de adaptación: herramientas con nombre → shell (cat/rg/find)
✓ 2 runtimes emitidos a partir de 1 fuente · contenido idéntico
fuente única · doc-summarizer.md
paridad del núcleo
100%

↑ Recreación ilustrativa del terminal (no es una captura de pantalla real). Entra una fuente; salen dos builds con el mismo contenido y distintas envolturas.

🎯

Ejercicio

Toma un subagente tuyo (o el doc-summarizer.md arriba) y adáptalo para Codex CLI. Entrega dos elementos: el archivo adaptado y una nota de adaptación con lo que cambió y lo que no es portable.

Cómo hacerlo

  1. Extrae lo esencial: separa el rol + los pasos + la salida + los límites; reescribe cualquier nombre de tool como capacidad.
  2. Cambia la cubierta: señala la nueva carpeta (.codex/prompts/), donde va la configuración (AGENTS.md) y cómo invocarlo.
  3. Lista los límites: señala al menos una cosa que no cruza (MCP, modelo del proveedor, enrutamiento automático) y qué hacer en su lugar.

✅ Criterio de verificación — cómo saber si acertaste

Tu entrega cumple si satisface los cuatro señales:

  • →O el núcleo quedó intacto — rol/pasos/salida idénticos en ambos.
  • →A la carcasa cambió — carpeta, configuración e invocación correctas para Codex.
  • →El cuerpo no menciona herramientas por nombre — habla de "leer/buscar", no de Grep.
  • →Existe al menos una nota de adaptación nombrando un límite real.

Si tuviste que reescribir la parte central para Codex, probablemente algo de la capa exterior se filtró al cuerpo; vuelve atrás y aísla.

Ejemplo resuelto (una línea de cada uno)

Núcleo (igual): "you are a precise document summarizer · read → search → 5 bullets + paths". Carcasa (intercambiada): archivo en .codex/prompts/, reglas en el AGENTS.md, invocado por /doc-summarizer. Nota: "model: haiku no existe en Codex: usar el modelo económico/rápido equivalente del proveedor".

✅ Resumen del módulo

✓
Idea > herramienta — el subagente es un patrón (delegar a un contexto aislado), no un recurso de una sola app.
✓
Codex CLI — las mismas piezas con otro nombre: prompt/agente, AGENTS.md en lugar de CLAUDE.md, invocación explícita.
✓
Polyskill — una fuente .md portable → varios builds; corriges en un lugar y sirve para todos.
✓
Equivalencia de tools — Read↔cat, Grep↔rg, Glob↔find; describe la capacidad, no el nombre.
✓
Cambia × no cambia — el principio/núcleo se mantiene firme; la capa exterior (carpeta, campos, activador, tools) es lo que se adapta.
✓
Portar + límites — extraer → cambiar la carcasa → probar la paridad; lo que no se traslada se convierte en una nota de adaptación.

Próximo módulo:

4.3 — Comparar modelos según su función. Opus/Sonnet/Haiku × GPT/Codex × otros proveedores: qué modelo usar para cada función de la flota.