Apa Itu AI Agent: Lima Tipe Klasik, Dua Definisi yang Bersaing

Contoh tertua di bidang ini adalah vacuum cleaner dalam dunia dua kotak, A dan B, masing-masing bisa bersih atau kotor.¹ Ia bertahan di setiap buku teks karena ini adalah dunia terkecil tempat sebuah agent bisa benar atau salah.

Percept-nya adalah sepasang nilai — di mana saya berada, dan apakah tempat ini kotor — dan aksinya adalah SUCK, LEFT, dan RIGHT. Seluruh programnya satu baris.

type Percept = { dirty: boolean; where?: "A" | "B" };
type Action = "SUCK" | "LEFT" | "RIGHT";

const textbook = (p: Percept): Action =>
  p.dirty ? "SUCK" : p.where === "A" ? "RIGHT" : "LEFT";   

Jalankan terhadap setiap konfigurasi awal dunia dua kotak:

A dirty, B dirty, start A    -> steps=3 clean=true
A clean, B dirty, start A    -> steps=2 clean=true
A dirty, B clean, start B    -> steps=2 clean=true

Itu adalah simple reflex agent: ia bertindak hanya berdasarkan percept saat ini, tanpa memori apa pun sebelumnya. Bukan kategori mainan — termostat termasuk di dalamnya, begitu juga satu call ke language model tanpa percakapan yang menyertainya.

Sekarang rusak seperti cara realitas merusaknya. Robot vacuum sungguhan punya sensor kotoran dan bumper, bukan kotak berlabel A di bawah karpet. Hapus lokasi dari percept dan jangan ubah apa pun:

const dirtOnly = (p: Percept): Action => (p.dirty ? "SUCK" : "RIGHT");

A dirty, B dirty, start A    -> steps=3   clean=true   still dirty=0
      t=0 at=A percept={dirty:true}  -> SUCK
      t=1 at=A percept={dirty:false} -> RIGHT
      t=2 at=B percept={dirty:true}  -> SUCK

A dirty, B clean, start B    -> steps=500 clean=false  still dirty=1
      t=0 at=B percept={dirty:false} -> RIGHT
      t=1 at=B percept={dirty:false} -> RIGHT
      t=2 at=B percept={dirty:false} -> RIGHT
      t=3 at=B percept={dirty:false} -> RIGHT

Program yang sama, dua kotak. Dari satu state awal ia selesai dalam tiga langkah; dari yang lain ia menabrak dinding kanan lima ratus kali dan akan terus begitu sampai baterainya habis. Ia tidak bisa mempersepsikan perbedaan antara dua situasi itu, jadi ia tidak bisa bertindak berbeda di dalamnya. Russell dan Norvig menyatakan hasil umumnya dalam satu baris: loop tak berujung sering kali tidak dapat dihindari bagi simple reflex agent di lingkungan yang hanya dapat diamati sebagian.¹

Ada perbaikan yang memakan satu baris dan tanpa memori, layak diukur sebelum kita meraih sesuatu yang lebih pintar.

let seed = 12345;
const rnd = () => ((seed = (seed * 1103515245 + 12345) & 0x7fffffff) / 0x7fffffff);

const coin = (p: Percept): Action => (p.dirty ? "SUCK" : rnd() < 0.5 ? "LEFT" : "RIGHT");  

Dua ribu run koridor yang semuanya kotor pada tiga ukuran, dengan satu generator seeded sepanjang jalan:

Randomisasi menghapus loop sepenuhnya. Ia juga mahal: delapan ruangan butuh lima belas gerakan jika kamu tahu apa yang kamu lakukan, dan agent ini rata-rata 68,7 dan pernah sampai 306. Itulah seluruh bab ini dalam bentuk mini. Setiap kemampuan yang kita tambahkan membeli kebenaran dalam kasus yang tidak bisa ditangani agent sebelumnya, dan menagihnya dalam mata uang yang harus kamu beri nama dulu.

