Belajar AI Engineer - Agents & Agentic Workflows

#Pendahuluan

Di episode 5 kalian sudah membangun loop tool-calling sederhana. Episode ini mengangkatnya ke level berikutnya: agents — sistem yang bisa menalar, mengambil keputusan, memanggil tools, dan mengulang sampai tugas selesai. Inilah inti tren agentic AI yang mendominasi 2026.

Mengapa penting? Karena banyak tugas nyata tidak bisa diselesaikan dalam satu panggilan LLM: "cari data penjualan, bandingkan dengan target, lalu kirim ringkasan ke email" butuh beberapa langkah dengan keputusan di antaranya. Agent adalah cara membuat LLM menyelesaikan tugas semacam itu dengan aman dan terukur.

#Apa Itu Agent?

Agent = LLM + tools + loop pengambilan keputusan. Tanpa LLM, ia script biasa. Tanpa tools, ia chatbot. Tanpa loop, ia panggilan API satu kali.

100%

Pola klasiknya adalah ReAct (Reasoning + Acting): model berpikir (reason) → bertindak (act/tool) → mengamati hasil (observe) → berpikir lagi, sampai jawaban final.

#Membangun Agent End-to-End

Kita buat agent riset sederhana dengan dua tools: web search dan kalkulator. Semua dengan loop manual yang transparan — ini penting agar kalian paham persis apa yang terjadi, sebelum memakai framework di episode 23.

agent.py - agent riset sederhana

import json
from openai import OpenAI
 
client = OpenAI()
 
TOOLS = [
    {"type": "function", "function": {
        "name": "web_search", "description": "Cari informasi terbaru di web.",
        "parameters": {"type": "object", "properties": {
            "query": {"type": "string"}}, "required": ["query"]}}},
    {"type": "function", "function": {
        "name": "calculate", "description": "Hitung ekspresi aritmatika.",
        "parameters": {"type": "object", "properties": {
            "expr": {"type": "string"}}, "required": ["expr"]}}},
]
 
def web_search(query: str) -> str:
    return json.dumps({"query": query, "ringkasan": "placeholder hasil pencarian"})
 
def calculate(expr: str) -> str:
    try:
        return str(eval(expr))  # HANYA untuk demo; jangan di produksi
    except Exception as e:
        return json.dumps({"error": str(e)})
 
TOOL_IMPL = {"web_search": web_search, "calculate": calculate}
 
def run_agent(task: str, max_iter: int = 8) -> None:
    messages = [{"role": "user", "content": task}]
    for i in range(max_iter):
        r = client.chat.completions.create(
            model="gpt-4o-mini", messages=messages, tools=TOOLS)
        msg = r.choices[0].message
        print(f"\n[iter {i}] -> {msg.content or '(tool call)'}")
        if not msg.tool_calls:
            return
        messages.append(msg)
        for call in msg.tool_calls:
            impl = TOOL_IMPL[call.function.name]
            args = json.loads(call.function.arguments)
            hasil = impl(**args)
            print(f"  tool {call.function.name}({args}) => {hasil}")
            messages.append({"role": "tool", "tool_call_id": call.id,
                             "content": hasil})
    print("\n[max iterasi tercapai, berhenti]")
 
run_agent("Hitung 15% dari 240.000 lalu cari arti singkatan RAG.")

Perhatikan tiga komponen keamanan yang sudah tertanam sejak awal:

• Batasan iterasi (max_iter=8) mencegah loop tak berujung.
• Tool diimplementasikan terpisah dari skema — model tidak pernah mengeksekusi kode, hanya meminta.
• Hasil tool dikembalikan sebagai pesan untuk langkah berikutnya.

#Kapan Agent Cocok (dan Tidak)

Agent bukan solusi untuk segalanya:

#Orchestrasi: Satu Agent atau Banyak?

Untuk tugas kompleks, ada dua pendekatan:

1. Single agent dengan banyak tools: sederhana, satu loop, mudah di-debug. Cukup untuk mayoritas kasus.
2. Orchestrator + sub-agent: LLM utama membagi tugas ke agent khusus (peneliti, penulis, reviewer). Lebih kuat untuk tugas besar, tapi jauh lebih kompleks dan mahal.

Aturan praktis: mulai dengan single agent. Naik ke multi-agent hanya jika: (a) tugas benar-benar berlapis, (b) tools terlalu banyak sehingga membingungkan satu model, atau (c) butuh isolasi konteks antar peran. Multi-agent kita bahas mendalam di episode 23.

#Common Pitfalls

• Agent tanpa tujuan yang jelas: tanpa task yang terdefinisi dan kriteria selesai, agent berputar tanpa arah. Definisikan exit condition.
• Tool berbahaya tanpa pengaman: tool yang menulis/menghapus harus punya izin dan konfirmasi (episode 18).
• eval() di tool: contoh di atas memakai eval hanya untuk demo. Di produksi, parser aritmatika yang aman wajib.
• Tanpa observability: agent multi-langkah sulit di-debug tanpa tracing — kita pasang di episode 17.

#Penutup

Inti yang harus dibawa pulang:

• Agent = LLM + tools + loop keputusan; pola dasarnya ReAct.
• Selalu pasang batas iterasi dan pisahkan skema tool dari implementasinya.
• Pilih pola paling sederhana yang menyelesaikan tugas; agent untuk tugas dengan keputusan dinamis.
• Debug agent butuh tracing — persiapkan dari awal.

Di episode 12 selanjutnya kita membuat agent mengingat: memory & state management — short/long-term memory, persistensi percakapan, conversation state, dan agent dengan memori yang benar. Sampai jumpa di episode 12!