Linear atau graf: cara mengatur banyak agent tanpa loop abadi

Kasih satu agent dua puluh tool dan system prompt sepanjang novel, hasil pertamanya biasanya kelihatan meyakinkan. Masalahnya tuh muncul belakangan: agent mulai salah pilih tool, lupa apa yang dia baca tiga langkah sebelumnya, lalu mengarang langkah yang nggak pernah ada di instruksi. Nggak ada error merah, cuma hasil yang makin lama makin ngawur.

Begitu tugasnya bertambah (nulis kode backend, nyusun unit test, audit keamanan, memperbaiki compile error, minta persetujuan manusia sebelum deploy), satu agent nggak lagi cukup. Solusinya memecah pekerjaan ke beberapa agent dengan peran sempit: Coder Agent, Reviewer Agent, Tester Agent, Deployment Agent. Prompt-nya pendek, tool-nya sedikit, tanggung jawabnya jelas.

Yang belum selesai justru pertanyaan sesudahnya: siapa yang ngatur giliran? Kalau semua agent dilepas ngobrol bebas, yang jadi pembatas cuma tagihan token yang kamu bayar. Kalau diatur jadi chain kaku, revisi jadi mustahil.

Chain linear mentok di revisi pertama

Workflow engine generasi awal memakai model chain: agent A bikin draf, agent B meninjau, agent C merilis. Apache Airflow termasuk kubu ini. Alurnya DAG, jadi boleh bercabang banyak, tapi nggak boleh membentuk cycle. Selama semuanya maju ke depan, model begini emang bersih dan gampang dilacak.

Proses review di dunia nyata jarang sebegitu rapi. Reviewer menemukan celah, kode dikembalikan ke coder, coder memperbaiki, lalu balik lagi ke reviewer. Cycle kayak gini normal, biasanya dua sampai tiga kali sebelum kode dianggap bersih.

Di dalam DAG, cycle itu secara definisi nggak ada. Namanya aja asiklik. Kalau dipaksa pakai while di Python dengan state yang dioper sebagai variabel biasa, tiga hal langsung hilang: state gampang berubah tanpa jejak, riwayat siapa mengubah apa nggak tercatat, dan kalau worker mati di tengah jalan, nggak ada titik untuk resume.

Graf cuma butuh empat bagian

Paradigma yang sekarang dipakai LangGraph sebenarnya sederhana:

• Node: unit kerja terisolasi. Bisa panggilan LLM dengan prompt khusus, bisa fungsi Python biasa.
• Edge: jalur dari satu node ke node berikutnya.
• Conditional edge: fungsi kecil yang membaca state dan memutuskan alurnya belok ke mana. Review APPROVED? Lurus ke deploy. Masih ada catatan? Balik ke coder.
• Shared state: satu objek dengan skema ketat (biasanya TypedDict atau model Pydantic). Tiap node mengembalikan potongan yang dia ubah, lalu reducer menggabungkannya.

Empat bagian itu cukup untuk menggambarkan alur yang punya cycle, bercabang, dan berhenti sendiri.

Ping-pong yang nggak pernah berhenti

Skenario paling mahal: coder mengirim kode dengan bug, reviewer menolak, coder mengubah baris yang salah, reviewer menolak lagi. Cycle ini bisa berjalan puluhan kali tanpa ada yang sadar, dan tagihannya baru kelihatan besok pagi 💸

Jadi gimana cara membatasinya? Mitigasinya dua lapis. Lapis pertama di runtime: recursion_limit. Satu hal yang sering salah kutip di tutorial: angka ini menghitung super-step (tiap node yang jalan), bukan jumlah cycle review. Nilai bawaannya juga bukan 25 lagi. Angkanya kok jadi 10007? Angka itu pindah tiga kali: 25 di 1.0.0, 10000 di 1.0.6 sampai 1.1.x, lalu 10007 sejak 1.2.0. Di LangGraph 1.2.16 yang kupakai di sini, DEFAULT_RECURSION_LIMIT isinya 10007, dan bisa di-override lewat environment variable LANGGRAPH_DEFAULT_RECURSION_LIMIT atau config saat invoke.

