Frameworks agénticos para Claude Code

Superpowers, gentle-ai, BMAD, GSD, nWave y más — comparativa completa 2026

“La IA es una herramienta. El humano dirige. La pregunta ya no es ‘qué framework uso’, sino ‘qué combinación encaja con mi contexto’.”

⚠️ Importante: las 2 familias de frameworks agénticos

Antes de entrar en materia, una aclaración que ahorra confusión:

El término “framework agéntico” se usa para dos categorías completamente diferentes:

🅰️ Familia A — Frameworks para CONSTRUIR agentes IA (librerías)

Librerías Python/TypeScript que importas en tu código para construir tus propios agentes como producto (chatbots, asistentes autónomos, pipelines RAG, sistemas multi-agente).

Ejemplos: CrewAI, LangGraph, AutoGen, Pydantic AI, Mastra, Agno, LlamaIndex, Semantic Kernel.

Usuario objetivo: developer que construye un producto con IA.

👉 Comparativa de frameworks para construir agentes IA (CrewAI, LangGraph, AutoGen…) ← este es el artículo hermano

🅱️ Familia B — Frameworks para GUIAR tu asistente de coding (este artículo)

Plugins, skills, scripts o metodologías que estructuran cómo tu asistente de IA (Claude Code, Cursor, Codex, OpenCode) te ayuda a programar.

Ejemplos: Superpowers, gentle-ai, BMAD, GSD, nWave, Archon, Spec-Kit, Ralph loop.

Usuario objetivo: developer que quiere escribir código más rápido usando IA.

Este artículo se centra exclusivamente en la Familia B.

brew install gentle-ai

Tabla maestra: los 10 frameworks en una vista

Marco conceptual: los dos ejes

Todos los frameworks se distribuyen en un plano con dos ejes ortogonales:

Eje 1: Autonomía vs Supervisión

• Autonomía total (AFK): el agente corre solo, sin intervención humana entre pasos. Ejemplo: Ralph loop.
• Supervisión total: el humano aprueba cada fase antes de avanzar. Ejemplo: nWave.
• Intermedio: gates configurables, aprobaciones opcionales.

Eje 2: Individual vs Enterprise

• Solo developer: sin ceremonia, sin sprint planning, sin stakeholders. Ejemplo: GSD.
• Enterprise: personas (PM, Architect, UX), procesos formales. Ejemplo: BMAD.

El mapa resultante

                     AUTONOMÍA TOTAL (AFK)
                            ↑
                            │
         Ralph ●            │            ● Rita Vrataski
                            │
                            │            ● Claude-Flow
                            │
                            │    ● GSD      ● Superpowers
   ←────────────────────────┼────────────────────────→
   INDIVIDUAL               │              ENTERPRISE
                            │
                     Archon ●
                            │    ● BMAD
                            │
                     nWave  ●    ● Spec-Kit
                            │
                            ↓
                    SUPERVISIÓN TOTAL

gentle-ai no aparece en el mapa porque no compite en él — es la capa que envuelve a los demás.

Matriz comparativa consolidada

Por características técnicas

Por tiempo de aprendizaje

Por coste aproximado

gentle-ai

“This is NOT an AI agent installer. This is an ecosystem configurator.”
— README oficial

Qué es

El ecosystem configurator de Alan Buscaglia (Gentleman-Programming). Toma cualquier agente de IA y lo transforma en una estación de trabajo SDD completa con memoria persistente, skills curadas, MCP preconfigurado y per-phase model routing.

Filosofía

No compite con los demás frameworks. Los envuelve y los hace compatibles. Con gentle-ai instalas la base común (Engram, SDD, skills, MCP) y luego añades encima el motor de ejecución que te encaje (GSD, Archon, Ralph…) según la tarea.

10 agentes soportados

v1.21.0 (release más reciente)

• Kimi como agente de primera clase
• OpenCode external profile sync
• Fix de Antigravity setup slug
• Fix en preflight de Kimi (uv dependency)
• Docs de Qwen Code añadidos

Casos de uso ideales

• Developers profesionales que usan múltiples agentes (Claude Code + OpenCode + Cursor)
• Cuando quieres memoria persistente REAL sin configurar MCP manualmente
• Proyectos medios/largos donde la continuidad entre sesiones importa
• Cuando quieres ahorro de costes vía per-phase model routing

