04 - マルチエージェントコーディング: LangGraph、CrewAI、AutoGen
認証システムを最初から実装するという複雑なタスクに直面していることを想像してください。 OAuth2、RBAC、監査ログ、統合テストを備えたエンタープライズ アプリケーション用 そしてドキュメント。たとえ有能であっても、単一の AI エージェントが管理することになるでしょう。 過密なコンテキスト ウィンドウ、矛盾する責任、および高いエラーのリスク カスケード状。ソリューションはより強力なエージェントではありません。それは 1 つのエージェントです。 エージェントのチーム 専門家 協力し、相互に検証し、作業を並列化します。
これがパラダイムです マルチエージェントコーディング: 複数の AI エージェントが存在するシステム 自律的な人々が協力して、一人の能力を超えるソフトウェア開発タスクを完了します シングルモデル。 2025 年には、3 つのフレームワークがこの分野を支配しています。 ランググラフ ステートフルなグラフ アーキテクチャにより、 CrewAI 役割ベースのモデルを使用 直感的、e 自動生成 (現在は AG2) 会話型アプローチを採用しています。これらに Claude Code のネイティブ システムとその並列サブエージェントが追加されます。
この記事は、4 つのシステムすべてに関する高度な詳細情報です: アーキテクチャ、コード例 ユースケースに適したものを選択するための、詳細な比較と実用的なガイドです。 バイブコーディングの基本概念をすでに理解していて、独自のエージェントワークフローを導入したい場合 次のレベルへ、あなたは正しい場所にいます。
何を学ぶか
- 単一の AI エージェントでは複雑な開発タスクには不十分であるため
- LangGraph: グラフ アーキテクチャ、StateGraph、ノード、エッジ、チェックポイント
- CrewAI: ロールベースのエージェント、タスク、順次および並列プロセス、ツール
- AutoGen/AG2: 会話型エージェント、GroupChat、コード実行サンドボックス
- クロード コード: サブエージェント、タスク ツール、並列実行パターン
- 詳細な比較: いつどのフレームワークを使用するか
- 実際のチーム向けの運用対応アーキテクチャ
- 重大な課題: コンテキスト汚染、エラー伝播、コスト管理
- 専門エージェントとフォールバック戦略のベスト プラクティス
単一のエージェントでは十分ではないため
フレームワークに入る前に、基本的な問題を理解することが重要です。 マルチエージェントコーディングで解決します。どんなに高度な AI エージェントであっても、単一の AI エージェントには限界があります 複雑な開発タスクで明らかに現れる構造的特徴。
最初の制限は、 コンテキストウィンドウ。対応機種であっても 200,000 トークンの場合、典型的な企業タスクでは、同時に以下の点に留意する必要があります。 既存のコードベース、機能仕様、アーキテクチャパターン、テスト 更新するドキュメントとセキュリティ制約を書き込みます。これらすべてを超えています 単一の一貫したコンテキストの機能を迅速に利用できます。
2番目の制限は、 専門化。ゼネラリストエージェントの傾向 いくつかのことを優れた方法で行うのではなく、すべてを平凡な方法で行うこと。エージェント セキュリティの専門家は、どのパターンを探し、どの標準を適用すべきかを正確に知っています。 一方、テストを専門とする人は、コンポーネントの各タイプのテスト パターンを知っています。
3番目の制限は、 クロスチェック。単一エージェントによる書き込み コードを作成してから「テスト」します。基本的には同じものを使って作業をチェックします。 彼がそれを生み出した認知バイアス。 2 つの別個のエージェント (1 つは実装するエージェント、もう 1 つは実行するエージェント) レビューは、真に異なる視点をもたらします。
役割分離の原則
人間の開発チームでは、役割の分離 (開発者、コードレビュー担当者、QA、 セキュリティ エンジニア、テクノロジー ライターなど）は官僚主義ではありません。それは認知的保護手段です。 マルチエージェント システムは、AI が生成したコードに同じ原則を適用します。 個々のエージェントの盲点を体系的に削減します。
2025 年の調査では、この直感が裏付けられています。AI が生成したコードの割合は次のとおりです。 単一の監視されていないエージェントによって生成される場合、脆弱性が大幅に高まります (Veracode 2025 は人間のコードの 2.74 倍の脆弱性を報告しています)。システム 専用のレビューエージェントを備えたマルチエージェントは、このギャップを大幅に削減します。
LangGraph: ステートフル グラフ オーケストレーション
LangChain チームによって開発された LangGraph は、アプローチの自然な進化を表しています。 to linear chains towards 循環ステートフル グラフ。基本的な直感 そして、複雑なエージェントワークフローは直線的ではなく、ループ、条件分岐、 あるパッセージと別のパッセージの間の状態の並行性と持続性。
LangChain チーム自体は 2025 年に「エージェントには LangGraph を使用し、 ラングチェーンではありません。」この選択は、エージェント システムという重要なアーキテクチャ上の真実を反映しています。 現代のシステムは基本的にはマシンであり、シーケンシャル パイプラインではありません。
LangGraph の基本的な概念
LangGraph は、構築する前に習得する必要がある 4 つの主要な概念に基づいています。 効果的なマルチエージェント システム:
- 状態グラフ: ワークフロー構造を定義するメイン グラフ e ノード間で共有される状態のタイプ
- 州： 情報を表す TypedDict (または Pydantic モデル) グラフのすべてのノード間で共有される
- ノード: 状態を受け取り、操作を実行する Python 関数 (多くの場合、LLM への呼び出し) ステータスの更新を返します。
- エッジ: ノード間の接続 (固定または条件付き) 現在の状態に基づいて
LangGraph - マルチエージェント コーディング システム (Python)
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'])}")この例では、LangGraph が複雑な開発ワークフローをどのように処理するかを示します。 自動レビューループ。の チェックポイント そして重要な機能 運用環境用: グラフの状態を保存し、実行を再開できます。 エラーが発生した場合でも、最初からやり直す必要はありません。
ランググラフ: 強み
- きめ細かい制御: フローのあらゆる側面がプログラム可能
- 状態の永続性: 長いワークフロー向けの統合チェックポイント機能
- 人間参加者: 人間の承認のために一時停止する可能性
- 並列実行: ノードは並列実行可能
- ストリーミング: 各ノードからのリアルタイム出力
- テスト済みの生産: 2025 年には数百の企業が本番環境で使用
CrewAI: 仮想チーム用の役割ベースのエージェント
CrewAI は、LangGraph に対して根本的に異なるアプローチを採用しています。 グラフと状態の観点から考えるように求められます。 チームと役割。 各エージェントは、明確な専門分野と明確な目標を持つチームメンバーです。 利用可能なツールのセット。このメンタル モデルは、次のような人にとってより直観的です。 開発チームの管理経験。
2025 バージョン 1.1.0 では、CrewAI は次の分離を導入しました。 乗組員 (高レベルのオーケストレーション) e フロー (きめ細かなワークフロー制御)、 LangGraph の柔軟性とロールベース モデルのシンプルさを提供します。
CrewAI アーキテクチャ
CrewAI の 4 つの基本要素は次のとおりです。
- エージェント: 独自の役割、目標、バックストーリーを定義する AI エンティティ 「個性」と「得意分野」
- タスク: 説明付きの特定のアクティビティ、expected_output および 特定のエージェントに割り当てられる
- ツール: 追加のエージェント機能 (ファイル I/O、Web 検索、 コード実行、データベースアクセス)
- クルー： エージェントとタスクをプロセスで調整するチーム (シーケンシャルまたはパラレル)
CrewAI - プランナー、開発者、レビュー担当者によるコーディング クルー
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)
CrewAI 2025 の特徴的な要素はオプションです。 allow_code_execution=True
エージェント上: 安全な自己管理サンドボックスでのコード実行を可能にします。
エラーとインテリジェントな再試行の防止。コードが例外をスローした場合、エージェントは
エラーメッセージが表示され、自分で修正してみてください（最大 max_retry_limit、
デフォルトは 2)。
CrewAI: 強み
- 学習曲線が低い: チーム/役割のメンタルモデルは直感的です
- 統合されたコード実行: 自動再試行による安全なサンドボックス
- 共有メモリ: エージェントは以前の会話のコンテキストを覚えています
- MCP サポート: MCP サーバーとの双方向統合 (2025)
- エンタープライズ機能: 可観測性、監査ログ、コントロール プレーン SaaS
- フロー: 必要に応じて複雑なワークフローをきめ細かく制御
AutoGen/AG2: 新たなタスクのための会話型エージェント
AutoGen (分岐後も開発を続けたコミュニティによって AG2 に名前変更されました) 2024 年に Microsoft によって）は、まったく異なるパラダイムを採用しています。 会話的な マルチエージェント。エージェントは、固定されたワークフローや厳密な役割を定義するのではなく、 彼らは自然言語メッセージや新たな行動を通じて相互にコミュニケーションします。 単純な相互作用から複雑なものまで。
このアプローチは、解決策が明確ではないタスクに特に効果的です。 事前に定義可能: 複雑なデバッグ問題、研究と実装 革新的なソリューション、または矛盾する制約の間でネゴシエーションを必要とするタスク。
AG2 アーキテクチャ: AssistantAgent と UserProxyAgent
AG2 の基本的な構成要素はトルクです アシスタントエージェント (AIエージェント) e ユーザープロキシエージェント （実行の代理）。 UserProxyAgent を実行できる ローカル サンドボックス内のコードを作成し、実際のフィードバックを AssistantAgent に提供します。 実際の実行結果に基づいてソリューションを反復します。
AG2 (AutoGen) - 会話型コーディング チーム
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: 強み
- 実際のコードの実行: コードは実際にはサンドボックス内で実行されます。 エージェントは実際の出力を確認します
- 新たな柔軟性: ワークフローが問題に適応し、 その逆ではない
- AG-UIプロトコル: リアルタイム ストリーミングを備えた動的フロントエンド (2025)
- オープンテレメトリ: エージェントのワークフローを完全に監視可能
- 人間参加者: で簡単に設定可能
human_input_mode - TypeScript のサポート: Microsoft AutoGen バージョン 0.4 (ネイティブ サポートあり)
クロード コード: サブエージェントと並列実行
Claude Code には、根本的に異なる方法で動作するネイティブ マルチエージェント システムがあります。 これまでに見てきた Python フレームワークから。 API を介して LLM モデルを調整する代わりに、Claude Code 始める 個別の Claude インスタンス (サブエージェント) 端末から直接、 それぞれに独自のクリーンなコンテキストウィンドウとファイルシステム上で操作できる機能があります。 孤立した方法で。
このアプローチには、フレームワークが不要、統合オーバーヘッドという大きな利点があります。 ターミナルツールをネイティブに備え、タスクを並行して実行する機能 複数のコアを備えたシステムの場合。タスクツールと主要なメカニズム: 次のコマンドを使用してサブエージェントを起動します。 特定のプロンプトが表示され、続行する前に結果を待ちます (タスクが独立している場合は、 すべてを並行して起動します)。
.claude/agents/code-reviewer.md - サブエージェントの定義
# 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
.claude/agents/security-auditor.md - セキュリティ サブエージェント
# 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
Claude Code - ターミナルからのマルチエージェント オーケストレーション
# 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.レプリト事件の教訓（2025年）
2025年、Replitは自律エージェントが排除した事例を文書化した。
「クリーンアップ」タスク中の運用データベース。この事件は、
コマンドの制限を明示的に構成する必要性を強調しました
破壊的な。クロード コードでは、これはセクションで処理されます。 deny
in .claude/settings.json: 常にブロックします rm -rf,
DROP TABLE, git push --force と同様です。
サブエージェントは、親エージェントと同じ制限を継承します。
詳細な比較: どのフレームワークを選択するか
フレームワークの選択は、特定のコンテキストによって異なります。総合優勝者はいない： 各ツールはさまざまなシナリオで優れた効果を発揮します。次の表は違いをまとめたものです 決定を助ける鍵。
| 基準 | ランググラフ | CrewAI | AG2 (オートジェン) | クロード・コード |
|---|---|---|---|---|
| パラダイム | ステートフル グラフ | 役割ベースのチーム | 会話型 | ネイティブサブエージェント |
| 学習曲線 | 高 (グラフ理論) | 低 (直感的) | 平均 | 低い |
| フロー制御 | 最大 | 中～高 | 新興 | 中くらい |
| コードの実行 | ツール経由 | 統合（サンドボックス） | 統合（ローカル） | ネイティブバッシュ |
| 状態の永続性 | ネイティブチェックポイント設定 | 内蔵メモリ | チャットメッセージ | ファイルシステム |
| 平行度 | 並列ノード | プロセス.パラレル | グループチャットの非同期 | ネイティブタスクツール |
| 可観測性 | ラング・スミス | CrewAI エンタープライズ | オープンテレメトリー | ネイティブログ |
| 人間関係者 | ネイティブ割り込み | コールバック | human_input_mode |
相互の作用 |
| 生態系 | ラングチェーン | 独立した | マイクロソフト/AG2 | 人間的 |
| に最適 | 条件付きロジックを使用した複雑なワークフロー | 役割が定義された仮想チーム | コード実行を伴う探索的タスク | CLI 自動化と既存のプロジェクト |
実践的な推奨事項
- ランググラフを選択してください 多くのフォークを含む複雑なワークフローがある場合 条件付き、セッション間で信頼性の高い状態の永続性が必要で、チームがいる ステートマシンと有向グラフの概念を理解している人。
- CrewAIを選択してください マルチエージェントをすぐに使い始めたい場合は、 あなたのチームは組織の役割の観点から考えることに慣れており、あなたが必要とするのは 自動エラー管理を備えた統合されたコード実行。
- AG2を選択してください タスクが探索的で、事前定義されたワークフローがない場合、 実際のコード実行を伴う実際の複数ラウンドの会話が必要です。 そしてあなたは Microsoft エコシステム (Azure、TypeScript) に属しています。
- クロードコードを選択 すでにクロードと協力している場合は、マルチエージェントが必要です 追加のフレームワークなしで、主なユースケースとタスクの自動化が可能 既存のコードベースでの開発。
実際のチームのための本番対応アーキテクチャ
実稼働環境のマルチエージェント システムには、アーキテクチャに関するさまざまな考慮事項が必要です 単純なエージェント オーケストレーションを超えたもの。これらを導入している企業は、 2025 年のシステムは、事前に知っておくと役立ついくつかの重要な教訓を学びました 始めるために。
統合されたアーキテクチャパターン
2025 年の調査によると、マルチエージェント コーディングの最も効果的なパターンは次のとおりです。 生産は次の 3 つです。
- スーパーバイザー パターン: オーケストレーター エージェントはタスクをエージェントに委任します 結果を特化して集約します。条件付きルーティングを備えた LangGraph に最適です。
- パイプライン パターン: エージェントが順番に配置され、1 つのエージェントが出力されます
次の入力になります。 CrewAI で自然に
contextそしてタスク 従業員。 - ピアツーピア パターン: エージェント同士が自由にコミュニケーションをとる 中央のオーケストレーターなしで。 AG2 ではグループチャットを使用するのが自然です。
運用アーキテクチャ - エラー処理とフォールバックを備えた構成
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")
raiseマルチエージェントコーディングの課題と限界
本番環境のマルチエージェント システムには、初めて明らかになる非明白な課題があります。 経験を積んで。それらを事前に知っているかどうかが、堅牢なシステムの違いとなります 最悪の場合、生産中に故障が発生する場合もあります。
5つの主な課題
- コンテキスト汚染: エージェントが出力に情報を含める場合 後続のエージェントに悪影響を与える無関係または騒々しいもの。解決策: フリー テキストの代わりに構造化スキーマ出力 (JSON/Pydantic) を定義します。
- エラーの伝播: 上流エージェントのエラーが増幅される パイプラインを通じて、ますます真実から遠ざかる出力が生成されます。解決策: スキーマ検証とフォールバックを使用した各ステップでの出力の検証。
- コストの爆発: 収束しないレビューループにより、 数百の API 呼び出しとタスクごとに数十ドルのコストがかかります。解決策: ハードリミットとサーキットブレーカーによる予算追跡。
- エージェント間の不一致: 2 人のエージェントが異なる雇用を行うことができる 同じアーキテクチャ上の点で、一貫性のないコードが生成されます。解決策: 共有 明示的な状態または共有コンテキスト ドキュメント。
- 監視の複雑さ: エージェントが 5 つを超えると、デバッグは次のようになります 指数関数的に複雑になります。解決策: 相関 ID を使用した分散トレース 各タスクと標準化されたログ構造。
留意すべき重要な統計: 2025 年の調査によると、 マルチエージェント システムの 75% は、制限を超えると管理が困難になります。 5 つのエージェント (主にデバッグの複雑さの指数関数的な増加による) そしてモニタリング。常に必要な最小数のエージェントから開始します。
効果的なマルチエージェント システムのベスト プラクティス
1. エージェントの外科専門分野
すべてのエージェントが持っている必要があります 1つの主要な責任 とセット
それを実行するために必要な最小限のツール。あらゆることを行うエージェントであり、実際には
何もうまくやらないエージェント。の定義では、 system_message または
の backstory具体的に: 「あなたは、次の分野を専門とするセキュリティ エンジニアです。
OWASP Top 10」は、「あなたはセキュリティの専門家ですか」よりもはるかに効果的です。
2. 構造化スキーマの出力
Pydantic モデルまたは JSON スキーマを使用して、各エージェントから期待される出力を定義します。
フリーテキストではあいまいさが生じ、パイプラインを通じて増幅されます。
を生成するエージェント ReviewReport フィールドあり
critical_issues: List[Issue] そして1つよりも無限に信頼できる
これにより、次のエージェントが解釈するための非構造化テキストが生成されます。
3. 監視と可観測性
運用環境では、各エージェントの呼び出しをタイムスタンプ、 使用されるモデル、入出力トークン、コスト、レイテンシ、ステータス。 LangGraph を使用する場合 ラングスミス; CrewAI ではエンタープライズ可観測性を使用します。 AG2 の場合は OpenTelemetry を使用します。 カスタム システムの場合は、常に相関 ID を使用してログを構造化します。
4. フォールバックとグレースフル デグラデーション
各重要なエージェントにはフォールバック、つまりより単純なエージェント (およびモデル) が必要です。 経済的）、キャッシュされた応答、または人間によるエスカレーション パス。システムは、次のことを行う必要があります。 エージェントに障害が発生した場合でも、機能が低下しても機能し続けます。
5. 強制収束による限定された反復
レビュー ループには反復の最大制限が必要です。
収束は理論的に保証できない: 査読者が尋ねた
常に変化し、それを常に軽やかに実装する開発者
そうしないと、無限に実行される可能性があります。常に設定する max_iterations
制限に達した場合は、「利用可能な最良のもの」を受け入れます。
ベスト プラクティス - Pydantic を使用した出力スキーマ
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()
}結論: 2026 年のマルチエージェント システムの将来
2025 年のマルチエージェント コーディングは概念実証からツールへと成熟しました 生産準備完了。 LangGraph は、複雑で制御されたワークフローで優位に立っています。 CrewAI は役割が定義された仮想チーム用、AG2 は探索的タスク用 実際のコード実行、およびエコシステム内のネイティブ自動化のための Claude Code 人間的。
2026 年の最も重要なトレンドは次のとおりです。 プロトコルの標準化 エージェント間: モデル コンテキスト プロトコル (MCP) とエージェント間 (A2A) が登場しています。 これにより、異なるフレームワークのエージェントが相互に通信できるようになります。 LangGraph エージェントが CrewAI スペシャリストに電話できるようになる、遠くない将来 AG2 ツールを使用することは SF ではなく、すでに部分的には可能です。
すぐに始めたい開発者にとって、次のアドバイスは実践的です。「始めないでください」 最も洗練されたフレームワークから。 2 人のエージェント (開発者 + レビュー担当者) で開始します。 自分が最もよく知っているツールを使用して結果を測定し、複雑さを増すだけです 問題が本当にそれを必要とするとき。ソフトウェアエンジニアリングの黄金律 ここにも当てはまります: 問題を解決する最良かつ最もシンプルなマルチエージェント システム あなたの問題。
推奨される次のステップ
- 前の記事: 法律 エージェントティック ワークフロー: AI の問題の分解 タスクを並列化する前にタスクを構造化する方法を理解する
- 次の記事: に行く AI が生成したコードをテストする AI 生成コードに特有の品質保証戦略のための
- 安全性： 法律 Vibe コーディングのセキュリティ マルチエージェント システムの脆弱性を管理するため
- クロード特有の: もっと詳しく知る クロード・コード: 端末エージェントの開発 ネイティブサブエージェントシステムの詳細については、
Vibe コーディングとエージェント開発シリーズ
これはシリーズの 4 番目の記事です。過去の記事の表紙 バイブコーディングパラダイム、ターミナルからのクロードコード、および分解 エージェントのワークフロー。今後の記事では、AI が生成したコードのテストについて取り上げます。 IDE の迅速なエンジニアリング、バイブコーディングのセキュリティ、開発の将来 2026年のエージェント。