Sebelum ngomongin agent, tools, memory, MCP, multi-agent, dan istilah keren lainnya, menurut gw kita perlu mundur dulu ke hal yang paling basic: LLM itu sebenernya ngapain sih?

Gw adalah salah satu orang yang nggak terlalu impress sama LLM, apalagi pas ChatGPT pertama kali booming. Waktu itu state-of-the-art language model sebenernya sudah lumayan oke. Sebelum GPT ramai, nama yang sering gw dengar adalah BERT. Jadi reaksi gw kurang lebih, “oh, ini model bahasa yang dibesarin pakai lebih banyak data dan komputasi.”

Ternyata pikiran itu nggak sepenuhnya salah, tapi terlalu menyederhanakan juga. BERT dan GPT sama-sama dibangun dari transformer, tetapi cara training dan tujuan pemakaiannya beda. BERT lebih fokus memahami context dari dua arah, sedangkan GPT menghasilkan teks secara autoregressive. Detailnya bisa panjang sendiri, jadi untuk sekarang gw cukup pegang persamaannya: keduanya belajar pola bahasa dari data dalam jumlah besar.

Artikel pertama ini bukan buat ngebahas semua detail matematika transformer karena, seperti yang sudah gw bilang di artikel sebelumnya, gw nggak terlalu jago matematika. Tujuannya lebih ke membangun mental model, supaya pas nanti ngomongin agent kita punya sedikit pemahaman tentang LLM itu sendiri. Agent tetap berdiri di atas LLM yang juga punya batasan. Gw tetap tertarik belajar sisi matematikanya, tapi kayaknya lebih enak dibuat jadi tulisan terpisah.

Kenapa mulai dari LLM

Karena inti dari AI agent yang kita pakai sekarang tetap sebuah LLM. Kemampuan memahami instruksi, menghasilkan bahasa, dan memilih langkah sangat bergantung pada model yang dipakai. Sistem di sekitarnya bisa memberi data dan tools, tapi nggak bisa menyulap model yang nggak cocok menjadi pintar mendadak.

Rute belajar

Gw belum akan belajar sisi matematika dari LLM. Untuk sekarang gw cuma pengen punya cerita besarnya dulu: dari teks masuk, diproses model, sampai akhirnya keluar token berikutnya.

Kalau diringkas, flow-nya kira-kira seperti ini:

Teks user
  ↓
Tokenization
  ↓
Embedding
  ↓
Position information
  ↓
Attention / context mixing
  ↓
Next-token probabilities
  ↓
Sampling / pilih token
  ↓
Repeat

Terlihat sederhana, tapi setiap step di dalamnya sebenernya kompleks. Di tulisan ini gw sengaja fokus ke flow dan mental model-nya dulu. Detail teknisnya bisa dipelajari belakangan setelah cerita besarnya kebentuk.

Next-token prediction

Hal paling dasar yang perlu dipahami: LLM memprediksi token berikutnya berdasarkan token-token sebelumnya.

Misalnya ada potongan kalimat:

Langit berwarna

Model akan mencoba menebak token berikutnya yang paling masuk akal. Bisa aja biru, gelap, cerah, atau token lain. Model tidak langsung mengambil jawaban dari database, tapi menghitung kemungkinan token berikutnya berdasarkan pola yang dipelajari saat training.

Dari proses sederhana ini, teks panjang bisa muncul karena prediksi dilakukan berulang:

Baca token saat ini
→ prediksi token berikutnya
→ tambahkan token berikutnya
→ ulangi

Dari proses yang diulang-ulang ini, jawaban panjang bisa terbentuk. Jadi ketika LLM terlihat seperti sedang “menjelaskan”, secara teknis dia sedang menghasilkan teks satu token demi satu token.

Tokenization

Token itu unit paling kecil yang dipake LLM buat baca dan menghasilkan teks. Jadi LLM gak bener-bener baca kalimat kayak manusia, tapi teksnya dipecah dulu jadi potongan-potongan kecil.

Potongan ini bisa berupa satu kata, sebagian kata, tanda baca, atau karakter tertentu. Jadi satu kata belum tentu selalu satu token. Ada kata yang bisa jadi satu token, tapi ada juga kata yang dipecah jadi beberapa token.

Gampangnya, tokenizer bisa mulai dari potongan kecil, lalu potongan yang sering muncul bareng bakal digabung jadi bagian yang lebih besar. Makanya ada kata yang kebaca utuh, tapi ada juga kata yang kebaca kepotong jadi beberapa bagian.

Contoh sederhananya, misalnya kita punya kalimat seperti ini:

Saya belajar AI.

Buat kita, itu kelihatan kayak beberapa kata biasa. Tapi buat model, kata seperti belajar bisa aja dilihat dari potongan kecil dulu:

b | e | l | a | j | a | r

Terus tokenizer bisa gabungin beberapa potongan itu jadi bagian yang lebih enak dipakai:

bel | ajar

Jadi kurang lebih, kalimatnya bisa kebaca sebagai token seperti ini:

Saya | bel | ajar | AI | .

Ini bukan hasil pasti buat semua model, karena tiap model bisa punya tokenizer yang beda. Tapi bayangan kasarnya kurang lebih gitu: teks masuk sebagai potongan token, bukan sebagai kalimat utuh.

Embedding

Setelah teks berubah jadi token, token itu belum langsung bisa diproses model. Model butuh angka. Jadi token akan diubah menjadi numerical representation.

Numerical representation ini disebut embedding. Cara bayanginnya, embedding itu kayak koordinat di peta makna. Kata yang sering muncul di konteks mirip akan punya posisi yang lebih dekat.