Tiempo de aprendizaje

• Instalación y uso básico: 30 minutos
• Dominar SDD workflow: 1-3 días
• Aprovechar per-phase profiles + Engram + skills: 1 semana

Recursos

• 📦 Repositorio: github.com/Gentleman-Programming/gentle-ai
• 🎥 YouTube: @GentlemanProgramming
• 👤 Autor: Alan Buscaglia (Angular GDE)

GSD (Get Shit Done)

Qué es

Sistema de meta-prompting, context engineering y spec-driven development para Claude Code que funciona en 14+ agentes diferentes (Claude Code, OpenCode, Gemini CLI, Codex, Copilot, Cursor, Windsurf, Antigravity, Augment, Trae, Qwen Code, CodeBuddy, Cline).

Creado por TÂCHES. El framework más estrellado del ecosistema (54.500 ⭐).

Filosofía

El autor lo resume sin filtros:

“Soy solo dev. No escribo código — Claude Code lo hace. Otras herramientas spec-driven existen: BMAD, Speckit… pero todas complican las cosas mucho más de lo necesario. No soy una empresa de 50 personas. No quiero jugar enterprise theater.”

Es anti-ceremonia por diseño.

Cómo funciona

1. Instalas con npx get-shit-done-cc@latest
2. Genera una carpeta .planning/ con XML prompt formatting
3. Subagent orchestration automática
4. Quality gates integrados: schema drift detection, security enforcement, scope reduction detection
5. Comandos: /gsd-new-project, /gsd-map-codebase, /gsd-spike, /gsd-sketch, /gsd-help

Casos de uso ideales

• Solo developers que quieren velocidad sin ceremonia
• Equipos pequeños (1-5 personas)
• MVPs y proyectos greenfield donde mandas tú
• Cuando trabajas con varios agentes y quieres consistencia

Casos donde NO usarlo

• Empresas grandes con procesos formales
• Equipos que necesitan trazabilidad enterprise (Jira, sprint planning)
• Entornos regulados donde cada decisión requiere approval humano

Tiempo de aprendizaje

2-4 horas para ser productivo. La instalación es 1 comando.

Tradeoff principal

Tiene un token crypto asociado ($GSD en Solana). Para algunos es red flag, aunque técnicamente no afecta al uso.

Recursos

• 📦 Repositorio: github.com/gsd-build/get-shit-done
• 💬 Discord: comunidad oficial en el repo
• 🐦 X/Twitter: @gsd_foundation

BMAD-METHOD

Qué es

Breakthrough Method for Agile AI-Driven Development. Framework enterprise que trata a la IA como colaborador experto, no como automatizador. Ciclo completo de desarrollo con personas especializadas.

Filosofía

“Partnership over automation. Trae tu mejor pensamiento en asociación con IA.”

Cómo funciona

Pipeline clásico con fases:

1. Brainstorming & Analysis
2. Planning (PM persona)
3. Architecture (Architect persona)
4. Implementation (Developer persona)
5. Deployment

Con “Party Mode” multi-perspective donde varias personas debaten decisiones.

12+ personas

PM, Architect, Developer, UX, QA, DevOps, Business Analyst, Scrum Master, Product Owner… Módulos especializados: BMGD (game dev), TEA (test strategy), CIS (innovation).

Casos de uso ideales

• Empresas 10+ personas
• Proyectos enterprise con stakeholders múltiples
• Sistemas complejos con arquitectura regulada
• Equipos que ya trabajan con Agile/Scrum

Casos donde NO usarlo

• Solo developers (exceso de ceremonia)
• MVPs rápidos
• Proyectos velocidad > estructura

Tiempo de aprendizaje

3-7 días para dominar las 12+ personas.

Tradeoff principal

Setup pesado: Node.js + Python + uv + módulos.

Recursos

• 📦 Repositorio: github.com/bmad-code-org/BMAD-METHOD
• 💬 Discord: comunidad activa enlazada desde el repo

Claude-Flow / SPARC

Qué es

Orquestador de multi-agentes distribuidos para Claude. Múltiples agentes que se hablan entre sí coordinados como un swarm, con MCP server nativo y RAG integrado.

