Transisi dari eksperimen prototipe kecerdasan buatan menuju penerapan di tingkat industri menuntut pergeseran paradigma mendasar. Banyak pengembang terjebak dalam pola pikir Model-First—mengandalkan model raksasa (frontier LLMs) untuk menyelesaikan setiap langkah tugas, yang berujung pada tingginya latensi, pembengkakan biaya API (token cost), serta risiko keandalan (hallucination dan looping tak terbatas).

Untuk membangun sistem Agentic AI yang berdaya tahan tinggi, hemat biaya (cost-effective), dan ringan, kita harus beralih ke pendekatan System-First Engineering.

1. Pergeseran Paradigma: Dari Model-First ke System-First

Dalam arsitektur Model-First, satu model cerdas berukuran besar dipaksa bertindak sebagai perencana (planner), pelaksana (executor), pemeriksa (verifier), hingga pencatat (logger). Hal ini analogi dengan mempekerjakan konsultan senior berbiaya tinggi hanya untuk mencatat inventaris harian.

Sebaliknya, arsitektur System-First memperlakukan model bahasa (LLM) hanya sebagai salah satu komponen kalkulasi dalam pipa orkestrasi yang terstruktur dan deterministik.

┌─────────────────────────────────────────────────────────────┐
│                 Permintaan Pengguna (Prompt)                │
└──────────────────────────────┬──────────────────────────────┘
                               ▼
            ┌────────────────────────────────────┐
            │   Intelligent Router / Classifier  │
            └──────────────┬──────────────┬──────┘
                           │              │
        [Tugas Sederhana]  ▼              ▼  [Tugas Penalaran Kompleks]
      ┌─────────────────────────┐    ┌─────────────────────────┐
      │ Small Language Model    │    │ Frontier Reasoning LLM  │
      │ (Local 8B / QLoRA)      │    │ (System-Prompt Terbatas)│
      └────────────┬────────────┘    └────────────┬────────────┘
                   │                              │
                   └──────────────┬───────────────┘
                                  ▼
      ┌────────────────────────────────────────────────────────┐
      │  Deterministic State Machine (Tool Execution & Memory) │
      └────────────────────────────────────────────────────────┘

2. Lima Pilar Arsitektur Agentic AI Hemat dan Ringan

A. Intelligent Routing (Penyortiran Tugas Bertingkat)

Jangan langsung memanggil model mahal untuk setiap input pengguna. Terapkan lapisan router ringan (misalnya model klasifikasi kecil atau aturan rule-based) untuk mengkategorikan kompleksitas prompt:

• Level 1 (Direct Retrieval / Deterministic): Ditangani oleh fungsi internal atau regex.
• Level 2 (Ekstraksi & Formatting): Ditangani oleh model lokal kecil (SLM 3B–8B).
• Level 3 (Penalaran Mendalam / Multi-Step Planning): Dieskalasikan ke frontier model hanya jika benar-benar diperlukan.

B. Spesialisasi & Model Distillation (PEFT & QLoRA)

Alih-alih mengandalkan model generalis serba bisa, lakukan teknik Fine-Tuning Efisien (Parameter-Efficient Fine-Tuning) seperti QLoRA pada model dasar berukuran 7B/8B. Model kecil yang dilatih khusus pada satu domain (misalnya format JSON atau SQL parsing) terbukti mengungguli model besar dengan biaya komputasi hingga 90% lebih rendah.

C. Rekayasa Memori & Konteks (Context & Memory Hygiene)

Salah satu pemborosan terbesar dalam Agentic AI adalah akumulasi riwayat pesan (context bloat). Strategi penghematan konteks meliputi:

1. Lazy Loading Tool Results: Hapus output detail alat (tool logs) dari riwayat percakapan setelah eksekusi berhasil dan simpan intisarinya saja.
2. Persistent Disk Storage: Simpan memori jangka panjang dalam format berkas terstruktur (Markdown/JSON) atau Vector DB terindeks, lalu panggil kembali hanya bagian yang relevan melalui RAG.

D. Orkestrasi Deterministik (Controlled State Machines)

Agen AI otonom murni (pure autonomous agents) rawan terjebak dalam infinite loop. Gunakan framework berbasis graf (seperti LangGraph atau finite state machine) di mana jalur transisi, batas iterasi (max iterations), dan fallback mechanisms didefinisikan secara tegas oleh kode pengembang.

E. Optimasi Mesin Inferensi (Inference Serving)

Gunakan engine inferensi modern berkinerja tinggi seperti vLLM, TGI, atau Ollama/llama.cpp yang mendukung PagedAttention, kuantisasi (INT4/INT8), dan continuous batching untuk memaksimalkan throughput pada hardware terbatas.

3. Matriks Perbandingan Arsitektur

4. Pola Implementasi: Router Cerdas Sederhana

Berikut adalah contoh pola perutean (routing pattern) modular dalam TypeScript:

interface TaskRequest {
  query: string;
  complexityScore: number; // Dihitung via classifier ringan
}

async function executeAgenticWorkflow(task: TaskRequest): Promise<string> {
  // 1. Triage Berdasarkan Kompleksitas
  if (task.complexityScore < 0.3) {
    // Jalur Cepat & Ringan: Menggunakan Model Lokal (SLM)
    return await callLocalSLM(task.query);
  }

  // 2. Jalur Penalaran: Menggunakan Frontier Model dengan batasan konteks
  const plan = await callFrontierPlanner(task.query);
  
  // 3. Eksekusi Alat Secara Deterministik
  const result = await executeDeterministicTools(plan);
  
  // 4. Bersihkan konteks sebelum menyimpan
  return compactOutput(result);
}

5. Kesimpulan

Membangun sistem Agentic AI yang siap produksi bukanlah tentang seberapa pintar model tunggal yang Anda sewa melalui API, melainkan tentang seberapa cerdas arsitektur sistem yang Anda bangun untuk membatasi, menyaring, dan mengarahkan komputasi secara presisi.

Dengan mengadopsi prinsip hemat, ringan, dan terarah, bisnis dapat menikmati keunggulan otomatisasi AI tanpa terbebani tagihan infrastruktur yang tidak rasional.

📖 Sumber & Publikasi Asli: Artikel ini disadur dan dikembangkan berdasarkan publikasi resmi redaksi di Medium: Agentic AI Adaptation: Building Intelligent Systems that are Cheap, Lightweight, and Efficient.