v2.8.0 to v2.8.0

1 added, 1 removed. Audit A to A.

---

name: multi-agent-orchestration

version: "2.8.0"

description: "Expert guide for designing and orchestrating multi-agent systems, agent swarms, 2026 Anthropic agentic design patterns, graph-based workflows (LangGraph, OpenAI Agents SDK, Google ADK, Mastra.ai), shared state memory, and human-in-the-loop guardrails in English and Indonesian."

- author: "vibes-plug-swarm"

+ author: "Roedy Rustam"

---

# Multi-Agent Orchestration Expert (2026 Edition)

[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)

---

## English

### Orchestration & Integration

Connects and orchestrates with relevant domain skills like `brainstorming`, `zero-to-prod-orchestrator`, `ai-llm-integration-expert`, `mcp-server-architect`, and `project-context-mapper` to ensure cohesive execution.

### Description

Expert guide for designing, building, and deploying production-grade multi-agent AI systems. Covers core agentic design patterns (Prompt Chaining, Routing, Parallelization, Orchestrator-Workers, Evaluator-Optimizer), stateful graph engines (LangGraph, OpenAI Agents SDK, Google ADK, Mastra.ai), shared episodic/semantic memory, tool execution sandboxes, and human-in-the-loop (HITL) guardrails.

**Swarm Synergy:** This skill acts as a master orchestrator when combined with `mcp-server-architect` (for external tool integration) and `ai-llm-integration-expert` (for foundation model setup). Together, they form a complete, end-to-end **AI Engineering Swarm**.

### Trigger Conditions

- Building autonomous AI agents that execute complex, multi-step tasks across several domains.

- Designing systems where multiple specialized AI agents collaborate, deliberate, and cross-validate.

- Implementing stateful, graph-based agent workflows with LangGraph, OpenAI Agents SDK, or Google ADK.

- Implementing Anthropic agentic design patterns: Evaluator-Optimizer loops, Orchestrator-Workers, or Routing.

- Integrating human-in-the-loop (HITL) pause checkpoints for high-risk actions (code execution, database migrations, financial transactions).

- Evaluating and selecting agent architectures across Python, TypeScript, and multi-platform swarms.

### Anthropic 2026 Core Agentic Design Patterns

Production systems should favor explicit **Workflows** over unbounded autonomous loops where predictability and reliability are required:

```

1. PROMPT CHAINING

[Input] ---> [LLM Step 1] ---> [Gate/Validator] ---> [LLM Step 2] ---> [Output]

2. ROUTING

[Input] ---> [Classifier/Router] ──┬──> [Specialist Agent A]

├──> [Specialist Agent B]

└──> [Specialist Agent C]

3. PARALLELIZATION (Sectioning & Voting)

[Input] ──┬──> [Task 1 (Subagent)] ──┐

├──> [Task 2 (Subagent)] ──┼──> [Aggregator / Synthesizer]

└──> [Task 3 (Subagent)] ──┘

4. ORCHESTRATOR-WORKERS (Dynamic Decomposition)

[Input] ---> [Orchestrator] ──┬──> [Worker 1 (Focused Context)] ──┐

├──> [Worker 2 (Focused Context)] ──┼──> [Orchestrator Synthesis]

└──> [Worker 3 (Focused Context)] ──┘

5. EVALUATOR-OPTIMIZER LOOP (Zero-Tolerance Quality Gate)

[Input] ---> [Generator Agent] <─────┐ (Feedback Loop)

│ │

▼ │

[Evaluator / Auditor] ────┘ (Reject / Needs Revision)

│

▼ (Approved)

[Output]

```

### Agent Framework Comparison (2026)

|---|---|---|---|

### Core Implementation Guidelines

#### 1. LangGraph — Persistent State & HITL Checkpoints

LangGraph models agent workflows as directed acyclic or cyclic graphs with persistent state:

```python

from langgraph.graph import StateGraph, END

from langgraph.checkpoint.memory import MemorySaver

from typing import TypedDict, Annotated

import operator

class AgentState(TypedDict):

messages: Annotated[list, operator.add]

task: str

code_artifact: str

audit_feedback: str

approved: bool

def generator_node(state: AgentState):

# Generates or refactors code based on previous feedback

code = coder_agent.invoke(state["task"], feedback=state.get("audit_feedback"))

return {"code_artifact": code}

def evaluator_node(state: AgentState):

# Runs automated linter/tests & security review

audit = auditor_agent.invoke(state["code_artifact"])

return {

"audit_feedback": audit.critique,

"approved": audit.is_passing

}

def route_next(state: AgentState) -> str:

return END if state["approved"] else "generator"

builder = StateGraph(AgentState)

builder.add_node("generator", generator_node)

builder.add_node("evaluator", evaluator_node)

builder.set_entry_point("generator")

builder.add_edge("generator", "evaluator")

builder.add_conditional_edges("evaluator", route_next, {"generator": "generator", END: END})

# Persist state with checkpointer for HITL interruption before destructive actions

checkpointer = MemorySaver()

graph = builder.compile(checkpointer=checkpointer, interrupt_before=["generator"])

```