Sebuah agent mempersepsikan lingkungannya melalui sensor dan bertindak melalui actuator. Agent program adalah fungsi dari percept ke aksi — setiap listing di atas adalah salah satunya. Percept sequence adalah semua yang telah dipersepsikan sejauh ini, dan simple reflex agent mengabaikan semuanya kecuali item terakhir.

Rasionalitas adalah kata yang paling sering disalahpahami artikel, dan memahaminya dengan benar membuat sisa bab ini berguna. Sebuah agent tidak rasional atau irasional pada dirinya sendiri. Russell dan Norvig mendefinisikan rational agent sebagai agent yang, untuk setiap kemungkinan percept sequence, memilih aksi yang diharapkan memaksimalkan performance measure-nya, berdasarkan bukti dari sequence itu dan pengetahuan bawaan apa pun yang dimilikinya.¹ Performance measure tidak berada di dalam agent: ia milik desainer, dan rasionalitas hanya didefinisikan relatif terhadapnya.

Spesifikasi ini secara konvensional ditulis sebagai empat hal, PEAS: performance measure, environment, actuators, sensors.

Perhatikan baris mana yang paling janggal. Hampir setiap tim yang membangun agent pada 2026 menuliskan E, A, dan S — skema tool, integrasi, format pesan — karena kode tidak akan berjalan tanpa itu. Hampir tidak ada yang menuliskan P. Tanpanya, "agent kita bekerja dengan baik" tidak punya makna yang bisa diperiksa siapa pun, dan "rasional" tidak bisa diterapkan ke sistem sama sekali, hanya ke demonstrasi. Bab 29 membahas cara mengubah P menjadi angka, dan inilah alasan bab itu ada.

    ┌───────────────────────── the environment ─────────────────────────┐
    │                                                                   │
    │   ┌──────────────────────── the agent ─────────────────────┐      │
    │   │                                                        │      │
 ───┼──►│  sensors  ──►  the agent program  ──►  actuators  ─────┼──────┼──►
percept │                                                        │    action
    │   └────────────────────────────────────────────────────────┘      │
    └───────────────────────────────────────────────────────────────────┘
                                   ▲
              the performance measure lives out here, in the head of
              whoever built the thing, and the agent cannot change it

Task environment selanjutnya diklasifikasikan sepanjang tujuh sumbu, lima di antaranya menentukan sebagian besar kesulitan di sini: dapat diamati penuh atau sebagian, deterministik atau tidak, episodik atau sekuensial, statis atau dinamis, diketahui atau tidak diketahui.¹ Agent yang berbicara dengan tool nyata lewat jaringan nyata berada di sudut sulit dari kelimanya — non-deterministik bahkan pada temperature nol (Bab 17), dan yang sering diremehkan, tidak diketahui, karena kamu tidak punya model andal tentang apa yang tool milikmu sendiri lakukan pada dunia. Itulah sebabnya loop Bab 23 lebih membutuhkan error handling daripada planning.

Lantai sungguhan tidak satu dimensi, jadi naikkan dunia menjadi denah. Tanda pagar adalah dinding, asterisk adalah kotoran, dan robot mulai di ruang tengah:

        col  0 1 2 3 4 5 6
      row 0  * . . # . . *
      row 1  . # . # . # .
      row 2  . # . S . # .        S = the robot starts here
      row 3  . # . # . # .
      row 4  * . . # . . *

Upgrade yang jelas adalah memori. Agent menyimpan peta: setiap kotak yang pernah ia pijak dan setiap kotak tempat bumper aktif. Aturannya adalah berjalan ke kotak bersebelahan yang belum ia kunjungi — kanan, lalu bawah, lalu kiri, lalu atas — dan mundur ketika semua di sekelilingnya sudah diketahui. Ini adalah model-based reflex agent: ia mempertahankan state internal dari riwayat percept, sehingga ia bisa bertindak berdasarkan apa yang tidak sedang ia lihat.

Ini peningkatan nyata, dan tetap belum cukup:

5,000 steps allowed -> steps=5,000  distinct squares visited=13/25  still dirty=2/4

