Apa itu Arsitektur Berbasis Agen? Penjelasan Lengkap untuk Pemula

Pendahuluan

Bayangkan kamu sedang membangun sebuah aplikasi seperti Gojek — ada pengemudi, pelanggan, sistem pembayaran, dan layanan peta yang semuanya bekerja secara terpisah tapi saling berkoordinasi. Inilah gambaran sederhana dari arsitektur berbasis agen (agent-based architecture).

Dalam dunia AI modern, arsitektur berbasis agen adalah cara merancang sistem di mana beberapa “agen” otonom bekerja sama untuk menyelesaikan tugas yang kompleks. Setiap agen punya peran, kemampuan, dan tanggung jawabnya sendiri — persis seperti tim developer yang masing-masing mengerjakan bagian berbeda dari satu proyek besar.

Kalau kamu sudah membaca tentang Mengenal Design Patterns: Fondasi Arsitektur Plugin yang Scalable, kamu sudah punya fondasi yang bagus. Arsitektur berbasis agen adalah salah satu aplikasi nyata dari prinsip-prinsip desain tersebut, tapi diterapkan khusus untuk sistem AI yang perlu berpikir dan bertindak secara mandiri.

Konsep Dasar

Apa itu “Agen” dalam Konteks Ini?

Agen (agent) adalah unit perangkat lunak yang:

1. Menerima input — dari pengguna, lingkungan, atau agen lain
2. Memproses informasi — menggunakan logika, model AI, atau aturan tertentu
3. Mengambil tindakan — memanggil API, menulis file, mengirim pesan, dll.
4. Mengembalikan output — hasil yang bisa dipakai agen lain atau ditampilkan ke pengguna

Analoginya: bayangkan kamu punya tim magang di kantor. Setiap magang punya spesialisasi berbeda — satu ahli riset, satu ahli menulis, satu ahli ngecek grammar. Kamu tinggal kasih tugas ke “manajer”, dan manajer mendistribusikan pekerjaan ke magang yang tepat.

Komponen Utama Arsitektur Berbasis Agen

┌─────────────────────────────────────────┐
│            ORCHESTRATOR                  │
│       (Manajer / Koordinator)            │
└──────┬──────────┬──────────┬────────────┘
       │          │          │
   ┌───▼──┐  ┌───▼──┐  ┌────▼──┐
   │Agen A│  │Agen B│  │Agen C │
   │Riset │  │Tulis │  │Review │
   └──────┘  └──────┘  └───────┘

1. Orchestrator — Bertanggung jawab menerima tugas utama, memecahnya menjadi sub-tugas, dan mendistribusikan ke agen yang sesuai.

2. Worker Agent — Agen spesialis yang mengerjakan satu tugas spesifik dengan sangat baik.

3. Memory / State — Tempat menyimpan hasil kerja setiap agen agar bisa dipakai agen lain.

4. Tools — Kemampuan tambahan yang bisa dipakai agen, seperti browsing web, menjalankan kode, atau mengakses database.

Mengapa Tidak Cukup Satu Agen Saja?

Satu agen tunggal punya keterbatasan:

• Context window terbatas — tidak bisa memproses terlalu banyak informasi sekaligus
• Tugas kompleks sulit dikelola — semakin panjang instruksi, semakin mudah agen “lupa” tujuan awalnya
• Tidak ada spesialisasi — satu agen yang harus melakukan segalanya hasilnya kurang optimal

Dengan arsitektur berbasis agen, setiap agen bisa fokus pada bidangnya. Mirip seperti membangun layanan seperti Tokopedia — tim frontend, backend, dan data analytics bekerja terpisah tapi tetap terintegrasi.

Pola Komunikasi Antar Agen

Ada beberapa cara agen saling berkomunikasi:

Contoh Kode

Mari kita bangun arsitektur berbasis agen sederhana menggunakan Python. Kita akan membuat sistem yang bisa menulis dan mereview artikel secara otomatis.

Setup Awal

# Pastikan install dulu:
# pip install anthropic python-dotenv

import os
from dataclasses import dataclass
from typing import Optional

# Simulasi tanpa API key nyata — kita pakai mock untuk demo
@dataclass
class AgentResult:
    agent_name: str
    output: str
    success: bool

Mendefinisikan Base Agent