Misalnya secara kasar, kata-kata yang dekat secara makna bisa dibayangkan seperti ini:

kucing ---- anjing

mobil ---- motor

pisang ---- apel

Kita gak perlu tahu arti setiap angka di dalam embedding. Yang penting, token sekarang sudah punya bentuk numerik yang bisa diproses model.

Position information

Angka saja belum cukup. Model juga perlu tahu urutan token.

Dua kalimat ini punya kata yang hampir sama, tapi artinya beda:

Adit menggigit anjing.
Anjing menggigit Adit.

Kalau model cuma tahu token-nya tanpa tahu posisi, dua kalimat itu akan terlihat terlalu mirip. Karena itu, model perlu position information.

Mental model sederhananya:

token representation = token embedding + position information

Embedding menjelaskan token-nya, sedangkan position information menjelaskan token itu muncul di posisi mana.

Attention

Setelah token punya embedding dan position information, model mulai memproses konteks.

Masalahnya begini: makna awal sebuah token masih umum. Padahal dalam bahasa, makna sering baru jelas setelah melihat kata lain di sekitarnya.

Misalnya kata bisa. Kalau token ini berdiri sendiri, maknanya masih ambigu:

bisa = mampu?
bisa = racun?

Setelah masuk ke kalimat, token bisa perlu melihat token lain:

Ular itu punya bisa yang mematikan.

Di sini kata ular dan mematikan memberi sinyal bahwa bisa lebih mungkin berarti racun, bukan kemampuan.

Kurang lebih:

Sebelum melihat konteks:
bisa = makna umum

Setelah melihat konteks:
bisa = racun, karena ada ular dan mematikan

Inilah inti yang perlu gw pahami dari attention: model mencampur informasi antar token supaya makna setiap token menjadi lebih sesuai dengan konteks.

Contoh lain:

Kucing itu duduk di dekat anjing karena dia lelah.

Kata dia juga ambigu. Untuk memahami dia, model perlu melihat token lain seperti kucing, anjing, dan lelah.

Model akan memberi bobot lebih besar ke token yang dianggap relevan, dan bobot lebih kecil ke token yang kurang relevan.

Contoh kasar:

dia → kucing: tinggi
dia → anjing: sedang
dia → duduk: rendah

Detail teknis cara model menghitung bobot ini cukup rumit. Tapi untuk mental model awal, gw cukup pegang ini dulu: LLM mengubah token menjadi context-aware representation.

Next-token probabilities

Setelah model mencampur konteks, dia punya representasi yang lebih kaya untuk menebak token berikutnya.

Model lalu memberi skor ke banyak kemungkinan token. Skor itu bisa dibayangkan sebagai probability.

Misalnya prompt-nya:

Ibu kota Indonesia adalah

Probability output-nya bisa dibayangkan seperti ini:

Jakarta     95%
Bandung      2%
Surabaya     1%
Lainnya      2%

Model lalu memilih atau mengambil sample satu token. Token itu ditambahkan ke sequence, lalu prosesnya balik lagi dari tokenization sampai output berikutnya.

Training and inference

Saat training, model belajar dari contoh teks dalam jumlah besar. Bentuk sederhananya seperti ini:

Masukan:
Langit berwarna

Token berikutnya yang benar:
biru

Model membuat prediksi. Prediksi itu dibandingkan dengan token yang benar. Kalau salah, model disesuaikan supaya ke depannya prediksinya lebih baik.

Bedanya dengan inference:

• Training: model belajar dan memperbarui weight.
• Inference: model yang sudah dilatih dipakai untuk menghasilkan jawaban.

Context window

Context window adalah batas seberapa banyak token yang bisa “dilihat” model dalam satu request. Jadi ini tetap konsep LLM, karena batasnya ada di model.

Tapi di agent, context window jadi masalah desain sistem. Agent sering perlu memasukkan instruksi, riwayat percakapan, hasil tool, dokumen, memory, dan state. Semua itu harus dipilih supaya muat di context window.

Kalau context terlalu sedikit, agent bisa kehilangan informasi penting. Kalau context terlalu banyak, jawaban bisa jadi tidak fokus dan biaya juga makin besar.

Kenapa LLM bisa salah

Beberapa limitasi yang penting untuk diingat:

• Model bisa hallucinate.
• Model tidak punya state bawaan.
• Model tidak otomatis tahu data terbaru.
• Model tidak bisa melakukan aksi tanpa tools.
• Model bisa salah memahami konteks.

Hal pentingnya: LLM dioptimalkan untuk menghasilkan teks yang mungkin, bukan otomatis memverifikasi kebenaran. Karena itu, jawaban yang terdengar lancar belum tentu benar.

Hubungannya dengan agent

Jadi intinya, agent berdiri di atas LLM, tapi agent bukan LLM doang. LLM memberi kemampuan bahasa dan reasoning dasar, tapi dia tetap punya batasan.

Karena itu agent butuh sistem di sekitarnya: pengaturan konteks, tools, memory, state, runtime, dan kontrol. Bagian-bagian ini bukan membuat LLM tiba-tiba jadi database atau punya tangan sendiri, tapi membantu LLM dipakai untuk menyelesaikan task yang lebih panjang dan lebih terarah.

Note

Kemungkinan besar masih akan ada perubahan di bagian ini karena seperti yg gw bilang gw masih mau belajar Reinforcement Learning untuk LLM dan pengennya beberapa bagian di buat lebih detail mungkin. Jadi expect more to come :)