Filosofía

Enfoque enterprise-grade de coordinación distribuida.

Cómo funciona

• Arquitectura multi-agente distribuida
• MCP (Model Context Protocol) como backbone
• RAG pipelines built-in
• Integración con HuggingFace
• Workflows autónomos coordinados

Casos de uso ideales

• Sistemas multi-agente serios
• Pipelines RAG complejos
• Orquestación distribuida a escala
• Integraciones HuggingFace

Casos donde NO usarlo

• Proyectos individuales
• Cuando no necesitas varios agentes coordinados
• Si no has usado MCP antes

Tiempo de aprendizaje

1-2 semanas. Sistemas distribuidos son sistemas distribuidos.

Tradeoff principal

Documentación menos pulida. Requiere conocimientos de sistemas distribuidos.

Recursos

• 📦 Repositorio: github.com/ruvnet/claude-flow
• 🌐 Sitio oficial: Cognitum.One

Archon

Qué es

“El primer harness builder open-source para AI coding.” Workflows deterministas mediante YAML DAGs. La inspiración declarada: Dockerfile pero para IA.

Creado por Cole Medin, uno de los YouTubers más seguidos en el nicho de AI coding.

Filosofía

Reproducibilidad sobre improvisación. Un workflow bien definido en YAML debería producir el mismo resultado dos veces.

Cómo funciona

• Defines un DAG en YAML
• Nodos pueden ser: IA-powered, deterministas (bash, git), loops condicionales, human approval gates
• Cada ejecución se aísla en su propio git worktree
• Self-iteration, smart routing, multi-agent review paralelo

Casos de uso ideales

• Workflows repetibles: PR reviews, issue fixing, refactoring
• Equipos que valoran reproducibilidad
• Integración profunda con GitHub
• Cuando quieres gates SOLO en puntos críticos

Casos donde NO usarlo

• Exploración pura / prototipado rápido
• Cuando no sabes aún qué workflow necesitas

Tiempo de aprendizaje

4-8 horas. YAML es sencillo pero modelar bien tu DAG la primera vez lleva tiempo.

Tradeoff principal

Nuevo (menos historial en producción). Principalmente enfocado en flujos GitHub.

Recursos

• 📦 Repositorio: github.com/coleam00/Archon
• 🎥 Canal de YouTube: @ColeMedin — uno de los mejores canales sobre AI coding en inglés

Spec-Kit

Qué es

Framework oficial de GitHub que invierte el paradigma tradicional: las especificaciones se vuelven ejecutables. La spec no es documentación que acompaña al código, es el artefacto primario que genera implementaciones.

Filosofía

Intent-driven development. El desarrollador expresa intención → la spec captura esa intención formalmente → el agente implementa contra la spec.

Cómo funciona

Seis fases secuenciales:

1. Constitution — principios inmutables
2. Specify — qué se quiere construir
3. Clarify — resolución de ambigüedades
4. Plan — cómo abordarlo
5. Tasks — breakdown granular
6. Implement — ejecución con 30+ agentes

Casos de uso ideales

• Equipos que ya trabajan con RFCs / ADRs
• Proyectos donde la claridad de intención > velocidad
• Sistemas donde la spec es contrato (APIs, sistemas críticos)
• Cuando quieres agnosticismo de tech stack

Casos donde NO usarlo

• MVPs rápidos
• Equipos sin cultura de documentación formal
• Exploración pura

Tiempo de aprendizaje

4-8 horas para la metodología. Más si el equipo no tiene cultura de specs.

Tradeoff principal

Más overhead que Ralph/GSD. Requiere disciplina de especificación.

Recursos

• 📦 Repositorio: github.com/github/spec-kit
• 📚 Documentación oficial: github.github.com/spec-kit

nWave

Qué es

Framework con 40 agentes especializados que divide el desarrollo en 7 “olas” (waves) con gates humanos obligatorios entre cada una.

Filosofía

“La máquina nunca corre sin supervisión end-to-end.”

Las 7 olas

1. DISCOVER — entender el problema
2. DIVERGE — explorar opciones
3. DISCUSS — debatir tradeoffs
4. DESIGN — diseño técnico
5. DEVOPS — infra/deployment
6. DISTILL — refinamiento + TDD + mutation testing
7. DELIVER — entrega de código

