Apa Itu 'Turn' dalam reins?

Apa Itu ‘Turn’ dalam reins? Gambar: dibuat AI

Siapa pun yang pernah menyerahkan pekerjaan besar kepada agen AI tahu hal ini. Loop selalu runtuh di titik yang sama: saat model mendeklarasikan sendiri “sudah selesai” — padahal kenyataannya belum.

reins adalah framework quest CLI yang merampas wewenang mendeklarasikan penyelesaian itu dari AI dan menyerahkannya kepada mesin. Ia memecah daftar pekerjaan menjadi butir-butir seperti quest dalam gim, memberikannya kepada AI satu per satu, dan memutuskan “sudah selesai atau belum” bukan berdasarkan kata-kata AI melainkan lewat pemeriksaan mesin. Dan di jantungnya duduk sebuah unit kecil bernama turn.

Dua kata akan terus muncul, jadi mari kita amankan dulu.

Gate — pemeriksa yang menginspeksi sebuah submisi secara mekanis dan memutuskan PASS atau FAIL. Bukan kesan manusia, bukan penilaian-diri AI.
Ratchet — roda gigi yang hanya berputar ke satu arah. Kita memakainya untuk berarti bahwa butir yang terkunci oleh sebuah kelulusan tidak pernah terbuka kembali.

Artikel ini mengikuti satu turn dari awal sampai akhir, melalui persis apa saja yang dilaluinya. Turn tampak kecil, tetapi jika dibongkar, ia adalah reins dalam bentuk miniatur.

Enam Elemen Inti Reins Engineering

Padatkan rekayasa yang menjadi pijakan reins menjadi satu baris dan bunyinya: rekayasa memindahkan wewenang mendeklarasikan penyelesaian dari AI ke gate mesin yang deterministik. “Deterministik” di sini bukan kata yang sulit. Artinya input yang sama selalu menghasilkan hasil yang sama. Sebuah tes lulus atau gagal, dan putusan kemarin tidak berbeda dari hari ini menurut suasana hati.

Dalam silsilah prompt engineering (memilih kata) → context engineering (menyuplai konteks) → harness engineering (membangun pagar), Reins adalah tali kekang yang menetapkan arah. Rekayasa ini dirakit dari enam elemen.

#	Elemen	Satu baris	Kalimat kanonis
1	Penyelesaian dinilai mesin	Kondisi penyelesaian harus bisa dijawab ya/tidak oleh mesin, dan mesinlah yang menilai — AI dicabut wewenangnya untuk memutuskan bahwa ia selesai	“Penyelesaian dinilai oleh gate, bukan diklaim”
2	Umpan balik deterministik	Fakta, bukan opini — “di mana, seharusnya apa, kenyataannya apa” menjadi sinyal yang menunjuk arah perbaikan	“Beri ia opini maka ia menjilat; beri ia fakta maka ia mengoreksi”
3	Konteks arah (manual + contoh)	Jika umpan balik adalah sinyal koreksi, manual dan contoh adalah sinyal arah — yang satu tak bisa menggantikan yang lain	“Hambatannya bukan kecerdasan melainkan konteks”
4	Ratchet Pattern (penguncian kontrak)	Butir yang lulus bersifat imutabel; pekerjaan tersisa hanya menyusut — selesai dijamin oleh struktur	`remaining(t+1) ≤ remaining(t)`
5	Persistensi kemajuan	Kemajuan hidup di luar proses (di disk) — meski AI mati, kemajuan tetap ada	“Agents are disposable; progress is cumulative.”
6	Pertahanan cheese (gate domain)	Bahkan pemeriksaan mesin bisa diakali jika hanya menginspeksi kulit — gate harus memverifikasi ulang fakta nyata domainnya	“Sebuah gate punya domain”