Waktu dicoba pakai graf dengan cycle tanpa syarat berhenti, GraphRecursionError baru muncul setelah 10007 langkah. Graf kosong begini selesai dalam dua detik, tapi dua detik itu percuma kalau tiap langkahnya panggilan LLM. Jadi angka 25 yang dulu jadi bawaan sekarang harus kamu pasang sendiri. Itu memang yang kamu mau.

Lapis kedua di level desain: penghitung di dalam state, misalnya iterasi <= 3. Lewat dari itu, alurnya dialihkan ke node eskalasi untuk manusia. Peran ini nggak bisa digantikan recursion_limit, karena angka itu cuma bilang "sudah terlalu banyak langkah", bukan "review gagal tiga kali, berhenti".

AutoGen punya bentuk pengaman yang mirip, cuma namanya lain. Group chat tanpa termination_condition memang jalan terus, dan dokumentasinya bilang begitu apa adanya. Yang biasa dipakai max_turns atau TextMentionTermination.

Konteks yang membengkak

Bahaya kedua kelihatan sepele nih: tiap agent menambahkan seluruh riwayat obrolan ke state. Setelah sepuluh cycle, context window penuh raw transcript yang sudah nggak relevan, dan biaya tiap panggilan ikut naik terus.

Obatnya pruning di reducer: yang disimpan cuma artefak terakhir (file kode versi terbaru, ringkasan catatan review), bukan transkrip lengkap. Ini keputusan desain dari awal, bukan saklar yang bisa dinyalakan belakangan.

Checkpoint: kenapa agent bisa di-pause

Framework graf modern menyimpan snapshot dari state tiap kali eksekusi pindah node. Snapshot itu diikat ke thread_id dan checkpoint_id di database persisten: PostgresSaver buat Postgres, RedisSaver buat Redis, InMemorySaver buat main-main di lokal.

Dari checkpoint itu tiga hal jadi mungkin. Kalau container restart di tengah kerjaan empat puluh menit, eksekusi di-resume dari checkpoint terakhir. Untuk persetujuan manusia sebelum node rilis, eksekusi di-pause lewat interrupt, state disimpan, dan graf menunggu resume. Untuk debugging, state lama bisa dibaca ulang, diedit, lalu dijalankan ulang dari titik itu.

Satu detail yang jarang disebut: checkpoint disimpan di batas super-step, bukan di tengah fungsi. Konsekuensinya, kalau eksekusi di-pause lalu di-resume, node yang sedang berjalan di-replay dari awal fungsi. Side effect-nya jadi wajib idempoten. Kirim email dua kali, potong saldo dua kali: itu bukan teori, itu yang beneran kejadian kalau node-nya nggak disiapkan.

Kodenya, versi yang jalan sekarang

Sekarang kita lihat kodenya. Ini graf revisi dengan pengaman. Reviewer-nya sengaja pakai aturan tetap, bukan LLM, biar bisa diuji tanpa API key.

from typing import TypedDict, Literal
from langgraph.graph import StateGraph, START, END
from langgraph.checkpoint.memory import InMemorySaver

class TimState(TypedDict):
    tugas: str
    draf: str
    catatan_review: str
    iterasi: int

MAKS_REVISI = 3

def coder(state: TimState) -> dict:
    iterasi = state.get("iterasi", 0) + 1
    print(f"[coder] menulis draf ke-{iterasi}")
    return {"draf": f"def bayar(): return True  # versi {iterasi}", "iterasi": iterasi}

def reviewer(state: TimState) -> dict:
    lolos = state["iterasi"] >= 2   # di produksi ini panggilan LLM
    print(f"[reviewer] draf ke-{state['iterasi']} -> {'lolos' if lolos else 'ditolak'}")
    return {"catatan_review": "APPROVED" if lolos else "belum ada error handling"}

def deploy(state: TimState) -> dict:
    print("[deploy] disetujui, lanjut rilis")
    return {}

def eskalasi(state: TimState) -> dict:
    print("[eskalasi] batas revisi habis, lempar ke manusia")
    return {}

def arah_setelah_review(state: TimState) -> Literal["coder", "deploy", "eskalasi"]:
    if state["catatan_review"] == "APPROVED":
        return "deploy"
    if state["iterasi"] >= MAKS_REVISI:
        return "eskalasi"
    return "coder"