Entry points flexibles: greenfield arranca en DISCOVER, bugfix salta a DISTILL.

Rigor profiles ajustables

• lean — mínimo viable
• standard — default
• thorough — proyectos serios
• exhaustive — sistemas críticos

Casos de uso ideales

• Decisiones arquitectónicas donde equivocarse cuesta 3 meses
• Sistemas críticos / regulados (fintech, salud, legal)
• Proyectos donde la supervisión ES el valor
• Equipos que priorizan calidad sobre velocidad

Casos donde NO usarlo

• Jamás para AFK — no tiene modo autónomo por diseño
• MVPs rápidos
• Exploración libre

Tiempo de aprendizaje

1-2 días para las 7 waves. La curva real está en los rigor profiles.

Tradeoff principal

Cero AFK. Es consciente y filosófico, no un bug. Coste: tiempo humano en cada gate.

Recursos

• 📦 Repositorio: github.com/nWave-ai/nWave

Rita Vrataski Loop

Qué es

No es un framework — es un patrón. 80 líneas de bash que resuelven un problema específico: AFK controlado por governance externa (Linear).

El nombre viene del personaje de Edge of Tomorrow: loopea pero mantiene memoria.

Filosofía

En lugar de que un while true ciego decida qué hacer (Ralph), Linear decide. El PM o tú mismo pre-autorizas trabajo metiendo issues en “To Do”, y el bucle los come.

Cómo funciona

while true; do
  ISSUE=$(linear issues list --assignee me --state "To Do" --limit 1)
  [ -z "$ISSUE" ] && sleep 60 && continue

  linear issues update "$ISSUE" --state "In Progress"
  linear tasks export "$ISSUE" "$SESSION_DIR"

  while has_pending_tasks; do sleep 10; done

  inject_create_pr_task
  while pr_task_pending; do sleep 10; done

  linear issues update "$ISSUE" --state "Done"
done

Casos de uso ideales

• Equipos que ya viven en Linear
• AFK con salvaguardas humanas (el humano decide qué entra en To Do)
• Backlog triage automatizado
• Implementación autónoma de PRDs

Casos donde NO usarlo

• Si no usas Linear
• Cuando necesitas supervisión dentro de la ejecución
• Proyectos donde los issues no están bien definidos

Tiempo de aprendizaje

1 hora. Es literalmente un script bash.

Tradeoff principal

Requiere disciplina de PM. Issues mal definidos → basura con eficiencia.

Recursos

• 📦 Repositorio: github.com/joa23/linear-cli (script en scripts/vrataski-loop.sh)

Superpowers

Qué es

El framework agéntico más estrellado del ecosistema con 158.000 ⭐ — y disponible en el marketplace oficial de Claude Code de Anthropic. Creado por Jesse Vincent (@obra), es una metodología completa de desarrollo software construida sobre skills composables que se activan automáticamente en tu agente.

No confundir con el intento homónimo de otros autores. Este es el Superpowers real, el que está en la marketplace oficial.

Filosofía

“It doesn’t just jump into trying to write code. Instead, it steps back and asks you what you’re really trying to do.”

No salta al código. Primero saca la spec de la conversación, te la enseña en trozos digeribles, y solo después de tu sign-off genera un plan de implementación claro. El agente se convierte en un orquestador que lanza subagentes por tarea mientras tú supervisas.

Cómo funciona

1. Spec extraction — conversación dirigida hasta que la spec está clara
2. Design approval — te muestra la spec en chunks cortos para aprobar
3. Implementation plan — plan tan claro que un “junior engineer entusiasta sin juicio ni context” podría seguirlo
4. Subagent-driven development — lanza subagentes que trabajan tarea por tarea
5. Autonomous runs — según el autor, “Claude puede trabajar autónomamente durante un par de horas sin desviarse del plan”

Principios fundamentales

• TDD estricto — red/green/refactor real, no decorativo
• YAGNI — You Aren’t Gonna Need It
• DRY — Don’t Repeat Yourself
• Composable skills — se activan automáticamente según contexto

Agentes soportados

