04 - Multi-Agent Coding: LangGraph, CrewAI und AutoGen
Stellen Sie sich vor, Sie nähern sich einer vollständigen Aufgabe: der Implementierung eines Authentifizierungssystems für eine Unternehmensanwendung, komplett mit OAuth2, RBAC, Audit-Log, Integrationstests und Dokumentation. Man wird übrigens auf einen einzelnen KI-Agenten stoßen, der a verwaltet gesättigtes Kontextfenster, widersprüchliche Verantwortlichkeiten und ein hohes Fehlerrisiko in Kaskade. Die Lösung ist kein stärkerer Agent: Sie ist ein Team von Agenten Spezialisten die zusammenarbeiten, sich gegenseitig überprüfen und die Arbeit parallelisieren.
Dies ist das Paradigma von Multi-Agent-Codierung: Systeme mit mehreren KI-Agenten arbeiten unabhängig voneinander zusammen, um Softwareentwicklungsaufgaben zu erledigen, die die Kapazität eines Einzelnen überschreiten einziges Modell. Bis 2025 dominieren drei Frameworks diesen Bereich: LangGraph mit seiner Stateful-Graph-Architektur, CrewAI mit seinem rollenbasierten Modell intuitiv, y AutoGen (jetzt AG2) mit seinem Konversationsschwerpunkt. Hier Das native System von Claude Code wird mit seinen parallelen Subagenten kombiniert.
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.
Was Sie Lernen Werden
- 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
Warum ein Einzelner Agent Nicht Ausreicht
Bevor man sich mit den Rahmenbedingungen befasst, ist es wichtig, das bestehende grundlegende Problem zu verstehen Multi-Agent-Codierungsauflösung. Ein einzelner KI-Agent unterliegt ohnehin Einschränkungen Strukturelemente, die sich in den gesamten Entwicklungsbereichen deutlich abzeichnen.
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.
Die zweite Grenze ist da Spezialisierung. Ein generalistischer Agent hält alles in mittelmäßiger Form zu machen, anstatt einige Dinge in hervorragender Form. Ein Agent Der auf Sicherheit spezialisierte Mitarbeiter weiß genau, auf welche Kunden er achten und welche Standards er anwenden muss. während ein Testspezialist die Testregeln für jeden Komponententyp kennt.
Die dritte Grenze ist da gegengeprüft. Ein einzelner Agent, der schreibt Code und wobei die „Prüfung“ im Grunde darin besteht, Ihre eigene Arbeit damit zu überprüfen Ich führe eine kognitive Konversation mit dem, was ich produziere. Zwei separate Agenten, einer implementiert und ein anderer implementiert Rezension, bringen Sie wirklich unterschiedliche Perspektiven ein.
Das Prinzip der Rollentrennung
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: Stateful-Graph-Orchestrierung
LangGraph, entwickelt vom LangChain-Team, repräsentiert die natürliche Entwicklung des Fokus de cadenas lineales hacia Zustandsbehaftete zyklische Diagramme. Grundlegende Intuition Das heißt, komplexe Agenturabläufe sind nicht linear: Sie erfordern Lücken, bedingte Verzweigungen, Parallelität und Beständigkeit des Zustands zwischen einem Schritt und dem nächsten.
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.
Grundlegende Konzepte von 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
- Zustand: ein TypedDict (oder Pydantic-Modell), das die Informationen darstellt wird von allen Knoten des Diagramms gemeinsam genutzt
- Knoten: Python-Funktionen, die den Status empfangen, führen eine Operation aus (im Allgemeinen ein Anruf bei einem LLM) und Aktualisierungen des Staates
- 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: Stärken
- 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 für Virtuelle Teams
CrewAI verfolgt einen grundlegend anderen Fokus als LangGraph: statt darüber nachzudenken Begriffe von Diagrammen und Zuständen, in denen Sie denken sollten Teams und Rollen. Jeder Agent ist ein Mitglied des Teams mit einer definierten Spezialisierung und einem klaren Ziel und eine Reihe von Hardware zur Verfügung. Dieses mentale Modell ist für die Menschen am intuitivsten zu befolgen Erfahrung in der Leitung von Entwicklungsteams.
In Version 1.1.0 von 2025 führte CrewAI die Trennung zwischen ein Besatzungen (Orchestrierung auf hohem Niveau) y Fließt (granulare Steuerung von Arbeitsabläufen), Bietet die Flexibilität von LangGraph mit der Einfachheit des rollenbasierten Modells.
CrewAI-Architektur
Los cuatro elementos fundamentales de CrewAI son:
- Agenten: eine KI-Einheit mit definierten Rollen, Zielen und Hintergrundgeschichten „Persönlichkeit“ und Kompetenzbereich
- Aufgaben: eine bestimmte Aktivität mit Beschreibung, erwartete_Ausgabe y einem bestimmten Agenten zugeordnet
- Tool: capacidades adicionales de los agentes (file I/O, web search, code execution, database access)
- Crew: das Team, das Agenten orchestriert und einen Prozess ausprobiert (sequentiell oder parallel)
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)
Ein besonderes Element von CrewAI 2025 ist die Option allow_code_execution=True
für Agenten: Aktivieren Sie die Codeausführung in einer sicheren Sandbox mit automatischer Verwaltung
de Fehler und intelligente Wiederholung. Wenn der Code eine Ausnahme generiert, erhält der Agent diese
meldet den Fehler und versucht, ihn selbstständig zu beheben (hasta max_retry_limit,
Standard 2).
CrewAI: Stärken
- Lernkurve baja: el modelo mental equipo/roles es intuitivo
- Integrierte Codeausführung: Sichere Sandbox mit automatischer Wiederholung
- Memoria compartida: los agentes recuerdan el contexto de conversaciones anteriores
- MCP unterstützt: Bidirektionale Integration mit MCP-Servern (2025)
- Enterprise features: observabilidad, audit log, control plane SaaS
- Flows: control granular para workflows complejos cuando sea necesario
AutoGen/AG2: Conversational Agents für Emergent Aufgaben
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
Der Grundbaustein von AG2 ist derselbe AssistantAgent (KI-Agent) j UserProxyAgent (Stellvertreter für die Ausführung). Der UserProxyAgent kann ausgeführt werden Ich programmiere in einer lokalen Sandbox und gebe dem AssistantAgent, der teilnehmen kann, echtes Feedback Iterieren Sie die Lösung basierend auf den effektiven Ergebnissen der Ausführung.
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: Stärken
- 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
- AG-UI-Protokoll: dynamische Frontends mit Echtzeit-Streaming (2025)
- OpenTelemetry: observabilidad completa de los workflows agénticos
- Human-in-the-Loop: einfach konfigurierbar mit
human_input_mode - TypeScript-Unterstützung: Microsoft AutoGen 0.4-Version mit nativer Unterstützung
Claude Code: Sub-Agents und Parallele Ausführung
Claude Code verfügt über ein natives Multiagentensystem, das grundlegend anders funktioniert Ich habe jetzt die Python-Frameworks gesehen. Anstelle der Bestellung von LLM-Modellen über die API bietet Claude Code Lanze Claude trennte sich (Unteragenten) direkt vom Terminal aus, jedes mit seinem eigenen klaren Kontextfenster und der Möglichkeit, im Dateisystem zu arbeiten de forma aislada.
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.Lektion aus dem Replit-Vorfall (2025)
Im Jahr 2025 dokumentierte Replit einen Fall, in dem ein autonomer Agent eliminiert wurde
eine Grundlage für Produktionsdaten während eines „Cleanup“-Bereichs. Dieser Unfall
betonte die Notwendigkeit, Grenzwerte in den Befehlen explizit zu konfigurieren
destruktiv. In Claude Code wird dies abschnittsübergreifend verwaltet deny
en .claude/settings.json: blockiert immer rm -rf,
DROP TABLE, git push --force und ähnliches.
Für die Subagenten gelten die strengsten Auflagen des Hauptagenten.
Detaillierter Vergleich: Welches Framework Wählen
Die Wahl des Frameworks hängt vom konkreten Kontext ab. Es gibt keinen absoluten Ganador: Jedes Stück zeichnet sich in verschiedenen Szenarien aus. Die folgende Tabelle fasst die Unterschiede zusammen Schlüssel, der Ihnen bei der Entscheidungsfindung hilft.
| Kriterium | LangGraph | CrewAI | AG2 (AutoGen) | Claude Code |
|---|---|---|---|---|
| Paradigma | Grafo stateful | Role-based Team | Konversationell | Sub-agent nativo |
| Lernkurve | Hoch (Graph Theory) | Niedrig (intuitiv) | Media | Baja |
| Flusskontrolle | Maximum | Mittel-hoch | Emergent | Medium |
| Code execution | Über Tool | Integrada (sandbox) | Integrada (local) | Bash nativo |
| State persistence | Checkpointing nativo | Integrierter Speicher | Chat-Nachrichten | Filesystem |
| Parallelismus | Parallele Knoten | Process.parallel | GroupChat async | Task tool nativo |
| Observierbarkeit | LangSmith | CrewAI Enterprise | OpenTelemetry | Native Logs |
| Human-in-the-loop | Interrupt nativo | Callback | human_input_mode |
Interaktiv |
| Ökosystem | LangChain | Unabhängig | Microsoft/AG2 | Anthropic |
| Ideal für | Komplexe Workflows mit bedingter Logik | Virtuelle Teams mit definierten Rollen | Explorative Aufgaben mit Code-Ausführung | CLI-Automatisierung und bestehende Projekte |
Praktische Empfehlungen
- 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 Wenn die Aufgabe explorativ ist und keinen vordefinierten Workflow hat, Ich brauche wirklich Gespräche über mehrere Runden mit echter Codeausführung. und befindet sich im Microsoft-Ökosystem (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.
Production-Ready-Architektur für Reale Teams
Ein Multiagentensystem in der Produktion erfordert architektonische Überlegungen, die berücksichtigt werden müssen mehr als die einfache Orchestrierung von Agenten. Die Unternehmen, die diese eingesetzt haben Die Systeme im Jahr 2025 haben einige wichtige Lektionen gelernt, die es zu wissen gilt de empezar.
Konsolidierte Architekturmuster
Las investigaciones de 2025 muestran que los patrones más eficaces para multi-agent coding en producción son tres:
- Vorgesetztenmuster: Ein Agent oder Questador delegiert Aufgaben an Agenten spezialisieren und aggregieren die Ergebnisse. Ideal für LangGraph mit bedingtem Routing.
- Pipeline Pattern: agentes en secuencia donde el output de uno
se convierte en el input del siguiente. Natural en CrewAI con
contexty tareas dependientes. - Peer-to-Peer-Muster: Agenten, die frei zwischen Ihnen kommunizieren ohne zentrales Orchester. Natural und AG2 mit 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")
raiseHerausforderungen und Einschränkungen des Multi-Agent Coding
Multi-Agenten-Systeme in der Produktion stellen Fehler dar, ohne dass Fehler auftreten, die erst auftreten mit Erfahrung. Vorkenntnisse machen den Unterschied zwischen einem robusten System und eines, das im schlimmsten Moment die Produktion unterbricht.
Die 5 Hauptherausforderungen
- 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.
- Fehlerausbreitung: ein Fehler in einem vorgelagerten Agenten verstärkt sich über die gesamte Pipeline hinweg und erzeugt jedes Mal Ergebnisse, die weiter von der Realität entfernt sind. Lösung: Validieren Sie die Ausgaben bei jedem Schritt mit Schemavalidierung und 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.
Eine wichtige Studie, die man im Hinterkopf behalten sollte: Die Untersuchungen von 2025 werden mehr zeigen 75 % der Multiagentensysteme werden schwierig zu verwalten, wenn sie die Grenze überschreiten 5 Agenten, hauptsächlich für die Erhöhung der Debugging-Komplexität y Überwachung. Setzen Sie immer die minimal erforderliche Anzahl an Agenten ein.
Best Practices für Effektive Multi-Agent Systems
1. Chirurgische Spezialisierung der Agenten
Jeder Agent muss nehmen eine Hauptverantwortung und ein Conjunto de
Zur Fertigstellung ist nur ein minimaler Wartungsaufwand erforderlich. Ein Agent, der alles in der Praxis erledigt
Agent, der nichts gut macht. In der Definition von system_message oder
von backstory, spezifisches Ich: „Sie sind ein spezialisierter Sicherheitsingenieur
„OWASP Top 10“ ist unendlich effektiver als „Sie sind ein Sicherheitsexperte“.
2. Strukturierte Output-Schemas
Verwenden Sie Pydantic-Modelle oder JSON-Schemas, um die erwarteten Ausgaben jedes Agenten zu definieren.
Der freie Text führt zu Mehrdeutigkeiten, die in der gesamten Pipeline verstärkt werden.
Ein Agent, der a produziert ReviewReport mit Campos
critical_issues: List[Issue] es ist unendlich märchenhafter als eines
Dadurch entsteht ein unstrukturierter Text, den der folgende Agent interpretieren muss.
3. Monitoring und 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 und Graceful Degradation
Jeder kritische Agent muss einen Fallback haben: einen einfacheren Agenten (mehr Modell). wirtschaftlich), eine zwischengespeicherte Antwort oder ein menschlicher Kletterpfad. Das System muss weiterhin funktionieren, auch in beeinträchtigter Form, selbst wenn ein Agent ausfällt.
5. Begrenzte Iterationen mit Erzwungener Konvergenz
Jeder Überprüfungsblock muss eine maximale Anzahl von Iterationen haben.
Konvergenz kann in theoretischer Form nicht garantiert werden: Bitte um einen Gutachter
immer Modifikationen und ein Entwickler, der diese immer leicht umsetzt
anders könnte auf unbestimmte Zeit gedreht werden. Immer stabil max_iterations
und akzeptieren Sie das „Beste verfügbar“, wenn das Limit erreicht ist.
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: Die Zukunft der Multi-Agent Systems im Jahr 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.
Der wichtigste Trend für 2026 ist Standardisierung von Protokollen Inter-Agent: Model Context Protocol (MCP) und Agent-to-Agent (A2A) entstehen als De-facto-Standards, die es Agenten aus verschiedenen Frameworks ermöglichen, miteinander zu kommunizieren. Es gibt keine Zukunft mehr, in der ein LangGraph-Agent einen CrewAI-Spezialisten anrufen kann Wenn Sie jemals ein AG2-Tool verwenden, ist das keine Science-Fiction: Das ist teilweise möglich.
Für Entwickler, die sich Ihnen anschließen möchten, ist der Rat praktisch: Gehen Sie nicht des ausgefeiltesten Frameworks. Arbeiten Sie mit zwei Agenten (Entwickler + Prüfer). das beste Know-how, unter den Ergebnissen, und sogar vollständig nur wenn das Problem ihn wirklich beruhigt. Die goldene Regel der Softwareentwicklung Auch hier gilt: Das beste Multiagentensystem ist am einfachsten zu lösen Du Problem.
Empfohlene Nächste Schritte
- 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
Die Serie Vibe Coding und Agentische Entwicklung
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.