Tak apa jika istilah tabel masih terasa asing. Turn adalah unit terkecil tempat keenamnya bertemu dalam satu siklus, sehingga mengikuti satu turn sampai tuntas mempertemukan keenam elemen itu, masing-masing di tempatnya. Menggambar petanya lebih dulu: compose, langkah pertama turn, merakit konteks arah dan umpan balik deterministik; judge menjatuhkan putusan mesin (pertahanan cheese adalah kualitas desain gate itu); record mengunci ratchet dan mempersistenkan kemajuan.

Apa Itu Reins Turn?

Reins Turn adalah unit eksekusi terkecil dalam reins, di mana satu percobaan atas satu butir quest berakhir sebagai generasi → penilaian → pencatatan. Loop tidak lain adalah pengulangan turn, dan kemajuan sebuah quest tidak lain adalah akumulasi turn. Maka definisinya cukup satu baris.

Turn N = Attempt ke-N yang tercatat. Yang tidak tercatat bukanlah turn.

Attempt adalah “satu catatan atas satu percobaan.” Di sinilah letak titik yang halus — turn bukanlah “LLM dipanggil sekali.” Syarat keberadaan sebuah turn bukan pemanggilan melainkan pencatatan. Jika LLM dipanggil tetapi hasilnya tak pernah dicatat ke ratchet, turn itu tidak pernah terjadi. Sebaliknya, hasil yang disubmit manusia dengan tangan, begitu tercatat, adalah turn. Bahkan tanpa LLM. Yang menghitung turn bukan model melainkan ratchet.

Satu definisi ini adalah akar dari semua sifat yang akan datang — independensi driver, ketahanan restart, auditabilitas. Untuk sekarang, biarkan nama-nama itu lewat saja. Kita akan bertemu masing-masing lagi di tempatnya yang semestinya.

Satu Turn Adalah Persis Empat Langkah

Sebuah turn melewati empat langkah secara berurutan. Langkah-langkah itu menyandang nama Inggris, tetapi yang dikerjakannya sederhana — merakit (compose), menghasilkan (generate), menilai (judge), mencatat (record).

Langkah	Yang dikerjakan	Sifat
① compose	Membaca catatan semua turn sebelumnya (Log) dan merakit prompt untuk LLM	Fungsi murni
② generate	Memanggil LLM sekali untuk menghasilkan keluaran	Satu-satunya langkah probabilistik
③ judge	Gate memutuskan atas keluaran (PASS / REVIEW / FAIL)	Deterministik
④ record	Menerapkan putusan ke ratchet dan menyimpan ke disk	Satu-satunya langkah ireversibel

“Fungsi murni” berarti input yang sama selalu menghasilkan output yang sama tanpa efek samping lain, dan “ireversibel” berarti sekali dieksekusi tidak bisa dibatalkan. Maka inti tabel itu terlihat — dari empat langkah, hanya ② yang probabilistik, dan hanya ④ yang ireversibel. Generasi tidak bisa menilai, dan penilaian tidak bisa menghasilkan. Ketidakpastian AI dikurung dalam satu sel, dan keputusan yang tak bisa dibatalkan dalam sel lain.

Satu pilihan desain yang khas patut dicatat. Kaskade empat langkah ini tidak diimplementasikan sebagai dua set kode Go. Ia didefinisikan dalam satu dokumen yang dapat dibaca manusia bernama pkg/cli/turn.md (sebuah dokumen TANGEUL), disematkan ke dalam biner (go:embed) dan diinterpretasikan saat runtime. Sumber kanonis dari “bagaimana sebuah turn berjalan” bukanlah kode melainkan dokumen yang dapat dibaca — alasan pilihan ini akan kembali di akhir artikel.

① compose — Konteks Hanya Datang dari Log

Log adalah buku besar, tersimpan di disk, tempat setiap turn sejauh ini dicatat. Dan input untuk merakit prompt turn N persis satu hal: Log ini. State yang bersembunyi di suatu tempat dalam memori program dan lenyap ketika proses mati — hal seperti itu tidak ada.