Disponible vía plugin marketplace en:

• Claude Code (marketplace oficial de Anthropic y marketplace propio)
• OpenAI Codex CLI y Codex App
• Cursor (Plugin Marketplace)
• OpenCode
• GitHub Copilot CLI

Instalación

# Claude Code (marketplace oficial)
/plugin install superpowers@claude-plugins-official

# Cursor
/add-plugin superpowers

Casos de uso ideales

• Cualquier developer usando Claude Code en serio — al estar en la marketplace oficial, es la opción por defecto con más adopción
• Proyectos con TDD estricto como requerimiento
• Cuando quieres runs autónomos de horas sin perder control
• Equipos que valoran YAGNI/DRY como principios reales
• Cross-agent: si usas varios (Claude + Codex + Cursor), es compatible con todos

Casos donde NO usarlo

• Si prefieres AFK puro sin sign-off previo (usa Ralph)
• Si tu filosofía es “cero ceremonia” total (usa Ralph o Rita Vrataski)
• Proyectos donde no vas a escribir tests (el framework te obliga)

Tiempo de aprendizaje

1-2 días para el flujo completo. Pero al activarse automáticamente, eres productivo desde minuto uno — el resto es aprender a confiar en el proceso.

Tradeoff principal

Es opinionado. Te obliga a pasar por el design/spec antes de tocar código. Si tu estilo es “código primero, diseño después”, vas a chocar con el framework. Si estás alineado con TDD y spec-first, es el ganador claro.

Recursos

• 📦 Repositorio: github.com/obra/superpowers
• 🏪 Marketplace oficial Claude Code: claude.com/plugins/superpowers
• 👤 Autor: Jesse Vincent (@obra)

Ralph loop (el patrón original)

Qué es

El patrón original que inició todo el ecosistema. Literalmente:

while :; do
  cat PROMPT.md | claude-code
done

Un prompt fijo se alimenta en bucle infinito. Cada iteración usa ventana de contexto fresca (clave). El agente selecciona tarea, la implementa, reinicia.

Creado por Geoffrey Huntley y reconocido por Thoughtworks Technology Radar en el ring ASSESS. No es un repositorio — es una técnica. Existen múltiples implementaciones open-source con diferente nivel de adopción.

Implementaciones populares de Ralph loop

Matt Pocock y la evangelización de Ralph

Matt Pocock (conocido educador de TypeScript, con millones de visualizaciones en YouTube y Twitter) ha sido uno de los principales evangelizadores de la técnica Ralph en workshops y streams. Tiene repositorios públicos con el material de sus workshops:

• 📦 github.com/mattpocock/ralph-workshop-repo-001
• 📦 github.com/mattpocock/ralph-workshop-repo-002

Estos son material didáctico, no frameworks en sí. Muestran cómo Matt aplica la técnica Ralph en su flujo real de desarrollo. Si quieres aprender Ralph con un enfoque práctico guiado, sus workshops son la mejor entrada.

Filosofía

“Una cosa por iteración. Fe en la consistencia eventual.”

Por qué funciona (según Huntley)

• Contexto fresco en cada iteración evita context rot
• El agente se auto-corrige documentando bugs
• Usa subagentes para operaciones costosas (~170k tokens por iteración)
• Convergencia gradual hacia la spec

Historia notable

Huntley reportó haber entregado un contrato cliente de $50.000 usando Ralph loop con coste real en tokens de $297. Ese ratio cost-displacement es lo que encendió el hype.

Veredicto de Thoughtworks

Ring: ASSESS — explora con cuidado.

Ventajas: - Simplicidad radical vs swarms coordinados - Prevención de context rot - Convergencia gradual

Tradeoff destacado: - 💸 Coste de tokens extraordinario (explícito en el Radar)

Casos de uso ideales

• Proyectos greenfield (~90% completion reportado)
• Creación de lenguajes / compiladores
• MVPs cost-displaced
• Cuando tienes senior engineering guidance

Casos donde NO usarlo

• Codebases establecidos (el autor lo dice explícitamente)
• Cuando necesitas outcomes deterministas
• Sistemas críticos
• Cuando el coste de tokens importa (producción a escala)

Tiempo de aprendizaje