#### 2. OpenAI Agents SDK — Agent Handoffs & Guardrails

Implement native agent handoffs where specialized agents transition control cleanly:

```python

from agents import Agent, Runner, handoff, input_guardrail, GuardrailFunctionOutput

researcher = Agent(

name="Researcher",

instructions="Research libraries, security advisories, and system specs.",

tools=[web_search, doc_retrieval],

)

architect = Agent(

name="Architect",

instructions="Synthesize technical architecture and delegate research when needed.",

handoffs=[handoff(researcher, tool_name_override="delegate_research")],

)

@input_guardrail

async def safety_guardrail(ctx, agent, input_data) -> GuardrailFunctionOutput:

if contains_destructive_commands(input_data):

return GuardrailFunctionOutput(output_info="Blocked destructive payload", tripwire_triggered=True)

return GuardrailFunctionOutput(output_info="Safe", tripwire_triggered=False)

result = await Runner.run(architect, "Design high-throughput ingestion pipeline", guardrails=[safety_guardrail])

```

#### 3. Google ADK — Gemini Multi-Agent Systems

Orchestrate Gemini 3.x agents with streaming subagent calls and Vertex AI tooling:

```python

from google.adk.agents import Agent

from google.adk.tools import google_search, code_execution

director = Agent(

model="gemini-3.1-pro",

name="director",

instruction="Coordinate domain specialists and synthesize final deliverables.",

sub_agents=[frontend_agent, backend_agent, security_agent],

tools=[google_search, code_execution],

)

```

#### 4. Mastra.ai — TypeScript-Native Agents

For modern Next.js / Node.js / Bun environments:

```typescript

import { Agent, MastraMemory } from '@mastra/core';

import { createTool } from '@mastra/core/tools';

import { z } from 'zod';

const researcher = new Agent({

name: 'researcher',

instructions: 'Find and summarize accurate technical documentation.',

model: { provider: 'ANTHROPIC', name: 'claude-3-7-sonnet-20250219' },

memory: new MastraMemory({ storage: supabaseStorage }),

});

```

#### 5. Human-in-the-Loop (HITL) Guardrails

Mandatory safeguards before executing irreversible operations:

- **Interrupt Checkpoints**: Halt workflow execution before executing code, migrating databases, or modifying production records.

- **Approval Dashboards**: Surface diff previews and proposed shell commands to the user or admin before proceeding.

- **Confidence Gates**: Auto-proceed only when model confidence score is >= 0.90; trigger human escalation otherwise.

#### 6. Swarm Circuit Breakers & Fallback Protocols

- **Retry Caps**: Maximum 2 automated retries per subagent.

- **Fallback Escalation**: If a specialist agent stalls or loops, the Swarm Director gracefully fallbacks to `fullstack-expert` or requests human guidance.

- **Checkpoint Persistence**: Always persist intermediate progress to `PROGRESS.md` or `BLUEPRINT.md` so sessions can resume without losing context.

---

## Bahasa Indonesia

### Integrasi Orkestrasi

Terhubung dan mengorkestrasi skill domain yang relevan seperti `brainstorming`, `zero-to-prod-orchestrator`, `ai-llm-integration-expert`, `mcp-server-architect`, dan `project-context-mapper` untuk memastikan eksekusi yang kohesif.

### Deskripsi

Panduan ahli untuk merancang, membangun, dan men-deploy sistem multi-agen AI tingkat produksi. Mencakup pola desain agentik inti (Prompt Chaining, Routing, Parallelization, Orchestrator-Workers, Evaluator-Optimizer), engine graph stateful (LangGraph, OpenAI Agents SDK, Google ADK, Mastra.ai), memori bersama episodik/semantik, sandbox eksekusi tool, dan guardrail human-in-the-loop (HITL).

**Sinergi Swarm:** Skill ini bertindak sebagai orkestrator utama jika dipadukan dengan `mcp-server-architect` (untuk integrasi tool eksternal) dan `ai-llm-integration-expert` (untuk konfigurasi foundation model). Bersama-sama, ketiganya membentuk **AI Engineering Swarm** yang tangguh dari awal hingga rilis produksi.