Prompt yang dirakit dari Log memiliki tiga lapis.

Yang harus dikerjakan — apa yang harus dihasilkan untuk butir ini (instruksi penulisan dan konteks verifikasi)
Manual — system prompt global, ditambah, jika turn sebelumnya FAIL, coaching untuk aturan penyebabnya (manual per-aturan)
Ekor umpan balik — fakta-fakta dari FAIL sebelumnya. “Di mana, seharusnya apa, kenyataannya apa”

Dalam bahasa keenam elemen di atas, manual adalah konteks arah dan ekor umpan balik adalah umpan balik deterministik. Keduanya dirakit secara mekanis dari Log, setiap turn.

Ada satu aturan yang halus tetapi penting. Yang dijadikan acuan oleh compose bukanlah Attempt terakhir melainkan Attempt terakhir yang telah dinilai (judged) — yang dibawa sampai putusan. Meski di antaranya terselip error generasi seperti gangguan server LLM, yang dilihat oleh percobaan ulang bukanlah pesan error infrastruktur melainkan umpan balik berbasis fakta dari FAIL sebelumnya. Kegagalan operasional tidak mengontaminasi konteks pekerjaan.

② generate — LLM Hanya Menghasilkan

Prompt yang telah dirakit dikirim ke backend LLM dalam satu panggilan. Tidak penting apakah backend itu HTTP API (ollama/xai/gemini) atau alat baris perintah (claude/grok/codex/geminicli). Apa pun itu, perannya tetap: generator. Framework tidak mengekspos API apa pun yang memungkinkan LLM diberi wewenang PASS. Bukan karena framework “memilih untuk tidak memberikan” wewenang menilai — melainkan tidak ada cara untuk memberikannya. Beginilah elemen 1 dari keenam (penyelesaian dinilai mesin) menjadi struktur.

Bahkan backend mana yang dipakai pun dihitung ulang dari Log setiap turn. Butir yang terus gagal pada model default dikirim naik ke model yang lebih kuat (eskalasi), dan keputusan ini pun dibaca dari Log setiap turn — “di antara aturan penyebab FAIL masa lalu, adakah yang menjadi target eskalasi?” Tidak ada sakelar yang dibiarkan menyala di suatu tempat, tidak ada variabel lokal di dalam loop. Program sama, Log sama — backend yang sama terpilih. Sifat berperilaku identik setelah Anda mematikan dan menyalakan ulang proses — ketahanan restart — datang gratis.

③ judge — Hanya Gate yang Menilai

Yang memutuskan atas keluaran adalah gate. Gate adalah sekumpulan aturan pendeteksi pelanggaran. Setiap aturan menyala (fire) ketika menemukan masalah yang menjadi tanggung jawabnya, dan meninggalkan satu fakta — di mana (Where), seharusnya apa (Expected), kenyataannya apa (Actual).

Agregasinya deterministik. Jika satu saja aturan Fail menyala, FAIL. Jika tidak, dan sebuah aturan Review menyala, REVIEW (zona abu-abu untuk diperiksa manusia). Jika tidak ada yang menyala, PASS. Submisi sama, aturan sama — putusan selalu sama. Tidak ada pemeriksa di sini yang jawabannya berubah setiap kali ditanya.

Pada domain kompleks tempat aturan saling terjalin — di mana satu pelanggaran membuat pemeriksaan lain tak bermakna — putusan dapat diangkat ke graf argumentasi (toulmin), dan logika penilaiannya sendiri dapat dipindahkan ke dokumen yang dapat diaudit (gate.md). Apa pun bentuknya, satu hal tidak berubah: penilainya adalah mesin.

④ record — Satu-satunya Langkah Ireversibel

Terapkan putusan ke ratchet, simpan ke disk, dan ekspor butir-butir yang telah berkesimpulan. Inilah satu-satunya titik dalam sebuah turn yang tidak bisa dibatalkan.