30 minutos para el script. Semanas para tunear bien el PROMPT.md.

Tradeoff principal

Outcomes no deterministas + coste de tokens brutal.

Recursos

• 📝 Artículo original de Geoffrey Huntley: ghuntley.com/ralph
• 📡 Thoughtworks Technology Radar: thoughtworks.com/radar/techniques/ralph-loop

Recomendaciones por perfil

“Soy solo dev, quiero resultados sin ceremonia”

Ganador: GSD
Alternativa más simple: Ralph directo (si sabes tunear prompts).

“Tengo equipo pequeño con Linear, quiero AFK con salvaguardas”

Ganador: Rita Vrataski pattern

“Proyecto enterprise con arquitectura crítica”

Ganador: BMAD (comunidad + personas)
Alternativa: nWave (si pesa el rigor de gates)

“Quiero orquestar múltiples agentes en paralelo con MCP”

Ganador: Claude-Flow / SPARC

“Ya trabajamos con specs / RFCs / ADRs”

Ganador: Spec-Kit (oficial GitHub)

“Quiero workflows deterministas con gates configurables”

Ganador: Archon

“Soy dev profesional que usa varios agentes”

Ganador: gentle-ai como base + uno de los anteriores encima según tarea.

“Quiero TDD forzoso”

Ganador claro: Superpowers (RED-GREEN-REFACTOR + YAGNI + DRY como principios no negociables, y al estar en marketplace oficial es plug-and-play). Alternativa: nWave (fase DISTILL) si necesitas también gates obligatorios en diseño.

“Soy dev que usa Claude Code y quiero LA opción por defecto bien probada”

Ganador: Superpowers
Con 158.000 ⭐ y presencia en el marketplace oficial de Anthropic, es la opción con mayor validación del mercado. Instalar y funciona.

“Quiero experimentar con el cutting edge”

Ganador: Ralph vanilla (con caveat de Thoughtworks sobre tokens)

Stacks ganadores (combinaciones reales)

Pocos developers usan UN solo framework. Las combinaciones más potentes:

Stack “Solo dev serio”

gentle-ai (base: memoria + SDD + skills + per-phase models)
   ↓
GSD (motor de ejecución día a día)
   ↓
nWave (solo para features críticas arquitectónicas)

Aprendizaje total: ~2 semanas.

Stack “Equipo en Linear”

gentle-ai (base)
   ↓
Rita Vrataski pattern (AFK gobernado por Linear)
   ↓
Spec-Kit (features donde la spec es contrato)

Aprendizaje total: ~2 semanas.

Stack “Enterprise serio”

BMAD (personas y ceremonia estructurada)
   ↓
Archon (workflows deterministas en YAML)
   ↓
Claude-Flow (orquestación multi-agente)

Aprendizaje total: ~2 meses.

Stack “Experimentador / Investigador”

Ralph vanilla (loop puro)
   ↓
Adaptaciones custom de PROMPT.md

Aprendizaje total: días-semanas.

Los gaps de gentle-ai frente a otros (análisis honesto)

Gentle-ai es un meta-layer excelente, pero hay cosas que no cubre y que otros frameworks sí. Esta es la parte honesta:

No tiene AFK loop nativo → Ralph o Rita Vrataski

Si quieres que el agente vaya comiendo backlog sin supervisión humana, gentle-ai no te lo da. Su filosofía es SDD con revisión entre fases.

No tiene swarm multi-agente distribuido → Claude-Flow

Gentle-ai orquesta UN agente a la vez. Para swarms distribuidos con MCP, Claude-Flow sigue siendo la referencia.

No tiene workflows YAML deterministas → Archon

No puedes declarar pipelines reproducibles en YAML. Archon sí.

No tiene 12+ personas enterprise → BMAD

SDD es lean. No modela PM, UX, Scrum Master como roles con contexto propio.

No tiene spec-executable inversion → Spec-Kit

En gentle-ai el código sigue siendo el output. En Spec-Kit la spec ES el output que genera código.

No tiene el volumen de community de GSD/BMAD

2.131 estrellas vs 54.500 (GSD) o 45.000 (BMAD).

No tiene quality gates tan específicos como GSD

GSD trae schema drift detection, security anchoring a threat models, scope reduction detection de serie.

