Hybrid Reasoning Agents: Berpikir Laten, Bertindak via Teks

Ini kebenaran yang tidak nyaman soal agen LLM: sebagian besar token yang mereka hasilkan adalah isian yang mahal. Agen reasoning yang memecahkan soal matematika dengan senang hati menulis “coba baca ulang pertanyaannya” dan “sejauh ini saya menemukan bahwa...” dengan biaya inferensi penuh, membakar komputasi yang sama untuk basa-basi retoris seperti halnya untuk aritmetika sungguhan. Latent reasoning, yaitu berpikir di dalam hidden state model alih-alih di dalam teks, sejak dulu jadi solusi yang jelas, dan paper baru tentang Hybrid Reasoning Agents menunjukkan bahwa solusi ini akhirnya bisa dipakai. Tapi solusi yang jelas ini punya harga yang tidak disukai siapa pun di bidang ini: Anda tidak bisa lagi membaca apa yang sedang dipikirkan model.

Saya sudah bertahun-tahun melihat tim mencoba membuat chain-of-thought lebih murah. Setiap pendekatan membentur tembok yang sama, dan penting untuk memahami kenapa pendekatan hibrida ini berbeda, serta kenapa saya tetap tidak mau men-deploy-nya di tempat yang tidak sanggup menanggung kegagalan diam-diam.

Mengapa Chain-of-Thought Berbasis Teks Membuang Token

Chain-of-thought adalah penemuan yang benar-benar hebat. Biarkan model menulis langkah-langkah perantara, dan akurasinya di soal matematika, logika, dan pertanyaan multi-hop melonjak drastis. Masalahnya, bahasa adalah format serialisasi yang buruk untuk komputasi. Kata-kata itu lossy, berlebihan, dan yang paling krusial untuk tagihan inferensi Anda, berurutan.

Pikirkan apa yang terjadi saat model “mengulang soalnya” sebelum menyelesaikannya. Itu beberapa ratus token yang dihasilkan satu per satu, dan setiap token butuh forward pass penuh, sementara isi informasinya hampir nol karena soalnya sudah ada di konteks. Model reasoning modern penuh dengan hal seperti ini. Siapa pun yang pernah membaca jejak reasoning dari model generasi terbaru pasti melihat paragraf penuh afirmasi diri, pengulangan, dan keraguan yang oleh engineer manusia akan dianggap sebagai noise. Pada tugas agentic dengan tool call, keadaannya lebih parah: model menceritakan apa yang akan dilakukannya, melakukannya, lalu menceritakan apa yang baru saja dilakukannya.

Ekonominya makin menumpuk di skala agen. Agen yang melakukan sepuluh tool call dengan preamble reasoning yang bertele-tele sebelum setiap panggilan bisa menghabiskan 80% budget token-nya untuk narasi. Kalau Anda membayar per token, dan memang begitulah adanya, itu uang sungguhan. Ini juga soal latensi, yang sangat penting untuk agen yang ditunggu manusia. Tekanan yang sama juga mendorong tier inferensi yang lebih murah dan cepat: hambatannya bukan kecerdasan, melainkan biaya untuk mengungkapkannya dalam kata-kata.

Percobaan yang Gagal: Pemotongan, Distilasi, dan Latent Reasoning Murni

Bidang ini sudah menyerang masalah ini dari tiga arah, dan masing-masing gagal dengan cara yang mengajarkan sesuatu.

Percobaan 1: Cukup hasilkan lebih sedikit token

Budget forcing, length penalty, fine-tune reasoning yang ringkas. Pendekatan naifnya adalah membuat model berpikir lebih sedikit dalam teks. Ini berhasil sampai titik tertentu, lalu akurasinya jatuh bebas. Jejak yang bertele-tele tidak sepenuhnya mubazir; sebagian redundansi yang terlihat itu justru menopang beban komputasi. Kompresi yang dilakukan membabi buta akan membuang komputasi bersama isiannya, dan dari luar Anda tidak bisa membedakan keduanya.

Percobaan 2: Latent reasoning murni