class BaseAgent:
    """
    Kelas dasar untuk semua agen.
    Setiap agen punya nama dan kemampuan (tools) sendiri.
    """
    
    def __init__(self, name: str, role: str):
        self.name = name
        self.role = role
        self.memory = []  # Menyimpan riwayat percakapan
    
    def remember(self, content: str):
        """Simpan informasi ke memori agen"""
        self.memory.append(content)
    
    def run(self, task: str) -> AgentResult:
        """
        Method utama yang harus di-override oleh setiap agen.
        """
        raise NotImplementedError("Setiap agen harus implementasi method run()")
    
    def __repr__(self):
        return f"Agent(name={self.name}, role={self.role})"

Membuat Worker Agents

class ResearchAgent(BaseAgent):
    """Agen spesialis pencarian dan pengumpulan informasi."""
    
    def __init__(self):
        super().__init__(
            name="ResearchAgent",
            role="Mengumpulkan dan merangkum informasi tentang topik tertentu"
        )
    
    def run(self, task: str) -> AgentResult:
        print(f"[{self.name}] Sedang meneliti: {task}")
        
        # Di production, di sini kamu akan memanggil API pencarian
        # atau menggunakan LLM untuk browsing web
        result = f"""
        Hasil riset tentang '{task}':
        - Definisi: Konsep fundamental dalam pemrograman modern
        - Kegunaan: Memudahkan pengelolaan kode yang kompleks
        - Contoh implementasi: Python, JavaScript, Java
        """
        
        self.remember(f"Riset topik: {task}")
        return AgentResult(
            agent_name=self.name,
            output=result.strip(),
            success=True
        )


class WriterAgent(BaseAgent):
    """Agen spesialis penulisan konten."""
    
    def __init__(self):
        super().__init__(
            name="WriterAgent",
            role="Menulis artikel berdasarkan hasil riset"
        )
    
    def run(self, task: str, research_result: str = "") -> AgentResult:
        print(f"[{self.name}] Sedang menulis artikel tentang: {task}")
        
        # Di production, di sini kamu akan memanggil LLM seperti Claude atau Gemini
        article = f"""
        # {task}
        
        Berdasarkan riset yang telah dilakukan:
        {research_result}
        
        ## Penjelasan Lengkap
        [Konten artikel yang sudah ditulis oleh LLM...]
        
        ## Kesimpulan
        [Penutup artikel...]
        """
        
        return AgentResult(
            agent_name=self.name,
            output=article.strip(),
            success=True
        )


class ReviewAgent(BaseAgent):
    """Agen spesialis review dan koreksi konten."""
    
    def __init__(self):
        super().__init__(
            name="ReviewAgent",
            role="Mereview kualitas dan akurasi artikel"
        )
    
    def run(self, task: str, article: str = "") -> AgentResult:
        print(f"[{self.name}] Sedang mereview artikel...")
        
        # Simulasi proses review
        issues = []
        
        if len(article) < 100:
            issues.append("Artikel terlalu pendek")
        
        if "##" not in article:
            issues.append("Tidak ada heading section")
        
        feedback = {
            "approved": len(issues) == 0,
            "issues": issues,
            "suggestions": ["Tambahkan contoh kode", "Perjelas bagian kesimpulan"]
        }
        
        result = f"Review selesai. Approved: {feedback['approved']}\n"
        result += f"Issues: {', '.join(feedback['issues']) if feedback['issues'] else 'Tidak ada'}"
        
        return AgentResult(
            agent_name=self.name,
            output=result,
            success=True
        )

Membuat Orchestrator

class ContentOrchestrator:
    """
    Orchestrator yang mengkoordinasikan semua agen.
    Ini adalah 'manajer' dalam tim agen kita.
    """
    
    def __init__(self):
        # Inisialisasi semua agen
        self.research_agent = ResearchAgent()
        self.writer_agent = WriterAgent()
        self.review_agent = ReviewAgent()
        
        print("Orchestrator siap dengan 3 agen:")
        print(f"  - {self.research_agent}")
        print(f"  - {self.writer_agent}")
        print(f"  - {self.review_agent}")
        print()
    
    def create_article(self, topic: str) -> dict:
        """
        Pipeline lengkap: riset → tulis → review
        Ini adalah pola Sequential yang paling umum dipakai.
        """
        print(f"=== Memulai pipeline untuk topik: '{topic}' ===\n")
        results = {}
        
        # Langkah 1: Riset
        research = self.research_agent.run(topic)
        results["research"] = research
        
        if not research.success:
            return {"error": "Riset gagal", "results": results}
        
        # Langkah 2: Tulis artikel berdasarkan hasil riset
        article = self.writer_agent.run(
            task=topic,
            research_result=research.output
        )
        results["article"] = article
        
        if not article.success:
            return {"error": "Penulisan gagal", "results": results}
        
        # Langkah 3: Review artikel
        review = self.review_agent.run(
            task=topic,
            article=article.output
        )
        results["review"] = review
        
        print("\n=== Pipeline selesai! ===")
        return {
            "success": True,
            "topic": topic,
            "results": results
        }