Lima ribu gerakan, setengah lantai tidak pernah terlihat. Petanya benar dan aturannya benar. Yang tidak bisa dilakukan agent adalah memakai peta untuk pergi ke suatu tempat: aturannya hanya pernah menjawab "dari empat tetangga saya, mana yang harus saya langkahi", jadi setelah tidak ada lagi kotak belum dikunjungi di sebelahnya, ia tidak punya cara untuk mengekspresikan pikiran ada kotak belum dikunjungi delapan langkah jauhnya dan saya ingin berdiri di sana. Ia tahu di mana ia berada. Ia tidak tahu ke mana ia ingin berada.

Goal-based agent memiliki, di atas model dunianya, deskripsi situasi yang ingin ia wujudkan, dan memilih aksi dengan mencari di antara sequence aksi sampai menemukan yang berakhir di sana. Goal mengubah pemilihan aksi dari lookup menjadi search.

Goal-nya adalah "tidak ada kotak kotor tersisa". Search-nya adalah breadth-first walk ke kotak kotor terdekat, dan jalur yang dikembalikannya adalah plan.

goal-based (fewest moves)      -> moves=27  battery=52  still dirty=0
      from 2,3 -> 4,6 via 5 moves:  2,3 2,4 3,4 4,4 4,5 4,6
      from 4,6 -> 0,6 via 4 moves:  4,6 3,6 2,6 1,6 0,6
      from 0,6 -> 4,0 via 10 moves: 0,6 0,5 0,4 1,4 2,4 2,3 2,2 3,2 4,2 4,1 4,0
      from 4,0 -> 0,0 via 4 moves:  4,0 3,0 2,0 1,0 0,0

Dua puluh tujuh gerakan, lantai bersih. Tapi lihat kolom baterai dan leg terakhir dari plan. Kolom 0 berkarpet: melintasi kotak berkarpet memakan enam unit baterai, kotak ubin satu. Agent pulang melalui kolom 0 karena itu empat gerakan, bukan delapan, dan empat gerakan berkarpet itu memakan 24 sementara jalan memutar delapan gerakan hanya memakan 13.

Ia tidak bisa melakukan selain itu. Goal adalah pengujian biner: lantai bersih atau tidak. Setiap plan yang berakhir dengan lantai bersih memenuhinya secara setara, jadi ketika beberapa berhasil, agent tidak punya dasar untuk memilih di antaranya. Memilih satu keberhasilan dibanding yang lain membutuhkan angka atas outcome, dan angka itu adalah utility function. Agent yang memaksimalkannya adalah utility-based agent.

Perubahan pada kode adalah satu term di dalam search. Breadth-first search menghitung gerakan; buat ia menghitung biaya, dan kamu punya algoritma Dijkstra serta agent yang berbeda:

const nd = dist.get(k)! + (byCost ? cell.cost : 1);   // <- the entire difference

goal-based    (fewest moves)   -> moves=27  battery=52  still dirty=0
utility-based (cheapest route) -> moves=31  battery=41  still dirty=0
      from 4,0 -> 0,0 via 8 moves: 4,0 4,1 4,2 3,2 2,2 1,2 0,2 0,1 0,0

Empat gerakan ekstra, sebelas unit baterai lebih sedikit: dua puluh satu persen lebih murah. Goal yang sama, peta yang sama, kode yang sama kecuali satu term. Kedua agent hanya berbeda dalam apa yang mereka coba kuasai, dan mereka mengambil rute pulang yang berbeda.

Ini juga titik pertama ketika agent membutuhkan sesuatu yang tidak bisa ia hasilkan. Seseorang harus memutuskan nilai satu unit baterai relatif terhadap satu gerakan. Utility adalah performance measure yang ditulis dalam bentuk yang bisa dihitung agent, dan menuliskannya adalah tugas desainer. Ketika orang berkata agent "mengoptimalkan hal yang salah", mereka hampir tidak pernah bermaksud bug. Maksud mereka baris ini ditulis sembarangan.

Sekarang biarkan kotoran datang kembali. Empat ruangan kembali kotor pada empat tingkat yang berbeda, dan agent tidak pernah diberi tahu tingkat itu. Ia mengunjungi satu ruangan per tick dan hanya melihat ruangan itu. Performance measure-nya adalah room-tick yang dihabiskan dalam keadaan kotor selama 4.000 tick — lebih rendah lebih baik.