Idenya lebih elegan: jangan hasilkan token berpikir sama sekali. Umpankan output embedding model kembali sebagai input, berupa “thought vector” kontinu alih-alih kata-kata diskret, lalu biarkan model bernalar secara internal untuk banyak langkah sebelum mengeluarkan jawaban. Riset seperti COCONUT menunjukkan pendekatan ini bisa menyamai atau mengalahkan chain-of-thought teks di beberapa tugas dengan jumlah forward pass yang jauh lebih sedikit. Tapi latent reasoning murni punya dua masalah fatal untuk agen. Pertama, dunia luar berbicara dengan teks: API tool menerima argumen string, mesin pencari menerima query, dan pengguna ingin jawaban dalam bentuk prosa. Model yang berpikir hanya dengan vektor tetap harus menerjemahkan semuanya di batas, dan di situlah error bersembunyi. Kedua, dan ini yang paling sering diperdebatkan, pemikirannya menjadi kotak hitam. Anda kehilangan jejak reasoning sepenuhnya, padahal itu satu-satunya jendela yang cukup layak untuk memahami kenapa model melakukan sesuatu.

Percobaan 3: Pause token dan komputasi pengisi

Ada lini kerja yang lebih senyap, yang mencoba menyisipkan token “pause” yang tidak bermakna untuk memberi model komputasi ekstra tanpa konten tambahan. Hasilnya campur aduk dan tidak pernah keluar dari lab. Ternyata isi token perantara justru penting untuk mengarahkan komputasi, bukan sekadar keberadaannya.

Yang Benar-Benar Berhasil: Hybrid Reasoning Agents

Paper HybridAgent mengambil posisi pragmatis yang saya harap lebih banyak riset ambil: berhenti memilih antara reasoning laten dan teks, dan biarkan model berpindah di tengah generasi. Berpikirlah secara laten saat melakukan komputasi internal; beralih ke teks saat perlu memanggil tool, membaca outputnya, atau menjelaskan diri ke manusia.

Arsitekturnya punya tiga bagian yang layak dipahami. Modul ringan bernama HybridLink menangani transisi, yaitu mengubah hidden state terakhir dari segmen laten menjadi sesuatu yang bisa dilanjutkan oleh mode teks, dan sebaliknya. Continuous working memory menyimpan seluruh konteks hibrida lintas giliran, sehingga pemikiran laten dari giliran pertama masih tersedia di giliran kelima alih-alih terlipat menjadi ringkasan teks. Di sisi training, ada dua tahap: HybridSFT melatih backbone agar bisa berkoordinasi dengan HybridLink, lalu HybridRL memakai reinforcement learning untuk mengajarkan model kapan setiap mode layak dengan biayanya.

Menurut saya, bagian terakhir itulah kontribusi utamanya. Masalah sulitnya bukan “bisakah model bernalar di ruang laten”, karena kita sudah tahu itu bisa. Masalah sulitnya adalah kebijakannya: bagian mana dari suatu tugas yang layak mendapat komputasi buram yang murah, dan mana yang layak mendapat teks yang mahal tapi bisa diinspeksi. Mempelajari kebijakan itu dengan RL, berdasarkan reward tugas yang sesungguhnya, adalah cara untuk mendapatkan sesuatu yang benar-benar bekerja, bukan sekadar bagus di demo.

Angka yang dilaporkan cukup mengesankan: di 11 benchmark yang mencakup matematika, sains, kedokteran, pencarian, dan reasoning agentic, agen hibrida mengklaim peningkatan performa sekitar 10% dibanding baseline berbasis teks maupun laten, dengan pengurangan token 35–55%, inferensi 1,8–2,6x lebih cepat, dan penghematan biaya sekitar 3x. Klaim benchmark dari satu paper tetap perlu disikapi dengan hati-hati, karena benchmark sering meleset dari kondisi workload nyata. Tapi arah hasilnya sejalan dengan teorinya. Kalau sebagian besar jejak itu isian, membuang sebagian besar jejak seharusnya terutama menurunkan biaya, bukan kemampuan.

Seperti Apa Latent Reasoning di Kode