### Kondisi Pemicu

- Membangun agen AI otonom yang mengeksekusi tugas kompleks multi-langkah lintas domain.

- Merancang sistem kolaborasi, deliberasi, dan validasi silang antar beberapa agen AI spesialis.

- Mengimplementasikan alur kerja graph stateful dengan LangGraph, OpenAI Agents SDK, atau Google ADK.

- Menerapkan 5 pola desain agentik standar: Prompt Chaining, Routing, Parallelization, Orchestrator-Workers, atau Evaluator-Optimizer.

- Mengintegrasikan pos henti human-in-the-loop (HITL) untuk tindakan berisiko tinggi (eksekusi kode, migrasi database, transaksi keuangan).

- Memilih dan mengevaluasi arsitektur agen di ekosistem Python, TypeScript, atau multi-platform.

### 5 Pola Desain Agentik Inti (Standar Anthropic 2026)

Untuk sistem produksi yang handal, utamakan arsitektur **Workflows** terstruktur daripada loop otonom tanpa batas:

1. **Prompt Chaining**: Memecah tugas menjadi langkah-langkah sekuensial dengan validasi output di setiap transisi.

2. **Routing**: Mengklasifikasikan input pengguna dan mengarahkannya ke model atau sub-agen yang memiliki spesialisasi yang tepat.

3. **Parallelization (Sectioning & Voting)**: Menjalankan beberapa sub-agen secara simultan untuk tugas independen atau menjalankan ensemble untuk konsensus voting.

4. **Orchestrator-Workers**: Agen orkestrator pusat memecah masalah dinamis, mendelegasikannya ke pekerja dengan konteks terfokus, lalu merangkum hasil akhirnya.

5. **Evaluator-Optimizer Loop**: Agen pembuat (*generator*) menghasilkan solusi sementara agen penilai (*evaluator*) memberikan audit dan umpan balik hingga standar kualitas terpenuhi.

### Perbandingan Framework Agen (2026)

|---|---|---|---|

### Panduan Implementasi Inti

#### 1. LangGraph — State Persisten & Checkpoint HITL

Memodelkan alur agen sebagai graf terarah dengan state bersama dan penyimpanan checkpoint:

- Simpan state di database (PostgreSQL / MemorySaver) agar alur kerja dapat dijeda dan dilanjutkan kapan saja.

- Terapkan `interrupt_before` sebelum node yang menjalankan perintah destruktif untuk meminta persetujuan manusia (*Human-in-the-loop*).

#### 2. OpenAI Agents SDK — Handoffs & Guardrails

Terapkan transisi kendali yang mulus antar agen dengan fungsi `handoff` bawaan serta pasang filter `guardrail` pada input dan output untuk mencegah eksekusi instruksi berbahaya.

#### 3. Google ADK — Multi-Agent Gemini

Bangun hierarki agen dengan model Gemini 3.x, di mana root agent mengoordinasikan sub-agents untuk riset, eksekusi kode, dan pembuatan dokumen.

#### 4. Mastra.ai — Solusi TypeScript Penuh

Gunakan Mastra untuk ekosistem Next.js dan Node.js: sediakan memori persisten ke Supabase/PostgreSQL, integrasikan tool MCP secara langsung, dan manfaatkan framework evaluasi bawaan.

#### 5. Guardrails Human-in-the-Loop (HITL)

Pengamanan wajib sebelum melakukan tindakan yang tidak dapat dibatalkan:

- **Pos Henti Interupsi**: Hentikan eksekusi sebelum menjalankan skrip shell berbahaya, migrasi skema tabel, atau memodifikasi data produksi.

- **Tinjauan Pratinjau**: Tampilkan ringkasan perbedaan (*diff*) kepada pengguna sebelum modifikasi dieksekusi.

- **Ambang Keyakinan**: Otomatis lanjutkan hanya jika skor keyakinan model >= 0.90; eskalasikan ke manusia jika berada di bawah ambang batas.

#### 6. Circuit Breakers & Protokol Pemulihan Swarm

- **Batas Percobaan Ulang**: Maksimal 2 kali perbaikan otomatis per sub-agen.

- **Eskalasi Fallback**: Jika agen spesialis mengalami kendala konteks atau gagal berulang kali, Swarm Director segera mengalihkan tugas ke `fullstack-expert` atau meminta masukan pengguna.

- **Persistensi Kemajuan**: Simpan selalu checkpoint di `PROGRESS.md` atau `BLUEPRINT.md` agar alur kerja dapat dilanjutkan secara efisien tanpa token berlebih.