Learning agent, dalam dekomposisi buku teks, adalah salah satu dari yang di atas ditambah tiga bagian: learning element yang mengubah agent, critic yang memberi tahu bagaimana performa agent terhadap standar performa tetap, dan problem generator yang mengusulkan aksi yang layak dicoba demi apa yang akan diajarkannya.¹ Tiga policy dalam lingkungan yang sama. Yang pertama tidak belajar; yang kedua dan ketiga mempelajari hal yang sama dan menggunakannya secara berbeda.

Tingkat tersembunyi adalah 0,35 untuk dapur, 0,05 untuk lorong, 0,02 untuk ruang kerja, dan 0,01 untuk loteng — dan learner A menemukannya. Ia dengan benar mengidentifikasi dapur sebagai ruangan terkotor di rumah, lalu pergi ke dapur setiap tick selama sisa simulasi sementara tiga ruangan lain kotor selamanya. Ia lima kali lebih buruk daripada tidak belajar sama sekali, dan ia tidak rusak.

Pelajarannya sama dengan bagian utility. Learner A memaksimalkan "probabilitas bahwa ruangan yang akan saya kunjungi kotor". Performance measure-nya adalah "room-tick yang dihabiskan dalam keadaan kotor". Angka yang berbeda; yang kedua adalah yang dinilai critic, dan tidak ada yang memberi tahu agent. Learner B mengalikan tingkat yang sama yang dipelajari dengan waktu sejak kunjungan terakhir — kotoran yang ia harapkan akan ditemukan, bukan peluang menemukan kotoran apa pun — dan mengalahkan patrol yang menjadi titik awalnya.

Satu detail implementasi menentukan hasilnya. Pada versi pertama learner B, ruangan yang tidak menunjukkan kotoran dalam tiga kunjungan mendapat tingkat tepat nol — dan nol kali apa pun adalah nol, jadi ruangan itu tidak pernah dikunjungi lagi dan estimasinya tidak pernah bisa dikoreksi. Smoothing fraksi, keberhasilan plus satu dibagi percobaan plus dua, mengubah 11.895 menjadi 1.576. "Belum diamati" dan "diukur dan hasilnya nol" adalah klaim yang berbeda, dan sistem yang menyimpannya di field yang sama membuat keputusan yang tidak bisa ia batalkan.

  1  simple reflex    percept ────────────────────────────────► rules ────► action
  2  model-based      percept ──► [state] ──────────────────► rules ────► action
  3  goal-based       percept ──► [state] ──► [goal] ──────► search ───► action
  4  utility-based    percept ──► [state] ──► [goal] ──► [U] ──► argmax ► action
  5  learning         all of the above, plus [critic] ──► changes the parts above

Kelima-limanya ada di produksi hari ini dengan nama lain.

Dua baris lebih dekat daripada analogi, dengan cara yang memakan biaya.

Chat adalah model-based reflex agent yang modelnya tidak internal. Dalam buku teks, state adalah variabel di dalam agent program. Dalam chat, state adalah transcript: ia hidup di sisi kamu, dikirim ulang penuh pada setiap call, dan dibangun ulang dari nol di dalam model setiap kali. Itulah tagihan kuadratik Bab 16, dan itu objek yang sama yang buku teks gambar sebagai kotak berlabel "state". Inilah perbedaannya, diukur pada satu pertanyaan lanjutan dengan dan tanpa dua pesan sebelumnya:

with the transcript      prompt=67  "The current temperature in Lisbon, Portugal is 15°C."
without the transcript   prompt=29  "Lisbon is the capital of Portugal, not a city in Portugal."

Model yang sama, tiga kata input pengguna yang sama, dan yang kedua adalah robot koridor yang menabrak dinding. Tidak ada tool dalam run itu, jadi angka 15 dikarang — tetapi state-lah yang membuat follow-up bermakna sama sekali. Kamu membangunnya ulang setiap kali dan membayar 2,3× input token untuknya pada percakapan dua turn. Bab 16 mengukur sejauh mana pengali itu sampai pada turn keempat puluh.