Secara mekanis, triknya lebih sederhana dari kedengarannya. Dalam mode teks, Anda mengambil sampel token, meng-embed-nya, lalu mengumpankannya kembali. Dalam mode laten, Anda melewati sampling dan langsung mengumpankan vektor output model sendiri, mungkin setelah melewati proyeksi kecil, sebagai input berikutnya. Sebuah token kontrol khusus atau gate yang dipelajari menentukan Anda sedang di mode mana. Secara skematis:

def hybrid_step(hidden_state, mode_gate, hybrid_link):
mode = mode_gate(hidden_state)  # learned: LATENT or TEXT
if mode == LATENT:
# No sampling. Feed the continuous thought back in.
next_input = hybrid_link.latent_in(hidden_state)
return next_input, None  # nothing human-readable emitted
# TEXT mode: normal autoregression
logits = lm_head(hidden_state)
token = sample(logits)
next_input = hybrid_link.text_in(embed(token))
return next_input, token  # inspectable output

Sistem sungguhannya menambahkan working memory dan mesin training, tapi inilah inti loop-nya. Perhatikan implikasinya untuk serving stack Anda: langkah laten tetap berupa forward pass penuh. Anda menghemat jumlah token, yaitu panjang output, pertumbuhan konteks, dan tekanan KV-cache dari jejak yang panjang, bukan komputasi per langkah. Percepatan inferensi lebih dari 2x sebagian besar datang dari urutan yang lebih pendek dan lebih sedikit dekoding teks autoregresif, bukan dari berpikir gratis. Salah satu komentator di paper ini menyarankan langkah lebih jauh, yaitu menjalankan jalur laten secara paralel dengan generasi teks, karena forward pass-nya toh sudah dibayar. Itu ide yang menarik, dan menunjukkan betapa mudanya ruang desain ini.

Harga Interpretabilitas yang Tidak Mau Dibayar Siapa Pun

Sekarang bagian yang akan terasa lalai kalau saya lewatkan. Jejak reasoning bukan sekadar kemudahan debugging, melainkan mekanisme keselamatan. Saat agen melakukan sesuatu yang aneh di production, hal pertama yang Anda lakukan adalah membaca jejaknya. Ketika peneliti alignment mencari perilaku menipu, mereka mencari reasoning yang bertentangan dengan jawaban akhir. Begitu reasoning dipindahkan ke vektor, kedua alur kerja itu menjadi gelap.

Paper ini mengklaim bahwa continuous working memory membuat pemikiran laten “bisa diinspeksi secara langsung”. Saya lebih suka menyebutnya benar secara teknis tapi menyesatkan secara praktis. Anda memang bisa memeriksa vektornya seperti hidden state lainnya: dengan probing classifier, proyeksi decoder, atau analisis nearest-neighbor di ruang embedding. Tapi itu tooling tingkat riset, bukan alur kerja on-call. Bedanya seperti membaca file log dengan melampirkan debugger ke core dump. Sebagian dari kami sudah lama skeptis terhadap klaim berlebihan soal interpretabilitas, dan buffer working memory tidak mengubah asimetri mendasarnya: teks bisa dibaca siapa saja, sedangkan latent hampir tidak bisa dibaca siapa pun.

Ada juga mode kegagalan yang jarang dibahas: propagasi error diam-diam. Dalam jejak teks, langkah perantara yang salah itu terlihat dan kadang bisa terkoreksi sendiri, karena model menangkap kesalahannya saat membaca ulang. Pemikiran laten yang salah menyebar lewat working memory tanpa jejak tekstual sama sekali. Jawaban akhir agen akan tetap terdengar sama fasihnya, baik deliberasi lateninya sehat maupun ngawur. Bagi tim yang menjalankan agen di production, ini berkaitan langsung dengan trade-off antara containment dan monitoring: agen hibrida mendorong Anda ke arah containment, karena monitoring jadi jauh lebih sulit.

Dalam diskusi seputar paper ini disebutkan bahwa latent reasoning secara informal masih dianggap tabu di sebagian komunitas riset, justru karena alasan-alasan ini. Tabu itu jelas sudah berakhir. Saya tidak menganggap itu otomatis buruk, tapi mereka yang memuji angka efisiensinya sebaiknya jujur bahwa mereka sedang membeli efisiensi itu dengan mengorbankan interpretabilitas.

