Belajar AI Engineer - Multi-Agent & Orchestration

#Pendahuluan

Di episode 11 kalian membangun agent tunggal; di episode 12-22 kalian membuatnya pintar, hemat, dan aman. Episode ini membuka level tertinggi orchestration: multi-agent systems — beberapa agent khusus bekerja bersama menangani tugas yang terlalu kompleks untuk satu agent.

Mengapa penting? Karena beberapa tugas nyata benar-benar butuh pembagian peran: seorang researcher mencari informasi, seorang writer menyusun laporan, seorang reviewer memeriksa kualitas. Memodelkan peran ini sebagai agent terpisah — dengan konteks masing-masing — menghasilkan kualitas yang sulit ditiru satu agent yang mencampur semuanya.

#Kapan Multi-Agent Layak?

Jangan asal multi-agent. Indikator yang sah:

• Tugas benar-benar berlapis dengan peran berbeda (riset → tulis → review).
• Tool terlalu banyak untuk satu konteks model (agent jadi bingung memilih).
• Butuh isolasi konteks: researcher bekerja dengan dokumen, writer tidak perlu semua dokumen.
• Proses bisa dijalankan paralel: riset dua topik bersamaan menghemat waktu.

Jika tidak ada indikator ini, satu agent lebih baik: lebih murah, lebih deterministik, lebih mudah di-debug. Multi-agent menambah biaya, latensi, dan titik kegagalan — investasi yang hanya terbayar untuk tugas yang benar-benar kompleks.

#Pola Orchestration

Dua pola arsitektur yang paling umum:

#1. Orchestrator (Task Delegation)

Satu agent pusat memecah tugas, mendelegasikan ke sub-agent, lalu merakit hasilnya.

100%

#2. Supervisor (Handoff)

Agent berbagi kontrol secara berurutan — tiap agent "menyerahkan" pekerjaan ke agent lain.

100%

LangGraph mendukung keduanya dengan model state graph yang eksplisit — lebih terkontrol daripada loop bebas.

#Membangun dengan LangGraph

LangGraph merepresentasikan agent sebagai graph: node (fungsi/langkah) dan edge (transisi). State mengalir antar node secara eksplisit — determinisme naik karena alur didefinisikan kode, bukan keputusan model liar.

Multi-agent supervisor dengan LangGraph

from langgraph.graph import StateGraph, END
from typing import TypedDict
 
class State(TypedDict):
    task: str
    riset: str
    draft: str
    feedback: str
 
def riset_node(state: State) -> dict:
    return {"riset": research_llm(state["task"])}
 
def tulis_node(state: State) -> dict:
    return {"draft": writer_llm(state["task"], state["riset"])}
 
def review_node(state: State) -> dict:
    return {"feedback": reviewer_llm(state["draft"])}
 
def route_after_review(state: State) -> str:
    return "tulis" if "revisi" in state["feedback"].lower() else END
 
g = StateGraph(State)
g.add_node("riset", riset_node)
g.add_node("tulis", tulis_node)
g.add_node("review", review_node)
g.set_entry_point("riset")
g.add_edge("riset", "tulis")
g.add_edge("tulis", "review")
g.add_conditional_edges("review", route_after_review)
 
app = g.compile()
hasil = app.invoke({"task": "Tulis laporan singkat tentang tren AI 2026"})
print(hasil["draft"])

Perhatikan route_after_review: transisi adalah keputusan kode (ada kata "revisi"), bukan keputusan model. Ini contoh determinisme — kita mengontrol alur, model hanya mengisi konten.

#CrewAI: Multi-Agent Berbasis Peran

CrewAI mengambil pendekatan berbeda: mendefinisikan crew (tim) berisi agent dengan peran dan task:

CrewAI - tim riset dan penulis

from crewai import Agent, Task, Crew
 
researcher = Agent(
    role="Peneliti AI",
    goal="Mengumpulkan fakta akurat tentang topik",
    backstory="Analis yang teliti dengan akses alat pencarian",
    tools=[search_tool],
)
 
writer = Agent(
    role="Penulis Teknis",
    goal="Menyusun laporan jelas dari hasil riset",
    backstory="Penulis berpengalaman di teknologi",
)
 
riset = Task(description="Riset tren AI 2026", agent=researcher)
laporan = Task(description="Tulis laporan 3 paragraf", agent=writer)
 
crew = Crew(agents=[researcher, writer], tasks=[riset, laporan])
result = crew.kickoff()

CrewAI menekankan kemudahan: definisikan peran dan task, framework mengatur interaksi. LangGraph menekankan kontrol eksplisit — penting untuk produksi yang butuh determinisme.

#Determinisme: Musuh Kompleksitas

Kompleksitas multi-agent mengundang nondeterminisme. Cara menjaga determinisme:

1. Batasi keputusan model: alur (route) dibuat kode; model hanya mengisi konten.
2. State eksplisit: semua konteks antar agent lewat state yang didefinisikan — bukan promp rahasia.
3. Batas jelas per node: maksimum tool call dan iterasi per node.
4. Trace wajib: tanpa tracing (episode 17), multi-agent mustahil di-debug.
5. Retry dan fallback per node: satu node gagal jangan menghancurkan seluruh graph (episode 25).

Batasi iterasi di LangGraph

from langgraph.graph import Graph
 
g = Graph()
g.add_node("agent", agent_node)
g.add_conditional_edges("agent", should_continue,
                        {"lanjut": "agent", "selesai": END})
app = g.compile()
app = app.with_retry(max_retries=2)   # retry node yang gagal

#Common Pitfalls

• Multi-agent tanpa kebutuhan: biaya dan kompleksitas naik, kualitas belum tentu. Mulai single agent.
• Alur dikendalikan model: transisi bebas (handoff tanpa batas) = perilaku tidak terprediksi. Kendalikan alur dengan kode.
• State bocor antar agent: setiap agent hanya perlu state yang relevan — jangan bagikan semua.
• Tanpa tracing: multi-agent tanpa observability adalah kotak hitam yang mahal.

#Penutup

Inti yang harus dibawa pulang:

• Multi-agent layak untuk tugas benar-benar berlapis; jika tidak, satu agent lebih baik.
• Dua pola: orchestrator (delegasi) dan supervisor (handoff).
• LangGraph memberi kontrol eksplisit (state graph); CrewAI memberi kemudahan peran.
• Determinisme dijaga dengan alur sebagai kode, state eksplisit, batas iterasi, dan trace.

Di episode 24 selanjutnya kita menggabungkan semua kemampuan knowledge: RAG lanjutan & agents — hybrid search, graph RAG, agentic RAG, dan merancang RAG skala produksi. Sampai jumpa di episode 24!