# Jalankan sistem
if __name__ == "__main__":
    orchestrator = ContentOrchestrator()
    hasil = orchestrator.create_article("Cara Kerja Machine Learning")
    
    print("\n--- HASIL AKHIR ---")
    print(f"Topik: {hasil['topic']}")
    print(f"Status: {'Berhasil' if hasil['success'] else 'Gagal'}")
    print("\nArtkel yang dibuat:")
    print(hasil['results']['article'].output)

Output yang Diharapkan

Orchestrator siap dengan 3 agen:
  - Agent(name=ResearchAgent, role=Mengumpulkan dan merangkum informasi...)
  - Agent(name=WriterAgent, role=Menulis artikel berdasarkan hasil riset)
  - Agent(name=ReviewAgent, role=Mereview kualitas dan akurasi artikel)

=== Memulai pipeline untuk topik: 'Cara Kerja Machine Learning' ===

[ResearchAgent] Sedang meneliti: Cara Kerja Machine Learning
[WriterAgent] Sedang menulis artikel tentang: Cara Kerja Machine Learning
[ReviewAgent] Sedang mereview artikel...

=== Pipeline selesai! ===

Konsep Percabangan dan Perulangan di Python sangat berguna di sini — kamu bisa lihat bagaimana logika if/else digunakan di ReviewAgent untuk memvalidasi artikel dan di ContentOrchestrator untuk menghentikan pipeline jika salah satu langkah gagal.

Troubleshooting: Error yang Sering Muncul

RecursionError: Maximum recursion depth exceeded

Penyebab: Agen memanggil dirinya sendiri secara tidak terbatas, biasanya karena kondisi berhenti (stopping condition) tidak terdefinisi dengan benar di loop pengambilan keputusan agen.

Solusi:

class BaseAgent:
    def __init__(self, name: str, role: str, max_iterations: int = 10):
        self.name = name
        self.role = role
        self.max_iterations = max_iterations
        self._iteration_count = 0
    
    def run(self, task: str) -> AgentResult:
        # Selalu tambahkan batas iterasi!
        if self._iteration_count >= self.max_iterations:
            return AgentResult(
                agent_name=self.name,
                output="Batas iterasi maksimum tercapai",
                success=False
            )
        self._iteration_count += 1
        # Lanjutkan logika agen...

TypeError: run() missing required argument

Penyebab: Orchestrator memanggil agen dengan parameter yang salah atau tidak lengkap. Ini sering terjadi saat struktur AgentResult berubah tapi kode pemanggil belum diupdate.

Solusi:

# SALAH — tidak ada fallback untuk parameter opsional
def run(self, task: str, research_result: str):  # research_result wajib!
    pass

# BENAR — beri nilai default
def run(self, task: str, research_result: str = "") -> AgentResult:
    if not research_result:
        research_result = "Tidak ada data riset sebelumnya."
    # Lanjutkan logika...

Agent Timeout / Agen Tidak Merespons

Penyebab: Agen terjebak menunggu respons dari API eksternal (seperti LLM) yang lambat atau tidak merespons, sehingga seluruh pipeline berhenti.

Solusi:

import asyncio
from concurrent.futures import TimeoutError

async def run_with_timeout(agent, task: str, timeout_seconds: int = 30):
    """Jalankan agen dengan batas waktu maksimum."""
    try:
        # Bungkus eksekusi agen dengan timeout
        result = await asyncio.wait_for(
            asyncio.to_thread(agent.run, task),
            timeout=timeout_seconds
        )
        return result
    except asyncio.TimeoutError:
        print(f"[WARNING] {agent.name} timeout setelah {timeout_seconds} detik")
        return AgentResult(
            agent_name=agent.name,
            output="Timeout — coba lagi nanti",
            success=False
        )