Jarak antara Paper dan GPU Anda

Kode, bobot, dan datanya publik, dan ini benar-benar bagus. Tapi hal ini juga langsung memunculkan realitas yang keras. Dalam hitungan jam, praktisi yang menjalankan model rilisan secara lokal melaporkan perilaku degenerate: satu build 8B yang di-quantize macet mengulang paragraf reasoning mode teks yang sama terus-menerus untuk pertanyaan “siapa paus?”, dan build 14B terus berputar pada variasi paragraf yang sama selama lima menit untuk tugas cari-dan-ringkas yang biasa saja, yang bisa ditangani model sejenis dengan baik.

Mungkin itu artefak quantization atau ketidakcocokan chat template. Dukungan llama.cpp untuk arsitektur baru memang selalu seperti lempar dadu. Tapi saya curiga kegagalan looping ini bukan kebetulan. Perpindahan mode adalah perilaku yang dipelajari, dan perilaku yang dipelajari justru yang paling dulu rusak oleh quantization dan distribution shift. Model yang kebijakan laten-tekstnya sedikit meleset tidak gagal dengan keras; ia gagal dengan tidak pernah memutuskan untuk berhenti berpikir. Ini mode kegagalan yang jauh lebih menyebalkan untuk agen production dibanding jawaban yang salah, karena ia membakar budget tanpa batas. Kalau Anda membangun agent loop hari ini, ini satu alasan lagi untuk memasang batas giliran dan batas token yang ketat di setiap pemanggilan model, disiplin semacam yang dibahas dalam cara CLI agentic menyusun loop-nya, apa pun paradigma reasoning yang Anda pilih.

Perlukah Anda Peduli? Vonis dari Sudut Pandang Pragmatis

Perlu, tapi sebagai penanda arah, bukan sebagai ketergantungan. Ini pembacaan jujur saya:

• Argumen efisiensinya nyata dan bersifat struktural. Teks adalah medium yang buruk untuk komputasi internal, dan ketika agen makin berhorizon panjang, pajak token untuk narasi hanya akan makin besar. Sejenis latent reasoning akan masuk ke model production, suka atau tidak. Bisa dibilang pendekatan “ringkasan reasoning” yang opaque dari lab frontier sudah merupakan langkah ke arah ini.
• Biaya interpretabilitasnya juga nyata, dan saat ini masih underpriced. Jika kasus penggunaan Anda menuntut audit mengapa agen bertindak, misalnya di bidang kedokteran, keuangan, atau apa pun yang diatur regulasi, jejak teks adalah fitur yang tidak boleh Anda lepaskan begitu saja.
• Artefak saat ini masih berada di tingkat riset. Loop degenerate pada prompt sederhana, perilaku quantization yang tidak pasti, dan kebijakan perpindahan mode yang sulit diinspeksi bukan hal yang layak ditaruh di balik API yang menghadap pelanggan.
• Pembingkaian hibrida adalah yang tepat. Latent reasoning murni tidak akan bertahan saat bersentuhan dengan API tool dan pengguna, sementara reasoning teks murni tidak akan bertahan menghadapi tagihan inferensi. Batas yang dipelajari di antara keduanya adalah tempat semua ini akan berakhir.

Poin yang lebih dalam adalah bahwa “berpikir dengan kata-kata” sejak awal hanyalah kebetulan dari cara kita melatih model ini, bukan hukum kognisi. Tidak ada teorema yang menyatakan bahwa bahasa adalah granularitas yang tepat untuk pemikiran mesin. Yang mengejutkan adalah bahwa cara ini bekerja sebaik itu. Hybrid reasoning agents adalah sketsa kredibel pertama tentang apa yang datang setelahnya: model yang berdeliberasi secara privat dan hanya berbicara saat berbicara memang tugasnya. Apakah kita bisa membangun masa depan itu tanpa kehilangan kemampuan memeriksa pekerjaan mesin, menurut saya, adalah pertanyaan terbuka paling penting dalam desain agen saat ini.