AI & Machine Learning

Membangun Sistem Multi-Agent Sederhana: Orchestrator, Worker, dan Tool Use

Agent tunggal mulai kewalahan untuk tugas kompleks. Pelajari pola orchestrator-worker dan bangun tim agent riset kecil dengan Python dan Claude API — lengkap dengan tool use.

NP
novan putra 6 Oktober 2026 · 4 mnt baca · 3.666 dilihat
Membangun Sistem Multi-Agent Sederhana: Orchestrator, Worker, dan Tool Use

Sepanjang 2026, istilah multi-agent muncul di mana-mana: dari demo riset otomatis sampai coding agent yang memecah pekerjaan ke beberapa "sub-agent". Idenya sederhana: daripada satu agent mengerjakan semuanya dengan konteks yang makin penuh, bagi tugas ke beberapa agent yang masing-masing fokus. Artikel ini membangun versi sederhananya dari nol — tanpa framework, supaya konsepnya jelas.

Kapan Butuh Multi-Agent?

Multi-agent bukan selalu lebih baik. Ia menambah biaya token dan kompleksitas. Gunakan jika:

  • Tugas bisa dipecah menjadi bagian yang independen dan bisa dikerjakan paralel.
  • Setiap sub-tugas butuh banyak konteks yang tidak relevan untuk sub-tugas lain.
  • Kamu ingin peran berbeda (peneliti, pengkritik, penulis) dengan instruksi berbeda.

Untuk tugas sederhana, satu agent dengan tools yang baik hampir selalu cukup.

Pola orchestrator-worker
Orchestrator memegang gambaran besar; worker fokus pada sub-tugas dengan konteks bersih.

Langkah 1: Agent Dasar dengan Tool Use

# agent.py
import json
import anthropic

client = anthropic.Anthropic()
MODEL = "claude-sonnet-5-5"

def jalankan_agent(sistem: str, tugas: str, tools: list, fungsi: dict, maks_langkah: int = 8) -> str:
    pesan = [{"role": "user", "content": tugas}]
    for _ in range(maks_langkah):
        resp = client.messages.create(
            model=MODEL, max_tokens=2048, system=sistem, tools=tools, messages=pesan
        )
        pesan.append({"role": "assistant", "content": resp.content})

        if resp.stop_reason != "tool_use":
            return "".join(b.text for b in resp.content if b.type == "text")

        hasil = []
        for blok in resp.content:
            if blok.type == "tool_use":
                try:
                    keluaran = fungsi[blok.name](**blok.input)
                except Exception as e:
                    keluaran = {"error": str(e)}
                hasil.append({
                    "type": "tool_result",
                    "tool_use_id": blok.id,
                    "content": json.dumps(keluaran, ensure_ascii=False),
                })
        pesan.append({"role": "user", "content": hasil})
    return "Berhenti: batas langkah tercapai."

Loop ini adalah inti setiap agent: model memutuskan memanggil tool, kita mengeksekusi, hasilnya dikirim kembali, sampai model selesai.

Langkah 2: Tools untuk Worker

def cari_artikel_blog(kata_kunci: str) -> list[dict]:
    # Contoh: panggil API pencarian blog / database
    return [{"judul": "pgvector: Pencarian Semantik", "slug": "pgvector-pencarian-semantik-postgresql"}]

TOOLS_RISET = [{
    "name": "cari_artikel_blog",
    "description": "Cari artikel di blog berdasarkan kata kunci. Mengembalikan judul dan slug.",
    "input_schema": {
        "type": "object",
        "properties": {"kata_kunci": {"type": "string"}},
        "required": ["kata_kunci"],
    },
}]
FUNGSI_RISET = {"cari_artikel_blog": cari_artikel_blog}

Langkah 3: Orchestrator

Orchestrator meminta model memecah tugas menjadi sub-tugas dalam format JSON, lalu membagikannya ke worker secara paralel:

from concurrent.futures import ThreadPoolExecutor

SISTEM_ORKESTRATOR = """Kamu adalah koordinator riset. Pecah permintaan pengguna menjadi
2-4 sub-tugas riset yang INDEPENDEN. Jawab HANYA JSON:
{"subtugas": [{"judul": "...", "instruksi": "..."}]}"""

SISTEM_WORKER = """Kamu adalah peneliti teliti. Kerjakan satu sub-tugas saja.
Gunakan tools bila perlu. Akhiri dengan ringkasan maksimal 150 kata dan sebutkan sumbernya."""

def orkestrasi(permintaan: str) -> str:
    rencana_raw = client.messages.create(
        model=MODEL, max_tokens=1024, system=SISTEM_ORKESTRATOR,
        messages=[{"role": "user", "content": permintaan}],
    ).content[0].text
    rencana = json.loads(rencana_raw[rencana_raw.find("{"): rencana_raw.rfind("}") + 1])

    def kerjakan(st):
        temuan = jalankan_agent(SISTEM_WORKER, st["instruksi"], TOOLS_RISET, FUNGSI_RISET)
        return f"## {st['judul']}\n{temuan}"

    with ThreadPoolExecutor(max_workers=4) as ex:
        temuan = list(ex.map(kerjakan, rencana["subtugas"]))

    laporan = client.messages.create(
        model=MODEL, max_tokens=2048,
        system="Gabungkan temuan menjadi laporan rapi berbahasa Indonesia. Jangan menambah fakta baru.",
        messages=[{"role": "user", "content": "\n\n".join(temuan)}],
    )
    return laporan.content[0].text

if __name__ == "__main__":
    print(orkestrasi("Buat rencana seri artikel tentang AI untuk developer pemula di blog ini."))

Kenapa Pola Ini Efektif?

Aspek Agent tunggal Orchestrator–worker
Konteks Menumpuk dan makin penuh Setiap worker mulai bersih
Kecepatan Berurutan Sub-tugas berjalan paralel
Fokus instruksi Satu prompt untuk semua Peran spesifik per worker
Biaya token Lebih rendah Lebih tinggi

Praktik Terbaik

  • Batasi langkah (maks_langkah) agar agent tidak berputar tanpa akhir.
  • Worker read-only jika memungkinkan; aksi berisiko hanya di orchestrator dengan konfirmasi manusia.
  • Gunakan model berbeda — worker sederhana bisa memakai model yang lebih kecil dan murah.
  • Log semuanya — simpan rencana, panggilan tool, dan hasil setiap worker untuk debugging.
  • Evaluasi — siapkan 10–20 contoh tugas dan bandingkan hasil multi-agent vs agent tunggal sebelum memutuskan.

Penutup

Multi-agent pada dasarnya adalah pola manajemen proyek yang diterapkan ke AI: pecah tugas, delegasikan, gabungkan hasil. Mulailah dari loop agent tunggal yang solid, baru tambahkan orchestrator ketika kamu benar-benar butuh paralelisme dan konteks yang terpisah.

NP
Ditulis oleh

novan putra

Penulis utama blog ini.

0 Komentar

Komentar ditinjau dulu sebelum tampil.