Reflexion adalah learning agent yang mengubah input-nya, bukan programnya. Dalam dekomposisi buku teks, learning element memodifikasi performance element. Reflexion membiarkan weights tetap dan menulis teks reflektif ke episodic buffer yang dibaca percobaan berikutnya.³ Learning element adalah prompt, memorinya baris database, performance element-nya model beku — dan diagramnya tetap diagram buku teks, tanpa perubahan.

Dan inilah batas jujur dari pemetaan itu. Lima tipe mengklasifikasikan agent program. Pada 2026, program itu terbelah dua: sebagian adalah kodemu, sebagian berada di dalam weights yang tidak kamu latih. Ketika model memutuskan sendiri untuk memanggil tool, apakah goal test ada di programmu atau di model? Taksonomi tidak punya jawaban, karena ketika ia ditulis tidak ada tempat lain untuk itu berada — dan pertanyaan itu persis tempat dua definisi modern berpisah.

Definisi adalah argumen tentang perilaku, dan jauh lebih mudah dinilai dengan trace di depanmu.

Loop di bawah mengirim percakapan ke model; jika balasan berisi tool call, ia mengeksekusi tool, menambahkan hasilnya, dan mengirim semuanya lagi. Ia berjalan terhadap Qwen2.5-0.5B-Instruct lokal di balik endpoint berbentuk OpenAI pada mesin ini — seam dari Bab 14, jadi loop tidak tahu dan tidak peduli apa yang ada di balik port.

const BASE = process.env.LLM_BASE_URL ?? "http://127.0.0.1:8799/v1";

async function loop(question: string, maxTurns = 6) {
  const messages: Msg[] = [
    { role: "system", content: SYSTEM },
    { role: "user", content: question },
  ];

  for (let turn = 1; turn <= maxTurns; turn++) {
    const reply = await call(messages, TOOLS);
    const calls = reply.choices[0].message.tool_calls ?? [];
    messages.push(reply.choices[0].message);

    if (!calls.length) return messages;                      

    for (const c of calls) {
      const out = runTool(c.function.name, JSON.parse(c.function.arguments));
      messages.push({ role: "tool", name: c.function.name, content: out });
    }
  }
  throw new Error("turn cap reached");                       
}

Dua baris memuat seluruh gagasan, dan keduanya ditandai; sisanya bookkeeping. Ketiga perilaku terlihat dalam satu run. Ditanya sesuatu yang bisa ia lakukan sendiri, model menjawab. Ditanya sesuatu yang tidak bisa, ia memanggil:

=== a question the model cannot answer, one tool available
  turn 1  prompt= 187  out= 21  finish=tool_calls  CALL get_temperature({"city": "Oslo"})
          tool  get_temperature -> {"city":"Oslo","celsius":4}
  turn 2  prompt= 238  out= 12  finish=stop        TEXT "The current temperature in Oslo is 4
                                                        degrees Celsius."
  => model calls=2  prompt tokens=425  output=33  wall=6,257 ms
  => stopped by: the model produced text instead of a call

Dan ia berhenti — perilaku ketiga, dan yang paling mudah terlewat, karena tampak seperti tidak ada yang terjadi. Loop berakhir karena turn 2 kembali tanpa tool call. Tidak ada yang memutuskan itu; model yang memutuskan, dengan memancarkan prosa. Termination condition program ini adalah tanda dari sebuah ketiadaan.

Dua run lagi layak mendapat ruang. Diminta membandingkan dua kota, model mengeluarkan kedua tool call dalam satu turn, mendapat kedua reading kembali, dan salah membandingkan:

  turn 1  prompt= 188  out= 43  finish=tool_calls  CALL get_temperature({"city": "Oslo"}),
                                                        get_temperature({"city": "Lisbon"})
          tool  get_temperature -> {"city":"Oslo","celsius":4}
          tool  get_temperature -> {"city":"Lisbon","celsius":19}
  turn 2  prompt= 284  out= 13  finish=stop        TEXT "Oslo is currently warmer than Lisbon
                                                        at 4°C."

