Belajar AI - Reasoning & Agentic AI

#Pendahuluan

Setelah 20 episode membangun fondasi lengkap — dari konsep sampai multimodal — episode ini membahas dua tren paling menentukan di 2025-2026: reasoning dan agentic AI. Keduanya mengubah pertanyaan mendasar dari "bisakah AI menjawab?" menjadi "bisakah AI berpikir dan menyelesaikan?"

Mengapa episode ini penting? Karena inilah batas kemampuan yang sedang dieksplorasi industri sekarang. Model reasoning menyelesaikan soal matematika dan logika yang mustahil bagi LLM biasa; agent otonom menjalankan alur kerja yang sebelumnya butuh manusia. Memahami keduanya berarti memahami arah AI 2027 — bukan hanya sekadar mengikuti.

#Chain-of-Thought (CoT)

Chain-of-thought adalah teknik meminta model memecah masalah menjadi langkah-langkah sebelum menjawab. Hasilnya dramatis untuk tugas yang butuh penalaran bertahap:

Prompt (tanpa CoT):
  "Jika sebuah toko menjual 3 apel seharga 2.000 dan 2 jeruk
   seharga 1.500, berapa total harga semua buah?"
Jawaban singkat -> sering salah
 
Prompt (dengan CoT):
  "Selesaikan langkah demi langkah:
   1. Hitung harga 3 apel: 3 x 2.000 = 6.000
   2. Hitung harga 2 jeruk: 2 x 1.500 = 3.000
   3. Total = 6.000 + 3.000 = 9.000"
Jawaban -> hampir selalu benar

CoT meniru cara manusia berpikir: memecah masalah besar menjadi sub-masalah. Ini teknik paling murah untuk meningkatkan kemampuan reasoning — tidak perlu model baru, cukup prompt yang lebih baik.

#Inference-Time Compute: o-Series dan R1

Perkembangan 2024-2026: menghabiskan lebih banyak komputasi saat inference untuk meningkatkan kualitas — kebalikan dari "semakin cepat semakin baik".

OpenAI o-series dan DeepSeek R1 memperkenalkan model yang, saat diberi pertanyaan sulit, secara internal berpikir lama — menghasilkan rantai penalaran tersembunyi (hidden reasoning) sebelum jawaban akhir. Konsep terkait: test-time compute scaling — semakin lama model "berpikir", semakin baik hasilnya pada tugas sulit.

from openai import OpenAI
 
client = OpenAI()
 
response = client.chat.completions.create(
    model="o3-mini",          # reasoning model
    messages=[
        {"role": "user", "content": "Buktikan bahwa akar 2 bukan bilangan rasional."}
    ],
    reasoning_effort="high",  # seberapa lama model berpikir
)
print(response.choices[0].message.content)

Implikasi biaya: reasoning model memakai 10-100x lebih banyak token daripada model biasa untuk pertanyaan yang sama. Aturan praktis: pakai reasoning model untuk tugas yang memang butuh penalaran (matematika, logika, keputusan kompleks) — bukan untuk tugas ringkas.

#Tool-Based Reasoning

Reasoning terbaik bukan hanya berpikir — tapi memeriksa fakta lewat tool. Inilah perpaduan episode 15 (agents) dan episode ini:

1. Model merencanakan langkah.
2. Memanggil tool untuk memverifikasi (kode, kalkulator, web, database).
3. Meninjau hasil, memperbaiki pendekatan, mengulang.

def verify(expression: str) -> str:
    # jalankan di sandbox, kembalikan hasil & error
    return run_code_sandbox(expression)
 
# agent loop: model menulis kode, tool mengeksekusi, hasil dikembalikan
result = agent_loop(
    "Hitung integral x^2 dari 0 sampai 3, lalu verifikasi secara numerik",
    tools={"python": verify},
)

Tool-based reasoning mengoreksi kelemahan dasar LLM — menghitung tidak akurat — dengan menyerahkan komputasi pada mesin yang memang akurat: kode. Inilah pola di balik "AI coding agent" yang menulis, menjalankan, dan memperbaiki kodenya sendiri.

#Workflow Automation vs Autonomous Agents

Tidak semua otomasi harus otonom. Dua spektrum yang perlu dibedakan:

Prinsip engineering: mulai dari workflow. Jika alur kerja bisa ditulis langkah demi langkah, lakukan — dengan checkpoint manusia di titik berisiko. Naikkan ke agent otonom hanya saat variasi tugas membuat workflow mustahil ditulis, dan selalu dengan guardrail (max steps, izin minimal, human approval untuk aksi berisiko — episode 15-16).

#Mengevaluasi Reliabilitas Agent

Agent yang sering gagal lebih berbahaya daripada tidak ada agent — kegagalannya bisa diam-diam. Evaluasi dengan kerangka yang sudah kita sentuh di episode 15, sekarang lebih dalam:

1. Task success rate: persentase task selesai benar — metrik utama.
2. Failure taxonomy: mengapa agent gagal? (salah pilih tool, loop, argument salah, salah memahami instruksi). Kategorikan kegagalan untuk perbaikan terarah.
3. Cost & latency per success: biaya token, langkah, dan waktu per keberhasilan.
4. Human override rate: seberapa sering manusia harus turun tangan — tanda keandalan yang buruk.
5. Safety incidents: berapa kali agent melakukan aksi yang seharusnya tidak (memberi izin yang tidak diminta, mengakses data di luar scope).

def log_trace(task_id, steps, success, cost):
    # simpan ke sistem observability (episode 18)
    return {
        "task_id": task_id,
        "steps": steps,
        "success": success,
        "cost_tokens": cost,
        "timestamp": now(),
    }

Gabungkan dengan trace-based debugging (episode 15): setiap kegagalan harus bisa di-replay langkah demi langkah untuk menemukan titik putusnya.

#Common Pitfalls

• CoT dihindari: menyuruh model menjawab langsung = membuang kemampuan reasoning gratis.
• Reasoning model untuk semua request: biaya 10-100x untuk tugas yang tidak butuh penalaran.
• Agent otonom tanpa workflow dulu: kompleksitas & risiko sebelum kebutuhan terbukti.
• Tanpa failure taxonomy: tidak tahu harus memperbaiki apa.
• Mengabaikan safety incidents: satu aksi berbahaya bisa menghancurkan kepercayaan.

#Penutup

Inti yang harus dibawa pulang:

• Chain-of-thought memecah masalah menjadi langkah — teknik paling murah untuk meningkatkan reasoning.
• Inference-time compute (o-series, R1) menghabiskan lebih banyak komputasi untuk berpikir lebih dalam — mahal, jadi pakai selektif.
• Tool-based reasoning: model memverifikasi lewat kode/tool — perpaduan agents dan reasoning.
• Mulai dari workflow automation; naik ke autonomous agents hanya jika perlu, dengan guardrail.
• Evaluasi agent: task success rate, failure taxonomy, cost per success, human override rate, safety incidents.

Di episode 22 selanjutnya kita melihat peta ekosistem lengkap 2026: Ekosistem & Tools Modern — pilihan model (Llama 4, Qwen3, Gemma 4, Phi-4, DeepSeek, Mistral, GPT/Claude/Gemini), framework (PyTorch 2.11, TensorFlow 2.21, Keras 3), dan tools (Ollama, vLLM, Hugging Face, LangChain, LlamaIndex, Dify) plus cara memilihnya. Sampai jumpa di episode 22!