04 - Multi-Agent Coding: LangGraph, CrewAI a AutoGen
Představte si, že stojíte před složitým úkolem: implementace autentizačního systému od nuly pro podnikovou aplikaci, kompletní s OAuth2, RBAC, protokolem auditu, integračními testy a dokumentaci. Jediný agent umělé inteligence, jakkoli schopný, by zjistil, že bude spravovat a přeplněné kontextové okno, protichůdné odpovědnosti a vysoké riziko chyb kaskádové. Řešením není silnější prostředek: je jedním tým agentů specialisté které spolupracují, vzájemně se ověřují a paralelizují práci.
Toto je paradigma Multiagentní kódování: systémy, ve kterých je více agentů AI autonomní lidé spolupracují na dokončení úkolů vývoje softwaru, které přesahují kapacitu jednoho jediný model. V roce 2025 dominovaly tomuto prostoru tři rámce: LangGraph s jeho stavovou grafovou architekturou, CrewAI se svým modelem založeným na rolích intuitivní, např AutoGen (nyní AG2) se svým konverzačním přístupem. K těmto Je přidán nativní systém Claude Code s jeho paralelními sub-agenty.
Tento článek je pokročilý hluboký ponor do všech čtyř systémů: architektury, příklady kódu funkční, podrobné srovnání a praktický průvodce výběrem toho správného pro váš případ použití. Pokud jste již obeznámeni se základními koncepty kódování vibrací a chcete přinést své vlastní agentské pracovní postupy do další úrovně, jste na správném místě.
Co se naučíte
- protože jediný agent umělé inteligence na složité vývojové úkoly nestačí
- LangGraph: Architektura grafů, StateGraph, Nodes, Edges a Checkpointing
- CrewAI: agenti na základě rolí, úkoly, sekvenční a paralelní procesy, nástroje
- AutoGen/AG2: konverzační agenti, GroupChat, sandbox pro provádění kódu
- Claude Code: dílčí agenti, nástroje úloh a vzory paralelního provádění
- Podrobné srovnání: kdy použít který rámec
- Architektura připravená na výrobu pro skutečné týmy
- Kritické výzvy: znečištění kontextu, šíření chyb, řízení nákladů
- Osvědčené postupy pro specializované agenty a záložní strategie
protože jeden agent nestačí
Než se ponoříme do rámců, je důležité pochopit základní problém, který multiagentní kódování řeší. Jediný agent AI, bez ohledu na to, jak pokročilý, má omezení strukturální rysy, které se jasně objevují ve složitých vývojových úkolech.
První limit je kontextové okno. I s modely, které podporují 200 000 tokenů, typický podnikový úkol vyžaduje, abyste současně měli na paměti: existující kódovou základnu, funkční specifikace, architektonické vzory, testy z napsat, dokumentaci k aktualizaci a bezpečnostní omezení. To vše překonává rychle schopnosti jediného koherentního kontextu.
Druhým limitem je specializace. Všeobecný agent má tendenci dělat všechno spíše průměrným způsobem než některé věci excelentním způsobem. Agent specializovaný na bezpečnost přesně ví, jaké vzory hledat a jaké standardy použít, zatímco někdo specializovaný na testování zná testovací vzory pro každý typ součásti.
Třetí limit je křížová kontrola. Jediný agent, který píše kód a pak "testování" je v podstatě kontrola vaší práce s tím samým kognitivní zaujatost, se kterou to produkoval. Dva oddělení agenti, jeden, který implementuje a jeden který recenze, přinášejí skutečně odlišné pohledy.
Princip oddělení rolí
V týmech lidského vývoje je oddělení rolí (vývojář, kontrolor kódu, QA, bezpečnostní inženýr, technický spisovatel) není byrokracie: je to kognitivní ochrana. Multiagentní systémy uplatňují stejný princip na kód generovaný AI, systematicky redukovat slepá místa každého jednotlivého agenta.
Výzkum z roku 2025 tuto intuici potvrzuje: kód generovaný AI má rychlost výrazně vyšší zranitelnosti, když jsou vytvářeny jedinými agenty bez dozoru (Veracode 2025 uvádí 2,74x více zranitelností než lidský kód). Systémy multi-agent s vyhrazenými revizními agenty tuto mezeru podstatně snižují.
LangGraph: Stateful Graph Orchestration
LangGraph, vyvinutý týmem LangChain, představuje přirozený vývoj přístupu k lineárním řetězcům směrem k cyklické stavové grafy. Základní intuice a že komplexní agentní pracovní postupy nejsou lineární: vyžadují smyčky, podmíněné bifurkace, paralelismus a přetrvávání stavu mezi jedním průchodem a druhým.
Samotný tým LangChain v roce 2025 výslovně komunikoval: „Používejte LangGraph pro agenty, ne LangChain." Tato volba odráží důležitou architektonickou pravdu: agentní systémy Moderní systémy byly v podstatě stroje, nikoli sekvenční potrubí.
Základní pojmy LangGraph
LangGraph je založen na čtyřech klíčových konceptech, které si musíte před stavbou osvojit efektivní multiagentní systémy:
- StateGraph: e. hlavní graf, který definuje strukturu pracovního postupu typ stavu sdíleného mezi uzly
- Stát: TypedDict (nebo Pydantický model) představující informace sdílené mezi všemi uzly grafu
- Uzly: Funkce Pythonu, které přijímají stav, provádějí operaci (často volání do LLM) a vrátit aktualizace stavu
- Hrany: spojení mezi uzly, která mohou být pevná nebo podmíněná na základě aktuálního stavu
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. DEFINIZIONE DELLO STATO CONDIVISO
# ============================================================
class CodingState(TypedDict):
"""Stato condiviso tra tutti gli agenti 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. INIZIALIZZAZIONE DEI MODELLI
# ============================================================
# Planner: usa Opus per ragionamento complesso
planner_model = ChatAnthropic(model="claude-opus-4-6")
# Developer: usa Sonnet per code generation veloce
developer_model = ChatAnthropic(model="claude-sonnet-4-6")
# Reviewer: usa Sonnet per analisi critica
reviewer_model = ChatAnthropic(model="claude-sonnet-4-6")
# ============================================================
# 3. DEFINIZIONE DEI NODI (AGENTI)
# ============================================================
def planner_agent(state: CodingState) -> dict:
"""Agente pianificatore: decompone il task in requirements."""
prompt = f"""Sei un software architect senior.
Task: {state['task_description']}
Analizza il task e produci una lista di requisiti tecnici specifici.
Formato: una lista puntata di requisiti chiari e implementabili.
"""
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 sviluppatore: implementa il codice dai requirements."""
requirements_text = "\n".join(f"- {r}" for r in state["requirements"])
prompt = f"""Sei un senior Python developer.
Implementa il seguente codice rispettando tutti i requisiti:
Task originale: {state['task_description']}
Requisiti:
{requirements_text}
Codice esistente (se presente):
{state.get('generated_code', 'Nessun codice precedente')}
Note del reviewer (se presenti):
{chr(10).join(state.get('review_comments', []))}
Produci SOLO il codice Python, senza spiegazioni.
"""
response = developer_model.invoke([HumanMessage(content=prompt)])
return {
"generated_code": response.content,
"status": "testing"
}
def test_writer_agent(state: CodingState) -> dict:
"""Agente test writer: scrive unit test per il codice generato."""
prompt = f"""Sei un QA engineer specializzato in Python testing.
Scrivi unit test completi per il seguente codice usando pytest:
{state['generated_code']}
Requisiti dei test:
- Copertura minima: 80%
- Testa happy path e edge cases
- Include test per casi di errore
- Usa fixtures dove appropriato
Produci SOLO il codice dei test, senza spiegazioni.
"""
response = developer_model.invoke([HumanMessage(content=prompt)])
return {
"test_code": response.content,
"status": "reviewing"
}
def code_reviewer_agent(state: CodingState) -> dict:
"""Agente code reviewer: analizza codice e test per qualità."""
prompt = f"""Sei un senior code reviewer con 10+ anni di esperienza.
Rivedi il seguente codice e i suoi test:
CODICE:
{state['generated_code']}
TEST:
{state['test_code']}
Analizza per:
1. Correttezza logica
2. qualità del codice (SOLID, DRY, KISS)
3. Completezza dei test
4. Performance
5. Leggibilita e manutenibilità
Se ci sono problemi critici, rispondimi con "NEEDS_REVISION:" seguito dai problemi.
Se il codice e accettabile, rispondimi con "APPROVED:" seguito da eventuali suggerimenti minor.
"""
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 sicurezza: verifica vulnerabilità nel codice."""
prompt = f"""Sei un security engineer specializzato in application security.
Analizza il seguente codice per vulnerabilità di sicurezza:
{state['generated_code']}
Cerca specificamente:
- Injection vulnerabilities (SQL, Command, Path traversal)
- Insecure deserialization
- Hardcoded secrets o credenziali
- Insecure random number generation
- Race conditions
- Input validation gaps
Lista SOLO i problemi trovati. Se nessun problema, scrivi "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 CONDIZIONALE
# ============================================================
def route_after_review(state: CodingState) -> str:
"""Decide il prossimo nodo dopo 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 iterazioni raggiunte
return "security"
def route_after_security(state: CodingState) -> str:
"""Decide se il codice e pronto o necessità un'altra iterazione."""
if state["security_issues"] and state.get("iteration_count", 0) < 3:
return "developer"
return END
# ============================================================
# 5. COSTRUZIONE DEL GRAFO
# ============================================================
def build_coding_graph() -> StateGraph:
graph = StateGraph(CodingState)
# Aggiunta nodi
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 fissi
graph.add_edge("planner", "developer")
graph.add_edge("developer", "test_writer")
graph.add_edge("test_writer", "reviewer")
# Edges condizionali
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. ESECUZIONE CON CHECKPOINTING
# ============================================================
checkpointer = MemorySaver()
app = build_coding_graph().compile(checkpointer=checkpointer)
# Esecuzione del sistema
config = {"configurable": {"thread_id": "project-auth-001"}}
initial_state = {
"task_description": """
Implementa un sistema di autenticazione JWT in Python con:
- Login con username/password
- Generazione access token (15 min) e refresh token (7 giorni)
- Middleware per proteggere endpoint
- Revoca token (blacklist in 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"Codice finale generato dopo {result['iteration_count']} iterazioni")
print(f"Problemi di sicurezza rilevati: {len(result['security_issues'])}")Tento příklad ukazuje, jak LangGraph zpracovává komplexní vývojový pracovní postup automatické revizní smyčky. The kontrolní bod a kritická vlastnost pro výrobu: umožňuje uložit stav grafu a obnovit provádění v případě chyb, aniž byste začínali od nuly.
LangGraph: Silné stránky
- Granulární kontrola: každý aspekt toku je programovatelný
- Stálost stavu: Integrované kontrolní body pro dlouhé pracovní postupy
- Člověk ve smyčce: možnost pauzy na schválení člověkem
- Paralelní provedení: uzly mohou běžet paralelně
- Streamování: výstup z každého uzlu v reálném čase
- Testovaná výroba: používá ve výrobě stovky společností v roce 2025
CrewAI: Role-Based Agents pro virtuální týmy
CrewAI zaujímá k LangGraph zásadně odlišný přístup: namísto přemýšlení pokud jde o grafy a stavy, žádá vás, abyste přemýšleli v pojmech týmy a role. Každý agent je členem týmu s definovanou specializací, jasným cílem a sadu dostupných nástrojů. Tento mentální model je intuitivnější pro ty, kteří mají Zkušenosti s vedením vývojových týmů.
Ve verzi 2025 1.1.0 zavedla CrewAI oddělení mezi Posádky (orchestrace na vysoké úrovni) e Toky (granulované řízení pracovního postupu), nabízí flexibilitu LangGraph s jednoduchostí modelu založeného na rolích.
Architektura CrewAI
Čtyři základní prvky CrewAI jsou:
- Zástupci: entita AI s rolemi, cíli a příběhem, které definují její vlastní „osobnost“ a oblast odbornosti
- úkoly: konkrétní činnost s popisem, očekávaným_výstupem a assigned to a specific agent
- Nástroje: další možnosti agenta (vstup/výstup souborů, vyhledávání na webu, code execution, database access)
- Posádka: tým, který organizuje agenty a úkoly s procesem (sekvenční nebo paralelní)
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. CONFIGURAZIONE MODELLI
# ============================================================
opus_llm = ChatAnthropic(model="claude-opus-4-6", temperature=0.1)
sonnet_llm = ChatAnthropic(model="claude-sonnet-4-6", temperature=0.2)
# ============================================================
# 2. DEFINIZIONE DEGLI STRUMENTI
# ============================================================
code_executor = CodeInterpreterTool()
file_reader = FileReadTool()
file_writer = FileWriteTool()
# ============================================================
# 3. DEFINIZIONE DEGLI AGENTI (MEMBRI DEL TEAM)
# ============================================================
tech_lead = Agent(
role="Tech Lead e Software Architect",
goal="""Analizzare i requisiti tecnici, definire l'architettura ottimale
e decomporre il lavoro in task specifici e implementabili.""",
backstory="""Hai 15 anni di esperienza in software architecture.
Hai guidato la transizione a microservizi per 3 startup unicorn.
Sei noto per la capacità di bilanciare pragmatismo e qualità tecnica.""",
llm=opus_llm,
verbose=True,
allow_delegation=True
)
senior_developer = Agent(
role="Senior Python Developer",
goal="""Implementare codice Python di alta qualità, pulito, testabile
e conforme alle best practices SOLID e alle specifiche del tech lead.""",
backstory="""Sei un Python developer con 8 anni di esperienza.
Contribuisci a progetti open source importanti.
Scrivi codice che altri developer amano leggere e mantenere.""",
llm=sonnet_llm,
verbose=True,
tools=[code_executor, file_writer],
allow_code_execution=True
)
qa_engineer = Agent(
role="QA Engineer e Test Specialist",
goal="""Verificare la correttezza del codice attraverso test exhaustivi,
trovare edge cases e garantire la copertura dei test al 90%+.""",
backstory="""Hai un background in matematica e sei ossessionato dalla
correttezza del software. Hai trovato bug critici in sistemi che erano
in produzione da anni. Non ti fidi del codice senza prove.""",
llm=sonnet_llm,
verbose=True,
tools=[code_executor],
allow_code_execution=True
)
code_reviewer = Agent(
role="Senior Code Reviewer",
goal="""Analizzare criticamente il codice per qualità, manutenibilità,
performance e conformità agli standard del team.""",
backstory="""Hai revisionato oltre 10.000 pull request nella tua carriera.
Hai un occhio infallibile per code smells, anti-pattern e problemi
di design che si manifestano solo in produzione.""",
llm=sonnet_llm,
verbose=True,
tools=[file_reader]
)
# ============================================================
# 4. DEFINIZIONE DEI TASK
# ============================================================
architecture_task = Task(
description="""
Analizza il seguente requisito e produci un documento di architettura:
REQUISITO: {task_description}
Il documento deve includere:
1. Diagramma dei componenti (in testo/ASCII)
2. Stack tecnologico raccomandato con giustificazioni
3. Struttura delle directory del progetto
4. Interfacce principali (classi/funzioni pubbliche)
5. Considerazioni su scalabilità e manutenibilità
6. Lista prioritizzata di task di implementazione
""",
expected_output="""Un documento di architettura dettagliato in markdown,
con diagrammi ASCII, struttura del progetto e lista di task.""",
agent=tech_lead
)
implementation_task = Task(
description="""
Implementa il codice Python basandoti sul documento di architettura
fornito dal Tech Lead.
Requisiti di implementazione:
- Segui esattamente le interfacce definite nell'architettura
- Usa type hints per tutte le funzioni pubbliche
- Aggiungi docstring in formato Google style
- Gestisci tutti i casi di errore con eccezioni custom
- Salva il codice in file separati per modulo
""",
expected_output="""Codice Python completo e funzionante, organizzato in moduli,
con type hints, docstring e gestione degli errori.""",
agent=senior_developer,
context=[architecture_task] # dipende dall'output dell'architettura
)
testing_task = Task(
description="""
Scrivi test completi per il codice implementato.
Requisiti:
- Framework: pytest con pytest-cov
- Copertura target: 90%
- Include unit test, integration test e test parametrici
- Testa happy path, edge cases e scenari di errore
- Usa mocking per dipendenze esterne
- Esegui i test per verificare che passino tutti
""",
expected_output="""File di test pytest completi che passano tutti,
con report di copertura al 90%+.""",
agent=qa_engineer,
context=[implementation_task]
)
review_task = Task(
description="""
Conduci una code review approfondita del codice e dei test prodotti.
Analizza per:
1. Rispetto dei principi SOLID
2. Presenza di code smells o anti-pattern
3. Correttezza logica e completezza
4. Performance e uso della memoria
5. Sicurezza (injection, validazione input, secrets)
6. qualità della documentazione
Produci un report con: problemi CRITICI, WARNINGS e SUGGESTIONS.
Per ogni problema, includi il file/riga e la fix raccomandata.
""",
expected_output="""Report di code review strutturato con categorie CRITICAL,
WARNING e SUGGESTION, con fix raccomandate per ogni problema.""",
agent=code_reviewer,
context=[implementation_task, testing_task]
)
# ============================================================
# 5. CREW - ASSEMBLAGGIO DEL TEAM
# ============================================================
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 per delega automatica
verbose=True,
memory=True, # abilita memoria condivisa tra agenti
embedder={
"provider": "anthropic",
"config": {"model": "claude-3-haiku-20240307"}
}
)
# ============================================================
# 6. AVVIO DEL CREW
# ============================================================
result = coding_crew.kickoff(inputs={
"task_description": """
Implementa un sistema di rate limiting per API REST con:
- Algoritmo token bucket per controllo del flusso
- Storage su Redis per distribuzione multi-instance
- Configurazione per-endpoint e per-user
- Header HTTP standard (X-RateLimit-*)
- Dashboard di monitoring con metriche Prometheus
"""
})
print(result.raw)
Charakteristickým prvkem CrewAI 2025 je možnost allow_code_execution=True
na agentech: Umožňuje spouštění kódu v zabezpečené, samospravující karanténě
chyb a inteligentního opakování. Pokud kód vyvolá výjimku, agent obdrží
chybovou zprávu a pokuste se ji opravit sami (až max_retry_limit,
výchozí 2).
CrewAI: Silné stránky
- Nízká křivka učení: mentální model týmu/rolí je intuitivní
- Integrované spuštění kódu: bezpečné pískoviště s automatickým opakováním
- Sdílená paměť: agenti si pamatují kontext předchozích rozhovorů
- Podpora MCP: obousměrná integrace se servery MCP (2025)
- Podnikové funkce: pozorovatelnost, protokol auditu, řídicí rovina SaaS
- Toky: podrobné ovládání pro komplexní pracovní postupy v případě potřeby
AutoGen/AG2: Konverzační agenti pro vznikající úkoly
AutoGen (přejmenován na AG2 komunitou, která pokračovala ve vývoji po divergenci od Microsoftu v roce 2024) přijímá zcela jiné paradigma: konverzační multi-agent. Místo definování pevných pracovních postupů nebo rigidních rolí agenti komunikují spolu prostřednictvím zpráv přirozeného jazyka, objevujícího se chování komplexní z jednoduchých interakcí.
Tento přístup je zvláště účinný u úloh, kde cesta řešení není a definovatelné a priori: komplexní problémy ladění, výzkum a implementace inovativní řešení nebo úkoly, které vyžadují vyjednávání mezi konfliktními omezeními.
Architektura AG2: AssistantAgent a UserProxyAgent
Základním stavebním kamenem AG2 je točivý moment AssistantAgent (agent AI) e UserProxyAgent (zmocněnec pro provedení). UserProxyAgent může spustit kód v místní karanténě a poskytuje skutečnou zpětnou vazbu AssistantAgentovi, který pak může iterujte řešení na základě skutečných výsledků provádění.
import autogen
from autogen import AssistantAgent, UserProxyAgent, GroupChat, GroupChatManager
from autogen.coding import LocalCommandLineCodeExecutor
import os
# ============================================================
# 1. CONFIGURAZIONE 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 LOCALE
# ============================================================
executor = LocalCommandLineCodeExecutor(
timeout=60,
work_dir="/tmp/autogen_workspace",
# Blocca comandi pericolosi
execution_policies={
"rm": False,
"curl": False,
"wget": False,
}
)
# ============================================================
# 3. DEFINIZIONE DEGLI AGENTI
# ============================================================
# Agente Software Architect - usa Opus per alta capacità di ragionamento
architect = AssistantAgent(
name="SoftwareArchitect",
system_message="""Sei un software architect senior con 15 anni di esperienza.
Il tuo ruolo e:
1. Analizzare i requisiti e proporre architetture solide
2. Definire le interfacce tra componenti
3. Identificare rischi tecnici e proporre mitigazioni
4. Guidare le decisioni tecniche del team
Quando proponi un'architettura, usa sempre diagrammi ASCII e spiega le
motivazioni delle scelte. Rispondi con "TERMINATE" quando il task e completo.""",
llm_config=opus_config,
)
# Agente Developer - implementa il codice
developer = AssistantAgent(
name="PythonDeveloper",
system_message="""Sei un senior Python developer.
Il tuo ruolo e:
1. Implementare il codice seguendo le specifiche dell'architetto
2. Scrivere codice pulito con type hints e docstring
3. Gestire gli errori in modo robusto
4. Rispettare i principi SOLID e DRY
Usa sempre blocchi di codice Python validi quando scrivi implementazioni.
Rispondi con "TERMINATE" solo quando il developer AND il reviewer approvano.""",
llm_config=llm_config,
)
# Agente Tester - scrive e verifica i test
tester = AssistantAgent(
name="QATester",
system_message="""Sei un QA engineer specializzato in Python testing.
Il tuo ruolo e:
1. Scrivere test pytest esaustivi per il codice del developer
2. Eseguire i test nella sandbox e riportare i risultati
3. Identificare edge cases non coperti
4. Garantire copertura 85%+
Produci sempre test eseguibili che posso verificare nella sandbox.""",
llm_config=llm_config,
)
# Agente Reviewer - code review critica
reviewer = AssistantAgent(
name="CodeReviewer",
system_message="""Sei un code reviewer senior con focus su qualità e sicurezza.
Il tuo ruolo e:
1. Analizzare il codice per code smells e anti-pattern
2. Verificare la sicurezza (OWASP Top 10)
3. Suggerire refactoring migliorativi
4. Approvare o richiedere modifiche
Concludi ogni review con "APPROVED" o "NEEDS_WORK: [lista problemi]".""",
llm_config=llm_config,
)
# UserProxy con esecuzione codice - fa da ponte tra agenti e sandbox
code_executor_proxy = UserProxyAgent(
name="CodeExecutor",
human_input_mode="NEVER", # completamente automatico
max_consecutive_auto_reply=5,
code_execution_config={
"executor": executor,
},
is_termination_msg=lambda msg: "TERMINATE" in msg.get("content", ""),
)
# ============================================================
# 4. GROUP CHAT - ORCHESTRAZIONE DELLA CONVERSAZIONE
# ============================================================
group_chat = GroupChat(
agents=[architect, developer, tester, reviewer, code_executor_proxy],
messages=[],
max_round=20, # massimo 20 round di conversazione
# Strategia di selezione del prossimo parlante
speaker_selection_method="auto",
# Ordine preferito per strutturare la conversazione
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 che orchestra la group chat
manager = GroupChatManager(
groupchat=group_chat,
llm_config=llm_config,
system_message="""Sei il project manager di questo team di sviluppo.
Orchestri la conversazione per garantire che il task venga completato
in modo efficiente e che ogni agente contribuisca nel momento opportuno.""",
)
# ============================================================
# 5. AVVIO DELLA CONVERSAZIONE
# ============================================================
task = """
Sviluppa un sistema di caching intelligente in Python con le seguenti caratteristiche:
- Cache LRU (Least Recently Used) con TTL configurabile per entry
- Backend multipli: in-memory, Redis, o filesystem
- Decorator @cache per applicazione trasparente alle funzioni
- Statistiche di hit/miss in tempo reale
- Thread-safe per applicazioni concorrenti
Architettura, implementazione, test e code review completi.
"""
chat_result = code_executor_proxy.initiate_chat(
manager,
message=task,
summary_method="reflection_with_llm",
)
print("\n=== SOMMARIO FINALE ===")
print(chat_result.summary)AG2: Silné stránky
- Skutečné provedení kódu: kód skutečně běží v sandboxu, agenti vidí skutečné výstupy
- Vznikající flexibilita: pracovní postupy se přizpůsobují problému, ne naopak
- AG-UI protokol: dynamická rozhraní se streamováním v reálném čase (2025)
- OpenTelemetry: úplná sledovatelnost pracovních postupů agentů
- Člověk ve smyčce: snadno konfigurovatelné s
human_input_mode - Podpora TypeScript: Microsoft AutoGen verze 0.4 s nativní podporou
Claude Code: Sub-Agents a paralelní provádění
Claude Code má nativní multiagentní systém, který funguje zásadně odlišným způsobem z dosud viděných frameworků Pythonu. Namísto orchestrace modelů LLM přes API, Claude Code začít Samostatné instance Claude (sub-agenti) přímo z terminálu, každý s vlastním čistým kontextovým oknem a schopností pracovat se souborovým systémem izolovaným způsobem.
Tento přístup má významné výhody: žádný rámec, režie integrace nativní s terminálovými nástroji a schopností spouštět úlohy paralelně na systémech s více jádry. Nástroj Task a klíčový mechanismus: spusťte sub-agenta pomocí konkrétní výzvu a před pokračováním čeká na výsledek (nebo, pokud jsou úkoly nezávislé, spustí je všechny paralelně).
# Code Reviewer Agent
## Ruolo
Senior code reviewer con focus su qualità, sicurezza e manutenibilità.
## Competenze
- Principi SOLID e design patterns
- OWASP Top 10 e sicurezza applicativa
- Performance optimization
- Clean code e refactoring
## Processo di Review
1. Leggi TUTTI i file modificati prima di commentare
2. Identifica problemi per categoria: CRITICAL, WARNING, SUGGESTION
3. Per ogni problema: specifica file, riga e fix raccomandata
4. Verifica che i test coprano i casi di errore
5. Controlla presenza di hardcoded secrets o credenziali
## Output Atteso
Report strutturato in markdown con sezioni:
- Executive Summary
- CRITICAL Issues (bloccanti per il merge)
- WARNINGS (da risolvere prima della prossima release)
- SUGGESTIONS (miglioramenti opzionali)
- Security Checklist# Security Auditor Agent
## Ruolo
Security engineer specializzato in application security e OWASP.
## Competenze
- OWASP Top 10 (2025 edition)
- Analisi di codice Python, JavaScript e SQL
- Threat modeling
- Dependency vulnerability scanning
## Checklist di Sicurezza
### Input Validation
- [ ] Tutti gli input utente sono validati e sanitizzati
- [ ] Nessuna query SQL costruita con concatenazione di stringhe
- [ ] Path traversal prevenuto con realpath/pathlib
### Authentication & Authorization
- [ ] Password hashing con bcrypt/argon2 (no MD5/SHA1)
- [ ] JWT firmati con chiavi di lunghezza adeguata
- [ ] RBAC implementato correttamente
### Secrets Management
- [ ] Nessun hardcoded secret nel codice
- [ ] Variabili d'ambiente usate per credenziali
- [ ] .gitignore include file di configurazione sensibili
### Dependencies
- [ ] Nessuna dipendenza con CVE critiche note
- [ ] requirements.txt con versioni pin-nate
## Output
- Lista vulnerabilità con CVSS score stimato
- Fix raccomandate con esempi di codice
- Priorità: CRITICAL (fix immediata), HIGH, MEDIUM, LOW# Esempio di prompt per orchestrazione multi-agent in Claude Code
# (questo e il contenuto di un file CLAUDE.md o di un prompt interattivo)
# --- ESEMPIO 1: SEQUENTIAL MULTI-AGENT ---
# Il task tool lancia sub-agent e attende i risultati in sequenza
Implementa le seguenti feature per il modulo auth/:
1. Usa il Task tool per lanciare il sub-agent "planner":
- Input: "Analizza auth/ e crea un piano di implementazione per
aggiungere 2FA con TOTP (RFC 6238)"
- Attendi il piano completo
2. Usa il Task tool per lanciare il sub-agent "developer":
- Input: "Implementa il piano seguente: [output del planner]"
- Attendi l'implementazione completa
3. Usa il Task tool per lanciare PARALLELAMENTE:
- Sub-agent "code-reviewer": rivedi il codice in auth/
- Sub-agent "security-auditor": verifica la sicurezza di auth/
(lancia entrambi contemporaneamente, attendi entrambi)
4. Applica le fix per tutti i problemi CRITICAL trovati
---
# --- ESEMPIO 2: PARALLEL WORKTREE ISOLATION ---
# Task indipendenti su worktree separati per massima parallelizzazione
Esegui queste task IN PARALLELO su worktree separati:
Task A (worktree: feature/user-service):
- Implementa UserService con CRUD completo
- Scrivi unit test 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
- Scrivi integration test
- Commit: "feat: add EmailService with SendGrid"
Task C (worktree: feature/notification-service):
- Implementa NotificationService (email + push + SMS)
- Usa UserService e EmailService come dipendenze
- Scrivi test end-to-end
- Commit: "feat: add NotificationService"
Dopo che tutti e tre i worktree sono completati:
- Mergia in ordine: A, B, C
- Risolvi eventuali conflitti
- Esegui la test suite completa
---
# --- ESEMPIO 3: AGENTE CON MEMORIA CONDIVISA ---
# Uso di file come meccanismo di comunicazione inter-agent
Prima di iniziare, crea il file /tmp/project-context.md con:
- Stack tecnologico del progetto
- Convenzioni di naming
- Pattern architetturali in uso
- Dipendenze principali
Ogni sub-agent che lanci deve:
1. Leggere /tmp/project-context.md all'inizio
2. Aggiornare /tmp/progress.md con lo stato dei propri task
3. Salvare output strutturati in /tmp/agent-outputs/[nome]/
Questo garantisce coerenza tra agenti paralleli senza conflitti di merge.Lekce z incidentu Replit (2025)
V roce 2025 Replit zdokumentoval případ, kdy byl eliminován autonomní agent
produkční databáze během úkolu "úklid". Tento incident má
zdůraznil potřebu explicitně nakonfigurovat omezení příkazů
destruktivní. V Claude Code je to řešeno prostřednictvím sekce deny
in .claude/settings.json: Vždy blokovat rm -rf,
DROP TABLE, git push --force a podobné.
Dílčí agenti dědí stejná omezení jako nadřazený agent.
Podrobné srovnání: Který rámec si vybrat
Výběr rámce závisí na konkrétním kontextu. Neexistuje žádný celkový vítěz: každý nástroj vyniká v různých scénářích. Následující tabulka shrnuje rozdíly klíč k rozhodnutí.
| Kritérium | LangGraph | CrewAI | AG2 (AutoGen) | Claude Code |
|---|---|---|---|---|
| Paradigma | Stavový graf | Týmy založené na rolích | Konverzační | Nativní sub-agent |
| Křivka učení | Vysoká (teorie grafů) | Nízká (intuitivní) | Průměrný | Nízký |
| Řízení toku | Maximum | Středně vysoká | Vznikající | Střední |
| Spuštění kódu | Prostřednictvím nástrojů | Integrovaný (sandbox) | Integrovaný (místní) | Nativní Bash |
| Vytrvalost státu | Nativní checkpointing | Integrovaná paměť | Chatové zprávy | Souborový systém |
| Rovnoběžnost | Paralelní uzly | Proces.paralelní | GroupChat asynchronní | Nativní nástroj pro úkoly |
| Pozorovatelnost | LangSmith | CrewAI Enterprise | OpenTelemetry | Nativní protokoly |
| Člověk ve smyčce | Nativní přerušení | Zpětná volání | human_input_mode |
Interaktivní |
| Ekosystém | LangChain | Nezávislý | Microsoft/AG2 | Antropický |
| Ideální pro | Komplexní pracovní postupy s podmíněnou logikou | Virtuální týmy s definovanými rolemi | Průzkumné úlohy se spouštěním kódu | Automatizace CLI a stávající projekty |
Praktická doporučení
- Vyberte LangGraph pokud máte složité pracovní postupy s mnoha větvemi podmíněné, potřebujete spolehlivou stálost stavu mezi relacemi a máte tým kdo rozumí pojmům stavové automaty a orientované grafy.
- Vyberte CrewAI pokud chcete rychle začít s multi-agentem, váš tým je zvyklý přemýšlet z hlediska organizačních rolí a vy potřebujete integrované spouštění kódu s automatickou správou chyb.
- Vyberte AG2 pokud je úkol průzkumný a nemáte předdefinovaný pracovní postup, potřebujete skutečné vícekolové konverzace se skutečným prováděním kódu, a jste v ekosystému Microsoftu (Azure, TypeScript).
- Vyberte Claude Code pokud již pracujete s Claudem, chcete multi-agenta bez dalších rámců a vašeho hlavního případu použití a automatizace úloh vývoj na stávajících kódových základech.
Architektura připravená na produkci pro skutečné týmy
Multiagentní systém ve výrobě vyžaduje různé architektonické úvahy nad rámec jednoduché orchestrace agentů. Společnosti, které je nasadily systémy v roce 2025 se naučily několik důležitých lekcí, které je užitečné vědět předem začít.
Konsolidované architektonické vzory
Výzkum z roku 2025 ukazuje, že nejúčinnější vzory pro multiagentní kódování v produkce jsou tři:
- Vzor supervizora: agent orchestrátoru deleguje úkoly na agenty specializovat a agregovat výsledky. Ideální pro LangGraph s podmíněným směrováním.
- Vzory potrubí: agentů v pořadí, kde výstup jednoho
se stane vstupem dalšího. Přirozené v CrewAI s
contexta úkoly zaměstnanci. - Vzor peer-to-peer: agenti, kteří spolu volně komunikují bez centrálního orchestrátora. Přirozené v AG2 s 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 # secondi
# ============================================================
# ERROR HANDLING - Nodo dedicato alla gestione errori
# ============================================================
def error_handler(state: ProductionCodingState) -> dict:
"""Gestisce errori e decide se riprovare o terminare."""
error_count = state.get("error_count", 0) + 1
logger.error(
f"Task {state['task_id']}: errore #{error_count} - {state.get('last_error', 'unknown')}"
)
if error_count >= state["max_errors"]:
logger.critical(f"Task {state['task_id']}: max errori raggiunto, terminazione")
return {"error_count": error_count, "review_status": "FAILED"}
# Exponential backoff prima del retry
wait_time = min(2 ** error_count, 30)
logger.info(f"Retry in {wait_time}s...")
time.sleep(wait_time)
return {"error_count": error_count, "review_status": "RETRY"}
# ============================================================
# TIMEOUT MANAGEMENT
# ============================================================
def check_timeout(state: ProductionCodingState) -> str:
"""Verifica se il task ha superato il timeout massimo."""
elapsed = time.time() - state["start_time"]
if elapsed > state["max_execution_time"]:
logger.warning(
f"Task {state['task_id']}: timeout dopo {elapsed:.1f}s "
f"(max: {state['max_execution_time']}s)"
)
return "timeout"
return "continue"
# ============================================================
# COST TRACKING - Tracciamento costi in tempo reale
# ============================================================
class CostTracker:
# Prezzi Anthropic (USD per 1M token, 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"Costo task: ${self.spent:.4f} (80% del budget ${self.budget})")
def check_budget(self) -> bool:
"""Ritorna True se il budget e ancora disponibile."""
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)
}
# ============================================================
# PERSISTENZA PRODUCTION CON POSTGRESQL
# ============================================================
# Il checkpointing su PostgreSQL garantisce durabilita del workflow
# anche in caso di crash dell'applicazione
def create_production_app(db_connection_string: str):
"""Crea un'applicazione LangGraph con persistenza PostgreSQL."""
# PostgresSaver per persistenza production-grade
checkpointer = PostgresSaver.from_conn_string(db_connection_string)
checkpointer.setup() # crea le tabelle se non esistono
graph = StateGraph(ProductionCodingState)
# ... aggiunta nodi e edges ...
return graph.compile(checkpointer=checkpointer)
# ============================================================
# CIRCUIT BREAKER - Protezione contro failure a cascata
# ============================================================
class CircuitBreaker:
"""Implementa il Circuit Breaker pattern per agenti inaffidabili."""
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=normale, OPEN=blocco, HALF-OPEN=test
def call(self, func, *args, **kwargs):
"""Chiama la funzione attraverso il circuit breaker."""
if self.state == "OPEN":
if time.time() - self.last_failure_time > self.recovery_time:
self.state = "HALF-OPEN"
logger.info("Circuit breaker: passaggio a HALF-OPEN")
else:
raise Exception("Circuit breaker OPEN: servizio non disponibile")
try:
result = func(*args, **kwargs)
if self.state == "HALF-OPEN":
self.state = "CLOSED"
self.failure_count = 0
logger.info("Circuit breaker: recupero riuscito, ritorno 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 dopo {self.failure_count} errori")
raiseVýzvy a omezení multiagentního kódování
Multiagentní systémy ve výrobě představují nesrozumitelné výzvy, které se teprve objevují se zkušenostmi. Znát je předem je rozdíl mezi robustním systémem a ten, který se ve výrobě přeruší v nejhorší chvíli.
5 hlavních výzev
- Kontextové znečištění: když agent zahrne informace do svých výstupů irelevantní nebo hlučné, které negativně ovlivňují následné agenty. Řešení: definovat výstupy strukturovaného schématu (JSON/Pydantic) namísto volného textu.
- Šíření chyb: chyba v upstream agentu je zesílena prostřednictvím potrubí a generování výstupů, které jsou stále vzdálenější pravdě. Řešení: validace výstupů v každém kroku s validací schématu a záložním řešením.
- Exploze nákladů: může generovat smyčka recenzí, která nekonverguje stovky volání API a náklady v řádu desítek dolarů za úkol. Řešení: sledování rozpočtu s pevnými limity a jističem.
- Nesoulad mezi agenty: dva agenti mohou přijímat různé nájmy na stejném architektonickém bodě, generování nekonzistentního kódu. Řešení: sdílené explicitní stav nebo sdílený kontextový dokument.
- Složitost sledování: nad 5 agenty se ladění stává exponenciálně složitější. Řešení: distribuované trasování s ID korelace pro každý úkol a standardizovanou strukturu protokolu.
Důležitá statistika, kterou je třeba mít na paměti: Výzkum z roku 2025 ukazuje, že i dál Když překročí 75 % multiagentních systémů, je obtížné je spravovat 5 agentů, hlavně kvůli exponenciálnímu růstu složitosti ladění a sledování. Vždy začněte s minimálním potřebným počtem agentů.
Nejlepší postupy pro efektivní multiagentní systémy
1. Chirurgická specializace agentů
Každý agent musí mít jedna primární odpovědnost a sadu
minimální nástroje potřebné k jeho provedení. Agent, který dělá vše a v praxi a
agent, který nic nedělá dobře. V definici system_message nebo
z backstory, buďte konkrétní: „jste bezpečnostní inženýr se specializací na
OWASP Top 10“ a nekonečně efektivnější než „jste bezpečnostní expert“.
2. Výstup strukturovaného schématu
Pomocí modelů Pydantic nebo schématu JSON definujte výstupy očekávané od každého agenta.
Volný text zavádí nejednoznačnost, která se prostřednictvím potrubí zesiluje.
Agent, který produkuje a ReviewReport s poli
critical_issues: List[Issue] a nekonečně spolehlivější než jeden
který vytváří nestrukturovaný text, který může interpretovat další agent.
3. Monitorování a pozorovatelnost
Ve výrobě musí být každé vyvolání agenta sledováno pomocí: časového razítka, použitý model, vstupní/výstupní token, náklady, latence a stav. Pro použití LangGraph LangSmith; pro CrewAI použít podnikovou pozorovatelnost; pro AG2 použijte OpenTelemetry. U vlastních systémů vždy strukturujte protokoly s ID korelace.
4. Záložní a ladná degradace
Každý kritický agent musí mít záložní: jednoduššího agenta (plus model ekonomická), odpověď uložená v mezipaměti nebo cesta lidské eskalace. Systém musí nadále fungovat, i když je degradován, i když agent selže.
5. Omezené iterace s vynucenou konvergencí
Jakákoli smyčka recenzí musí mít maximální limit iterací.
Konvergenci nelze zaručit teoreticky: ptá se recenzent
vždy se mění a vývojář, který je vždy lehce implementuje
jinak by to mohlo běžet donekonečna. Vždy nastaveno max_iterations
a po dosažení limitu přijmout „nejlepší dostupné“.
from pydantic import BaseModel, Field
from typing import List, Literal, Optional
from langchain_anthropic import ChatAnthropic
from langchain_core.messages import HumanMessage
# ============================================================
# OUTPUT SCHEMA STRUTTURATI - Eliminano ambiguità tra agenti
# ============================================================
class Issue(BaseModel):
"""Singolo problema identificato nella code review."""
file_path: str = Field(description="Path del file con il problema")
line_number: Optional[int] = Field(default=None, description="Numero di riga")
severity: Literal["CRITICAL", "HIGH", "MEDIUM", "LOW"]
category: Literal["security", "logic", "performance", "style", "test_coverage"]
description: str = Field(description="Descrizione chiara del problema")
suggested_fix: str = Field(description="Fix raccomandata con esempio di codice")
class CodeReviewReport(BaseModel):
"""Report strutturato di code review."""
approved: bool = Field(description="True se il codice può essere mergato")
summary: str = Field(description="Sommario esecutivo in 2-3 frasi")
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 sicurezza 0-100")
quality_score: int = Field(ge=0, le=100, description="Score qualità 0-100")
test_coverage_estimate: float = Field(
ge=0.0, le=1.0,
description="Stima copertura test (0.0-1.0)"
)
class SecurityAuditReport(BaseModel):
"""Report di security audit strutturato."""
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)
# ============================================================
# UTILIZZO: agente con output strutturato
# ============================================================
def code_reviewer_with_schema(code: str) -> CodeReviewReport:
"""Agente code reviewer che produce output strutturato."""
model = ChatAnthropic(model="claude-sonnet-4-6")
# Usa structured output per garantire formato corretto
structured_model = model.with_structured_output(CodeReviewReport)
prompt = f"""Conduci una code review approfondita del seguente codice Python:
{code}
Analizza per: correttezza logica, qualità, sicurezza, performance e copertura test."""
report = structured_model.invoke([HumanMessage(content=prompt)])
return report
# ============================================================
# UTILIZZO NEL GRAFO LANGGRAPH
# ============================================================
def reviewer_node(state: dict) -> dict:
"""Nodo LangGraph che usa output strutturato."""
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,
# Il prossimo agente riceve dati strutturati, non testo ambiguo
"review_report": report.model_dump()
}Závěry: Budoucnost multiagentních systémů v roce 2026
Multiagentní kódování v roce 2025 dospělo od proof-of-concept k nástroji připraveno na výrobu. LangGraph dominuje pro komplexní a kontrolované pracovní postupy, CrewAI pro virtuální týmy s definovanými rolemi, AG2 pro průzkumné úkoly s skutečné provádění kódu a Claude Code pro nativní automatizaci v ekosystému Antropický.
Nejvýraznějším trendem pro rok 2026 je standardizace protokolů inter-agent: Model Context Protocol (MCP) a Agent-to-Agent (A2A) se objevují jako de-facto standardy, které umožní agentům z různých frameworků mezi sebou komunikovat. Ne-daleká budoucnost, kde agent LangGraph může zavolat specialistovi CrewAI který zase používá nástroj AG2 není sci-fi: je to již částečně možné.
Pro vývojáře, kteří chtějí začít okamžitě, je praktická rada: nezačínejte z nejpropracovanějšího rámce. Začněte s použitím dvou agentů (vývojář + recenzent). nástroj, který znáte nejlépe, měřte výsledky a pouze přidávejte na složitosti když to problém skutečně vyžaduje. Zlaté pravidlo softwarového inženýrství platí i zde: nejlepší a nejjednodušší multiagentní systém, který řeší váš problém.
Doporučené další kroky
- Předchozí článek: zákony Agentické pracovní postupy: Dekompoziční problémy pro AI pochopit, jak strukturovat úkoly před jejich paralelizací
- Další článek: jít do Testujte kód vygenerovaný AI pro strategie zajištění kvality specifické pro kód generovaný AI
- Bezpečnost: zákony Bezpečnost v kódování Vibe ke správě zranitelností v multiagentních systémech
- Claude konkrétně: dozvědět se více Claude Code: Terminal Agent Development podrobnosti o nativním systému sub-agentů
Řada Vibe Coding a Agentic Development Series
Toto je čtvrtý článek ze série. Předchozí články pokrývají paradigma kódování vibrací, Claudeův kód z terminálu a rozklad Agentní pracovní postupy. Budoucí články se budou zabývat testováním kódu generovaného umělou inteligencí, rychlé inženýrství pro IDE, bezpečnost kódování vibrací a budoucnost vývoje agent v roce 2026.