Tool berfungsi. Parallel call berfungsi. Loop berfungsi. Jawabannya salah, dengan kedua angka benar duduk di transcript. Membungkus model dalam loop tidak membuatnya bernalar; itu memberi model yang salah kemampuan untuk bertindak berdasarkan kesalahannya — yang merupakan Bab 30 lebih awal, dan setengah dari Bab 29.

Sekarang hapus return yang ditandai dan biarkan loop berjalan sampai cap-nya. Pertanyaan yang sama, model yang sama:

  turn 1  prompt= 187  out= 21  CALL get_temperature({"city": "Oslo"})
  turn 2  prompt= 238  out= 12  TEXT "The current temperature in Oslo is 4 degrees Celsius."
  turn 3  prompt= 261  out= 30  TEXT "Could you please specify the exact location you're..."
  turn 4  prompt= 302  out= 14  TEXT "Sure! Could you tell me which city you're interested in?"
  turn 5  prompt= 327  out= 35  TEXT "I'm sorry, but I need more details to provide an..."
  turn 6  prompt= 373  out= 12  TEXT "Which city would you like to know the temperature for?"
  => model calls=6  prompt tokens=1,688  output=124  wall=25,261 ms  stopped by: turn cap

Empat kali input token, empat kali wall clock, dan ending tempat agent sudah lupa apa yang ditanyakan dan menginterogasi pengguna tentang pertanyaan yang sudah mereka jawab pada turn satu. Jawaban yang benar sudah ada di layar pada turn 2, dan setiap turn setelahnya membuat transcript lebih buruk.

Jadi agent bukan loop. Ia adalah loop plus aturan untuk keluar darinya, dan yang ini punya tepat satu aturan seperti itu. Bab 23 menemukan lima, dan menunjukkan apa yang rusak ketika masing-masing hilang.

Keduanya dikutip, bukan diparafrasekan, karena parafrase adalah tempat kebingungan diproduksi.

Definisi pertama meletakkan batas pada siapa yang mengendalikan alur. Building effective agents dari Anthropic menamai ambiguitas itu dan memberi keputusan:

"Di Anthropic, kami mengategorikan semua variasi ini sebagai agentic systems, tetapi menarik perbedaan arsitektural penting antara workflows dan agents: Workflows adalah sistem tempat LLM dan tools diorkestrasi melalui jalur kode yang telah didefinisikan sebelumnya. Agents, di sisi lain, adalah sistem tempat LLM secara dinamis mengarahkan proses dan penggunaan tool mereka sendiri, sambil mempertahankan kendali atas cara mereka menyelesaikan tugas."⁴

Ujiannya adalah pertanyaan tentang source code kamu: siapa yang memilih langkah berikutnya? Sebuah switch dalam programmu: workflow. Model: agent. Dokumen yang sama mengatakan agents "biasanya hanyalah LLM yang menggunakan tools berdasarkan feedback lingkungan dalam loop" — yang persis listing di atas.

Definisi kedua meletakkan batas pada independensi dari pengguna. A practical guide to building agents dari OpenAI membuka halaman definisinya seperti ini:

"Sementara software konvensional memungkinkan pengguna merampingkan dan mengotomatisasi workflows, agents mampu menjalankan workflows yang sama atas nama pengguna dengan tingkat independensi yang tinggi. Agents adalah sistem yang secara independen menyelesaikan tugas atas namamu."⁵

Dua kalimat kemudian, di halaman yang sama, ia mengecualikan:

"Aplikasi yang mengintegrasikan LLM tetapi tidak menggunakannya untuk mengendalikan eksekusi workflow—bayangkan chatbot sederhana, single-turn LLMs, atau sentiment classifiers—bukan agents."⁵

Baca kutipan itu berurutan. Kalimat pembuka menarik garis pada independensi: apakah benda ini pergi dan menyelesaikan pekerjaan tanpa saya? Kalimat keempat menariknya pada kendali eksekusi, yang persis garis Anthropic. Uji yang berbeda, halaman yang sama, dan ada sistem nyata tempat keduanya tidak sepakat.

