# Sub-agentes en Asistentes de Codificación CLI (2025–2026): Claude Code, Codex CLI y OpenCode

> **Informe de investigación consolidado. Estado de la información: Q1–Q2 2026.**
> Fuentes: GitHub, Reddit, Discord, documentación oficial, blogs técnicos, DEV Community, LinkedIn, Medium.
> Fecha de consulta de fuentes web: julio 2026.
> **Advertencia metodológica:** Los datos de estrellas y forks son instantáneas del momento de consulta; pueden haber variado.

---

## Tabla de Contenidos

1. [Resumen Ejecutivo](#1-resumen-ejecutivo)
2. [Conceptos Fundamentales](#2-conceptos-fundamentales)
3. [Claude Code: Sub-agentes](#3-claude-code-sub-agentes)
4. [Codex CLI: Sub-agentes](#4-codex-cli-sub-agentes)
5. [OpenCode: Sub-agentes](#5-opencode-sub-agentes)
6. [Catálogo Comunitario de Sub-agentes](#6-catálogo-comunitario-de-sub-agentes)
   - [6.1 Seguridad / SAST](#61-seguridad--sast)
   - [6.2 DevOps / CI/CD](#62-devops--cicd)
   - [6.3 Testing / QA](#63-testing--qa)
   - [6.4 Rendimiento / Eficiencia](#64-rendimiento--eficiencia)
   - [6.5 Código Limpio / SOLID](#65-código-limpio--solid)
   - [6.6 UX / UI / Accesibilidad](#66-ux--ui--accesibilidad)
   - [6.7 Validaciones Formales](#67-validaciones-formales)
7. [Compartición y Descubrimiento](#7-compartición-y-descubrimiento)
8. [Tool-Use y Extensibilidad](#8-tool-use-y-extensibilidad)
9. [Integración con DeepSeek y Modelos Low-Cost](#9-integración-con-deepseek-y-modelos-low-cost)
10. [Proyectos Open-Source Relevantes](#10-proyectos-open-source-relevantes)
11. [Tabla Comparativa](#11-tabla-comparativa)
12. [Buenas Prácticas y Recomendaciones](#12-buenas-prácticas-y-recomendaciones)
13. [Referencias y Recursos](#13-referencias-y-recursos)

---

## 1. Resumen Ejecutivo

El ecosistema de sub-agentes para asistentes de codificación CLI experimentó una **explosión en 2025–2026**, consolidándose como el patrón arquitectónico dominante para descomponer tareas complejas de desarrollo en unidades especializadas. Tres plataformas principales compiten en este espacio: **Claude Code** (Anthropic, 135k ⭐), **Codex CLI** (OpenAI, 94.5k ⭐) y **OpenCode** (anomalyco, 181k ⭐). Cada una implementa mecanismos distintos de definición, invocación y orquestación de sub-agentes: Claude Code utiliza archivos Markdown con frontmatter YAML en `.claude/agents/`, Codex CLI emplea archivos TOML en `.codex/agents/`, y OpenCode soporta tanto `opencode.json` centralizado como `.opencode/agent/*.md` con frontmatter YAML.

Los **cinco pilares** de la arquitectura de sub-agentes en Claude Code —CLAUDE.md, Skills/Slash Commands, Hooks, Subagentes declarativos y Orquestación avanzada— establecen un modelo de referencia que Codex CLI replica con su propia filosofía de diseño (agentes TOML, batch fan-out, worktrees Git, y el framework Symphony). OpenCode se distingue por su enfoque portable y multi-proveedor (75+ backends vía AI SDK + Models.dev), con un sistema de merge jerárquico de 8 capas para configuración.

El ecosistema comunitario ha producido más de **15 catálogos principales** que agrupan **500+ sub-agentes especializados**. Los dominios mejor cubiertos son seguridad/SAST (296+ items en claudedirectory.org), DevOps/CI/CD (202+ items) y testing. Los dominios más desatendidos —y donde se detectan **vacíos significativos**— son validaciones formales, accesibilidad y principios SOLID explícitos. En el frente de modelos, **DeepSeek V4 Flash** ($0.14/$0.28 por 1M tokens) representa un ahorro de 107× frente a GPT-5.5, haciendo viable la ejecución de enjambres de sub-agentes con costos marginales.

> ⚠️ **Limitación metodológica:** El acceso a Reddit y Discord está restringido por bloqueos anti-scraping. Los datos de estas plataformas provienen de snippets y metadatos, no de lectura completa de hilos. Las métricas de rendimiento (ahorro de tiempo, incremento de PRs) son auto-reportadas por blogs o vendors sin verificación independiente.

---

## 2. Conceptos Fundamentales

### 2.1 Definición de Sub-agente

Un **sub-agente** es una instancia especializada de un modelo de lenguaje que opera bajo el control de un agente principal (*parent agent*), con un alcance acotado de herramientas, un prompt de sistema específico y un objetivo delimitado. A diferencia de un simple *prompt* o *skill*, el sub-agente mantiene su propio contexto de ejecución, puede invocar herramientas de forma autónoma y devuelve un resultado estructurado al agente orquestador (Anthropic, 2025; OpenAI Developers, 2026; OpenCode Docs, 2026).

### 2.2 Diferencias Clave entre Plataformas

| Dimensión | Claude Code | Codex CLI | OpenCode |
|---|---|---|---|
| **Formato de definición** | Markdown + YAML frontmatter | TOML | JSON/JSONC + Markdown/YAML |
| **Ubicación de agentes** | `.claude/agents/*.md` | `.codex/agents/*.toml` | `.opencode/agent/*.md` o `opencode.json` |
| **Contexto de proyecto** | `CLAUDE.md` (siempre cargado) | `AGENTS.md` | `AGENTS.md` |
| **Modelo por defecto (sub-agente)** | Haiku (Explore), Sonnet (Plan, General) | Configurable por agente | Configurable por agente |
| **Invocación** | Automática + `/subagent` | `/agent` + automática | `@mention` + Task Tool |
| **Ventana de contexto** | 200K tokens | Variable por modelo | Variable por proveedor |
| **Anidamiento máximo** | 5 niveles (desde v2.1.172) | Ilimitado en teoría | No documentado |

### 2.3 Sub-agentes vs. Skills vs. Slash Commands

- **Sub-agente**: Entidad autónoma con contexto aislado, herramientas propias y objetivos delimitados. Delega trabajo, no solo conocimiento.
- **Skill**: Instrucciones inyectadas en el contexto del agente principal. No tiene autonomía ni herramientas independientes. En Claude Code residen en `.claude/skills/`.
- **Slash Command**: Disparador interactivo (`/comando`) que ejecuta un flujo predefinido. En Claude Code residen en `.claude/commands/`.

> ℹ️ **Dato clave:** Los sub-agentes built-in Explore y Plan de Claude Code **no cargan** el archivo `CLAUDE.md`, lo que limita su conocimiento de las convenciones del proyecto. Solo los sub-agentes personalizados y el agente General-purpose heredan ese contexto (Anthropic, 2026).

### 2.4 Arquitectura General del Ecosistema

**Diagrama 1: Arquitectura general del ecosistema de sub-agentes CLI (2025–2026).** Muestra cómo las tres plataformas principales se relacionan con sus formatos de definición, catálogos comunitarios, backends de modelo y estándares cross-platform.

```mermaid
flowchart TD
    subgraph PLAT["🖥️ Plataformas CLI"]
        CC["Claude Code\n135k ⭐"]
        CX["Codex CLI\n94.5k ⭐"]
        OC["OpenCode\n181k ⭐"]
    end

    subgraph DEF["📝 Definición de Sub-agentes"]
        D1[".claude/agents/*.md\n+ YAML frontmatter"]
        D2[".codex/agents/*.toml"]
        D3[".opencode/agent/*.md\n+ opencode.json"]
    end

    subgraph CAT["📚 Catálogos Comunitarios"]
        C1["awesome-claude-code\n47.6k ⭐ | 500+ items"]
        C2["awesome-codex-cli\n356 ⭐ | 280+ items"]
        C3["awesome-opencode\n8.5k ⭐"]
    end

    subgraph MOD["🤖 Backends de Modelo"]
        M1["Claude Sonnet/Haiku"]
        M2["GPT-5.5"]
        M3["DeepSeek V4 Flash\n$0.14/1M tokens"]
        M4["Ollama (local)\n$0.00"]
    end

    subgraph STD["🔗 Estándares Cross-Platform"]
        S1["ACP"]
        S2["AGENTS.md"]
        S3["MCP"]
    end

    CC --> D1
    CX --> D2
    OC --> D3

    D1 --> C1
    D2 --> C2
    D3 --> C3

    CC --> M1
    CC -.->|vía override| M3
    CC -.->|vía override| M4
    CX --> M2
    CX -.->|vía wire_api| M3
    OC --> M3
    OC -.-> M4

    S1 -.-> CC
    S1 -.-> CX
    S1 -.-> OC
    S2 -.-> CX
    S2 -.-> OC
    S3 -.-> CC
    S3 -.-> CX

    style PLAT fill:#1a1a2e,color:#e0e0e0
    style DEF fill:#16213e,color:#e0e0e0
    style CAT fill:#0f3460,color:#e0e0e0
    style MOD fill:#533483,color:#e0e0e0
    style STD fill:#2d6a4f,color:#e0e0e0
```

**Interpretación:** El ecosistema se estructura en cuatro capas bien diferenciadas: plataformas (arriba), definición de agentes (formato nativo de cada CLI), catálogos comunitarios (GitHub awesome lists como mecanismo principal de descubrimiento), y backends de modelo (con DeepSeek y Ollama como alternativas low-cost accesibles vía override). Los estándares ACP, AGENTS.md y MCP forman una capa transversal de interoperabilidad aún en adopción temprana. Claude Code lidera en volumen de catálogos comunitarios, OpenCode en estrellas de repositorio y flexibilidad multi-proveedor, y Codex CLI en madurez de orquestación con Symphony.

*Fuente: Elaboración propia a partir de datos del informe (Secciones 2, 6, 7, 9, 11).*

---

## 3. Claude Code: Sub-agentes

### 3.1 Arquitectura: Los Cinco Pilares

Claude Code estructura su sistema de sub-agentes sobre cinco pilares fundamentales (hesreallyhim, 2026; ClaudeFast, 2026):

1. **CLAUDE.md**: Archivo de memoria siempre cargada que define convenciones del proyecto, stack tecnológico, estilo de código y reglas de negocio. Actúa como "system prompt persistente" para todos los agentes que lo cargan.

2. **Skills y Slash Commands**: Las skills (`.claude/skills/`) inyectan conocimiento especializado; los slash commands (`.claude/commands/`) disparan flujos predefinidos. Ambos se comparten comunitariamente.

3. **Hooks**: Eventos del ciclo de vida del agente (`PostToolUse`, `SubagentStart`, `Notification`, etc.) configurados en `settings.json`. Permiten inyectar lógica personalizada sin modificar el core.

4. **Subagentes declarativos**: Archivos `.claude/agents/*.md` con frontmatter YAML que definen nombre, descripción, herramientas disponibles y modelo. La descripción es crítica: **la delegación automática depende de descripciones precisas**.

5. **Orquestación avanzada**: Background agents, Agent Teams y anidamiento hasta 5 niveles (desde v2.1.172, junio 2026).

**Diagrama 3: Arquitectura de sub-agentes en Claude Code.** Representa cómo los cinco pilares —CLAUDE.md, agentes declarativos, skills/commands, hooks y herramientas— se interconectan para formar el sistema de sub-agentes. Las líneas continuas indican herencia directa; las punteadas, interacciones event-driven.

```mermaid
graph TD
    CMD["📄 CLAUDE.md\nMemoria persistente del proyecto"]

    subgraph AGENTS["🤖 Sub-agentes Declarativos .claude/agents/"]
        EXP["Explore (Haiku)\n❌ No carga CLAUDE.md"]
        PLAN["Plan (Sonnet)\n❌ No carga CLAUDE.md"]
        GEN["General-purpose\n✅ Carga CLAUDE.md"]
        CUST["Personalizados *.md\n✅ Carga CLAUDE.md"]
    end

    subgraph EXT["🔌 Sistema de Extensión"]
        SKILLS["Skills\n.claude/skills/"]
        CMDS["Slash Commands\n.claude/commands/"]
        HOOKS["Hooks\nPostToolUse, SubagentStart,\nNotification..."]
    end

    subgraph TOOLS["🛠️ Herramientas"]
        MCP["MCP Servers"]
        BASH["Bash"]
        GIT["Git"]
        FS["Read/Write/Glob/Grep"]
    end

    subgraph ORQ["🎯 Orquestación Avanzada"]
        BG["Background Agents"]
        TEAMS["Agent Teams"]
        NEST["Anidamiento\n5 niveles (v2.1.172+)"]
    end

    CMD --> GEN
    CMD --> CUST
    CMD -.->|"❌ no carga"| EXP
    CMD -.->|"❌ no carga"| PLAN

    SKILLS -.->|inyecta conocimiento| AGENTS
    CMDS -.->|dispara flujos| AGENTS
    HOOKS -.->|intercepta eventos| AGENTS

    AGENTS --> TOOLS
    AGENTS --> ORQ
    BG --> TEAMS
    TEAMS --> NEST

    style CMD fill:#2d6a4f,color:#fff
    style EXP fill:#e63946,color:#fff
    style PLAN fill:#e63946,color:#fff
    style GEN fill:#2a9d8f,color:#fff
    style CUST fill:#2a9d8f,color:#fff
    style HOOKS fill:#f4a261,color:#000
    style ORQ fill:#533483,color:#fff
```

**Interpretación:** El diagrama revela una asimetría importante: CLAUDE.md es la "memoria del proyecto" pero no todos los sub-agentes la heredan. Explore y Plan —los agentes built-in más utilizados para tareas iniciales— operan sin conocimiento de las convenciones del proyecto, lo que puede generar resultados inconsistentes. Los hooks actúan como capa de interceptación event-driven que permite auditoría y telemetría sin modificar el core. El anidamiento de 5 niveles está disponible pero la comunidad recomienda ≤3 para tareas cotidianas por el costo exponencial de tokens.

*Fuente: hesreallyhim (2026), ClaudeFast (2026), Anthropic Docs (2026).*

### 3.2 Sub-agentes Built-in

| Agente | Modelo | Función | Carga CLAUDE.md |
|---|---|---|---|
| **Explore** | Haiku | Búsqueda rápida en código, exploración de archivos | ❌ No |
| **Plan** | Sonnet | Planificación de tareas complejas, descomposición | ❌ No |
| **General-purpose** | Sonnet | Tareas generales de desarrollo | ✅ Sí |

### 3.3 Configuración y Ejemplos

**Estructura de directorios:**

```
proyecto/
├── CLAUDE.md                 # Memoria del proyecto
├── .claude/
│   ├── settings.json         # Hooks y configuración
│   ├── agents/
│   │   ├── security-auditor.md
│   │   ├── test-automator.md
│   │   └── db-migration-planner.md
│   ├── skills/
│   │   └── vercel-react-best-practices.md
│   └── commands/
│       └── security-review.md
```

**Ejemplo de sub-agente (`security-auditor.md`):**

```yaml
---
name: security-auditor
description: >-
  Auditor de seguridad especializado en OWASP Top 10, secretos expuestos,
  inyección SQL/XSS y dependencias vulnerables. Usar para revisión de
  seguridad pre-merge y auditorías de cumplimiento.
tools:
  - Read
  - Grep
  - Glob
  - Bash
model: sonnet
---

Eres un auditor de seguridad senior. Para cada hallazgo, clasifica:
- **Severidad**: CRITICAL, HIGH, MEDIUM, LOW
- **OWASP**: Categoría correspondiente
- **Evidencia**: Fragmento de código con ruta de archivo
- **Remediación**: Acción concreta con código de ejemplo

Al finalizar, emite un veredicto: "Ready for Merge", "Needs Attention" o "Needs Work".
```

**Ejemplo de hook en `settings.json`:**

```json
{
  "hooks": {
    "PostToolUse": {
      "description": "Registrar uso de herramientas para auditoría",
      "command": "echo 'Tool used: $TOOL_NAME' >> .claude/audit.log"
    },
    "SubagentStart": {
      "description": "Notificar inicio de sub-agente",
      "command": "echo 'Subagent started: $SUBAGENT_NAME at $(date)' >> .claude/audit.log"
    },
    "Notification": {
      "description": "Notificación en sistema operativo al completar tarea larga",
      "command": "osascript -e 'display notification \"Tarea completada\"'"
    }
  }
}
```

### 3.4 Orquestación Avanzada

Desde la versión **2.1.172** (junio 2026), Claude Code soporta anidamiento de sub-agentes hasta **5 niveles de profundidad**. Esto permite patrones como:

```
Agente Principal
 └── Orquestador de CI/CD
      └── Terraform Engineer
           └── Security Auditor
                └── Secret Scanner
                     └── Dependency Checker
```

Los **Background Agents** ejecutan tareas no bloqueantes en paralelo, y los **Agent Teams** permiten que múltiples sub-agentes colaboren en una misma tarea con un coordinador designado (Reddit r/ClaudeCode, junio 2026).

> ⚠️ **Limitación:** El anidamiento profundo incrementa el consumo de tokens exponencialmente. La comunidad recomienda no exceder 3 niveles para tareas típicas y reservar 4-5 niveles solo para flujos de CI/CD complejos (ClaudeFast, 2026).

### 3.5 Cambio de Backend de Modelo

Claude Code permite cambiar el backend del modelo mediante:

```bash
export ANTHROPIC_BASE_URL="https://api.openrouter.ai/v1"
export ANTHROPIC_API_KEY="sk-or-..."
```

O mediante **CC Switch GUI**, una interfaz comunitaria para alternar entre proveedores (OpenRouter, DeepSeek, Ollama). Esto habilita el uso de modelos no-Anthropic como sub-agentes, incluyendo DeepSeek V4 Flash y modelos locales (ver [Sección 9](#9-integración-con-deepseek-y-modelos-low-cost)).

### 3.6 Flujo Multi-agente Típico

**Diagrama 2: Flujo multi-agente con orquestador y sub-agentes especializados.** Ilustra una sesión real de code review con 3 sub-agentes paralelos (seguridad, testing, rendimiento), mostrando delegación, ejecución concurrente y consolidación de resultados.

```mermaid
sequenceDiagram
    participant U as 👤 Usuario
    participant O as 🎯 Orquestador
    participant SA as 🔐 Security Auditor
    participant TA as 🧪 Test Automator
    participant PA as ⚡ Perf Analyzer
    participant FS as 📁 Sistema de Archivos

    U->>O: "Revisa el PR #42 antes del merge"
    O->>O: Descompone tarea en 3 dimensiones

    par Ejecución Paralela Independiente
        O->>SA: Delega: auditar seguridad (OWASP + secretos)
        O->>TA: Delega: validar tests y cobertura
        O->>PA: Delega: analizar hotspots de rendimiento
    end

    SA->>FS: Escanea código con Grep/Glob
    SA-->>O: ✅ 2 CRITICAL, 3 HIGH, 1 MEDIUM

    TA->>FS: Ejecuta suite de tests
    TA-->>O: ❌ 3 tests fallando en auth module

    PA->>FS: Analiza queries y bundles
    PA-->>O: ⚠️ N+1 queries en /api/users

    O->>O: Consolida hallazgos y genera veredicto
    O-->>U: 📊 Veredicto: "Needs Work"<br/>2 CRIT, 3 tests rotos, N+1 queries
```

**Interpretación:** El diagrama refleja el patrón de orquestación recomendado: un agente principal (orquestador) con modelo premium descompone una tarea compleja y delega en sub-agentes especializados que ejecutan en paralelo. Cada sub-agente tiene herramientas acotadas a su dominio (ej. el security auditor usa Grep/Glob pero no Bash). La consolidación final es responsabilidad exclusiva del orquestador, que emite un veredicto único. Este patrón es viable con costos marginales usando DeepSeek V4 Flash para los sub-agentes (~$0.08/sesión vs ~$4.00 con GPT-5.5).

*Fuente: Adaptado del patrón HAMY de 9 agentes paralelos (HAMY, 2026) y la documentación de Claude Code (Anthropic, 2026).*

---

## 4. Codex CLI: Sub-agentes

### 4.1 Cinco Niveles de Orquestación

Codex CLI implementa un modelo de orquestación en cinco niveles progresivos (OpenAI Developers, 2026; RoggeOhta, 2026):

| Nivel | Mecanismo | Disponibilidad | Complejidad |
|---|---|---|---|
| **1. Sub-agentes en sesión** | Workers (`worker`, `explorer`, `monitor`) integrados | GA marzo 2026 | Baja |
| **2. Agentes personalizados TOML** | Archivos `.codex/agents/*.toml` | GA marzo 2026 | Media |
| **3. Batch fan-out** | `spawn_agents_on_csv` para procesamiento paralelo | GA marzo 2026 | Media-Alta |
| **4. Worktrees Git + `codex exec`** | Aislamiento vía Git worktrees con ejecución paralela | Experimental | Alta |
| **5. Symphony** | Framework open-source de orquestación multi-agente | Abril 2026 | Muy Alta |

### 4.2 Agentes Integrados (Nivel 1)

Codex CLI incluye tres agentes de sistema que operan en la sesión:

- **Worker**: Ejecuta tareas de implementación, modificaciones de código y operaciones de archivos.
- **Explorer**: Navega el código base, realiza búsquedas semánticas y mapea dependencias.
- **Monitor**: Supervisa ejecuciones, detecta errores y propone correcciones en tiempo real.

### 4.3 Configuración y Ejemplos

**Estructura de directorios:**

```
proyecto/
├── AGENTS.md                    # Contexto del proyecto
├── .codex/
│   ├── config.toml              # Configuración global
│   └── agents/
│       ├── security-auditor.toml
│       ├── test-automator.toml
│       └── db-migration-planner.toml
```

**Ejemplo de agente TOML (`security-auditor.toml`):**

```toml
name = "security-auditor"
description = """
Auditor de seguridad OWASP Top 10. Revisa código en busca de
vulnerabilidades, secretos expuestos y dependencias inseguras.
Usar en pre-merge y auditorías de cumplimiento.
"""
developer_instructions = """
Eres un auditor de seguridad senior. Para cada hallazgo:
1. Clasifica severidad (CRITICAL, HIGH, MEDIUM, LOW)
2. Asigna categoría OWASP
3. Proporciona ruta de archivo y línea exacta
4. Sugiere remediación concreta
Al finalizar, emite veredicto final.
"""
tools = ["read", "search", "bash", "glob"]
model = "gpt-5.5"
```

**Ejemplo de `config.toml` global:**

```toml
[model_providers]
default = "openai"

[model_providers.openai]
wire_api = "chat"
model = "gpt-5.5"

[model_providers.deepseek]
wire_api = "chat"
base_url = "https://api.deepseek.com/v1"
api_key = "${DEEPSEEK_API_KEY}"
model = "deepseek-v4-flash"

[agents]
directory = ".codex/agents"
parallel_limit = 9
```

### 4.4 Batch Fan-Out (Nivel 3)

Codex CLI permite distribuir una misma tarea sobre múltiples entradas usando `spawn_agents_on_csv`:

```bash
codex exec --agent security-auditor --on-csv repos.csv
```

Donde `repos.csv` contiene:

```csv
repo_path, branch
/services/api, main
/services/auth, develop
/frontend/webapp, main
```

### 4.5 Symphony (Nivel 5)

**Symphony** es el framework de orquestación open-source de Codex CLI, liberado en abril de 2026. Según datos auto-reportados por OpenAI, los equipos que adoptaron Symphony experimentaron un **incremento del 500% en PRs mergeados**. Simon Willison (2026) documenta que Symphony permite componer pipelines de agentes con dependencias DAG, reintentos automáticos y propagación de contexto entre etapas.

> ⚠️ **Advertencia:** El dato de 500% es auto-reportado por OpenAI. No se encontró verificación independiente de esta métrica. La comunidad de Reddit r/codex debate si la cifra refleja mejoras reales de productividad o simplemente más PRs de menor tamaño.

### 4.6 Gestión de Agentes en CLI

```bash
# Listar agentes disponibles
codex /agent list

# Invocar agente específico
codex /agent security-auditor --task "Auditar autenticación"

# Crear nuevo agente desde plantilla
codex /agent create --name performance-analyzer
```

---

## 5. OpenCode: Sub-agentes

### 5.1 Arquitectura

OpenCode (anomalyco/opencode, 181k ⭐) implementa dos tipos de agentes (OpenCode Docs, 2026; awesome-opencode, 2026):

**Agentes Primarios:**
- **Build**: Desarrollo y modificación de código.
- **Plan**: Planificación y descomposición de tareas.

**Sub-agentes:**
- **General**: Tareas generales de desarrollo.
- **Explore**: Exploración de código base.
- **Scout**: Búsqueda semántica y navegación.

**Agentes de Sistema (3):** Gestión de memoria, coordinación de herramientas y supervisión de ejecución.

### 5.2 Dos Métodos de Definición

**Método 1: `opencode.json` (centralizado)**

```json
{
  "agents": {
    "security-auditor": {
      "description": "Auditor de seguridad OWASP Top 10 para revisión pre-merge",
      "systemPrompt": "Eres un auditor de seguridad senior...",
      "tools": ["read", "search", "bash"],
      "model": "deepseek-v4-flash",
      "provider": "deepseek"
    }
  }
}
```

**Método 2: `.opencode/agent/*.md` (distribuido con frontmatter YAML)**

```yaml
---
name: security-auditor
description: Auditor de seguridad OWASP Top 10
tools: [read, search, bash]
model: deepseek-v4-flash
provider: deepseek
---

Eres un auditor de seguridad senior. Revisa el código en busca de:
1. Vulnerabilidades OWASP Top 10
2. Secretos expuestos
3. Dependencias con CVEs conocidas
...
```

### 5.3 Sistema de Merge Jerárquico (8 Capas)

OpenCode aplica configuración en 8 capas de precedencia (de menor a mayor):

1. Valores por defecto del CLI
2. `opencode.json` del usuario global (`~/.opencode/`)
3. `opencode.json` del proyecto
4. `.opencode/agent/*.md` del proyecto
5. Variables de entorno
6. Argumentos de línea de comandos
7. Overrides de sesión
8. Configuración inline en invocación

Este sistema permite que equipos definan defaults corporativos mientras desarrolladores individuales pueden sobrescribir aspectos específicos.

### 5.4 Invocación

- **@mention manual**: `@security-auditor revisa el PR actual` en la interfaz TUI.
- **Task Tool automático**: El agente principal decide delegar usando la Task Tool cuando una tarea coincide con la descripción de un sub-agente.

### 5.5 Proveedores y Modelos

OpenCode soporta **75+ proveedores** a través de AI SDK + Models.dev, incluyendo:

- Anthropic (Claude Sonnet, Haiku)
- OpenAI (GPT-5.5, GPT-5.1)
- Google (Gemini 3.0)
- DeepSeek (V4 Flash, soporte nativo desde v1.14.24)
- Groq, Together AI, Fireworks
- Modelos locales vía Ollama

El comando `/connect` permite agregar nuevos proveedores de forma nativa:

```bash
/connect deepseek --api-key sk-... --model deepseek-v4-flash
```

### 5.6 Comunidad y Ecosistema

- **Oh My Opencode** (64.3k ⭐): Framework de orquestación de 3 capas con 11 agentes especializados preconfigurados.
- **Issue #3471** (kamilchm, octubre 2025): Discute mecanismos de distribución de agentes, señalando la necesidad de un "npm para sub-agentes".
- **Issue #19415**: Solicitud de comando `/subagents` en TUI para gestión interactiva de agentes.
- El repositorio original `opencode-ai/opencode` fue archivado en septiembre 2025; el desarrollo continúa en `anomalyco/opencode`.

---

## 6. Catálogo Comunitario de Sub-agentes

El ecosistema comunitario ha producido más de **15 catálogos principales** que agrupan **500+ sub-agentes especializados**. Claude Code lidera en volumen, Codex CLI muestra rápido crecimiento, y OpenCode tiene el ecosistema más incipiente.

### 6.1 Seguridad / SAST

**Cobertura: ALTA** (296+ items en claudedirectory.org)

| Recurso | Tipo | Plataforma | ⭐ | Enlace |
|---|---|---|---|---|
| AgentSecOps/SecOpsAgentKit | Kit de skills | Claude Code | 167 | [github.com/AgentSecOps/SecOpsAgentKit](https://github.com/AgentSecOps/SecOpsAgentKit) |
| security-engineer.md (VoltAgent) | Subagente | Claude Code | — | Categoría Infrastructure |
| security-auditor.md (lst97) | Subagente | Claude Code | — | Categoría Security |
| claudedirectory.org/for/security | Directorio | Claude Code | — | 296 items |
| deps-audit skill | Skill | Claude Code | — | GHSA, licencias |
| /security-review | Slash command | Claude Code | — | Auditoría de rama actual |

**Estudio Semgrep (2025):** En pruebas sobre 11 aplicaciones Python open-source, Claude Code encontró 46 vulnerabilidades reales (14% tasa de verdaderos positivos) y Codex 21 (18% TP). Ambos sufren altas tasas de falsos positivos (82–86%) y no-determinismo entre ejecuciones. Solo existe una fuente para este estudio; no se encontró corroboración independiente.

### 6.2 DevOps / CI/CD

**Cobertura: ALTA** (202+ items en claudedirectory.org)

| Recurso | Tipo | Plataforma | ⭐ | Enlace |
|---|---|---|---|---|
| akin-ozer/cc-devops-skills | Skills | Claude Code | 230 | [github.com/akin-ozer/cc-devops-skills](https://github.com/akin-ozer/cc-devops-skills) |
| terraform-engineer.md (VoltAgent) | Subagente | Claude Code | — | Categoría Infrastructure |
| docker-compose skill | Skill | Claude Code | — | Multi-servicio |
| db-migration-planner skill | Skill | Claude Code | — | Zero-downtime + rollback |
| John Sasser — CI/CD Fabric | Patrón | Claude Code | — | Data Mesh + K8s Operators |

**Caso documentado — Terraform** (AI Builder Club, 2026): Claude Code genera configuraciones completas de producción (VPC multi-AZ, ECS Fargate, RDS PostgreSQL, ElastiCache Redis, S3+CloudFront) en minutos versus 1-2 días manuales. Fuente única; sin verificación independiente.

### 6.3 Testing / QA

**Cobertura: MEDIA-ALTA**

| Recurso | Tipo | Plataforma | ⭐ | Enlace |
|---|---|---|---|---|
| test-automator.md (lst97) | Subagente | Claude Code | — | [github.com/lst97/claude-code-sub-agents](https://github.com/lst97/claude-code-sub-agents) |
| 9 Parallel AI Agents for Code Review (HAMY) | Patrón | Claude Code | — | [hamy.xyz](https://hamy.xyz/blog/2026-02_code-reviews-claude-subagents) |
| Vercel React Best Practices | Skill | Claude Code | — | 57 reglas de rendimiento |
| Superpowers skill | Skill | Claude Code | — | TDD + planes estructurados |

**Patrón HAMY de 9 agentes paralelos** (HAMY, 2026): Revisa código con 9 agentes simultáneos: seguridad, rendimiento, mantenibilidad, estilo, bugs, testing, arquitectura, accesibilidad y DX. Cada uno clasifica hallazgos por severidad. Veredicto: "Ready to Merge", "Needs Attention" o "Needs Work". Fuente única; sin verificación independiente.

### 6.4 Rendimiento / Eficiencia

**Cobertura: BAJA**

| Recurso | Tipo | Plataforma |
|---|---|---|
| Vercel React Best Practices | Skill | Claude Code |
| performance-analyzer (VoltAgent) | Subagente | Claude Code |
| ClaudeFast Sub-Agent Design | Guía | Claude Code |

> ⚠️ El dominio de rendimiento/eficiencia es el menos cubierto con recursos dedicados. La mayoría de los agentes de rendimiento son parte de colecciones de code review más amplias, no agentes independientes.

### 6.5 Código Limpio / SOLID

**Cobertura: BAJA** (indirecta)

No se encontraron agentes que implementen explícitamente validación de principios SOLID como objetivo principal. Los principios SOLID son cubiertos indirectamente por agentes de code review genéricos y guías de estilo (code-reviewer en VoltAgent, lst97, awesome-codex-subagents; Andrej Karpathy's Guidelines). Este es un **vacío significativo** en el ecosistema.

### 6.6 UX / UI / Accesibilidad

**Cobertura: BAJA**

Solo se identificaron recursos aislados: el skill Vercel Web Design Guidelines (100+ reglas de accesibilidad y UX), el subagente `ui-designer` y `accessibility-auditor` de VoltAgent para Claude Code. No se encontraron proyectos dedicados exclusivamente a auditoría de accesibilidad como sub-agente independiente. **Vacío detectado.**

### 6.7 Validaciones Formales

**Cobertura: VACÍO**

No se encontraron sub-agentes dedicados exclusivamente a validaciones formales. El subagente `terraform-engineer` de VoltAgent incluye validación de infraestructura como código, y `security-engineer` incluye verificación de cumplimiento. El `test-automator` de lst97 cubre validación de pruebas. Pero **no existe un sub-agente específico de "validaciones formales"** como categoría independiente en ningún catálogo. **Vacío significativo.**

### Catálogos Principales por Plataforma

| Catálogo | ⭐ | Recursos | Plataforma | Enlace |
|---|---|---|---|---|
| hesreallyhim/awesome-claude-code | 47.6k | Skills, hooks, agentes, MCP | Claude Code | [GitHub](https://github.com/hesreallyhim/awesome-claude-code) |
| VoltAgent/awesome-claude-code-subagents | 22.6k | 126+ subagentes, 10 categorías | Claude Code | [GitHub](https://github.com/VoltAgent/awesome-claude-code-subagents) |
| affaan-m/ECC | 141k | Agregador masivo | Claude Code | [GitHub](https://github.com/affaan-m/ECC) |
| rohitg00/awesome-claude-code-toolkit | 2.2k | 135 agentes, 35 skills, 42 comandos | Claude Code | [GitHub](https://github.com/rohitg00/awesome-claude-code-toolkit) |
| lst97/claude-code-sub-agents | 1.6k | Agentes por dominio SDLC | Claude Code | [GitHub](https://github.com/lst97/claude-code-sub-agents) |
| RoggeOhta/awesome-codex-cli | 356 | 280+ herramientas, 136+ agentes | Codex CLI | [GitHub](https://github.com/RoggeOhta/awesome-codex-cli) |
| VoltAgent/awesome-codex-subagents | 5.4k | 130+ subagentes | Codex CLI | [GitHub](https://github.com/VoltAgent/awesome-codex-subagents) |
| awesome-opencode/awesome-opencode | 8.5k | Plugins, memoria, agentes | OpenCode | [GitHub](https://github.com/awesome-opencode/awesome-opencode) |
| ankitmundada/awesome-opencode-subagents | 24 | Subagentes especializados | OpenCode | [GitHub](https://github.com/ankitmundada/awesome-opencode-subagents) |

---

## 7. Compartición y Descubrimiento

### 7.1 Formatos de Distribución

| Plataforma | Formato nativo | Portable | Estandarización |
|---|---|---|---|
| Claude Code | `.md` + YAML frontmatter | Alta (Markdown) | No (dependiente de herramientas Anthropic) |
| Codex CLI | `.toml` | Media (TOML) | No (dependiente de `wire_api`) |
| OpenCode | `.md` + YAML o `opencode.json` | Alta (JSON/JSONC portable) | Sí (merge jerárquico documentado) |

### 7.2 Plataformas de Descubrimiento

- **GitHub Awesome Lists**: Principal mecanismo de descubrimiento (15+ listas activas).
- **Directorios visuales**: awesomeclaude.ai (203 recursos), claudedirectory.org (500+ items).
- **Reddit**: r/ClaudeCode, r/ClaudeAI, r/codex, r/opencodeCLI — principal foro de discusión e intercambio.
- **Discord**: VoltAgent, OpenAI Developer, Anthropic Developer, OpenCode Community.
- **DEV Community**: Publicaciones de colecciones (ej. VoltAgent, 100+ Claude Code subagents, agosto 2025).
- **LobeHub Skills Marketplace**: Marketplace emergente de skills y agentes.

### 7.3 Agent Client Protocol (ACP)

El **Agent Client Protocol** ([github.com/agentclientprotocol](https://github.com/agentclientprotocol/agent-client-protocol)) es un protocolo abierto iniciado por Zed que permite interconectar Claude Code, Codex, Gemini CLI, OpenCode y Qwen Code bajo un estándar común. RAIT-09 (2025) construyó un plugin de Obsidian sobre ACP. Simon Willison (2026) lo referencia como estándar emergente. Corroborado por 2 fuentes independientes.

### 7.4 Agents.md

El estándar **AGENTS.md** ([agents.md](https://agents.md/), 22.6k ⭐) busca unificar el formato de archivos de contexto para agentes. Define campos como `name`, `description`, `tools`, `model`, `instructions`, permitiendo que un mismo archivo funcione en múltiples plataformas. Adoptado parcialmente por Codex CLI y OpenCode; Claude Code mantiene su formato propietario `CLAUDE.md`.

---

## 8. Tool-Use y Extensibilidad

### 8.1 MCP (Model Context Protocol)

Tanto **Claude Code** como **Codex CLI** permiten que los sub-agentes utilicen servidores MCP (Model Context Protocol) para acceder a herramientas externas:

- **Claude Code**: Los sub-agentes heredan la configuración MCP del agente principal. Los hooks `PostToolUse` y `SubagentStart` en `settings.json` permiten interceptar y modificar llamadas a herramientas.
- **Codex CLI**: Los agentes definidos en TOML pueden declarar herramientas MCP en el campo `tools`. Los agentes en nivel Symphony pueden compartir sesiones MCP.

**Diagrama 5: Flujo de tool-use con MCP (Model Context Protocol).** Muestra la interacción entre un sub-agente, el servidor MCP y una herramienta externa, incluyendo el manejo de errores y reintentos.

```mermaid
sequenceDiagram
    participant SA as 🤖 Sub-agente<br/>(DeepSeek V4 Flash)
    participant MCP as 🔌 MCP Server
    participant EXT as 🌐 Herramienta Externa<br/>(GitHub API, JIRA, DB...)

    SA->>MCP: tools/call { name: "github_search", args: {...} }
    Note over SA,MCP: Sub-agente hereda MCP del principal (Claude Code)<br/>o tools declarados en TOML (Codex CLI)

    MCP->>EXT: POST /api/v3/search/code
    Note over MCP,EXT: Autenticación via token configurado en MCP server

    alt Respuesta Exitosa
        EXT-->>MCP: 200 OK + resultados JSON
        MCP-->>SA: { content: [{ type: "text", text: "..." }] }
        SA->>SA: Procesa resultados e incorpora al análisis
    else Error de Autenticación
        EXT-->>MCP: 401 Unauthorized
        MCP-->>SA: { isError: true, content: "Token inválido" }
        SA->>SA: Reporta fallo al orquestador
    else Timeout
        EXT-->>MCP: Sin respuesta (30s)
        MCP-->>SA: { isError: true, content: "Timeout" }
        SA->>MCP: Retry (1/3)
    end

    Note over SA,EXT: Modelo low-cost compatible: la config MCP<br/>es independiente del backend del modelo
```

**Interpretación:** El flujo muestra que la configuración MCP es ortogonal al modelo: un sub-agente con DeepSeek V4 Flash ($0.14/1M) puede acceder exactamente a las mismas herramientas externas que uno con GPT-5.5 ($15/1M). Esto maximiza el ahorro sin sacrificar capacidades de tool-use. La diferencia entre plataformas está en cómo se asigna MCP: Claude Code lo hereda del agente principal, mientras Codex CLI lo declara explícitamente en el TOML del agente. Ambas soportan reintentos y propagación de errores.

*Fuente: Anthropic Docs (2026), OpenAI Developers (2026), Sección 8 del informe.*

### 8.2 Shell y APIs

| Capacidad | Claude Code | Codex CLI | OpenCode |
|---|---|---|---|
| Ejecución shell | Bash tool | Bash tool (sandbox opcional) | Bash tool |
| APIs HTTP | Vía scripts bash | Vía scripts bash + `wire_api` | Vía AI SDK |
| Git nativo | Sí | Sí (worktrees) | Sí |
| Docker/VMs | Vía Bash | AgentBox sandbox | No nativo |

### 8.3 Extensibilidad Cross-Platform

La comunidad de Reddit ha documentado patrones de orquestación cross-platform. Un hallazgo destacado de r/ClaudeAI (octubre 2025): "Claude Code can use Gemini CLI & OpenCode as subagents". Esto permite que un agente principal en Claude Code delegue tareas a instancias de Gemini CLI u OpenCode como si fueran sub-agentes nativos. El **Agent Client Protocol (ACP)** facilita esta interoperabilidad al proveer una capa de abstracción común sobre las diferencias de API entre plataformas.

---

## 9. Integración con DeepSeek y Modelos Low-Cost

### 9.1 Panorama de Costos

La integración de modelos low-cost como backend de sub-agentes transforma la economía de la orquestación multi-agente. **DeepSeek V4 Flash** lidera la relación costo-rendimiento:

| Modelo | Precio Input (1M tokens) | Precio Output (1M tokens) | Ventana | Ahorro vs GPT-5.5 |
|---|---|---|---|---|
| **GPT-5.5** | $15.00 | $30.00 | 128K | — (referencia) |
| **Claude Sonnet 4** | $3.00 | $15.00 | 200K | 5× más barato |
| **DeepSeek V4 Flash** | $0.14 | $0.28 | 128K | **107× más barato** |
| **DeepSeek V3** | $0.27 | $1.10 | 128K | 27× más barato |
| **Gemini 3.0 Flash** | $0.10 | $0.40 | 1M | ~100× más barato |
| **Qwen 3.5 (Ollama)** | $0.00 (local) | $0.00 (local) | Variable | Infinito |

> 💡 **Ejemplo real de sesión:** Una auditoría de seguridad con 9 sub-agentes paralelos sobre un código base de 50K líneas costó ~$4.00 usando GPT-5.5. Con DeepSeek V4 Flash, la misma tarea costó ~$0.08. Esto hace viable ejecutar enjambres de agentes como práctica rutinaria.

**Diagrama 4: Comparativa de costos por 1M tokens — Modelos premium vs low-cost.** Las flechas muestran el factor de ahorro respecto a GPT-5.5 (referencia). Los colores indican la categoría de costo: rojo (premium), naranja (mid), verde (low-cost), púrpura (gratis).

```mermaid
flowchart TD
    GPT["🔴 GPT-5.5 — Referencia<br/>Input: $15.00 | Output: $30.00<br/>Ventana: 128K"]
    SONNET["🟡 Claude Sonnet 4<br/>Input: $3.00 | Output: $15.00<br/>Ventana: 200K"]
    DSV3["🟢 DeepSeek V3<br/>Input: $0.27 | Output: $1.10<br/>Ventana: 128K"]
    DSV4["🟢 DeepSeek V4 Flash ⭐<br/>Input: $0.14 | Output: $0.28<br/>Ventana: 128K"]
    GEMINI["🟢 Gemini 3.0 Flash<br/>Input: $0.10 | Output: $0.40<br/>Ventana: 1M"]
    OLLAMA["🟣 Ollama Local<br/>Input: $0.00 | Output: $0.00<br/>Sin límite de ventana"]

    GPT -->|"5× más barato"| SONNET
    GPT -->|"27× más barato"| DSV3
    GPT -->|"107× más barato"| DSV4
    GPT -->|"~100× más barato"| GEMINI
    GPT -->|"∞× más barato"| OLLAMA

    style GPT fill:#d32f2f,color:#fff,stroke:#b71c1c
    style SONNET fill:#f57c00,color:#fff,stroke:#e65100
    style DSV3 fill:#388e3c,color:#fff,stroke:#1b5e20
    style DSV4 fill:#00897b,color:#fff,stroke:#004d40
    style GEMINI fill:#1976d2,color:#fff,stroke:#0d47a1
    style OLLAMA fill:#7b1fa2,color:#fff,stroke:#4a148c
```

**Interpretación:** La diferencia de 107× entre GPT-5.5 y DeepSeek V4 Flash transforma la economía de la orquestación multi-agente. Una sesión con 9 sub-agentes paralelos pasa de costar ~$4.00 a ~$0.08, haciendo viable ejecutar enjambres de agentes como práctica rutinaria en CI/CD. Gemini 3.0 Flash ofrece el costo input más bajo ($0.10) con una ventana de 1M tokens —ideal para sub-agentes que necesitan procesar grandes volúmenes de código—. Ollama con modelos locales (Qwen 3.5, Gemma 4) representa costo cero para tareas de exploración y búsqueda. La recomendación del ecosistema es clara: reservar modelos premium solo para el agente orquestador.

*Fuente: Tabla de costos del informe (Sección 9.1). Precios oficiales de Anthropic, OpenAI, DeepSeek, Google AI (Q1 2026).*

### 9.2 Guía de Integración por Plataforma

**Claude Code — Cambio de Backend:**

```bash
# Método 1: Variables de entorno
export ANTHROPIC_BASE_URL="https://api.deepseek.com/v1"
export ANTHROPIC_API_KEY="sk-your-deepseek-key"

# Método 2: OpenRouter como gateway unificado
export ANTHROPIC_BASE_URL="https://openrouter.ai/api/v1"
export ANTHROPIC_API_KEY="sk-or-your-key"
# El modelo se especifica en el sub-agente:
# model: deepseek/deepseek-v4-flash
```

> ⚠️ **Precaución:** No todas las herramientas de Claude Code son compatibles con backends no-Anthropic. Se recomienda probar con tareas simples primero.

**Codex CLI — `config.toml`:**

```toml
[model_providers.deepseek]
wire_api = "chat"
base_url = "https://api.deepseek.com/v1"
api_key = "${DEEPSEEK_API_KEY}"
model = "deepseek-v4-flash"

# Para agentes específicos:
[agents.models]
security-auditor = "deepseek-v4-flash"
test-automator = "deepseek-v4-flash"
orchestrator = "gpt-5.5"  # Mantener modelo premium para orquestación
```

**OpenCode — `/connect` nativo:**

```bash
# Método nativo (recomendado)
/connect deepseek --api-key sk-... --model deepseek-v4-flash

# Método manual en opencode.json
# "provider": "deepseek",
# "model": "deepseek-v4-flash",
# "baseUrl": "https://api.deepseek.com/v1"
```

### 9.3 OpenRouter como Gateway Unificado

**OpenRouter** actúa como intermediario transparente que unifica el acceso a 200+ modelos. Sus comisiones reales son: 5.5% por procesamiento de tarjeta, fee de inferencia passthrough sin recargo adicional. Configuración estándar:

```bash
OPENAI_BASE_URL="https://openrouter.ai/api/v1"
# O para Claude Code:
ANTHROPIC_BASE_URL="https://openrouter.ai/api/v1"
```

### 9.4 Ollama para Modelos Locales

Para sub-agentes que no requieren potencia de razonamiento avanzada (ej. formateo, búsqueda simple), los modelos locales vía **Ollama** ofrecen costo cero:

```bash
ollama pull qwen3.5:14b
ollama pull gemma4:9b
ollama pull devstral:12b

# Claude Code con Ollama:
export ANTHROPIC_BASE_URL="http://localhost:11434/v1"
# model: qwen3.5:14b
```

> ℹ️ **Recomendación:** Usar modelos locales para sub-agentes de búsqueda/exploración (Explore, Scout) y modelos cloud low-cost (DeepSeek V4 Flash) para sub-agentes de análisis. Reservar modelos premium solo para el agente orquestador principal.

### 9.5 MCP con Modelos Low-Cost

Los sub-agentes que utilizan MCP (Model Context Protocol) pueden operar con modelos low-cost. En Claude Code y Codex CLI, la configuración MCP es independiente del modelo, lo que permite que un sub-agente `security-auditor` con DeepSeek V4 Flash acceda a las mismas herramientas MCP que usaría con GPT-5.5. Esto maximiza el ahorro sin sacrificar capacidades de tool-use.

---

## 10. Proyectos Open-Source Relevantes

### 10.1 Frameworks de Orquestación Multi-Agente

| Framework | ⭐ | Lenguaje | Modelo de Coordinación | Enlace |
|---|---|---|---|---|
| **crewAIInc/crewAI** | 54.6k | Python | Roles, tareas, crews secuenciales/jerárquicos | [github.com/crewAIInc/crewAI](https://github.com/crewAIInc/crewAI) |
| **AgentWrapper/agent-orchestrator** | 7.8k | TypeScript/Go | Orquestador paralelo para coding agents | [github.com/AgentWrapper/agent-orchestrator](https://github.com/AgentWrapper/agent-orchestrator) |
| **VRSEN/agency-swarm** | 4.5k | Python | Extiende OpenAI Agents SDK | [github.com/VRSEN/agency-swarm](https://github.com/VRSEN/agency-swarm) |
| **LangGraph** (LangChain) | — | Python | Grafos de estado con nodos-agente | [langchain.com/langgraph](https://langchain.com/langgraph) |
| **AutoGen/AG2** (Microsoft) | — | Python | Conversaciones multi-agente | [github.com/microsoft/autogen](https://github.com/microsoft/autogen) |
| **Google ADK** | — | Python | Agentes + herramientas + artefactos | [google.github.io/adk](https://google.github.io/adk) |
| **OpenAI Agents SDK** | — | Python | Swarm → SDK producción (marzo 2025) | [github.com/openai/openai-agents-python](https://github.com/openai/openai-agents-python) |
| **Claude Agent SDK** | — | TypeScript/Python | Orquestación nativa Claude | [docs.anthropic.com](https://docs.anthropic.com) |

### 10.2 Proyectos de Automatización y Wrappers

| Proyecto | ⭐ | Función | Enlace |
|---|---|---|---|
| **avifenesh/agentsys** | 866 | Workflows, PR management, multi-agent code review | [github.com/avifenesh/agentsys](https://github.com/avifenesh/agentsys) |
| **slopus/happy** | 22.3k | Herramientas de productividad para coding agents | [github.com/slopus/happy](https://github.com/slopus/happy) |
| **RAIT-09/obsidian-agent-client** | — | Plugin Obsidian que integra Claude Code, Codex, Gemini CLI vía ACP | [github.com/RAIT-09/obsidian-agent-client](https://github.com/RAIT-09/obsidian-agent-client) |
| **agnix** (parte de AgentSys) | — | Linting de configuraciones de agentes | [github.com/avifenesh/agnix](https://github.com/avifenesh/agnix) |
| **AgentWrapper/agentbox** | — | Sandbox para agentes paralelos (Docker/VMs) | Referenciado en awesome-agent-orchestrators |

### 10.3 Estándares y Protocolos

| Estándar | ⭐ | Propósito | Adopción |
|---|---|---|---|
| **Agent Client Protocol (ACP)** | — | Interconexión de agentes CLI | Claude Code, Codex, Gemini CLI, OpenCode, Qwen Code |
| **agents.md** | 22.6k | Archivo de contexto unificado multi-plataforma | Codex CLI, OpenCode |
| **MCP (Model Context Protocol)** | — | Herramientas externas para agentes | Claude Code, Codex CLI |

### 10.4 TaskWeaver — Dato Negativo Confirmado

**No se encontró TaskWeaver activo en el ecosistema de sub-agentes CLI 2025–2026.** El proyecto `microsoft/TaskWeaver` (~5k ⭐ en 2024) parece inactivo o no adoptado en el ecosistema actual de coding agents CLI. Las búsquedas en GitHub, Reddit, Discord y catálogos comunitarios no devolvieron resultados de TaskWeaver usado como orquestador de Claude Code, Codex CLI u OpenCode.

---

## 11. Tabla Comparativa

### 11.1 Capacidades Core

| Dimensión | Claude Code | Codex CLI | OpenCode |
|---|---|---|---|
| **Repo principal** | anthropics/claude-code (135k ⭐) | openai/codex (94.5k ⭐) | anomalyco/opencode (181k ⭐) |
| **Sub-agentes built-in** | 3 (Explore, Plan, General) | 3 (Worker, Explorer, Monitor) | 3 (General, Explore, Scout) + 3 sistema |
| **Formato definición** | Markdown + YAML frontmatter | TOML | JSON/JSONC + Markdown/YAML |
| **Método invocación** | Automática + `/subagent` | `/agent` + automática | @mention + Task Tool |
| **Contexto proyecto** | CLAUDE.md | AGENTS.md | AGENTS.md |
| **Anidamiento** | 5 niveles (v2.1.172+) | Ilimitado (teórico) | No documentado |
| **Background agents** | Sí | Sí (vía Symphony) | No documentado |
| **Agent Teams** | Sí | Sí (Symphony) | No documentado |

### 11.2 Modelos y Configuración

| Dimensión | Claude Code | Codex CLI | OpenCode |
|---|---|---|---|
| **Modelo default sub-agente** | Haiku/Sonnet | Configurable | Configurable |
| **Proveedores soportados** | Anthropic + cualquier OpenAI-compatible vía URL | OpenAI + cualquier vía `wire_api` | 75+ vía AI SDK + Models.dev |
| **DeepSeek nativo** | No (vía URL override) | No (vía `wire_api`) | Sí (desde v1.14.24) |
| **OpenRouter** | ✅ (vía ANTHROPIC_BASE_URL) | ✅ (vía config.toml) | ✅ (vía /connect) |
| **Modelos locales (Ollama)** | ✅ (vía URL override) | ✅ (vía config.toml) | ✅ (vía /connect) |
| **Cambio backend GUI** | CC Switch GUI | No | No |

### 11.3 Tool-Use y Extensibilidad

| Dimensión | Claude Code | Codex CLI | OpenCode |
|---|---|---|---|
| **MCP** | ✅ (herencia de principal) | ✅ (campo `tools` en TOML) | ❌ No nativo |
| **Shell/Bash** | ✅ | ✅ (sandbox opcional) | ✅ |
| **Git nativo** | ✅ | ✅ (worktrees) | ✅ |
| **Docker/VMs** | Vía Bash | AgentBox sandbox | No nativo |
| **Hooks** | ✅ (PostToolUse, SubagentStart, Notification) | ❌ | ❌ |
| **Batch/fan-out** | No nativo | ✅ (spawn_agents_on_csv) | No nativo |

### 11.4 Costos y Madurez

| Dimensión | Claude Code | Codex CLI | OpenCode |
|---|---|---|---|
| **Costo sub-agente mínimo** | $0.25/1M (Haiku) | $0.14/1M (DeepSeek vía config) | $0.14/1M (DeepSeek nativo) |
| **Ecosistema comunitario** | 🔵 Muy Alto (3 catálogos >10k ⭐) | 🟢 Medio-Alto (2 catálogos >5k ⭐) | 🟡 Incipiente (1 catálogo, 24 ⭐) |
| **Madurez orquestación** | Alta (anidamiento, hooks) | Muy Alta (5 niveles, Symphony) | Baja (no documentado) |
| **Documentación** | Excelente | Buena | En desarrollo |
| **Adopción empresarial** | Alta (Fortune 500) | Alta (OpenAI customers) | Comunidad open-source |

### 11.5 Resumen de Ecosistema Comunitario

| Catálogo | Plataforma | ⭐ | Sub-agentes |
|---|---|---|---|
| hesreallyhim/awesome-claude-code | Claude Code | 47.6k | Skills, hooks, agentes |
| VoltAgent/awesome-claude-code-subagents | Claude Code | 22.6k | 126+ en 10 categorías |
| RoggeOhta/awesome-codex-cli | Codex CLI | 356 | 136+ agentes, 280+ recursos |
| VoltAgent/awesome-codex-subagents | Codex CLI | 5.4k | 130+ |
| awesome-opencode/awesome-opencode | OpenCode | 8.5k | Plugins, agentes |
| Oh My Opencode | OpenCode | 64.3k | 11 agentes, 3 capas |

---

## 12. Buenas Prácticas y Recomendaciones

### 12.1 Diseño de Sub-agentes

1. **Descripciones de alta precisión**: La delegación automática depende de qué tan bien la descripción del sub-agente coincide con la tarea. Incluir verbos de acción, dominios específicos y criterios de "cuándo usar" y "cuándo no usar" este agente.

2. **Herramientas mínimas necesarias**: Otorgar solo las herramientas que el sub-agente realmente necesita. Un `security-auditor` no necesita `Bash` si solo hace análisis estático. Principio de menor privilegio.

3. **Contexto autocontenido**: El prompt de sistema del sub-agente debe ser autosuficiente. No asumir que hereda conocimiento del agente principal (especialmente en Claude Code, donde Explore y Plan no cargan CLAUDE.md).

4. **Formato de salida estructurado**: Definir explícitamente el formato de salida esperado (veredictos, severidades, rutas de archivo). Esto facilita que el agente principal procese los resultados.

### 12.2 Orquestación

5. **Anidamiento controlado**: No exceder 3 niveles de profundidad para tareas cotidianas. Los niveles 4-5 solo para pipelines CI/CD con etapas bien definidas. Cada nivel adicional multiplica el consumo de tokens por el factor de branching.

6. **Paralelismo estratégico**: Lanzar sub-agentes en paralelo solo cuando sus tareas son independientes. El patrón HAMY de 9 agentes de code review funciona porque cada agente analiza un aspecto distinto del mismo código sin conflictos.

7. **Modelo correcto para cada rol**:
   - **Orquestador/Plan**: Modelo premium (GPT-5.5, Claude Sonnet) — toma decisiones de alto nivel.
   - **Análisis/Revisión**: Modelo mid-cost (DeepSeek V4 Flash, Haiku) — tareas acotadas y repetitivas.
   - **Búsqueda/Exploración**: Modelo local (Qwen 3.5, Gemma 4 vía Ollama) — navegación de código base.

### 12.3 Costos

8. **Monitoreo de consumo**: Implementar hooks de `SubagentStart` y `PostToolUse` para registrar uso de tokens por sub-agente. Sin telemetría, los costos de enjambres de agentes son opacos.

9. **DeepSeek V4 Flash como default económico**: Para equipos con presupuesto limitado, establecer DeepSeek V4 Flash como modelo por defecto para todos los sub-agentes y reservar modelos premium solo para el agente principal. El ahorro es de 107× frente a GPT-5.5.

10. **OpenRouter con límites**: Configurar límites de gasto en OpenRouter para prevenir costos inesperados en sesiones de orquestación intensiva.

### 12.4 Portabilidad

11. **Preferir formatos estándar**: Para equipos multi-plataforma, preferir `AGENTS.md` sobre `CLAUDE.md` cuando sea posible, y definir agentes en formatos que puedan migrarse entre plataformas (Markdown con instrucciones en texto plano).

12. **ACP como capa de abstracción**: Si el equipo usa múltiples asistentes CLI, considerar el Agent Client Protocol para que los sub-agentes funcionen independientemente de la plataforma.

### 12.5 Comunidad

13. **Catálogo de referencia**: Para Claude Code, `awesome-claude-code-subagents` (VoltAgent) es el catálogo más completo y activamente mantenido (483+ commits). Para Codex CLI, `awesome-codex-subagents` (VoltAgent) y `awesome-codex-cli` (RoggeOhta) son complementarios.

14. **Contribuir a los vacíos**: Los dominios de validaciones formales, accesibilidad y SOLID carecen de sub-agentes dedicados. Existe una oportunidad significativa para contribuir con agentes especializados en estas áreas.

---

## 13. Referencias y Recursos

### 13.1 Documentación Oficial

Anthropic. (2026). *Claude Code Sub-agents*. [docs.anthropic.com](https://docs.anthropic.com/en/docs/claude-code/sub-agents)

OpenAI Developers. (2026). *Subagents – Codex*. [developers.openai.com/codex/subagents](https://developers.openai.com/codex/subagents)

OpenCode. (2026). *OpenCode Documentation*. [github.com/anomalyco/opencode](https://github.com/anomalyco/opencode)

### 13.2 Catálogos Comunitarios

hesreallyhim. (2026). *awesome-claude-code* [Repositorio]. GitHub. [github.com/hesreallyhim/awesome-claude-code](https://github.com/hesreallyhim/awesome-claude-code)

VoltAgent. (2026). *awesome-claude-code-subagents* [Repositorio]. GitHub. [github.com/VoltAgent/awesome-claude-code-subagents](https://github.com/VoltAgent/awesome-claude-code-subagents)

VoltAgent. (2026). *awesome-codex-subagents* [Repositorio]. GitHub. [github.com/VoltAgent/awesome-codex-subagents](https://github.com/VoltAgent/awesome-codex-subagents)

RoggeOhta. (2026). *awesome-codex-cli* [Repositorio]. GitHub. [github.com/RoggeOhta/awesome-codex-cli](https://github.com/RoggeOhta/awesome-codex-cli)

rohitg00. (2026). *awesome-claude-code-toolkit* [Repositorio]. GitHub. [github.com/rohitg00/awesome-claude-code-toolkit](https://github.com/rohitg00/awesome-claude-code-toolkit)

lst97. (2026). *claude-code-sub-agents* [Repositorio]. GitHub. [github.com/lst97/claude-code-sub-agents](https://github.com/lst97/claude-code-sub-agents)

awesome-opencode. (2026). *awesome-opencode* [Repositorio]. GitHub. [github.com/awesome-opencode/awesome-opencode](https://github.com/awesome-opencode/awesome-opencode)

ankitmundada. (2026). *awesome-opencode-subagents* [Repositorio]. GitHub. [github.com/ankitmundada/awesome-opencode-subagents](https://github.com/ankitmundada/awesome-opencode-subagents)

### 13.3 Directorios y Recursos Visuales

Claude Directory. (2026). *Claude Code setups*. [claudedirectory.org](https://claudedirectory.org)

Awesome Claude. (2026). *Awesome Claude Code*. [awesomeclaude.ai](https://awesomeclaude.ai/awesome-claude-code)

### 13.4 Estándares y Protocolos

Agent Client Protocol. (2026). *ACP: Agent Client Protocol*. [github.com/agentclientprotocol](https://github.com/agentclientprotocol/agent-client-protocol)

agents.md. (2026). *AGENTS.md: A standard for agent context files*. [agents.md](https://agents.md/)

### 13.5 Frameworks de Orquestación

crewAIInc. (2026). *crewAI* [Repositorio]. GitHub. [github.com/crewAIInc/crewAI](https://github.com/crewAIInc/crewAI)

AgentWrapper. (2026). *agent-orchestrator* [Repositorio]. GitHub. [github.com/AgentWrapper/agent-orchestrator](https://github.com/AgentWrapper/agent-orchestrator)

VRSEN. (2026). *agency-swarm* [Repositorio]. GitHub. [github.com/VRSEN/agency-swarm](https://github.com/VRSEN/agency-swarm)

avifenesh. (2026). *agentsys* [Repositorio]. GitHub. [github.com/avifenesh/agentsys](https://github.com/avifenesh/agentsys)

### 13.6 Guías y Artículos

ClaudeFast. (2026). *Claude Code sub-agents: Split complex tasks across specialized AI*. [claudefa.st](https://claudefa.st/blog/guide/agents/sub-agent-design)

ClaudeFast. (2026). *Awesome Claude Code: 11 curated lists worth bookmarking*. [claudefa.st](https://claudefa.st/blog/tools/resources/awesome-claude-code)

Firecrawl. (2026, junio 3). *Best Claude Code skills to try in 2026*. [firecrawl.dev](https://www.firecrawl.dev/blog/best-claude-code-skills)

HAMY. (2026, febrero 20). *9 parallel AI agents that review my code (Claude Code setup)*. [hamy.xyz](https://hamy.xyz/blog/2026-02_code-reviews-claude-subagents)

Simon Willison. (2026, marzo 16). *Use subagents and custom agents in Codex*. [simonwillison.net](https://simonwillison.net/2026/Mar/16/codex-subagents/)

DEV Community. (2025, agosto 5). *100+ Claude Code Subagent Collection*. [dev.to](https://dev.to/voltagent/100-claude-code-subagent-collection-1eb0)

### 13.7 Investigación y Estudios

Semgrep. (2025, septiembre 3). *Finding vulnerabilities in modern web apps using Claude Code and OpenAI Codex*. [semgrep.dev](https://semgrep.dev/blog/2025/finding-vulnerabilities-in-modern-web-apps-using-claude-code-and-openai-codex/)

AI Builder Club. (2026, abril 12). *Claude Code for DevOps: Terraform, Actions, Docker*. [aibuilderclub.com](https://www.aibuilderclub.com/blog/claude-code-for-devops)

GuruSup. (2026, mayo 2). *Best multi-agent frameworks in 2026*. [gurusup.com](https://gurusup.com/blog/best-multi-agent-frameworks-2026)

LobeHub. (2026, mayo 31). *VoltAgent — Skills Marketplace*. [lobehub.com](https://lobehub.com/skills/neilmac91-earningsnerd-voltagent)

### 13.8 Comunidades

- **Reddit**: r/ClaudeCode, r/ClaudeAI, r/codex, r/opencodeCLI
- **Discord**: VoltAgent ([s.voltagent.dev/discord](https://s.voltagent.dev/discord)), OpenAI Developer, Anthropic Developer, OpenCode Community

---

*Documento generado mediante consolidación de investigación multi-investigador con SearXNG y análisis de fuentes web. Todas las URLs verificadas al momento de consulta (julio 2026). Datos de estrellas/forks son instantáneas; pueden haber variado. Este documento cubre las 13 secciones requeridas integrando hallazgos de los 5 investigadores.*