Un sistema multiagente para el desarrollo de software con gobernanza humana, control de costos y toma de decisiones estratégicas
→ Código y repositorio completo en GitHub: https://github.com/rheorix/agentic-company
Introducción
Este fin de semana me pregunté cómo aprovechar realmente la IA para hacer más eficiente todo el proceso de desarrollo de software (SDLC – Software Development Life Cycle).
No me interesaba usar Claude Code para escribir código más rápido ni mejorar la calidad de líneas individuales.
Quería algo más radical:
¿Qué pasaría si un equipo de desarrollo estuviera compuesto únicamente por agentes de IA especializados?
- Un Product Manager que no existe físicamente
- Un Developer que no existe
- Un QA Engineer que no existe
- Un Cost Controller que no existe
Y tú, en el centro del sistema, ya no como ejecutor, sino como responsable estratégico de la toma de decisiones.
No microgestionas el trabajo.
No escribes cada línea de código.
Defines la dirección, estableces restricciones, evalúas la calidad de las decisiones y gobiernas el presupuesto de todo el sistema.
El objetivo no es automatizar el desarrollo.
Es construir una organización de agentes de IA con roles especializados, donde el trabajo se distribuye pero la responsabilidad de las decisiones sigue siendo humana.
→ Código y repositorio completo en GitHub: https://github.com/rheorix/agentic-company
¿Qué es una arquitectura multiagente?
En el contexto del desarrollo de software, una arquitectura multiagente distribuye el trabajo entre modelos especializados en lugar de depender de un único LLM de propósito general.
En el patrón Orchestrator → Subagents:
- cada agente tiene una responsabilidad clara y limitada
- cada agente opera con una ventana de contexto aislada
- un sistema central (el Orchestrator) coordina el flujo de trabajo
El resultado es un sistema más:
- estable
- predecible
- controlable
En resumen
- Arquitectura: Orchestrator → Subagents
- Roles: PM, Developer, QA, Cost Controller
- Stack: Java 21, Spring Boot 3.x, Maven, JUnit 5 + Mockito
- Resultado: aplicación REST completa
- Costo promedio por funcionalidad: < $1
Por qué un solo agente no es suficiente
La verdadera limitación no es la capacidad del modelo, sino la gestión del contexto.
Un LLM puede sobresalir en lógica de aplicación, diseño de APIs o escritura de tests.
Pero cuando tiene que mantener todo junto, aparece el fenómeno de la dilución de la atención.
Dilución de la atención
Es una condición en la que, al aumentar la cantidad de información en el contexto, el modelo tiene dificultades para asignar el peso adecuado a los detalles realmente relevantes.
Es la misma razón por la que el trabajo se divide en los equipos humanos:
no por incapacidad individual, sino para mejorar la calidad global.
La solución: separar los contextos
El principio es simple: cada agente ve solo lo que necesita.
- PM → requisitos y objetivos
- Developer → especificaciones técnicas
- QA → código producido
Sin contexto innecesario.
Sin solapamientos inútiles.
Este enfoque aumenta la precisión y reduce la ambigüedad.
El patrón Orchestrator → Subagents
El flujo es lineal y controlado:
Orchestrator
↓
PM → especificación
↓ (aprobación humana)
Developer → código
↓ (aprobación humana)
QA → tests + informe
↓ (aprobación humana)
Cost Controller → informe de costosNo es una red caótica de agentes que se comunican libremente.
Es una pipeline estructurada con puntos de control explícitos.
Setup: cómo empezar
Prerrequisitos
- Java 21
- Maven
npm install -g @anthropic-ai/claude-codeclaude login
Estructura del proyecto
agentic-company/
├── CLAUDE.md
├── .claude/agents/
├── shared/
└── output/.claude/agents/→ comportamiento de los agentesshared/→ estado compartidooutput/→ código generado
CLAUDE.md: el sistema operativo del equipo
Este archivo define las reglas constitucionales del sistema:
- stack tecnológico
- reglas de comunicación
- puertas de aprobación obligatorias
Reglas fundamentales
- Ningún código sin especificaciones aprobadas
- Ningún commit sin validación humana
- Cada fase se detiene para aprobación
Roles de los agentes
- Product Manager → transforma solicitudes informales en especificaciones (
shared/spec.md) - Developer → implementa solo lo definido (
output/src/) - QA Engineer → escribe tests e informes (
shared/qa_report.md) - Cost Controller → monitorea tokens y costos (
shared/cost_report.md)
El estado compartido vive en el sistema de archivos:
shared/project_state.jsonshared/decisions_log.md
→ El sistema de archivos se convierte en la capa de coordinación
Primer run
claudePrompt inicial:
Build a Spring Boot REST API for a TODO list using the full agent workflow with approval gates.
El flujo siempre permanece igual:
especificación → aprobación → implementación → aprobación → testing → validación
Paralelismo (cuando tiene sentido)
El paralelismo funciona solo en tareas independientes.
Ejemplo:
- Developer implementa endpoints
- QA escribe los tests correspondientes
Regla práctica: máximo 2–3 agentes en paralelo
Optimización de costos
| Rol | Modelo |
|---|---|
| Product Manager | Sonnet |
| Developer | Sonnet |
| QA Engineer | Haiku |
| Cost Controller | Haiku |
Esta distribución permite una fuerte reducción de costos sin sacrificar la calidad.
Errores comunes a evitar
- Excesiva autonomía (sin puertas de aprobación)
- Especificaciones demasiado vagas
- Demasiado paralelismo
- Ignorar el registro de decisiones
Qué cambia realmente
Este experimento no trata solo de automatizar el desarrollo.
Se trata de gobernar el trabajo técnico mediante agentes de IA.
El rol humano se desplaza en tres ejes:
- Visión estratégica
- Gobernanza del sistema
- Control de costos e impacto
Ya no eres un ejecutor.
Eres el punto de control de decisiones del sistema.
Conclusión
Este experimento nació como una curiosidad técnica.
Pero el resultado más importante es organizativo:
estamos aprendiendo a construir sistemas de trabajo donde la ejecución puede delegarse, pero la responsabilidad no.
Estamos pasando de herramientas de productividad a verdaderos sistemas de producción gobernados por responsables humanos de la toma de decisiones.
Separar roles, limitar el contexto e introducir puntos de control ya no es solo ingeniería de software:
se está convirtiendo en una forma madura de gobernanza operativa impulsada por IA.
Y, al menos por ahora, el verdadero valor no reside en la autonomía del sistema, sino en la calidad de las decisiones humanas.
→ Código y repositorio completo en GitHub: https://github.com/rheorix/agentic-company
Si estás experimentando con sistemas multiagente o workflows similares, me interesa saber cómo los estás construyendo: deja aquí abajo un comentario con tu enfoque o tus resultados.