Ada tabrakan kosakata di bawahnya, dan itu menyebabkan perdebatan dalam rapat sungguhan. Dalam dokumen pertama, workflow adalah arsitektur, dan itu hal yang bukan agent. Dalam yang kedua, workflow adalah "sequence of steps that must be executed to meet the user's goal" — pekerjaannya sendiri, yang dimiliki setiap agent. "Kami mengganti workflow dengan agent" koheren menurut definisi pertama dan nyaris tidak bermakna menurut definisi kedua.

Tiga sistem yang ada pada 2026, menurut kedua definisi.

Dua dari tiga berpindah sisi. Itu bukan kegagalan salah satu dokumen. Itu peringatan tentang jenis rapat ketika dua orang yang sepenuhnya sepakat tentang apa yang dilakukan sebuah sistem menghabiskan satu jam tidak sepakat tentang harus menyebutnya apa.

Definisi bertabrakan karena masing-masing memadatkan dua pertanyaan independen menjadi satu kata. Pisahkan keduanya dan ketidaksepakatan menjadi tabel, yang lebih berguna daripada vonis.

Setiap definisi memperdebatkan sel yang berbeda, dan dua lainnya sama sekali tidak diperdebatkan. Jadi ketika label penting — dalam kontrak, tinjauan risiko, postmortem — dua kalimat yang layak ditulis bukan "apakah ini agent" melainkan siapa yang memilih langkah berikutnya dan siapa yang mengawasi. Keduanya bisa dijawab dengan membaca kode, keduanya tidak membutuhkan definisi siapa pun, dan bersama-sama keduanya membawa setiap konsekuensi yang tadinya diwakili label itu.

Tidak ada yang baru dalam hal ini. Wooldridge dan Jennings mensurvei berbagai makna "agent" yang bersaing pada 1995;⁶ Franklin dan Graesser mengajukan pertanyaan bab ini pada 1996, mengumpulkan definisi yang beredar dan menemukan bahwa definisi itu tidak sepakat.⁷ Survei 2023 masih mendefinisikan agents dari prinsip pertama — "artificial entities that sense their environment, make decisions, and take actions"⁸ — karena belum ada definisi mapan untuk dikutip, dan CoALA mendeskripsikan bagian-bagian alih-alih menarik batas sama sekali.⁹ Tiga puluh tahun menolak sepakat menunjukkan kata itu melakukan lebih dari satu pekerjaan.

Sekarang konsekuensi yang datang sebelum filsafat, yaitu tagihan.

Setiap pengukuran di sini punya bentuk yang sama. Single call memakan 39 input token; pertanyaan yang sama dengan satu tool memakan 420 di dua call; loop dengan stopping rule-nya dihapus memakan 1.688 di enam call. Pertumbuhan lebih buruk daripada linear, karena turn n membawa setiap turn sebelumnya: kolom prompt dari run enam turn itu berbunyi 187, 238, 261, 302, 327, 373. Bab 16 menurunkan bahwa totalnya adalah $\Theta(n^2)$ dan memfitting kurvanya pada percakapan nyata. Agent mengubah setiap tugas menjadi percakapan itu, entah manusia pernah melihatnya atau tidak.

Jika hitungan token terukur itu dikirim ke endpoint komersial dengan tarif yang dibaca Bab 16 pada 6 September 2026 — $2,00 per sejuta input token dan $12,00 per sejuta output — empat run dihargai seperti ini:

Baris dua terhadap baris satu adalah angka yang perlu diingat. Biaya tujuh setengah kali lipat, untuk jawaban yang lebih buruk atas pertanyaan yang sudah diketahui model. Tidak ada yang salah konfigurasi: sebuah tool ada, jadi model menggunakannya — dan temuan Bab 18, bahwa harga katalog dan bukan akurasinya yang menyakitkan, punya demonstrasi termurahnya di sini dengan katalog berisi satu.

