04 - Multi-Agent Coding: LangGraph, CrewAI e AutoGen
Imagine abordar uma tarefa completa: implementar um sistema de autenticação a partir daí para um aplicativo corporativo, completo com OAuth2, RBAC, log de auditoria, testes de integração e documentação. Um único agente de IA, aliás, será encontrado gerenciando um janela de contexto saturada, responsabilidades conflitantes e alto risco de erros em cascata. A solução não é um agente mais poderoso: é um equipe de agentes especialistas que colaboram, verificam-se e paralelizam o trabalho.
Este é o paradigma Codificação Multiagente: sistemas nos quais vários agentes de IA cooperar de forma independente para concluir tarefas de desenvolvimento de software que excedam a capacidade de um único modelo. Em 2025, três estruturas dominaram este espaço: LangGraph com sua arquitetura gráfica stateful, Tripulação AI com seu modelo baseado em papéis intuitivo, sim Geração automática (agora AG2) com sua ênfase conversacional. Aqui O sistema nativo do Código Claude é combinado com seus subagentes paralelos.
Este artículo es un deep dive avanzado sobre los cuatro sistemas: arquitecturas, code examples funcionales, comparación detallada y guía práctica para elegir el adecuado para tu caso de uso. Si ya tienes familiaridad con los conceptos básicos del vibe coding y quieres llevar tus workflows agénticos al siguiente nivel, estás en el lugar correcto.
O que Você Aprenderá
- Por qué un único agente de IA no basta para tareas de desarrollo complejas
- LangGraph: arquitectura de grafo, StateGraph, Nodes, Edges y Checkpointing
- CrewAI: role-based agents, Tasks, Process secuencial y paralelo, Tools
- AutoGen/AG2: conversational agents, GroupChat, code execution sandbox
- Claude Code: sub-agents, Task tool y patrones de ejecución paralela
- Comparación detallada: cuándo usar qué framework
- Arquitectura production-ready para equipos reales
- Desafíos críticos: context pollution, error propagation, cost management
- Best practices para agentes especializados y estrategias de fallback
Por que um Único Agente Não Basta
Antes de entrar nos frameworks, é importante compreender o problema fundamental que existe resolução de codificação multiagente. Um único agente de IA, tal como é, tem limitações elementos estruturais que emergem claramente em todas as áreas de desenvolvimento.
El primer límite es el context window. Incluso con modelos que soportan 200K tokens, una tarea enterprise típica requiere mantener simultáneamente en mente: el codebase existente, las especificaciones funcionales, los patrones arquitectónicos, los tests a escribir, la documentación a actualizar y las restricciones de seguridad. Todo esto supera rápidamente las capacidades de un único contexto coherente.
O segundo limite está aí especialização. Um agente generalista detém fazer tudo de forma medíocre em vez de algumas coisas de forma excelente. Um agente especializado em segurança sabe exatamente quais clientes procurar e quais padrões aplicar, enquanto um especialista em testes conhece as regras de teste para cada tipo de componente.
O terceiro limite está aí verificado. Um único agente que escreve código e onde a "verificação" é basicamente verificar seu próprio trabalho com o mesmo Tenho uma conversa cognitiva com o que produzo. Dois agentes separados, um implementador e outro implementador revisão, trazem perspectivas genuinamente diferentes.
O Princípio da Separação de Papéis
En los equipos de desarrollo humanos, la separación de roles (developer, code reviewer, QA, security engineer, tech writer) no es burocracia: es una salvaguarda cognitiva. Los sistemas multi-agent aplican el mismo principio al código generado por IA, reduciendo sistemáticamente los puntos ciegos de cada agente individual.
Las investigaciones de 2025 confirman esta intuición: el código generado por IA tiene tasas de vulnerabilidad significativamente más altas cuando es producido por agentes individuales no supervisados (Veracode 2025 reporta 2.74x más vulnerabilidades respecto al código humano). Los sistemas multi-agent con agentes de revisión dedicados reducen esta brecha de forma sustancial.
LangGraph: Orquestração de Grafo Stateful
LangGraph, desenvolvido pela equipe LangChain, representa a evolução natural do foco de cadeias lineares hacia Gráficos cíclicos com estado. Intuição fundamental isto é, os fluxos de trabalho complexos das agências não são lineares: exigem lacunas, bifurcações condicionais, paralelismo e persistência do estado entre uma etapa e a seguinte.
El propio equipo de LangChain comunicó explícitamente en 2025: "Use LangGraph for agents, not LangChain." Esta elección refleja una verdad arquitectónica importante: los sistemas agénticos modernos son fundamentalmente state machines, no pipelines secuenciales.
Conceitos Fundamentais do LangGraph
LangGraph se basa en cuatro conceptos clave que es necesario dominar antes de construir sistemas multi-agent eficaces:
- StateGraph: el grafo principal que define la estructura del workflow y el tipo de estado compartido entre los nodos
- Estado: um TypedDict (ou modelo Pydantic) que representa as informações compartilhado entre todos os nós do gráfico
- Nós: Funções Python que recebem o estado, executam uma operação (geralmente uma chamada para um LLM) e atualizações devuelven para o estado
- Edges: conexiones entre nodos, que pueden ser fijas o condicionales basadas en el estado actual
from typing import TypedDict, Annotated, List
from langgraph.graph import StateGraph, END
from langgraph.checkpoint.memory import MemorySaver
from langchain_anthropic import ChatAnthropic
from langchain_core.messages import HumanMessage, AIMessage
import operator
# ============================================================
# 1. DEFINICIÓN DEL ESTADO COMPARTIDO
# ============================================================
class CodingState(TypedDict):
"""Estado compartido entre todos los agentes del sistema."""
task_description: str
requirements: List[str]
generated_code: str
test_code: str
review_comments: List[str]
security_issues: List[str]
final_code: str
iteration_count: int
status: str # "planning", "coding", "testing", "reviewing", "done"
# ============================================================
# 2. INICIALIZACIÓN DE LOS MODELOS
# ============================================================
# Planner: usa Opus para razonamiento complejo
planner_model = ChatAnthropic(model="claude-opus-4-6")
# Developer: usa Sonnet para code generation rápida
developer_model = ChatAnthropic(model="claude-sonnet-4-6")
# Reviewer: usa Sonnet para análisis crítico
reviewer_model = ChatAnthropic(model="claude-sonnet-4-6")
# ============================================================
# 3. DEFINICIÓN DE LOS NODOS (AGENTES)
# ============================================================
def planner_agent(state: CodingState) -> dict:
"""Agente planificador: descompone la tarea en requisitos."""
prompt = f"""Eres un software architect senior.
Task: {state['task_description']}
Analiza la tarea y produce una lista de requisitos técnicos específicos.
Formato: una lista con viñetas de requisitos claros e implementables.
"""
response = planner_model.invoke([HumanMessage(content=prompt)])
requirements = [
line.strip().lstrip("- ")
for line in response.content.split("\n")
if line.strip().startswith("-")
]
return {
"requirements": requirements,
"status": "coding"
}
def developer_agent(state: CodingState) -> dict:
"""Agente desarrollador: implementa el código a partir de los requisitos."""
requirements_text = "\n".join(f"- {r}" for r in state["requirements"])
prompt = f"""Eres un senior Python developer.
Implementa el siguiente código respetando todos los requisitos:
Tarea original: {state['task_description']}
Requisitos:
{requirements_text}
Código existente (si existe):
{state.get('generated_code', 'Ningún código previo')}
Notas del reviewer (si existen):
{chr(10).join(state.get('review_comments', []))}
Produce SOLO el código Python, sin explicaciones.
"""
response = developer_model.invoke([HumanMessage(content=prompt)])
return {
"generated_code": response.content,
"status": "testing"
}
def test_writer_agent(state: CodingState) -> dict:
"""Agente test writer: escribe unit tests para el código generado."""
prompt = f"""Eres un QA engineer especializado en Python testing.
Escribe unit tests completos para el siguiente código usando pytest:
{state['generated_code']}
Requisitos de los tests:
- Cobertura mínima: 80%
- Testea happy path y edge cases
- Incluye tests para casos de error
- Usa fixtures donde sea apropiado
Produce SOLO el código de los tests, sin explicaciones.
"""
response = developer_model.invoke([HumanMessage(content=prompt)])
return {
"test_code": response.content,
"status": "reviewing"
}
def code_reviewer_agent(state: CodingState) -> dict:
"""Agente code reviewer: analiza código y tests por calidad."""
prompt = f"""Eres un senior code reviewer con 10+ años de experiencia.
Revisa el siguiente código y sus tests:
CÓDIGO:
{state['generated_code']}
TESTS:
{state['test_code']}
Analiza por:
1. Corrección lógica
2. Calidad del código (SOLID, DRY, KISS)
3. Completitud de los tests
4. Performance
5. Legibilidad y mantenibilidad
Si hay problemas críticos, respóndeme con "NEEDS_REVISION:" seguido de los problemas.
Si el código es aceptable, respóndeme con "APPROVED:" seguido de sugerencias menores.
"""
response = reviewer_model.invoke([HumanMessage(content=prompt)])
comments = [response.content]
needs_revision = response.content.startswith("NEEDS_REVISION:")
return {
"review_comments": comments,
"iteration_count": state.get("iteration_count", 0) + 1,
"status": "coding" if needs_revision else "security_check"
}
def security_agent(state: CodingState) -> dict:
"""Agente de seguridad: verifica vulnerabilidades en el código."""
prompt = f"""Eres un security engineer especializado en application security.
Analiza el siguiente código en busca de vulnerabilidades de seguridad:
{state['generated_code']}
Busca específicamente:
- Injection vulnerabilities (SQL, Command, Path traversal)
- Insecure deserialization
- Hardcoded secrets o credenciales
- Insecure random number generation
- Race conditions
- Input validation gaps
Lista SOLO los problemas encontrados. Si no hay problemas, escribe "SECURITY_OK".
"""
response = reviewer_model.invoke([HumanMessage(content=prompt)])
issues = []
if response.content.strip() != "SECURITY_OK":
issues = [response.content]
return {
"security_issues": issues,
"final_code": state['generated_code'] if not issues else "",
"status": "done" if not issues else "coding"
}
# ============================================================
# 4. ROUTING CONDICIONAL
# ============================================================
def route_after_review(state: CodingState) -> str:
"""Decide el siguiente nodo después de la code review."""
if state["status"] == "coding" and state.get("iteration_count", 0) < 3:
return "developer"
elif state["status"] == "security_check":
return "security"
else:
# Max iteraciones alcanzadas
return "security"
def route_after_security(state: CodingState) -> str:
"""Decide si el código está listo o necesita otra iteración."""
if state["security_issues"] and state.get("iteration_count", 0) < 3:
return "developer"
return END
# ============================================================
# 5. CONSTRUCCIÓN DEL GRAFO
# ============================================================
def build_coding_graph() -> StateGraph:
graph = StateGraph(CodingState)
# Adición de nodos
graph.add_node("planner", planner_agent)
graph.add_node("developer", developer_agent)
graph.add_node("test_writer", test_writer_agent)
graph.add_node("reviewer", code_reviewer_agent)
graph.add_node("security", security_agent)
# Entry point
graph.set_entry_point("planner")
# Edges fijos
graph.add_edge("planner", "developer")
graph.add_edge("developer", "test_writer")
graph.add_edge("test_writer", "reviewer")
# Edges condicionales
graph.add_conditional_edges(
"reviewer",
route_after_review,
{
"developer": "developer",
"security": "security"
}
)
graph.add_conditional_edges(
"security",
route_after_security,
{
"developer": "developer",
END: END
}
)
return graph
# ============================================================
# 6. EJECUCIÓN CON CHECKPOINTING
# ============================================================
checkpointer = MemorySaver()
app = build_coding_graph().compile(checkpointer=checkpointer)
# Ejecución del sistema
config = {"configurable": {"thread_id": "project-auth-001"}}
initial_state = {
"task_description": """
Implementa un sistema de autenticación JWT en Python con:
- Login con username/password
- Generación de access token (15 min) y refresh token (7 días)
- Middleware para proteger endpoints
- Revocación de token (blacklist en Redis)
""",
"requirements": [],
"generated_code": "",
"test_code": "",
"review_comments": [],
"security_issues": [],
"final_code": "",
"iteration_count": 0,
"status": "planning"
}
result = app.invoke(initial_state, config=config)
print(f"Código final generado tras {result['iteration_count']} iteraciones")
print(f"Problemas de seguridad detectados: {len(result['security_issues'])}")Este ejemplo muestra cómo LangGraph gestiona un workflow de desarrollo complejo con bucles de revisión automáticos. El checkpointing es una feature crítica para producción: permite guardar el estado del grafo y reanudar la ejecución en caso de errores, sin empezar de cero.
LangGraph: Pontos Fortes
- Control granular: cada aspecto del flujo es programable
- State persistence: checkpointing integrado para workflows largos
- Human-in-the-loop: posibilidad de pausa para aprobación humana
- Parallel execution: los nodos pueden ejecutarse en paralelo
- Streaming: output en tiempo real desde cada nodo
- Probado en producción: utilizado en producción por cientos de empresas en 2025
CrewAI: Role-Based Agents para Equipas Virtuais
CrewAI adota um foco fundamentalmente diferente do LangGraph: em vez de pensar nisso termos de gráficos e estados, você deve pensar em termos de equipes e funções. Cada agente é um membro da equipe com uma especialização definida, um objetivo claro e um conjunto de hardware à sua disposição. Este modelo mental é mais intuitivo para as pessoas seguirem experiência em gerenciamento de equipes de desenvolvimento.
Na versão 1.1.0 de 2025, CrewAI introduziu a separação entre Tripulações (orquestração de alto nível) y Fluxos (controle granular de fluxos de trabalho), Oferecendo a flexibilidade do LangGraph com a simplicidade do modelo baseado em funções.
Arquitetura CrewAI
Los cuatro elementos fundamentales de CrewAI son:
- Agentes: uma entidade de IA com funções, objetivos e história de fundo definidos “personalidade” e área de competência
- Tarefas: uma atividade específica com descrição, saída_esperada e atribuído a um agente específico
- Tool: capacidades adicionales de los agentes (file I/O, web search, code execution, database access)
- Equipe: a equipe que orquestra agentes e tenta com um processo (sequencial ou paralelo)
from crewai import Agent, Task, Crew, Process
from crewai.tools import CodeInterpreterTool, FileReadTool, FileWriteTool
from crewai_tools import GithubSearchTool
from langchain_anthropic import ChatAnthropic
# ============================================================
# 1. CONFIGURACIÓN DE MODELOS
# ============================================================
opus_llm = ChatAnthropic(model="claude-opus-4-6", temperature=0.1)
sonnet_llm = ChatAnthropic(model="claude-sonnet-4-6", temperature=0.2)
# ============================================================
# 2. DEFINICIÓN DE LAS HERRAMIENTAS
# ============================================================
code_executor = CodeInterpreterTool()
file_reader = FileReadTool()
file_writer = FileWriteTool()
# ============================================================
# 3. DEFINICIÓN DE LOS AGENTES (MIEMBROS DEL EQUIPO)
# ============================================================
tech_lead = Agent(
role="Tech Lead y Software Architect",
goal="""Analizar los requisitos técnicos, definir la arquitectura óptima
y descomponer el trabajo en tareas específicas e implementables.""",
backstory="""Tienes 15 años de experiencia en software architecture.
Has liderado la transición a microservicios para 3 startups unicornio.
Eres conocido por la capacidad de equilibrar pragmatismo y calidad técnica.""",
llm=opus_llm,
verbose=True,
allow_delegation=True
)
senior_developer = Agent(
role="Senior Python Developer",
goal="""Implementar código Python de alta calidad, limpio, testeable
y conforme a las best practices SOLID y a las especificaciones del tech lead.""",
backstory="""Eres un Python developer con 8 años de experiencia.
Contribuyes a proyectos open source importantes.
Escribes código que otros developers disfrutan leer y mantener.""",
llm=sonnet_llm,
verbose=True,
tools=[code_executor, file_writer],
allow_code_execution=True
)
qa_engineer = Agent(
role="QA Engineer y Test Specialist",
goal="""Verificar la corrección del código a través de tests exhaustivos,
encontrar edge cases y garantizar la cobertura de tests al 90%+.""",
backstory="""Tienes un background en matemáticas y estás obsesionado con la
corrección del software. Has encontrado bugs críticos en sistemas que llevaban
años en producción. No confías en el código sin pruebas.""",
llm=sonnet_llm,
verbose=True,
tools=[code_executor],
allow_code_execution=True
)
code_reviewer = Agent(
role="Senior Code Reviewer",
goal="""Analizar críticamente el código en cuanto a calidad, mantenibilidad,
performance y conformidad con los estándares del equipo.""",
backstory="""Has revisado más de 10.000 pull requests en tu carrera.
Tienes un ojo infalible para code smells, anti-patterns y problemas
de diseño que solo se manifiestan en producción.""",
llm=sonnet_llm,
verbose=True,
tools=[file_reader]
)
# ============================================================
# 4. DEFINICIÓN DE LOS TASKS
# ============================================================
architecture_task = Task(
description="""
Analiza el siguiente requisito y produce un documento de arquitectura:
REQUISITO: {task_description}
El documento debe incluir:
1. Diagrama de componentes (en texto/ASCII)
2. Stack tecnológico recomendado con justificaciones
3. Estructura de directorios del proyecto
4. Interfaces principales (clases/funciones públicas)
5. Consideraciones sobre escalabilidad y mantenibilidad
6. Lista priorizada de tareas de implementación
""",
expected_output="""Un documento de arquitectura detallado en markdown,
con diagramas ASCII, estructura del proyecto y lista de tareas.""",
agent=tech_lead
)
implementation_task = Task(
description="""
Implementa el código Python basándote en el documento de arquitectura
proporcionado por el Tech Lead.
Requisitos de implementación:
- Sigue exactamente las interfaces definidas en la arquitectura
- Usa type hints para todas las funciones públicas
- Añade docstrings en formato Google style
- Gestiona todos los casos de error con excepciones custom
- Guarda el código en archivos separados por módulo
""",
expected_output="""Código Python completo y funcional, organizado en módulos,
con type hints, docstrings y gestión de errores.""",
agent=senior_developer,
context=[architecture_task] # depende del output de la arquitectura
)
testing_task = Task(
description="""
Escribe tests completos para el código implementado.
Requisitos:
- Framework: pytest con pytest-cov
- Cobertura objetivo: 90%
- Incluye unit tests, integration tests y tests paramétricos
- Testea happy path, edge cases y escenarios de error
- Usa mocking para dependencias externas
- Ejecuta los tests para verificar que todos pasan
""",
expected_output="""Archivos de test pytest completos que pasan todos,
con reporte de cobertura al 90%+.""",
agent=qa_engineer,
context=[implementation_task]
)
review_task = Task(
description="""
Realiza una code review en profundidad del código y los tests producidos.
Analiza por:
1. Respeto de los principios SOLID
2. Presencia de code smells o anti-patterns
3. Corrección lógica y completitud
4. Performance y uso de memoria
5. Seguridad (injection, validación de input, secrets)
6. Calidad de la documentación
Produce un reporte con: problemas CRÍTICOS, WARNINGS y SUGGESTIONS.
Para cada problema, incluye el archivo/línea y el fix recomendado.
""",
expected_output="""Reporte de code review estructurado con categorías CRITICAL,
WARNING y SUGGESTION, con fixes recomendados para cada problema.""",
agent=code_reviewer,
context=[implementation_task, testing_task]
)
# ============================================================
# 5. CREW - ENSAMBLAJE DEL EQUIPO
# ============================================================
coding_crew = Crew(
agents=[tech_lead, senior_developer, qa_engineer, code_reviewer],
tasks=[architecture_task, implementation_task, testing_task, review_task],
process=Process.sequential, # o Process.hierarchical para delegación automática
verbose=True,
memory=True, # habilita memoria compartida entre agentes
embedder={
"provider": "anthropic",
"config": {"model": "claude-3-haiku-20240307"}
}
)
# ============================================================
# 6. INICIO DEL CREW
# ============================================================
result = coding_crew.kickoff(inputs={
"task_description": """
Implementa un sistema de rate limiting para API REST con:
- Algoritmo token bucket para control de flujo
- Storage en Redis para distribución multi-instance
- Configuración por-endpoint y por-user
- Header HTTP estándar (X-RateLimit-*)
- Dashboard de monitoring con métricas Prometheus
"""
})
print(result.raw)
Um elemento distintivo do CrewAI 2025 é a opção allow_code_execution=True
para agentes: habilite a execução de código em um sandbox seguro, com gerenciamento automático
de erros e nova tentativa inteligente. Se o código gerar uma exceção, o agente irá recebê-la
mensagem de erro e tenta corrigi-lo de forma independente (até max_retry_limit,
padrão 2).
CrewAI: Pontos Fortes
- Curva de aprendizagem baja: el modelo mental equipo/roles es intuitivo
- Execução de código integrada: Sandbox seguro com nova tentativa automática
- Memoria compartida: los agentes recuerdan el contexto de conversaciones anteriores
- O MCP suporta: Integração bidirecional com servidores MCP (2025)
- Enterprise features: observabilidad, audit log, control plane SaaS
- Flows: control granular para workflows complejos cuando sea necesario
AutoGen/AG2: Conversational Agents para Tarefas Emergentes
AutoGen (renombrado AG2 por la comunidad que continuó el desarrollo tras la divergencia de Microsoft en 2024) adopta un paradigma completamente diferente: el conversational multi-agent. En lugar de definir workflows fijos o roles rígidos, los agentes se comunican entre sí a través de mensajes en lenguaje natural, emergiendo comportamientos complejos de interacciones simples.
Este enfoque es particularmente eficaz para tareas donde el camino de solución no es definible a priori: problemas de debugging complejos, investigación e implementación de soluciones innovadoras, o tareas que requieren negociación entre restricciones contrapuestas.
Arquitectura AG2: AssistantAgent y UserProxyAgent
O alicerce fundamental do AG2 é o mesmo AssistenteAgente (Agente de IA) sim AgenteProxydoUsuário (proxy para execução). O UserProxyAgent pode ser executado Eu codifico em uma sandbox local, fornecendo feedback real ao AssistantAgent que pode entrar iterar sobre a solução com base nos resultados efetivos da execução.
import autogen
from autogen import AssistantAgent, UserProxyAgent, GroupChat, GroupChatManager
from autogen.coding import LocalCommandLineCodeExecutor
import os
# ============================================================
# 1. CONFIGURACIÓN LLM
# ============================================================
config_list = [
{
"model": "claude-sonnet-4-6",
"api_key": os.environ["ANTHROPIC_API_KEY"],
"api_type": "anthropic",
}
]
llm_config = {
"config_list": config_list,
"temperature": 0.1,
"timeout": 120,
}
opus_config = {
"config_list": [{
"model": "claude-opus-4-6",
"api_key": os.environ["ANTHROPIC_API_KEY"],
"api_type": "anthropic",
}],
"temperature": 0.1,
}
# ============================================================
# 2. CODE EXECUTOR - SANDBOX LOCAL
# ============================================================
executor = LocalCommandLineCodeExecutor(
timeout=60,
work_dir="/tmp/autogen_workspace",
# Bloquea comandos peligrosos
execution_policies={
"rm": False,
"curl": False,
"wget": False,
}
)
# ============================================================
# 3. DEFINICIÓN DE LOS AGENTES
# ============================================================
# Agente Software Architect - usa Opus para alta capacidad de razonamiento
architect = AssistantAgent(
name="SoftwareArchitect",
system_message="""Eres un software architect senior con 15 años de experiencia.
Tu rol es:
1. Analizar los requisitos y proponer arquitecturas sólidas
2. Definir las interfaces entre componentes
3. Identificar riesgos técnicos y proponer mitigaciones
4. Guiar las decisiones técnicas del equipo
Cuando propongas una arquitectura, usa siempre diagramas ASCII y explica las
motivaciones de las elecciones. Responde con "TERMINATE" cuando la tarea esté completa.""",
llm_config=opus_config,
)
# Agente Developer - implementa el código
developer = AssistantAgent(
name="PythonDeveloper",
system_message="""Eres un senior Python developer.
Tu rol es:
1. Implementar el código siguiendo las especificaciones del arquitecto
2. Escribir código limpio con type hints y docstrings
3. Gestionar los errores de forma robusta
4. Respetar los principios SOLID y DRY
Usa siempre bloques de código Python válidos cuando escribas implementaciones.
Responde con "TERMINATE" solo cuando el developer Y el reviewer aprueben.""",
llm_config=llm_config,
)
# Agente Tester - escribe y verifica los tests
tester = AssistantAgent(
name="QATester",
system_message="""Eres un QA engineer especializado en Python testing.
Tu rol es:
1. Escribir tests pytest exhaustivos para el código del developer
2. Ejecutar los tests en la sandbox y reportar los resultados
3. Identificar edge cases no cubiertos
4. Garantizar cobertura 85%+
Produce siempre tests ejecutables que puedo verificar en la sandbox.""",
llm_config=llm_config,
)
# Agente Reviewer - code review crítica
reviewer = AssistantAgent(
name="CodeReviewer",
system_message="""Eres un code reviewer senior con foco en calidad y seguridad.
Tu rol es:
1. Analizar el código en busca de code smells y anti-patterns
2. Verificar la seguridad (OWASP Top 10)
3. Sugerir refactoring de mejora
4. Aprobar o solicitar modificaciones
Concluye cada review con "APPROVED" o "NEEDS_WORK: [lista de problemas]".""",
llm_config=llm_config,
)
# UserProxy con ejecución de código - hace de puente entre agentes y sandbox
code_executor_proxy = UserProxyAgent(
name="CodeExecutor",
human_input_mode="NEVER", # completamente automático
max_consecutive_auto_reply=5,
code_execution_config={
"executor": executor,
},
is_termination_msg=lambda msg: "TERMINATE" in msg.get("content", ""),
)
# ============================================================
# 4. GROUP CHAT - ORQUESTACIÓN DE LA CONVERSACIÓN
# ============================================================
group_chat = GroupChat(
agents=[architect, developer, tester, reviewer, code_executor_proxy],
messages=[],
max_round=20, # máximo 20 rondas de conversación
# Estrategia de selección del próximo hablante
speaker_selection_method="auto",
# Orden preferido para estructurar la conversación
allowed_or_disallowed_speaker_transitions={
architect: [developer],
developer: [tester, code_executor_proxy],
tester: [code_executor_proxy, reviewer],
code_executor_proxy: [developer, tester, reviewer],
reviewer: [developer, architect],
},
speaker_transitions_type="allowed",
)
# Manager que orquesta el group chat
manager = GroupChatManager(
groupchat=group_chat,
llm_config=llm_config,
system_message="""Eres el project manager de este equipo de desarrollo.
Orquestas la conversación para garantizar que la tarea se complete
de forma eficiente y que cada agente contribuya en el momento oportuno.""",
)
# ============================================================
# 5. INICIO DE LA CONVERSACIÓN
# ============================================================
task = """
Desarrolla un sistema de caching inteligente en Python con las siguientes características:
- Cache LRU (Least Recently Used) con TTL configurable por entry
- Backend múltiples: in-memory, Redis, o filesystem
- Decorator @cache para aplicación transparente a las funciones
- Estadísticas de hit/miss en tiempo real
- Thread-safe para aplicaciones concurrentes
Arquitectura, implementación, tests y code review completos.
"""
chat_result = code_executor_proxy.initiate_chat(
manager,
message=task,
summary_method="reflection_with_llm",
)
print("\n=== RESUMEN FINAL ===")
print(chat_result.summary)AG2: Pontos Fortes
- Ejecución de código real: el código se ejecuta realmente en sandbox, los agentes ven los outputs reales
- Flexibilidad emergente: los workflows se adaptan al problema, no al revés
- Protocolo AG-UI: frontends dinâmicos com streaming em tempo real (2025)
- OpenTelemetry: observabilidad completa de los workflows agénticos
- Humano no circuito: facilmente configurável com
human_input_mode - Suporte TypeScript: Versão Microsoft AutoGen 0.4 com suporte nativo
Claude Code: Sub-Agents e Execução Paralela
Claude Code possui um sistema multiagente nativo que opera de uma maneira fundamentalmente diferente Eu vi os frameworks Python agora. Em vez de solicitar modelos LLM via API, Claude Code lança instâncias Claude separou (subagentes) diretamente do terminal, cada um com sua própria janela de contexto clara e a capacidade de operar no sistema de arquivos de forma isolada.
Este enfoque tiene ventajas significativas: ningún overhead de framework, integración nativa con las herramientas del terminal, y la posibilidad de ejecutar tareas en paralelo en sistemas con múltiples cores. El Task tool es el mecanismo clave: lanza un sub-agent con un prompt específico y espera el resultado antes de proceder (o, si las tareas son independientes, las lanza todas en paralelo).
# Code Reviewer Agent
## Rol
Senior code reviewer con foco en calidad, seguridad y mantenibilidad.
## Competencias
- Principios SOLID y design patterns
- OWASP Top 10 y seguridad aplicativa
- Performance optimization
- Clean code y refactoring
## Proceso de Review
1. Lee TODOS los archivos modificados antes de comentar
2. Identifica problemas por categoría: CRITICAL, WARNING, SUGGESTION
3. Para cada problema: especifica archivo, línea y fix recomendado
4. Verifica que los tests cubran los casos de error
5. Controla presencia de hardcoded secrets o credenciales
## Output Esperado
Reporte estructurado en markdown con secciones:
- Executive Summary
- CRITICAL Issues (bloqueantes para el merge)
- WARNINGS (a resolver antes del próximo release)
- SUGGESTIONS (mejoras opcionales)
- Security Checklist# Security Auditor Agent
## Rol
Security engineer especializado en application security y OWASP.
## Competencias
- OWASP Top 10 (2025 edition)
- Análisis de código Python, JavaScript y SQL
- Threat modeling
- Dependency vulnerability scanning
## Checklist de Seguridad
### Input Validation
- [ ] Todos los inputs de usuario están validados y sanitizados
- [ ] Ninguna query SQL construida con concatenación de strings
- [ ] Path traversal prevenido con realpath/pathlib
### Authentication & Authorization
- [ ] Password hashing con bcrypt/argon2 (no MD5/SHA1)
- [ ] JWT firmados con claves de longitud adecuada
- [ ] RBAC implementado correctamente
### Secrets Management
- [ ] Ningún hardcoded secret en el código
- [ ] Variables de entorno usadas para credenciales
- [ ] .gitignore incluye archivos de configuración sensibles
### Dependencies
- [ ] Ninguna dependencia con CVE críticas conocidas
- [ ] requirements.txt con versiones fijadas
## Output
- Lista de vulnerabilidades con CVSS score estimado
- Fixes recomendados con ejemplos de código
- Prioridad: CRITICAL (fix inmediato), HIGH, MEDIUM, LOW# Ejemplo de prompt para orquestación multi-agent en Claude Code
# (este es el contenido de un archivo CLAUDE.md o de un prompt interactivo)
# --- EJEMPLO 1: SEQUENTIAL MULTI-AGENT ---
# El task tool lanza sub-agent y espera los resultados en secuencia
Implementa las siguientes features para el módulo auth/:
1. Usa el Task tool para lanzar el sub-agent "planner":
- Input: "Analiza auth/ y crea un plan de implementación para
añadir 2FA con TOTP (RFC 6238)"
- Espera el plan completo
2. Usa el Task tool para lanzar el sub-agent "developer":
- Input: "Implementa el siguiente plan: [output del planner]"
- Espera la implementación completa
3. Usa el Task tool para lanzar EN PARALELO:
- Sub-agent "code-reviewer": revisa el código en auth/
- Sub-agent "security-auditor": verifica la seguridad de auth/
(lanza ambos simultáneamente, espera a ambos)
4. Aplica los fixes para todos los problemas CRITICAL encontrados
---
# --- EJEMPLO 2: PARALLEL WORKTREE ISOLATION ---
# Tareas independientes en worktrees separados para máxima paralelización
Ejecuta estas tareas EN PARALELO en worktrees separados:
Task A (worktree: feature/user-service):
- Implementa UserService con CRUD completo
- Escribe unit tests con 90% coverage
- Commit: "feat: add UserService with full CRUD"
Task B (worktree: feature/email-service):
- Implementa EmailService con template system
- Integra con SendGrid API
- Escribe integration tests
- Commit: "feat: add EmailService with SendGrid"
Task C (worktree: feature/notification-service):
- Implementa NotificationService (email + push + SMS)
- Usa UserService y EmailService como dependencias
- Escribe tests end-to-end
- Commit: "feat: add NotificationService"
Después de que los tres worktrees estén completados:
- Mergea en orden: A, B, C
- Resuelve eventuales conflictos
- Ejecuta la test suite completa
---
# --- EJEMPLO 3: AGENTE CON MEMORIA COMPARTIDA ---
# Uso de archivos como mecanismo de comunicación inter-agent
Antes de empezar, crea el archivo /tmp/project-context.md con:
- Stack tecnológico del proyecto
- Convenciones de naming
- Patrones arquitectónicos en uso
- Dependencias principales
Cada sub-agent que lances debe:
1. Leer /tmp/project-context.md al inicio
2. Actualizar /tmp/progress.md con el estado de sus propias tareas
3. Guardar outputs estructurados en /tmp/agent-outputs/[nombre]/
Esto garantiza coherencia entre agentes paralelos sin conflictos de merge.Lição do Incidente Replit (2025)
Em 2025, Replit documentou um caso em que um agente autônomo eliminou
com base em dados de produção durante uma área de “limpeza”. Este acidente
destacou a necessidade de configurar limites explicitamente nos comandos
destrutivo. No Código Claude, isso é gerenciado em toda a seção deny
en .claude/settings.json: sempre bloqueia rm -rf,
DROP TABLE, git push --force e semelhantes.
Os subagentes têm as mais restrições do agente principal.
Comparação Detalhada: Qual Framework Escolher
A escolha do quadro depende do contexto específico. Não existe um ganador absoluto: Cada peça se destaca em diferentes cenários. A tabela a seguir resume as diferenças chave para ajudá-lo a tomar a decisão.
| Critério | LangGraph | CrewAI | AG2 (AutoGen) | Claude Code |
|---|---|---|---|---|
| Paradigma | Grafo stateful | Equipa role-based | Conversacional | Sub-agent nativo |
| Curva de aprendizagem | Alta (graph theory) | Baixa (intuitivo) | Media | Baja |
| Controlo do fluxo | Máximo | Médio-alto | Emergente | Médio |
| Code execution | Via tool | Integrada (sandbox) | Integrada (local) | Bash nativo |
| State persistence | Checkpointing nativo | Memória integrada | Mensagens chat | Filesystem |
| Paralelismo | Nós paralelos | Process.parallel | GroupChat async | Task tool nativo |
| Observabilidade | LangSmith | CrewAI Enterprise | OpenTelemetry | Logs nativos |
| Human-in-the-loop | Interrupt nativo | Callback | human_input_mode |
Interativo |
| Ecossistema | LangChain | Independente | Microsoft/AG2 | Anthropic |
| Ideal para | Workflows complexos com lógica condicional | Equipas virtuais com papéis definidos | Tarefas exploratórias com code execution | Automatização CLI e projetos existentes |
Recomendações Práticas
- Elige LangGraph si tienes workflows complejos con muchas bifurcaciones condicionales, necesitas state persistence fiable entre sesiones, y tienes un equipo que comprende los conceptos de state machine y grafos dirigidos.
- Elige CrewAI si quieres empezar rápidamente con multi-agent, tu equipo está acostumbrado a pensar en términos de roles organizacionales, y necesitas code execution integrada con gestión automática de errores.
- Elite AG2 Se a tarefa for exploratória e não tiver um fluxo de trabalho predefinido, Realmente preciso de conversas em várias rodadas com execução de código real, e está no ecossistema da Microsoft (Azure, TypeScript).
- Elige Claude Code si ya trabajas con Claude, quieres multi-agent sin frameworks adicionales, y tu caso de uso principal es automatización de tareas de desarrollo en codebases existentes.
Arquitetura Production-Ready para Equipas Reais
Um sistema multiagente em produção requer considerações arquitetônicas que precisam ser mais do que a simples orquestração de agentes. As empresas que implantaram esses sistemas em 2025 aprenderam algumas lições importantes que é útil saber antes de empezar.
Padrões Arquitetônicos Consolidados
Las investigaciones de 2025 muestran que los patrones más eficaces para multi-agent coding en producción son tres:
- Padrão de Supervisor: um agente orquestrador delega tarefas aos agentes especializar e agregar os resultados. Ideal para LangGraph com roteamento condicional.
- Pipeline Pattern: agentes en secuencia donde el output de uno
se convierte en el input del siguiente. Natural en CrewAI con
contexty tareas dependientes. - Padrão ponto a ponto: agentes que se comunicam livremente entre vocês sem orquestra central. Natural em AG2 com GroupChat.
from langgraph.graph import StateGraph, END
from langgraph.checkpoint.postgres import PostgresSaver
from typing import TypedDict, Optional
import logging
import time
logger = logging.getLogger(__name__)
class ProductionCodingState(TypedDict):
task_id: str
task_description: str
generated_code: str
test_results: str
review_status: str
error_count: int
max_errors: int
last_error: Optional[str]
start_time: float
max_execution_time: float # segundos
# ============================================================
# ERROR HANDLING - Nodo dedicado a la gestión de errores
# ============================================================
def error_handler(state: ProductionCodingState) -> dict:
"""Gestiona errores y decide si reintentar o terminar."""
error_count = state.get("error_count", 0) + 1
logger.error(
f"Task {state['task_id']}: error #{error_count} - {state.get('last_error', 'unknown')}"
)
if error_count >= state["max_errors"]:
logger.critical(f"Task {state['task_id']}: max errores alcanzado, terminación")
return {"error_count": error_count, "review_status": "FAILED"}
# Exponential backoff antes del retry
wait_time = min(2 ** error_count, 30)
logger.info(f"Retry en {wait_time}s...")
time.sleep(wait_time)
return {"error_count": error_count, "review_status": "RETRY"}
# ============================================================
# TIMEOUT MANAGEMENT
# ============================================================
def check_timeout(state: ProductionCodingState) -> str:
"""Verifica si la tarea ha superado el timeout máximo."""
elapsed = time.time() - state["start_time"]
if elapsed > state["max_execution_time"]:
logger.warning(
f"Task {state['task_id']}: timeout tras {elapsed:.1f}s "
f"(max: {state['max_execution_time']}s)"
)
return "timeout"
return "continue"
# ============================================================
# COST TRACKING - Rastreo de costes en tiempo real
# ============================================================
class CostTracker:
# Precios Anthropic (USD por 1M tokens, Feb 2026)
PRICES = {
"claude-opus-4-6": {"input": 15.0, "output": 75.0},
"claude-sonnet-4-6": {"input": 3.0, "output": 15.0},
"claude-haiku-4-5": {"input": 0.25, "output": 1.25},
}
def __init__(self, budget_usd: float):
self.budget = budget_usd
self.spent = 0.0
self.calls = 0
def track(self, model: str, input_tokens: int, output_tokens: int) -> None:
prices = self.PRICES.get(model, {"input": 3.0, "output": 15.0})
cost = (input_tokens * prices["input"] + output_tokens * prices["output"]) / 1_000_000
self.spent += cost
self.calls += 1
if self.spent > self.budget * 0.8:
logger.warning(f"Coste tarea: ${self.spent:.4f} (80% del presupuesto ${self.budget})")
def check_budget(self) -> bool:
"""Retorna True si el presupuesto aún está disponible."""
return self.spent < self.budget
def report(self) -> dict:
return {
"total_cost_usd": round(self.spent, 4),
"budget_remaining_usd": round(self.budget - self.spent, 4),
"api_calls": self.calls,
"budget_utilization_pct": round(self.spent / self.budget * 100, 1)
}
# ============================================================
# PERSISTENCIA PRODUCTION CON POSTGRESQL
# ============================================================
# El checkpointing en PostgreSQL garantiza durabilidad del workflow
# incluso en caso de crash de la aplicación
def create_production_app(db_connection_string: str):
"""Crea una aplicación LangGraph con persistencia PostgreSQL."""
# PostgresSaver para persistencia production-grade
checkpointer = PostgresSaver.from_conn_string(db_connection_string)
checkpointer.setup() # crea las tablas si no existen
graph = StateGraph(ProductionCodingState)
# ... adición de nodos y edges ...
return graph.compile(checkpointer=checkpointer)
# ============================================================
# CIRCUIT BREAKER - Protección contra failure en cascada
# ============================================================
class CircuitBreaker:
"""Implementa el Circuit Breaker pattern para agentes poco fiables."""
def __init__(self, failure_threshold: int = 5, recovery_time: int = 60):
self.failure_count = 0
self.failure_threshold = failure_threshold
self.recovery_time = recovery_time
self.last_failure_time = 0
self.state = "CLOSED" # CLOSED=normal, OPEN=bloqueo, HALF-OPEN=test
def call(self, func, *args, **kwargs):
"""Llama a la función a través del circuit breaker."""
if self.state == "OPEN":
if time.time() - self.last_failure_time > self.recovery_time:
self.state = "HALF-OPEN"
logger.info("Circuit breaker: paso a HALF-OPEN")
else:
raise Exception("Circuit breaker OPEN: servicio no disponible")
try:
result = func(*args, **kwargs)
if self.state == "HALF-OPEN":
self.state = "CLOSED"
self.failure_count = 0
logger.info("Circuit breaker: recuperación exitosa, vuelta a CLOSED")
return result
except Exception as e:
self.failure_count += 1
self.last_failure_time = time.time()
if self.failure_count >= self.failure_threshold:
self.state = "OPEN"
logger.error(f"Circuit breaker OPEN tras {self.failure_count} errores")
raiseDesafios e Limitações do Multi-Agent Coding
Sistemas multiagentes em produção apresentam falhas sem obviações que surgem apenas com experiência. Conhecimento prévio é a diferença entre um sistema robusto e aquele que interrompe a produção no pior momento.
Os 5 Desafios Principais
- Context Pollution: cuando un agente incluye en sus outputs información irrelevante o ruidosa que influye negativamente en los agentes siguientes. Solución: definir output schemas estructurados (JSON/Pydantic) en lugar de texto libre.
- Propagação de erros: um erro em um agente upstream amplifica em todo o pipeline, gerando resultados cada vez mais distantes da realidade. Solução: Valide as saídas em cada etapa do processo com validação de esquema e fallback.
- Cost Explosion: un bucle de revisión que no converge puede generar cientos de API calls y costes en el orden de decenas de dólares por tarea. Solución: budget tracking con hard limits y circuit breaker.
- Inconsistencia entre agentes: dos agentes pueden hacer suposiciones diferentes sobre el mismo punto arquitectónico, generando código inconsistente. Solución: shared state explícito o documento de contexto compartido.
- Complejidad de monitoring: más allá de 5 agentes, el debugging se vuelve exponencialmente más complejo. Solución: distributed tracing con correlation ID para cada tarea y estructura de logs estandarizada.
Um estudo importante a ter em conta: as investigações de 2025 vão mostrar mais 75% dos sistemas multiagentes tornam-se difíceis de gerenciar quando excedem o 5 agentes, principalmente para o crescimento da complexidade de depuração e monitoramento. Sempre empregue o número mínimo de agentes necessários.
Best Practices para Multi-Agent Systems Eficazes
1. Especialização Cirúrgica dos Agentes
Cada agente deve assumir uma responsabilidade primária e um conjunto de
Manutenção mínima necessária para completá-lo. Um agente que faz tudo na prática
agente que não faz nada bem. Na definição de system_message ou
de backstory, específico: "Você é um engenheiro de segurança especializado
OWASP Top 10" é infinitamente mais eficaz do que "você é um especialista em segurança".
2. Output Schemas Estruturados
Use modelos Pydantic ou esquema JSON para definir os resultados esperados de cada agente.
O texto livre introduz ambiguidade que é amplificada em todo o pipeline.
Um agente que produz um ReviewReport com campos
critical_issues: List[Issue] é infinitamente mais conto de fadas do que um
que produz um texto não estruturado que o agente seguinte deve interpretar.
3. Monitoring e Observability
En producción, cada invocación de agente debe ser rastreada con: timestamp, modelo usado, tokens input/output, coste, latencia y estado. Para LangGraph usa LangSmith; para CrewAI usa enterprise observability; para AG2 usa OpenTelemetry. Para sistemas custom, estructura siempre los logs con correlation ID.
4. Fallback e Graceful Degradation
Cada agente crítico deve ter um substituto: um agente mais simples (mais modelo econômico), uma resposta em cache ou uma trilha de escalada humana. O sistema deve continuar funcionando, mesmo de forma degradada, mesmo quando um agente falha.
5. Iterações Limitadas com Convergência Forçada
Qualquer bloco de revisão deve ter um número máximo de iterações.
A convergência não pode ser garantida na forma teórica: um revisor, por favor
sempre modificações e um desenvolvedor que sempre as implementa de forma leve
diferente poderia ser transformado indefinidamente. Sempre estável max_iterations
e aceitar o “melhor disponível” quando o limite for atingido.
from pydantic import BaseModel, Field
from typing import List, Literal, Optional
from langchain_anthropic import ChatAnthropic
from langchain_core.messages import HumanMessage
# ============================================================
# OUTPUT SCHEMAS ESTRUCTURADOS - Eliminan ambigüedad entre agentes
# ============================================================
class Issue(BaseModel):
"""Problema individual identificado en la code review."""
file_path: str = Field(description="Path del archivo con el problema")
line_number: Optional[int] = Field(default=None, description="Número de línea")
severity: Literal["CRITICAL", "HIGH", "MEDIUM", "LOW"]
category: Literal["security", "logic", "performance", "style", "test_coverage"]
description: str = Field(description="Descripción clara del problema")
suggested_fix: str = Field(description="Fix recomendado con ejemplo de código")
class CodeReviewReport(BaseModel):
"""Reporte estructurado de code review."""
approved: bool = Field(description="True si el código puede ser mergeado")
summary: str = Field(description="Resumen ejecutivo en 2-3 frases")
critical_issues: List[Issue] = Field(default_factory=list)
warnings: List[Issue] = Field(default_factory=list)
suggestions: List[Issue] = Field(default_factory=list)
security_score: int = Field(ge=0, le=100, description="Score seguridad 0-100")
quality_score: int = Field(ge=0, le=100, description="Score calidad 0-100")
test_coverage_estimate: float = Field(
ge=0.0, le=1.0,
description="Estimación cobertura tests (0.0-1.0)"
)
class SecurityAuditReport(BaseModel):
"""Reporte de security audit estructurado."""
has_critical_vulnerabilities: bool
owasp_findings: List[Issue] = Field(default_factory=list)
hardcoded_secrets: List[str] = Field(default_factory=list)
vulnerable_dependencies: List[str] = Field(default_factory=list)
remediation_priority: Literal["immediate", "high", "medium", "low"]
cvss_score_estimate: float = Field(ge=0.0, le=10.0)
# ============================================================
# UTILIZACIÓN: agente con output estructurado
# ============================================================
def code_reviewer_with_schema(code: str) -> CodeReviewReport:
"""Agente code reviewer que produce output estructurado."""
model = ChatAnthropic(model="claude-sonnet-4-6")
# Usa structured output para garantizar formato correcto
structured_model = model.with_structured_output(CodeReviewReport)
prompt = f"""Realiza una code review en profundidad del siguiente código Python:
{code}
Analiza por: corrección lógica, calidad, seguridad, performance y cobertura de tests."""
report = structured_model.invoke([HumanMessage(content=prompt)])
return report
# ============================================================
# UTILIZACIÓN EN EL GRAFO LANGGRAPH
# ============================================================
def reviewer_node(state: dict) -> dict:
"""Nodo LangGraph que usa output estructurado."""
report = code_reviewer_with_schema(state["generated_code"])
return {
"review_approved": report.approved,
"critical_issues": [issue.model_dump() for issue in report.critical_issues],
"security_score": report.security_score,
"quality_score": report.quality_score,
# El próximo agente recibe datos estructurados, no texto ambiguo
"review_report": report.model_dump()
}Conclusiones: O Futuro dos Multi-Agent Systems em 2026
El multi-agent coding en 2025 ha madurado de proof-of-concept a herramienta production-ready. LangGraph domina para workflows complejos y controlados, CrewAI para equipos virtuales con roles definidos, AG2 para tareas exploratorias con code execution real, y Claude Code para automatización nativa en el ecosistema Anthropic.
A tendência mais significativa para 2026 é padronização de protocolos interagente: Model Context Protocol (MCP) e Agent-to-Agent (A2A) estão emergindo como padrões de facto que permitirão que agentes de diferentes estruturas se comuniquem entre si. Não existe mais um futuro em que um agente LangGraph possa ligar para um especialista da CrewAI Se você usar uma ferramenta AG2, não é ficção científica: isso é parcialmente possível.
Para os desenvolvedores que querem se juntar a você, o conselho é prático: não saia da estrutura mais sofisticada. Trabalhe com dois agentes (desenvolvedor + revisor) usando o melhor know-how, entre os resultados, e até completo apenas quando o problema realmente o acalma. A regra de ouro da engenharia de software também pode ser aplicado aqui: o melhor sistema multiagente é o mais simples de resolver seu problema.
Próximos Passos Recomendados
- Artículo anterior: lee Workflows Agénticos: Descomponer Problemas para IA para entender cómo estructurar las tareas antes de paralelizarlas
- Artículo siguiente: ve a Testear el Código Generado por IA para estrategias de quality assurance específicas para código generado por IA
- Seguridad: lee Seguridad en el Vibe Coding para gestionar las vulnerabilidades en los sistemas multi-agent
- Claude específico: profundiza en Claude Code: Desarrollo Agéntico desde Terminal para los detalles del sistema sub-agent nativo
A Série Vibe Coding e Desenvolvimento Agêntico
Este es el cuarto artículo de la serie. Los artículos anteriores cubren el paradigma vibe coding, Claude Code desde el terminal, y la descomposición de workflows agénticos. Los próximos artículos tratarán sobre testing de código generado por IA, prompt engineering para IDE, seguridad en vibe coding y el futuro del desarrollo agéntico en 2026.