PASS / REVIEW / SKIPPED / BLOCKED → kunci. Ratchet berjalan satu arah; ia tidak berputar balik.
FAIL → jumlah percobaan (Tries) bertambah 1 dan butir tetap TODO. Saat mencapai percobaan maksimum (default 3), ia dikunci sebagai DONE. “Butir ini tidak berhasil dengan cara ini” juga sebuah bentuk kesimpulan — satu butir yang macet tidak dibiarkan menyandera seluruh loop selamanya.
Error generasi → tetap dicatat di Log sebagai Attempt (jejak apa yang terjadi disimpan), tetapi tidak mengonsumsi percobaan. Server LLM yang mati bukan kesalahan si butir; itu kegagalan operasional. Jika kegagalan berlanjut, pengaman terpisah menghentikan loop (berhenti setelah N kegagalan generasi berturut-turut — sebuah circuit breaker).

Hanya dengan langkah inilah Log menjadi ada untuk dibaca oleh compose turn berikutnya. record adalah penutup turn sekaligus pembangkit turn berikutnya.

Kegagalan Adalah Fakta, Bukan Opini

Dalam bentuk apa sebuah FAIL kembali — inilah kunci agar turn konvergen (mendekati jawaban pada setiap percobaan ulang). Bukan opini seperti “kualitasnya agak kurang,” melainkan ini:

FAIL. root cause = who-anchor-present
  Fact: where=who.anchors expected="source substring" actual="Asisten Manajer Budi Santoso"

Membacanya sederhana. Field yang mana (where), seharusnya apa (expected — string yang benar-benar ada di sumber), kenyataannya apa (actual). Lokasi + nilai yang diharapkan + nilai aktual. Bagi LLM, ini adalah umpan balik yang tak menyisakan siapa pun untuk dijilat — angka dan lokasi bukanlah emosi. Fakta terstrukturlah yang menuntun model penjilat bukan ke perdebatan melainkan ke konvergensi.

Satu bonus di atasnya. Teks FAIL yang disuapkan ke model adalah rendering yang persis sama dengan string yang tercetak di layar ketika manusia menjalankan perintah submit (feedback parity). Umpan balik yang dilihat manusia dan yang dilihat model tak pernah berbeda. Misteri “apa gerangan yang dikirim ke AI sampai ia memperbaikinya seperti ini?” secara struktural tidak ada.

Tiga Pintu Masuk, Satu Turn

Sebut siapa pun yang menggerakkan turn sebagai driver. reins punya tiga: next, di mana manusia menerima prompt secara langsung; submit, di mana manusia menyubmit hasil; dan loop otomatis yang berjalan tanpa pengawasan. Tetapi ketiganya bukan tiga implementasi terpisah. Mereka adalah tiga pintu masuk ke dokumen turn yang sama. Yang memisahkan manual dari otomatis persis satu aturan di dalam dokumen itu.

Sifat praktis yang dihasilkannya: ganti driver di tengah quest dan prompt tetap identik byte demi byte. Jalankan loop otomatis kemarin, biarkan manusia mengambil alih dengan next hari ini — dengan state Log yang sama, prompt yang keluar sama. Ini mungkin karena konteks hanya datang dari Log (kita melihatnya di langkah ①), dan ini sifat yang terbukti, bukan harapan — sebuah driver-swap golden test memverifikasi identitas byte dengan membandingkan output lintas driver.

Mengikuti Satu Turn Sampai Tuntas

Teori selesai. Mari kita saksikan satu turn nyata dari awal sampai akhir. Ini satu butir dalam quest yang mengekstrak alamat email dari dokumen, pada percobaan keduanya setelah turn sebelumnya FAIL dengan “bukan format email yang valid.”

