Cara Memperbaiki Loop Handoff Tak Terbatas Agen AI

Sistem multi-agen gagal dengan cara khas. Alih-alih macet total, mereka jadi sopan: sebuah router menyerahkan tugas ke spesialis, spesialis memutuskan itu di luar cakupannya dan menyerahkan kembali, router menyerahkannya lagi, dan keduanya berputar sampai Anda menghentikan prosesnya atau tagihannya membuat ciut.

Inilah loop handoff, salah satu mode kegagalan paling umum begitu Anda beranjak dari satu agen. Panduan ini membahas mengapa itu terjadi, cara merancangnya agar tidak muncul, dan cara menambahkan penjaga runtime yang menghentikan loop sebelum menguras anggaran token Anda.

Apa itu loop handoff sebenarnya

Handoff adalah satu agen menyerahkan kendali, beserta konteks, ke agen lain. Dalam sistem sehat, handoff mengalir menuju penyelesaian. Dalam sistem rusak, handoff membentuk siklus: agen A menyerah ke B, B menyerah kembali ke A, dan tak ada yang memegang momen di mana tugas dinyatakan selesai.

Loop hampir selalu berakar pada salah satu dari beberapa penyebab dasar:

• Tanggung jawab yang tumpang tindih, sehingga dua agen sama-sama mengira sebuah tugas milik yang lain.
• Tidak ada kondisi terminasi, sehingga tak ada apa pun dalam sistem yang boleh berkata berhenti.
• Handoff dipicu ketidakpastian, sehingga agen bingung mengoper alih-alih memutuskan, dan kebingungan itu menular.

Beri satu agen keputusannya

Perbaikan paling andal bersifat struktural: satu orkestrator memegang alur, dan spesialis adalah worker yang ia panggil, bukan rekan sejawat yang saling memanggil. Worker mengembalikan hasil ke orkestrator; mereka tidak pernah handoff menyamping. Anthropic menggambarkan bentuk orchestrator-worker ini sebagai default untuk kerja multi-agen, justru karena kendali tetap di satu tempat.

Kodekan hierarki itu ke dalam loop-nya sendiri, dengan penjaga yang mengakhiri jalannya proses alih-alih membiarkannya bersiklus:

# Orchestrator loop, pseudocode
for step in range(MAX_STEPS):
    result = worker.run(task, context)
    if result.done:
        return result            # success: stop here
    if seen(result.state):
        abort("repeat detected")  # loop guard
    task, context = plan_next(result)
return abort("hit MAX_STEPS")      # hard cap

Tambahkan kondisi terminasi

Struktur mencegah sebagian besar loop; aturan berhenti eksplisit menangkap sisanya. Tiap jalannya proses agentik butuh kondisi yang mengharuskannya berakhir:

• Batas maksimum iterasi atau jumlah handoff, setelahnya proses berhenti dan melaporkan kemajuan parsial.
• Detektor pengulangan yang berhenti ketika keadaan sama atau handoff sama berulang, karena pengulangan adalah loop yang sedang berlangsung.
• Anggaran waktu nyata atau token, sehingga proses tidak bisa melampaui nilai ekonomisnya.
• Uji keberhasilan yang jelas, sehingga sistem tahu seperti apa selesai itu dan bisa berhenti begitu mencapainya.

Buat handoff membawa konteks yang cukup

Banyak loop sebenarnya adalah amnesia. Ketika handoff mengoper tugas tetapi bukan alasan di baliknya, agen penerima menurunkan ulang situasinya, sampai pada kesimpulan berbeda, dan menyerahkannya kembali. Tiap agen mulai dari nol, sehingga sistem tak pernah konvergen.

Perbaikannya adalah memperlakukan muatan handoff sebagai kontrak: apa yang sudah dicoba, apa yang sudah diputuskan, dan apa yang diharapkan dihasilkan penerima. Handoff yang terbentuk baik menggerakkan tugas maju; yang gundul mengundang penerima menebak ulang dan memantulkannya kembali.

Amati sebelum Anda percaya

Anda tidak bisa memperbaiki loop yang tidak bisa Anda lihat, jadi pasang instrumen pada sistem sebelum membiarkannya berjalan tanpa pengawasan:

• Catat tiap handoff dengan sumber, target, dan alasannya, sehingga sebuah siklus muncul sebagai pola jelas dalam jejaknya.
• Beri peringatan pada jumlah iterasi yang naik menuju batas, karena itu adalah loop yang terbentuk sebelum menyentuh langit-langit.
• Jaga proses tetap bisa direproduksi, sehingga Anda bisa memutar ulang sebuah loop terhadap perbaikan dan memastikan ia benar-benar konvergen sekarang.

Loop handoff tak terbatas adalah bau desain, bukan misteri. Tempatkan satu orkestrator sebagai penanggung jawab, beri tiap worker kontrak yang berakhir dengan return, dan sokong semuanya dengan batas iterasi dan anggaran yang keras. Loop yang tidak bisa terjadi jauh lebih berharga daripada retry yang menutupinya.