Belajar Generative AI - Multi-Agent Systems

#Pendahuluan

Di episode 10 kita diperkenalkan dengan konsep multi-agent orchestration; episode 19 membawa reasoning & agentic RAG. Sekarang saatnya membangun sistem multi-agent yang utuh — bukan sekadar banyak model yang dipanggil, tetapi tim agent dengan peran, komunikasi, dan kontrol yang dirancang dengan sengaja.

Mengapa penting? Karena task produksi yang nyata (riset mendalam, otomasi workflow, penanganan tiket kompleks) sering melampaui kemampuan satu agent: butuh keahlian berbeda, butuh verifikasi, atau butuh paralelisme. Multi-agent adalah cara membangunnya — tapi juga cara paling mudah untuk membangun sistem yang lambat, mahal, dan tidak bisa diprediksi. Episode ini mengajarkan kapan dan bagaimana.

#Kapan Multi-Agent, Kapan Tidak

Sebelum membangun tim agent, jujurlah: kebanyakan kasus cukup satu agent. Multi-agent hanya masuk akal jika:

1. Keahlian terpisah — analisis data, penulisan, kode, dengan model/config berbeda.
2. Verifikasi diperlukan — pekerjaan penting yang hasilnya harus diperiksa agent lain.
3. Paralelisme nyata — banyak sub-task independen yang bisa dijalankan bersamaan.

Jika tidak ada alasan di atas, satu agent lebih cepat, murah, dan mudah di-debug. Ini keputusan arsitektur — bukan prestise.

#Peran: Planner, Executor, Verifier

Pola paling teruji untuk sistem multi-agent:

Perhatikan: verifier adalah kunci keandalan. Tanpa verifier, kesalahan executor langsung lolos ke pengguna; dengan verifier, ada lapisan koreksi. Ini yang membuat multi-agent lebih andal — bukan karena "beberapa otak lebih pintar".

#Framework: LangGraph, CrewAI, AutoGen

#LangGraph: State Machine Multi-Agent

Karena kalian sudah kenal LangGraph di episode 10, kita kembangkan dengan beberapa agent:

from langgraph.graph import StateGraph
 
def planner_node(state):
    plan = plan_agent.invoke(state["task"])       # LLM: pecah jadi langkah
    return {"plan": plan}
 
def executor_node(state):
    results = {}
    for step in state["plan"]:                    # bisa paralel (fan-out)
        results[step["id"]] = executor_agent.invoke(step)
    return {"results": results}
 
def verifier_node(state):
    report = verifier_agent.invoke(state["results"])
    return {"verdict": report["verdict"], "issues": report["issues"]}
 
def route_after_verify(state):
    return "executor" if state["verdict"] == "fail" else "final"
 
g = StateGraph(AgentState)
g.add_node("planner", planner_node)
g.add_node("executor", executor_node)
g.add_node("verifier", verifier_node)
g.add_node("final", final_node)
g.set_entry_point("planner")
g.add_edge("planner", "executor")
g.add_edge("executor", "verifier")
g.add_conditional_edges("verifier", route_after_verify,
                        {"executor": "executor", "final": "final"})

#CrewAI: Deklaratif

Untuk prototipe cepat, CrewAI meringkas peran & goal:

from crewai import Agent, Task, Crew, Process
 
researcher = Agent(role="Researcher", goal="Kumpulkan data pasar",
                   backstory="Analis pasar senior", tools=[web_search])
writer = Agent(role="Writer", goal="Susun laporan dari data",
               backstory="Penulis laporan profesional")
 
t1 = Task(description="Riset tren GenAI 2026", agent=researcher)
t2 = Task(description="Tulis ringkasan 1 halaman", agent=writer)
 
crew = Crew(agents=[researcher, writer], tasks=[t1, t2],
            process=Process.sequential)
result = crew.kickoff()

CrewAI bagus untuk eksplorasi pola peran; untuk produksi dengan kebutuhan kontrol & determinisme, LangGraph lebih disarankan.

#Human-in-the-Loop: Orang Masih di Dalam

Multi-agent yang baik tahu kapan meminta konfirmasi manusia. Untuk aksi berisiko (pengiriman email, pembayaran, publish) atau keputusan ambigu, agent harus pause dan menunggu approval. Di LangGraph, ini disebut interrupt:

from langgraph.types import interrupt
 
def send_email_node(state):
    draft = email_agent.invoke(state)
    decision = interrupt({                          # pause → manusia menilai
        "type": "email_draft",
        "draft": draft,
        "to": state["recipient"],
    })
    if decision.get("approved"):
        return {"status": "sent"}
    return {"status": "rejected", "reason": decision.get("reason")}
 
# resume setelah approval: graph.invoke(None, config={"thread_id": ...})

Human-in-the-loop bukan tanda kelemahan — ia kontrol yang disengaja untuk menjaga kepercayaan (dan menghindari bencana).

#Praktik: Sistem Research & Automation

Contoh nyata: sistem research agent yang menyusun laporan. Alurnya:

1. Planner memecah topik riset menjadi subtopik.
2. Executors (paralel) mencari sumber per subtopik via web/RAG.
3. Synthesizer merangkum temuan menjadi draf laporan.
4. Verifier memeriksa: semua klaim punya sumber? tidak kontradiktif?
5. Human approval sebelum laporan dipublikasikan.

def run_research(topic):
    plan = planner(topic)                      # ["sejarah", "arsitektur", "biaya"]
    findings = run_parallel(research, plan)    # executor per subtopik
    draft = synthesizer(topic, findings)
    report = verifier(draft, sources=findings)
    return report  # + request human approval di titik interrupt

Ukuran keberhasilan sistem ini: berapa persen laporan lolos verifier tanpa revisi dan berapa lama total. Keduanya harus di-monitor (episode 18).

#Common Pitfalls

• Multi-agent tanpa alasan — menambah kompleksitas tanpa manfaat.
• Tanpa verifier — kesalahan menyebar ke output final.
• Agent berbicara tanpa batas — loop percakapan tak berujung; batasi iterasi & total token.
• Tanpa human-in-the-loop untuk aksi berisiko — agent mengirim email yang salah.
• Tanpa observability — sistem multi-agent hampir mustahil di-debug tanpa trace.

#Penutup

Inti yang harus dibawa pulang:

• Multi-agent hanya jika ada keahlian terpisah, verifikasi, atau paralelisme.
• Pola planner → executor → verifier + orchestrator; verifier kunci keandalan.
• LangGraph untuk produksi (state machine), CrewAI/AutoGen untuk eksplorasi.
• Human-in-the-loop (interrupt) untuk aksi berisiko; batasi komunikasi antar-agent.

Di episode 21 selanjutnya kita akan membahas Cost Optimization & Scaling — model routing, caching, prompt compression, hybrid self-host vs API, batch processing, rate limiting, dan optimasi GPU inference (vLLM, batching). Sampai jumpa di episode 21!