# Cara pakai:
# result = await run_with_timeout(research_agent, "topik riset", timeout_seconds=60)

State Tidak Sinkron Antar Agen

Penyebab: Dua agen menulis ke memori bersama secara bersamaan (race condition), menyebabkan data rusak atau inkonsisten. Ini sering terjadi saat menjalankan agen secara paralel tanpa manajemen state yang benar.

Solusi:

import threading

class SharedMemory:
    """Memori bersama yang thread-safe untuk semua agen."""
    
    def __init__(self):
        self._data = {}
        self._lock = threading.Lock()  # Kunci untuk mencegah konflik
    
    def write(self, key: str, value: str):
        with self._lock:  # Hanya satu agen yang bisa menulis sekaligus
            self._data[key] = value
            print(f"[Memory] Disimpan: {key}")
    
    def read(self, key: str) -> Optional[str]:
        with self._lock:
            return self._data.get(key)

# Pakai shared memory di orchestrator
shared_mem = SharedMemory()
shared_mem.write("research_result", "Hasil riset dari ResearchAgent...")
hasil_riset = shared_mem.read("research_result")

Pertanyaan yang Sering Diajukan

Apa perbedaan arsitektur berbasis agen dengan microservices biasa?

Microservices adalah pendekatan arsitektur untuk memecah aplikasi menjadi layanan kecil yang independen, biasanya berkaitan dengan fungsi bisnis. Arsitektur berbasis agen lebih spesifik ke sistem AI, di mana setiap agen punya kemampuan untuk berpikir, membuat keputusan, dan mengambil tindakan secara otonom berdasarkan konteks dan tujuan yang diberikan.

Bagaimana cara memilih antara pola Sequential dan Parallel untuk agen?

Gunakan Sequential ketika output satu agen menjadi input agen berikutnya (seperti riset → tulis → review). Gunakan Parallel ketika tugas-tugasnya independen dan tidak saling bergantung — misalnya, dua agen yang meneliti dua topik berbeda secara bersamaan untuk menghemat waktu.

Apakah arsitektur berbasis agen selalu membutuhkan model AI seperti GPT atau Claude?

Tidak harus. Agen bisa berupa kode biasa yang mengikuti aturan tertentu (rule-based agent). Namun, kombinasi dengan model AI membuat agen jauh lebih fleksibel karena bisa memahami instruksi dalam bahasa natural dan menangani skenario yang tidak terprediksi sebelumnya.

Mengapa pipeline saya lambat padahal sudah pakai beberapa agen?

Kemungkinan besar kamu menjalankan semua agen secara sequential padahal sebagian bisa dijalankan paralel. Periksa apakah ada dependensi yang sebenarnya tidak perlu — jika dua agen tidak saling membutuhkan output satu sama lain, jalankan keduanya bersamaan menggunakan asyncio atau threading.

Berapa banyak agen yang ideal untuk satu sistem?

Tidak ada angka pasti, tapi prinsipnya: mulai dari yang paling sedikit. Dua atau tiga agen sudah cukup untuk kebanyakan kasus. Tambahkan agen baru hanya ketika ada kebutuhan spesialisasi yang jelas. Terlalu banyak agen justru membuat sistem sulit di-debug dan di-maintain.

Kesimpulan

Arsitektur berbasis agen adalah cara modern untuk membangun sistem AI yang kompleks dengan membagi tanggung jawab ke beberapa agen spesialis. Kunci utamanya adalah:

• Satu agen, satu tanggung jawab — setiap agen fokus pada tugasnya
• Orchestrator sebagai koordinator — yang mengatur alur dan komunikasi antar agen
• Memory bersama — untuk menjaga sinkronisasi state antar agen
• Penanganan error yang robust — termasuk timeout, batas iterasi, dan validasi output

Dengan memahami konsep ini, kamu sudah siap membangun pipeline AI yang lebih canggih — misalnya sistem otomatisasi konten seperti yang dipakai KamusNgoding sendiri, atau chatbot cerdas yang bisa melakukan riset dan menjawab pertanyaan secara otonom.

Selamat belajar dan terus bereksperimen! Arsitektur berbasis agen adalah salah satu topik paling menarik di dunia AI saat ini — jangan ragu untuk eksplorasi lebih dalam dan temukan artikel-artikel relevan lainnya di KamusNgoding.