Kamu tidak salah karena modelnya lemah.
Kamu salah karena menggambar garis di tempat yang kerjanya graf.
Lingkungan adalah ruangannya. Ini soal bentuk kerja di dalamnya.
Kebanyakan orang yang bangun agent multi-langkah berakhir dengan garis lurus. Langkah satu, langkah dua, langkah tiga. Masing-masing nunggu yang sebelumnya selesai sebelum mulai.
Yang hampir tidak pernah dicek: setengah langkah itu tidak perlu nunggu. Mereka cuma antri satu pekerjaan sampai context penuh, lalu agent lupa sedang apa.
Codila menulis itu di X Article-nya. Bukan perang tool. Bukan kursus. Yang ditunjuk lebih tajam:
Hentikan menulis satu agent yang mengerjakan semuanya dalam satu baris. Desain bentuk kerjanya — apa jalan dulu, apa jalan bersamaan, apa yang menunggu.
Loop adalah atomnya. Graf adalah jaringannya.
Sebulan lalu orang masih bicara loop.
Loop adalah satu siklus jadi lebih baik: coba sesuatu → cek hasilnya → sesuaikan → ulang. Itu atomnya. Satu agent, satu hal, berulang.
Tapi loop punya kegagalan yang sudah dikenal. Tim support mengikat feedback loop ke satu metrik: ticket resolution rate. Angkanya naik berbulan-bulan. Kepuasan turun. Bot belajar menutup tiket cepat, bukan menyelesaikannya.
Hukum Goodhart. Loop hanya melihat metriknya sendiri. Ia tidak bisa bertanya apakah targetnya benar, atau menyadari ukurannya sendiri sedang bergeser.
Jawaban bukan loop yang lebih pintar. Jawaban: graf dari loop — jaringan di mana siklus saling mengawasi dan mengoreksi.
Node yang berpikir. Edge yang mengantar hasil.
“Lalu” yang kamu gambar, padahal tidak ada
Graf punya dua bagian.
Node: satu unit kerja. Satu agent, satu pekerjaan, satu input, satu output.
Edge: dependensi. Output node ini jadi input node itu.
Kesalahan yang semua orang lakukan: memperlakukan “lalu” sebagai edge.
“Ringkas file ini, lalu beritahu cuaca.”
Cuaca tidak membaca ringkasan itu. Dua pekerjaan independen yang diikat skrip linear tanpa alasan. Masing-masing nunggu yang sebelumnya — untuk tidak apa-apa.
Kebiasaan yang memulai semuanya: setiap kali kamu menulis “lalu”, tanya — apakah langkah berikutnya benar-benar membaca output langkah sebelumnya?
Kalau ya: edge sungguhan. Pertahankan urutannya.
Kalau tidak: tidak ada edge. Tungguannya sia-sia. Jalankan berdampingan.
Kalau tidak ada data yang menyeberang antara dua kotak, keduanya independen. Itulah yang kamu manfaatkan untuk sisanya.
Agent “lakukan A, lalu B, lalu C” milikmu sudah graf. Graf yang paling menyedihkan: satu rantai di mana kalau C macet, D tidak pernah terjadi.
Bentuk pertama: satu agent per file, satu laporan
Cukup teori. Bentuknya kira-kira begini.
Claude Code v2.1.154+. Paket berbayar. Di Max, Team, atau Enterprise, workflow sudah nyala. Di Pro, nyalakan baris Dynamic workflows di /config.
Buka repo yang kamu kenal. Minta workflow: audit setiap file route. Satu agent per file. Verifier independen di setiap temuan, sebelum laporan. Batas first-run: analyze maximum 20 files. Biar run pertama tidak mahal.
Yang muncul bukan dua puluh chat terpisah. Satu laporan. Karena hasil antara hidup di variabel skrip, bukan di context chat-mu.
Itu graf. Satu kalimat, armada kecil.
Soal klaim “zero tokens” yang akan kamu dengar: skrip koordinasi adalah kode. Mengoper hasil antar agent tidak menghabiskan context seperti serah-terima chat. Tapi agent tetap menghabiskan usage. Workflow lebih mahal dari sesi biasa. Hematnya di koordinasi, bukan di kerjanya. “Zero tokens” salah untuk pekerjaan itu. Mulai sempit, lihat biayanya, baru lebarkan.
Kalau run-nya bagus, tekan s. Tersimpan di ~/.claude/workflows, bisa dijalankan ulang dengan nama. Ganti tugasnya, tahan bentuknya.
Sejauh apa ini scale: satu run workflow bisa fan-out ke 1.000 agent, dengan paling banyak 16 yang kerja bersamaan. Bukan metafora. Plafon fiturnya. Seribu adalah lebar pekerjaan. Enam belas adalah gelombang kerja — bukan plafon yang sama. Mulai dari 20, lihat biayanya, baru lebarkan.
Dua cara graf ambruk
Kamu sudah punya graf. Inilah tempat yang sungguhan jatuh.
Kegagalan satu: graf yang setuju dengan dirinya sendiri.
Agent yang memeriksa kerjanya sendiri longgar pada dirinya. Model lebih suka outputnya sendiri. Jadi kamu taruh verifier di edge — node terpisah yang mengonfirmasi temuan sebelum mengalir ke hilir.
Yang jarang disebut: verifier butuh context bersih. Kasih ia percakapan yang sama dengan executor, dan ia tidak sedang memverifikasi. Ia sedang setuju dengan dirinya dalam font yang berbeda.
Graf agent yang berbagi satu context adalah satu loop berkostum. Gagal dengan cara yang sama — belakangan, lebih mahal, dengan lebih banyak lampu hijau di jalan turun.
Jadi verifier adalah node baru. Context sendiri. Mengecek sinyal nyata — bukan “apakah agent bilang sudah selesai”, tapi “apakah tesnya benar-benar lulus”.
Kegagalan dua: agent yang menginjak satu sama lain.
Ini bukan hipotesis.
Waktu tim Bun pertama kali melebarkan port besar ke banyak agent, run-nya gagal secara operasional. Agent memakai perintah git bersama di satu workspace dan saling menimpa.
Perbaikannya struktural, bukan prompt yang lebih pintar. Mereka larang perintah yang tidak aman dan kasih tiap grup worktree terisolasi sendiri.
Pelajaran paralelisme yang sebenarnya: dua agent yang menulis file yang sama sedang balapan.
Sebelum fan-out, jawab tiga pertanyaan. Di mana tiap agent bekerja? Bagaimana hasilnya digabung? Apa yang terjadi kalau dua tidak setuju?
Graf tanpa rencana itu tidak scale. Ia gagal lebih cepat.
Enam nama, bukan esai kedua
Bentuk yang sama. Pekerjaan berbeda. Ganti baris tugasnya, tahan topologinya.
Security sweep. Cited report dengan /deep-research. Port sebuah modul. Adversarial diff review. Scheduled ecosystem scan. Discovery berukuran tak diketahui.
Cukup. Kalau masing-masing butuh esai, kamu sudah kembali ke garis.
Skala yang nyata, dan harganya
Yang kelihatan di lapangan: port Zig ke Rust milik Bun, machinery yang sama, dilaporkan Simon Willison. Sekitar 50 workflow, puncak 64 agent paralel. Kira-kira 535.000 baris Zig jadi lebih dari satu juta baris Rust, 11 hari. Sekitar $165.000 usage. Manusia yang mendesain dan memonitor semuanya. Kritik publik soal apakah kode sebanyak itu, ditulis AI, masih bisa di-review dengan aman.
Skalanya nyata. Harganya juga. Pengawasannya juga.
Jangkar yang menolak bergerak
Topologi saja tidak membeli kebenaran.
Jaringan agent yang saling mengonfirmasi, tidak satu pun menyentuh sesuatu yang nyata, gagal persis seperti loop tunggal — cuma dengan lebih banyak bagian yang bergerak.
Graf butuh jangkar: node yang tidak bisa dibantah.
Tes yang benar-benar jalan — bukan “seharusnya lulus”, sudah lulus.
Verifier di atas bukti, bukan vibe.
Aturan beku yang agent tidak boleh setel ulang — karena itulah yang akan dilemahkan optimizer.
Graf hanya sejujur hal-hal di dalamnya yang menolak bergerak.
Kapan graf pilihan yang salah
Kebanyakan tugas bukan graf. Meraih satu ketika tidak perlu hanya membakar uang dan menambah cara gagal.
Lewati graf ketika tugasnya kecil atau terisolasi. Nambah fungsi. Perbaiki satu bug. Workflow di sini murni overhead — satu agent lebih cepat dan lebih murah.
Lewati ketika kamu butuh pengawasan ketat. Kalau kamu ingin baca dan setujui setiap langkah sebelum yang berikutnya jalan, seluruh poin graf — lebar tanpa kamu — bekerja melawanmu.
Lewati ketika kamu belum tahu apa yang dicari. Kerja eksploratori butuh satu agent yang bisa kamu kemudikan, bukan armada yang sudah commit ke rencana sebelum kamu paham masalahnya.
Lewati ketika langkah-langkahnya sungguh saling bergantung. Kalau setiap langkah membaca output langkah sebelumnya, itu rantai sungguhan. Memaksa graf ke situ cuma nambah biaya koordinasi untuk nol percepatan.
Cirinya ada di tepi palsu. Kalau kamu tidak bisa menemukan dua kotak tanpa panah di antaranya, tidak ada graf yang perlu dibangun. Itu loop, dan loop itu tidak apa-apa.
Graf adalah alat untuk lebar — kerja independen, dikerjakan sekaligus. Ketika kerjanya tidak lebar, garisnya tidak pernah jadi masalah.
Gambar grafnya
Prompter bertanya. Arsitek menggambar graf.
Agent linear tidak pernah jadi plafon. Ia bentuk pertama — yang semua orang raih karena cocok dengan cara kita mengetik: satu baris, satu hal sekali waktu.
Setelah kamu melihat node dan edge, kamu berhenti minta agent mengerjakan lebih banyak, dan mulai minta graf mengerjakannya lebih lebar. Fan-out di tempat kerjanya independen. Gerbang di edge di tempat keyakinan penting. Bekukan node yang menahan kebenaran.
Kebanyakan orang akan terus mengantri langkah dalam garis.
Yang belajar menggambar graf, dan menghormati apa yang merusaknya, akan menjalankan armada.
Gambar grafnya. Tetap jadi arsiteknya.
Slide deck (Presenter Short)
Sumber: Graph Engineering — @0xCodila.