[Pemeriksaan masuk turn]  Apakah butir TODO? Masih ada sisa percobaan? → lanjut
① compose      Cari Attempt judged terakhir di Log → FAIL, penyebab = email-format
               Manual = prompt global + coaching aturan email-format
               Prompt = yang harus dikerjakan + "FAIL. Fact: where=email
                        expected='valid email format' actual='kim at example'"
② generate     Panggilan LLM → {"email":"kim@example.com", ...}
③ judge        Sapuan aturan: email-format lolos, source-lacks-email lolos, freemail lolos
               → tidak ada aturan Fail yang menyala → PASS
④ record       Ratchet mengunci (ireversibel) → Attempt #2 tercatat → disimpan → export

Model, yang diberi fakta kegagalan sebelumnya (“kim at example bukan format email yang valid”), memperbaiki persis titik itu; gate mengonfirmasi kelulusan; ratchet menguncinya. Butir ini kini PASS selamanya. Turn berikutnya melewatinya, dan pekerjaan tersisa hanya menyusut. Ketika setiap butir mencapai keadaan berkesimpulan (PASS, REVIEW, atau percobaan maksimum), loop berakhir. Bukan “ketika AI merasa selesai” melainkan ketika butir tersisa mencapai nol. Konvergensi dijamin oleh struktur.

Loop Engineering — Industri Menamai Masalah yang Sama

Pada Juni 2026, sebuah pergeseran cara menangani agen mendapat nama. Peter Steinberger menulis, “You shouldn’t be prompting coding agents anymore. You should be designing loops that prompt your agents” (Anda seharusnya tidak lagi mem-prompt agen coding. Anda seharusnya mendesain loop yang mem-prompt agen Anda), dan awal bulan itu Boris Cherny dari Anthropic, yang membangun Claude Code, berkata di sebuah acara, “I don’t prompt Claude anymore. I have loops running… My job is to write loops” (Saya tidak lagi mem-prompt Claude. Ada loop-loop yang berjalan… Pekerjaan saya adalah menulis loop). Beberapa hari kemudian, Addy Osmani dari Google memberi arus ini sebuah nama: Loop Engineering — dari orang yang mem-prompt agen menjadi orang yang mendesain sistem yang mem-prompt agen.

Wacana ini menggambar satu narasi transisi. Prompt engineering (memilih kata) → context engineering (memilih informasi yang ditampilkan) → harness engineering (membangun lingkungan eksekusi) → loop engineering (mendesain siklus amati-bertindak-verifikasi-pulihkan itu sendiri). Daya ungkit telah bergerak keluar satu lapis demi satu lapis: dari kata ke informasi, dari informasi ke lingkungan, dari lingkungan ke siklus.

Anatomi loop yang baik versi Osmani seharusnya terasa akrab bagi siapa pun yang telah membaca sampai sini. Eksternalisasikan state ke disk atau papan, bukan ke percakapan. Pisahkan agen yang membangun dari agen yang memverifikasi. Biarkan terminasi dikonfirmasi oleh penilai terpisah, bukan deklarasi-diri agen coding. Letakkan di samping turn dan korespondensinya tajam.

Rekomendasi Loop Engineering	Strukturisasi turn reins
Eksternalisasikan state ke disk atau papan (model lupa)	Log bukan alat bantu ingatan melainkan satu-satunya input turn — compose adalah fungsi murni dari Log
Pisahkan pembangun dari pemverifikasi (subagen)	Pemverifikasinya bukan LLM lain melainkan gate deterministik — API pemberi PASS sama sekali tidak ada
Definisikan kondisi terminasi yang dapat diuji	Monotonisitas ratchet menjamin konvergensi sebagai invarian — struktur, bukan kondisi
Bedakan kegagalan yang dapat dipulihkan dari yang fatal	Terpasang dalam aturan record — FAIL mengonsumsi percobaan; error generasi milik circuit breaker