builder = StateGraph(TimState)
builder.add_node("coder", coder)
builder.add_node("reviewer", reviewer)
builder.add_node("deploy", deploy)
builder.add_node("eskalasi", eskalasi)

builder.add_edge(START, "coder")
builder.add_edge("coder", "reviewer")
builder.add_conditional_edges("reviewer", arah_setelah_review, ["coder", "deploy", "eskalasi"])
builder.add_edge("deploy", END)
builder.add_edge("eskalasi", END)

app = builder.compile(checkpointer=InMemorySaver())

config = {"configurable": {"thread_id": "tugas-1"}}
app.invoke({"tugas": "tulis endpoint pembayaran"}, config)
print("state akhir:", app.get_state(config).values)

Outputnya, dijalankan pakai LangGraph 1.2.16 dan Python 3.12:

[coder] menulis draf ke-1
[reviewer] draf ke-1 -> ditolak
[coder] menulis draf ke-2
[reviewer] draf ke-2 -> lolos
[deploy] disetujui, lanjut rilis
state akhir: {'tugas': 'tulis endpoint pembayaran', 'draf': 'def bayar(): return True  # versi 2', 'catatan_review': 'APPROVED', 'iterasi': 2}

Kalau reviewer kamu buat selalu menolak, cycle-nya berhenti di iterasi ketiga dan alurnya pindah ke node eskalasi. Itu inti pengamannya: graf tetap boleh punya cycle, tapi ada angka yang menentukan kapan harus berhenti.

Satu catatan biar nggak bingung waktu baca tutorial lama: MemorySaver masih bisa diimpor, tapi sekarang cuma alias dari InMemorySaver. Dua-duanya jalan, yang satunya ketinggalan zaman.

Terus AutoGen?

AutoGen sering disebut sebaris dengan LangGraph, padahal bentuknya beda. AutoGen lebih dekat ke percakapan terstruktur: beberapa agent dengan peran, satu termination condition yang menentukan kapan berhenti. Kamu nggak mendefinisikan grafnya sendiri.

Statusnya yang perlu kamu tahu: sejak 16 Oktober 2026 proyeknya menyatakan diri diarsipkan. Ini lebih tegas daripada sekadar berhenti dapat fitur baru, karena Microsoft menyatakan nggak menyediakan perbaikan bug, perbaikan keamanan, apalagi dukungan untuk proyek ini. Rilis terakhirnya, 0.7.5, masih bisa di-install dari PyPI, tapi jangan harap ada tambalan sesudahnya.

Penggantinya Microsoft Agent Framework, dibangun tim inti AutoGen dan Semantic Kernel. Bagian workflow-nya menyediakan dua gaya sekaligus, fungsional dan berbasis graf, dan per Oktober 2026 paket Python-nya sudah rilis stabil (agent-framework 1.22.0).

Satu catatan biar presisi: yang diarsipkan itu proyeknya, bukan repo GitHub-nya. Halamannya masih bisa dibuka dan masih bisa di-star sampai sekarang. Dan ini klaim yang paling cepat basi dari seluruh artikel ini, jadi cek tanggalnya sendiri sebelum mengutip.

Jadi linear atau graf?

Kalau alurnya memang lurus dan nggak ada yang perlu dikembalikan, chain linear cukup, dan graf cuma menambah bagian yang harus dirawat. Graf baru bernilai begitu ada revisi, percabangan, dan manusia yang harus menyetujui di tengah jalan.

Jadi, semua harus pindah ke graf? Nggak juga sih. Sistem multi-agent yang waras bukan berarti beberapa model dibiarkan ngobrol bebas. Yang bikin dia waras: peran yang sempit, state dengan skema, batas cycle yang eksplisit (kamu yang pilih angkanya), dan checkpoint yang bikin kerjanya bisa di-resume kapan saja ⚙️

Kalau agent-mu mulai jalan di loop tanpa ujung, yang pertama dicek bukan modelnya, tapi apakah ada angka yang membatasi cycle-nya. Sisanya cuma soal rapi-rapi state dan sabar baca trace. Semoga tagihanmu nggak bikin kaget di akhir bulan 😄