Conclusión sobre gentle-ai

Gentle-ai es el sistema operativo. Los demás son aplicaciones.

No eliges entre gentle-ai y GSD. Instalas gentle-ai como base, y luego decides qué motor de ejecución pones encima según la tarea.

Veredicto final

Si tuviera que apostar TODO hoy a una estrategia

• Base inmutable: gentle-ai
• Motor diario: GSD
• AFK controlado: Rita Vrataski pattern en Linear
• Gates para decisiones críticas: Spec-Kit o nWave
• Ralph vanilla: NUNCA en producción
• BMAD: solo en equipos >10 personas
• Claude-Flow: solo si necesitas swarms reales
• Archon: alternativa sólida a GSD si prefieres declarativo
• Superpowers: la opción por defecto si usas Claude Code — 158k ⭐ y marketplace oficial Anthropic

La verdad incómoda

Nadie está ganando “el” framework. El mercado se está fragmentando en nichos, y eso es sano. Cada framework optimiza para un contexto específico.

El error más común es adoptar el framework equivocado para tu contexto porque es el más popular. GSD es excelente para solo devs y terrible para enterprise. BMAD es al revés. Ralph es genial para MVPs y un suicidio financiero a escala.

La decisión inteligente es stackear 2-3 herramientas:

1. Capa base (gentle-ai recomendado)
2. Motor de ejecución (GSD / Archon / nWave según perfil)
3. Patrón de autonomía (Ralph / Rita Vrataski si aplica)

Preguntas clave para decidir

1. ¿Cuánto vale tu tiempo vs tokens? — Ralph sale caro si escalas. nWave sale caro si eres solo dev.
2. ¿Cuántos agentes usas? — Si >1, gentle-ai te ahorra dolor.
3. ¿Tienes disciplina de specs? — Sí → Spec-Kit/nWave. No → GSD/Ralph.
4. ¿Trabajas en equipo con PM? — Sí → Rita Vrataski o BMAD. No → lo demás.
5. ¿Cuánto vale un error arquitectónico? — Mucho → nWave/BMAD. Poco → Ralph/GSD.

Glosario

• AFK (Away From Keyboard): el agente corre sin supervisión humana activa.
• Context rot: degradación de calidad cuando la ventana de contexto se llena con historial acumulado.
• DAG (Directed Acyclic Graph): grafo de nodos con dependencias direccionales sin ciclos.
• Engram: sistema de memoria persistente de gentle-ai.
• MCP (Model Context Protocol): protocolo de Anthropic para comunicación entre agentes y herramientas.
• SDD (Spec-Driven Development): metodología donde la especificación guía el desarrollo.
• Swarm: múltiples agentes coordinados trabajando en paralelo.
• TDD (Test-Driven Development): escribir tests antes que código.
• Worktree: feature de Git que permite múltiples branches checked out en directorios separados.

Recursos y referencias

Frameworks

• gentle-ai — GitHub · YouTube @GentlemanProgramming
• GSD — GitHub · X @gsd_foundation
• BMAD-METHOD — GitHub
• Claude-Flow — GitHub · Cognitum.One
• Archon — GitHub · YouTube @ColeMedin
• Spec-Kit — GitHub · Docs oficiales
• nWave — GitHub
• Rita Vrataski Loop — GitHub
• Superpowers — GitHub · Marketplace oficial Anthropic
• Ralph loop (técnica original) — ghuntley.com/ralph · Thoughtworks Radar
• Ralph loop — implementación más popular — github.com/mikeyobrien/ralph-orchestrator (2.724 ⭐)
• Ralph loop — multi-agente — github.com/Th0rgal/open-ralph-wiggum (1.497 ⭐)
• Matt Pocock workshop material — workshop-001 · workshop-002

Guía actualizada en Abril 2026. Las estrellas de GitHub y estado de mantenimiento se verificaron directamente contra la API oficial.

Artículo relacionado

👉 Frameworks agénticos para construir agentes IA: CrewAI, LangGraph, AutoGen y Pydantic AI

Si lo que quieres es construir tus propios agentes (no programar con ayuda de IA), ese es el artículo que buscas. Cubre la Familia A: librerías Python/TypeScript para armar productos agénticos.