Jantung perbedaannya adalah jarak antara rekomendasi dan struktur. Literatur loop engineering sendiri mengakui hierarki verifikasi — LLM-as-judge, mempercayakan putusan kepada AI, “can be gamed or can collude with the actor” (bisa diakali atau bisa berkolusi dengan aktor), maka di mana pun pemeriksaan deterministik dimungkinkan, pasanglah pemeriksaan deterministik. Tetapi itu tetap praktik terbaik — rekomendasi yang dititipkan pada niat baik sang perancang. Jika subagen pemverifikasi pada akhirnya juga LLM, pintu kolusi tetap terbuka. reins menutup pintu itu lewat desain. Hanya gate yang menilai, dan framework tidak mengekspos cara apa pun untuk memberi LLM sebuah PASS.

Dan di mana loop engineering berbicara tentang keseluruhan loop, reins menjadikan satu putaran loop itu sebuah kontrak. Untuk melangkah satu langkah melampaui “pekerjaan saya adalah menulis loop”-nya Cherny, apa yang dilakukan sebuah loop dalam satu putaran — apa yang probabilistik, apa yang deterministik, apa yang ireversibel — harus didefinisikan lebih dulu. Nama definisi itu adalah turn.

Mengapa Unit Ini

Kencangkan turn seperti ini dan Anda memperoleh tiga hal. Nama-nama yang tadi lewat sekilas menemukan tempatnya di sini.

Auditabilitas — jawaban atas “apa beda loop otomatis dari next manual?” bukanlah pekerjaan membandingkan dua basis kode melainkan satu aturan dalam sebuah dokumen. Anda bisa memastikan dengan mata sendiri bahwa persis satu jalur dalam dokumen itu yang dapat mengunci sebuah PASS. Inilah alasan sumber kanonis turn adalah dokumen yang dapat dibaca, bukan kode.
Ketahanan restart — setiap input sebuah turn diturunkan dari Log di disk, sehingga meski proses mati, Log yang sama mereproduksi turn yang sama.
Keterbuangan agen — tukar agen-agennya (LLM, driver) dan kemajuan tetap terakumulasi dan tak pernah mundur. “Agents are disposable; progress is cumulative.”

Dibalik: sistem yang turn-nya kabur — konteks bersembunyi di memori sesi, model mendeklarasikan sendiri penyelesaian, dan percobaan ulang bersandar pada riwayat percakapan — kehilangan ketiganya.

Turn tampak kecil. Tetapi sebagai unit terkecil yang memisahkan dan menserialkan generasi (probabilitas), penilaian (determinisme), dan pencatatan (ireversibilitas) dalam satu siklus, memahami turn berarti memahami seluruh reins.

Bacaan lanjutan (eksternal)

Building Effective Agents — Anthropic — klasik desain loop agen. Pembedaannya antara “workflow (orkestrasi deterministik) dan agen (dikendalikan model)” beresonansi dengan pemisahan generasi/penilaian artikel ini.
Agentic Loops: From ReAct to Loop Engineering — Data Science Dojo — survei silsilah loop agen, dari ReAct hingga loop engineering.
The Anthropic leader who built Claude Code says he ditched prompting — now he just writes loops — The New Stack — liputan industri atas pergeseran Boris Cherny.

Referensi

Loop Engineering — Addy Osmani — 2026-06. Penamaan istilah dan anatomi loop yang baik (otomatisasi, worktree, skill, subagen, penilai terpisah, eksternalisasi state).
What Is Loop Engineering? A Complete Guide from Prompt to Harness Engineering — Tosea.ai — transisi empat tahap prompt→context→harness→loop, hierarki verifikasi yang mendahulukan determinisme, dan risiko kolusi LLM-as-judge.
Claude Code’s Creators Explain Agent Loops — The Neuron — Boris Cherny dan Cat Wu tentang operasi loop secara rinci: /loop dan /goal, eksternalisasi state ke disk dan Linear, pemisahan pembangun dari pemverifikasi.