Itulah sebabnya separuh berguna dari kedua dokumen adalah separuh tentang tidak membangun ini. Anthropic blak-blakan: temukan solusi sesederhana mungkin dan tambahkan kompleksitas hanya ketika diperlukan, yang "mungkin berarti tidak membangun agentic systems sama sekali", karena agentic systems "menukar latensi dan biaya demi performa tugas yang lebih baik" dan "untuk banyak aplikasi, mengoptimalkan single LLM calls dengan retrieval dan in-context examples biasanya cukup".⁴ Kasusnya untuk agent sempit: masalah open-ended ketika kamu tidak bisa memprediksi jumlah langkah dan tidak bisa hardcode jalur, di lingkungan yang kamu percayai, sambil menerima "biaya yang lebih tinggi, dan potensi error yang berlipat".⁴ Layar OpenAI adalah bayangan cerminnya — penilaian kompleks, rule set yang tidak dapat dipelihara, data tidak terstruktur — dan berakhir dengan cara yang sama: "otherwise, a deterministic solution may suffice".⁵

Jadi, dalam taksonomi bab ini: jumlah langkah tetap dalam urutan tetap adalah pipeline, dan menyebutnya agent tidak akan membuatnya lebih cepat. Jika jumlah langkah bergantung pada apa yang kamu temukan di jalan, kamu menginginkan loop — dan kamu membeli fleksibilitas itu dengan N call, transcript kuadratik, dan sistem yang bisa salah N kali alih-alih sekali.

Sekarang kamu punya taksonomi, kedua definisi modern, dua sumbu yang membuatnya kompatibel, dan loop pendek yang menjawab, memanggil, dan berhenti.

Loop itu punya satu cara untuk berakhir: model berhenti meminta tools. Bab 23 merusaknya dengan sengaja, tujuh kali, dan setiap kerusakan menambahkan satu bagian. Tugas mustahil, dan ia tidak pernah berakhir — turn cap. Semalam berjalan, dan tagihan datang — budget dalam dolar. Tool yang gagal — error yang bisa ditindaklanjuti model. Call yang sama dua kali — idempotency key. File yang seharusnya tidak disentuh — human approval. Restart di tengah jalan — session persistence. Tool yang memakan tiga menit dalam diam — progress dan cancellation. Hasilnya adalah harness, file yang dipakai sisa kursus ini.

Yang tersisa adalah pertanyaan yang sebenarnya dibahas diagonal sengketa bab ini. Loop yang menentukan langkah berikutnya sendiri harus menentukan kapan berhenti, dan kita baru saja melihat apa yang terjadi ketika ia tidak bisa: enam turn, empat kali tagihan, dan agent menginterogasi pengguna tentang pertanyaan yang sudah ia jawab. Stopping bukan satu condition. Ada berapa banyak, dan mana yang menyala dulu?

LLM Powered Autonomous Agents (2023) dari Lilian Weng adalah dekomposisi language agent paling terkenal menjadi planning, memory, dan penggunaan tool, dan merupakan bacaan berikutnya yang tepat bersama dua dokumen vendor; tiga komponennya adalah Bab 23, 24, dan 18 dari kursus ini dalam urutan itu.

Setiap angka dalam bab ini dihasilkan di mesin ini dan tidak ada yang diestimasi. Koridor, denah lantai, empat agent yang berjalan di atasnya, dan tiga policy patrol adalah TypeScript di atas, dijalankan di Node 22; angka agent yang diacak adalah mean atas 2.000 seeded run masing-masing dan angka patrol adalah single seeded run sepanjang 4.000 tick. Trace model berasal dari Qwen2.5-0.5B-Instruct dalam float32 di CPU dengan greedy decoding, disajikan lewat loopback oleh endpoint Python lokal kecil yang memuat weights dan berbicara dalam bentuk OpenAI chat-completions — seam lagi, dengan tensor di sisi Python dan loop di sisi TypeScript — jadi hitungan token adalah tokenizer model itu dan latensinya milik mesin itu. Satu-satunya angka yang diambil dari tempat lain adalah dua harga di tabel biaya, yaitu tarif yang dibaca Bab 16 dari halaman pricing OpenAI pada 6 September 2026, diterapkan di sini pada hitungan token terukur lokal sebagai ilustrasi dan bukan sebagai invoice yang diamati.