Panduan Lengkap Multi-Agent System di AutoGen

Pendahuluan

Bayangkan kamu sedang membangun sebuah sistem kompleks — misalnya platform analitik seperti yang digunakan Tokopedia untuk memproses jutaan transaksi. Satu agen AI saja tidak cukup untuk menangani semua pekerjaan: ada yang bertugas menganalisis data, ada yang menulis kode, ada yang melakukan review, dan ada yang memastikan output sudah benar. Di sinilah Multi-Agent System hadir sebagai solusi.

AutoGen adalah framework open-source dari Microsoft yang dirancang khusus untuk membangun sistem multi-agent yang kompleks. Berbeda dengan pendekatan single-agent biasa, AutoGen memungkinkan beberapa agen AI berkolaborasi, berdiskusi, dan saling mengkritisi hasil kerja satu sama lain — persis seperti tim developer yang bekerja bersama.

Artikel ini membahas arsitektur internal AutoGen, cara implementasi group chat, hingga integrasi tools eksternal dan human-in-the-loop. Jika kamu sudah familiar dengan konsep dasar AI Agent (seperti yang dibahas di artikel Apa itu AI Agent? Panduan Lengkap untuk Pemula), kamu siap untuk naik level ke multi-agent orchestration.

Prasyarat dan Instalasi

Sebelum mulai, pastikan kamu sudah menginstall dependensi yang dibutuhkan:

pip install pyautogen openai

Simpan API key di environment variable agar tidak hardcoded:

# Linux/macOS
export OPENAI_API_KEY="sk-..."

# Windows (PowerShell)
$env:OPENAI_API_KEY="sk-..."

Arsitektur dan Konsep Inti Multi-Agent di AutoGen

AutoGen memiliki dua kelas utama yang menjadi fondasi semua interaksi:

ConversableAgent — Induk Semua Agen

Semua agen di AutoGen merupakan turunan dari ConversableAgent. Kelas ini mengelola:

• Memori percakapan (conversation history)
• System prompt dan persona agen
• Kemampuan eksekusi kode (opsional)
• Integrasi LLM via config

import os
from autogen import ConversableAgent

# Konfigurasi LLM — baca API key dari environment variable
llm_config = {
    "model": "gpt-4o",
    "api_key": os.environ.get("OPENAI_API_KEY"),
    "temperature": 0.1,
}

# Membuat agen dasar
agent = ConversableAgent(
    name="DataAnalyst",
    system_message="Kamu adalah analis data senior. Berikan analisis yang akurat dan terstruktur.",
    llm_config=llm_config,
    human_input_mode="NEVER",
)

AssistantAgent dan UserProxyAgent

Dua subclass paling umum di AutoGen:

import os
from autogen import AssistantAgent, UserProxyAgent

llm_config = {
    "model": "gpt-4o",
    "api_key": os.environ.get("OPENAI_API_KEY"),
    "temperature": 0.1,
}

# AssistantAgent: agen yang menggunakan LLM untuk berpikir dan merespons
assistant = AssistantAgent(
    name="Coder",
    llm_config=llm_config,
    system_message="Kamu adalah software engineer Python senior. Tulis kode yang bersih dan efisien.",
)

# UserProxyAgent: bertindak sebagai perantara manusia atau eksekutor kode
user_proxy = UserProxyAgent(
    name="Executor",
    human_input_mode="NEVER",
    code_execution_config={
        "work_dir": "workspace",
        "use_docker": False,  # gunakan Docker di production untuk isolasi
    },
    max_consecutive_auto_reply=10,
)

# Mulai percakapan dua agen
user_proxy.initiate_chat(
    recipient=assistant,
    message="Buat fungsi Python untuk menghitung statistik deskriptif dari sebuah list angka.",
    max_turns=5,
)

Alur Komunikasi Antar Agen

AutoGen menggunakan pola request-reply berbasis percakapan. Setiap pesan memiliki metadata role (user/assistant) dan name (nama agen pengirim). Agen memutuskan kapan harus berhenti dengan mendeteksi kata kunci seperti "TERMINATE" di dalam respons.

Implementasi Group Chat untuk Kolaborasi Agent

GroupChat adalah fitur inti AutoGen yang memungkinkan lebih dari dua agen berinteraksi dalam satu sesi. Ada satu komponen tambahan: GroupChatManager yang bertugas sebagai orchestrator — memutuskan agen mana yang harus berbicara berikutnya.

Contoh Lengkap: Tim Developer Multi-Agent

Berikut adalah contoh lengkap yang bisa langsung dijalankan — sistem tim developer dengan empat agen yang berkolaborasi:

import os
from autogen import AssistantAgent, UserProxyAgent, GroupChat, GroupChatManager

# Pastikan OPENAI_API_KEY sudah di-set di environment
llm_config = {
    "model": "gpt-4o",
    "api_key": os.environ.get("OPENAI_API_KEY"),
    "temperature": 0,
    "cache_seed": 42,  # cache agar respons identik tidak memanggil API ulang
}

# Agen 1: Planner — merancang arsitektur dan langkah implementasi
planner = AssistantAgent(
    name="Planner",
    system_message="""Kamu adalah arsitek sistem. Tugasmu:
1. Terima requirement dari user
2. Buat rencana langkah-langkah implementasi yang jelas
3. Delegasikan tugas ke Coder dan Reviewer
Selalu akhiri responsmu dengan daftar tugas yang terstruktur.""",
    llm_config=llm_config,
)

# Agen 2: Coder — menulis kode Python berdasarkan rencana
coder = AssistantAgent(
    name="Coder",
    system_message="""Kamu adalah software engineer Python.
Implementasikan sesuai rencana dari Planner.
Tulis kode lengkap yang siap dijalankan.
Gunakan hanya library standar: os, sys, json, datetime, collections.
Gunakan type hints dan docstring.""",
    llm_config=llm_config,
)

# Agen 3: Reviewer — melakukan code review dan memberi feedback
reviewer = AssistantAgent(
    name="Reviewer",
    system_message="""Kamu adalah senior engineer yang melakukan code review.
Periksa: keamanan, performa, dan best practices.
Berikan feedback konstruktif dengan format:
- ISSUE: [masalah yang ditemukan]
- SARAN: [perbaikan yang direkomendasikan]
Jika semua sudah bagus, tulis 'LGTM' lalu 'TERMINATE' di baris terakhir.""",
    llm_config=llm_config,
)

# Agen 4: Executor — menjalankan kode dan melaporkan hasil
executor = UserProxyAgent(
    name="Executor",
    human_input_mode="NEVER",
    code_execution_config={
        "work_dir": "output",
        "use_docker": False,
    },
    is_termination_msg=lambda msg: "TERMINATE" in msg.get("content", ""),
    default_auto_reply="Kode berhasil dieksekusi. Silakan lanjutkan.",
)

# Buat group chat dengan semua agen
groupchat = GroupChat(
    agents=[planner, coder, reviewer, executor],
    messages=[],
    max_round=16,
    speaker_selection_method="auto",  # LLM memilih speaker berikutnya
    allow_repeat_speaker=False,
)

# Manager yang mengorkestrasikan percakapan
manager = GroupChatManager(
    groupchat=groupchat,
    llm_config=llm_config,
)

# Mulai sesi kolaborasi
executor.initiate_chat(
    manager,
    message="""Buat sistem monitoring log sederhana yang:
1. Membaca file teks berisi log (buat contoh data log-nya juga)
2. Mendeteksi baris yang mengandung kata 'ERROR' atau 'CRITICAL'
3. Mencetak ringkasan: total baris, jumlah error, dan daftar error yang ditemukan
""",
)

Strategi Pemilihan Speaker

AutoGen mendukung tiga strategi speaker_selection_method:

Kamu juga bisa membuat custom speaker selection dengan fungsi Python:

def custom_speaker_selection(last_speaker, groupchat):
    """Selalu arahkan ke Reviewer setelah Coder berbicara."""
    messages = groupchat.messages
    if last_speaker.name == "Coder":
        return reviewer
    elif last_speaker.name == "Reviewer":
        last_content = messages[-1]["content"] if messages else ""
        if "LGTM" in last_content:
            return executor
    return "auto"  # fallback ke LLM selection

groupchat = GroupChat(
    agents=[planner, coder, reviewer, executor],
    messages=[],
    max_round=16,
    speaker_selection_method=custom_speaker_selection,
)

Kustomisasi Lanjutan: Human-in-the-Loop dan Tools Eksternal

Human-in-the-Loop

Mode human_input_mode pada UserProxyAgent mengontrol kapan manusia dilibatkan:

import os
from autogen import AssistantAgent, UserProxyAgent

llm_config = {
    "model": "gpt-4o",
    "api_key": os.environ.get("OPENAI_API_KEY"),
    "temperature": 0,
}

# ALWAYS: selalu minta konfirmasi manusia
# NEVER: fully autonomous
# TERMINATE: minta input hanya saat agen ingin berhenti

supervisor = UserProxyAgent(
    name="Supervisor",
    human_input_mode="TERMINATE",  # manusia dikonfirmasi hanya saat agen selesai
    code_execution_config=False,
    is_termination_msg=lambda msg: "TERMINATE" in msg.get("content", ""),
)

assistant = AssistantAgent(
    name="Assistant",
    llm_config=llm_config,
    system_message="Bantu user menyelesaikan tugasnya. Tulis TERMINATE jika sudah selesai.",
)

supervisor.initiate_chat(
    assistant,
    message="Jelaskan perbedaan antara list dan tuple di Python.",
    max_turns=3,
)

Integrasi Tools Eksternal dengan Function Calling

AutoGen mendukung registrasi tools menggunakan register_function — mirip konsep function calling di Panduan Prompt Engineering Tingkat Lanjut:

import os
import json
import requests
from typing import Annotated
from autogen import AssistantAgent, UserProxyAgent, register_function

llm_config = {
    "model": "gpt-4o",
    "api_key": os.environ.get("OPENAI_API_KEY"),
    "temperature": 0,
}

# Definisikan tool sebagai fungsi Python biasa
def get_weather(
    city: Annotated[str, "Nama kota, contoh: Jakarta, Surabaya, Bandung"]
) -> dict:
    """Ambil data cuaca untuk kota tertentu (simulasi)."""
    # Data simulasi — ganti dengan API cuaca nyata di production
    weather_data = {
        "Jakarta": {"suhu": 32, "kondisi": "Cerah berawan", "kelembaban": 75},
        "Surabaya": {"suhu": 34, "kondisi": "Panas terik", "kelembaban": 68},
        "Bandung": {"suhu": 22, "kondisi": "Berkabut", "kelembaban": 85},
    }
    return weather_data.get(city, {"error": f"Data untuk {city} tidak tersedia"})

def analyze_sentiment(
    text: Annotated[str, "Teks untuk dianalisis sentimennya"]
) -> str:
    """Analisis sentimen teks secara sederhana."""
    positive_words = ["bagus", "baik", "senang", "mantap", "keren", "nyaman"]
    negative_words = ["buruk", "jelek", "parah", "rusak", "macet", "banjir"]
    text_lower = text.lower()
    pos_score = sum(1 for w in positive_words if w in text_lower)
    neg_score = sum(1 for w in negative_words if w in text_lower)
    if pos_score > neg_score:
        return "positif"
    elif neg_score > pos_score:
        return "negatif"
    return "netral"

# Agen yang akan menggunakan tools
weather_analyst = AssistantAgent(
    name="WeatherAnalyst",
    llm_config=llm_config,
    system_message="""Kamu adalah analis cuaca. Gunakan tools yang tersedia untuk:
1. Mengambil data cuaca kota yang diminta
2. Menganalisis kondisinya
3. Berikan rekomendasi aktivitas yang sesuai
Tulis TERMINATE setelah memberikan rekomendasi lengkap.""",
)

proxy = UserProxyAgent(
    name="Proxy",
    human_input_mode="NEVER",
    code_execution_config=False,
    is_termination_msg=lambda msg: "TERMINATE" in msg.get("content", ""),
)

# Daftarkan implementasi fungsi
register_function(
    get_weather,
    caller=weather_analyst,
    executor=proxy,
    name="get_weather",
    description="Ambil data cuaca untuk kota tertentu di Indonesia",
)

register_function(
    analyze_sentiment,
    caller=weather_analyst,
    executor=proxy,
    name="analyze_sentiment",
    description="Analisis sentimen dari teks ulasan atau laporan",
)

# Jalankan
proxy.initiate_chat(
    weather_analyst,
    message="Cek cuaca di Jakarta dan Bandung, lalu rekomendasikan kota mana yang lebih nyaman untuk kegiatan outdoor hari ini.",
)

Contoh Kasus Nyata: Pipeline Analisis Laporan Keuangan Otomatis

Berikut contoh lengkap sistem multi-agent untuk menganalisis laporan keuangan — bayangkan kamu ingin membangun sistem seperti yang digunakan fintech Indonesia untuk memproses laporan perusahaan secara otomatis:

import os
from autogen import AssistantAgent, UserProxyAgent, GroupChat, GroupChatManager

llm_config = {
    "model": "gpt-4o",
    "api_key": os.environ.get("OPENAI_API_KEY"),
    "temperature": 0,
    "cache_seed": 42,
}

# Agen 1: mengumpulkan dan memformat data mentah
data_collector = AssistantAgent(
    name="DataCollector",
    system_message="""Kamu adalah data engineer keuangan.
Terima data laporan keuangan dalam format apapun.
Ekstrak dan format ulang ke JSON dengan field berikut:
- revenue (pendapatan)
- net_profit (laba bersih)
- total_assets (total aset)
- total_debt (total utang)
Berikan hasilnya dalam format JSON yang valid.""",
    llm_config=llm_config,
)

# Agen 2: menghitung rasio keuangan
financial_analyst = AssistantAgent(
    name="FinancialAnalyst",
    system_message="""Kamu adalah analis keuangan berpengalaman.
Berdasarkan data JSON dari DataCollector, hitung rasio-rasio berikut:
- ROA = net_profit / total_assets * 100 (%)
- Debt-to-Equity = total_debt / (total_assets - total_debt)
- Net Profit Margin = net_profit / revenue * 100 (%)
Tampilkan hasil perhitungan dan interpretasi singkat setiap rasio.""",
    llm_config=llm_config,
)

# Agen 3: menilai risiko dan memberi rekomendasi
risk_assessor = AssistantAgent(
    name="RiskAssessor",
    system_message="""Kamu adalah manajer risiko investasi.
Berdasarkan analisis FinancialAnalyst:
- Kategorikan risiko keseluruhan: LOW / MEDIUM / HIGH
- Berikan alasan untuk setiap kategori risiko
- Rekomendasikan tindakan: BUY / HOLD / AVOID
- Tulis ringkasan eksekutif 2-3 kalimat
WAJIB tulis TERMINATE di baris terakhir setelah laporan selesai.""",
    llm_config=llm_config,
)

proxy = UserProxyAgent(
    name="ReportGenerator",
    human_input_mode="NEVER",
    code_execution_config=False,
    is_termination_msg=lambda x: "TERMINATE" in x.get("content", ""),
)

# Konfigurasi group chat
groupchat = GroupChat(
    agents=[data_collector, financial_analyst, risk_assessor, proxy],
    messages=[],
    max_round=12,
    speaker_selection_method="round_robin",  # urutan: Collector → Analyst → Assessor
)

manager = GroupChatManager(groupchat=groupchat, llm_config=llm_config)

# Jalankan pipeline analisis
proxy.initiate_chat(
    manager,
    message="""Analisis laporan keuangan PT Contoh Tbk Q3 2024:
- Revenue: Rp 5.200.000.000.000
- Net Profit: Rp 800.000.000.000
- Total Assets: Rp 25.000.000.000.000
- Total Debt: Rp 8.000.000.000.000
""",
)

# Simpan riwayat percakapan ke file JSON untuk dokumentasi
import json
with open("laporan_analisis.json", "w", encoding="utf-8") as f:
    json.dump(groupchat.messages, f, ensure_ascii=False, indent=2)

print(f"\nAnalisis selesai. Riwayat disimpan ke laporan_analisis.json")
print(f"Total giliran percakapan: {len(groupchat.messages)}")

Troubleshooting: Error yang Sering Muncul

openai.RateLimitError saat Group Chat Berjalan

Penyebab: Terlalu banyak agen memanggil API secara bersamaan dalam satu sesi group chat, melampaui rate limit token per menit dari provider LLM.

Solusi:

import os
import time
from autogen import ConversableAgent

llm_config = {
    "model": "gpt-4o",
    "api_key": os.environ.get("OPENAI_API_KEY"),
    "temperature": 0,
    "request_timeout": 120,
    "retry_wait_time": 30,  # tunggu 30 detik sebelum retry otomatis
}

# Override method reply untuk menambahkan delay antar panggilan
class ThrottledAgent(ConversableAgent):
    def generate_reply(self, messages=None, sender=None, **kwargs):
        time.sleep(1.5)  # delay 1.5 detik antar reply
        return super().generate_reply(messages=messages, sender=sender, **kwargs)

# Gunakan ThrottledAgent sebagai pengganti AssistantAgent
coder = ThrottledAgent(
    name="Coder",
    llm_config=llm_config,
    system_message="Kamu adalah software engineer Python senior.",
    human_input_mode="NEVER",
)

GroupChat Tidak Pernah Selesai (max_round Terlampaui)

Penyebab: Tidak ada agen yang mengirimkan sinyal terminasi yang benar, atau kondisi is_termination_msg tidak terdefinisi dengan tepat.

Solusi:

import os
from autogen import AssistantAgent, UserProxyAgent

llm_config = {
    "model": "gpt-4o",
    "api_key": os.environ.get("OPENAI_API_KEY"),
    "temperature": 0,
}

# Fungsi terminasi yang memeriksa berbagai format
def is_termination(msg: dict) -> bool:
    content = msg.get("content", "") or ""
    return any(
        keyword in content.upper()
        for keyword in ["TERMINATE", "SELESAI", "DONE", "FINISHED"]
    )

proxy = UserProxyAgent(
    name="Proxy",
    human_input_mode="NEVER",
    is_termination_msg=is_termination,
    code_execution_config=False,
)

# Tambahkan instruksi terminasi eksplisit di setiap agen
reviewer = AssistantAgent(
    name="Reviewer",
    system_message="""Lakukan review kode yang diberikan.
Berikan feedback konstruktif jika ada masalah.
PENTING: Jika kode sudah baik dan tidak ada perbaikan lagi,
WAJIB tulis kata 'TERMINATE' di baris terakhir responsmu.""",
    llm_config=llm_config,
)

CodeExecutionError: Dependency Tidak Tersedia di Environment

Penyebab: Agen menulis kode yang mengimpor library yang tidak terinstall di environment eksekusi.

Solusi:

import os
from autogen import AssistantAgent, UserProxyAgent

llm_config = {
    "model": "gpt-4o",
    "api_key": os.environ.get("OPENAI_API_KEY"),
    "temperature": 0,
}

# Opsi 1: gunakan Docker untuk isolasi environment yang konsisten
executor = UserProxyAgent(
    name="Executor",
    human_input_mode="NEVER",
    code_execution_config={
        "work_dir": "workspace",
        "use_docker": "python:3.11-slim",  # image Docker dengan library standar
        "timeout": 60,
    },
)

# Opsi 2: beri tahu agen Coder library apa saja yang tersedia
coder = AssistantAgent(
    name="Coder",
    system_message="""Tulis kode Python HANYA menggunakan library yang sudah terinstall:
- Standard library: os, sys, json, datetime, collections, re, math, csv
- Third-party: pandas, numpy, requests
JANGAN gunakan library lain tanpa konfirmasi terlebih dahulu.""",
    llm_config=llm_config,
)

Agen Terus Mengulang Percakapan yang Sama (Infinite Loop)

Penyebab: Speaker selection method "auto" kebingungan karena system message agen tidak cukup jelas membatasi peran masing-masing.

Solusi:

import os
from autogen import AssistantAgent, UserProxyAgent, GroupChat, GroupChatManager

llm_config = {
    "model": "gpt-4o",
    "api_key": os.environ.get("OPENAI_API_KEY"),
    "temperature": 0,
}

planner = AssistantAgent(name="Planner", llm_config=llm_config,
    system_message="Buat rencana saja. Jangan menulis kode.")
coder = AssistantAgent(name="Coder", llm_config=llm_config,
    system_message="Tulis kode saja berdasarkan rencana Planner. Jangan merencanakan.")
reviewer = AssistantAgent(name="Reviewer", llm_config=llm_config,
    system_message="Review kode dari Coder saja. Tulis TERMINATE jika sudah oke.")
proxy = UserProxyAgent(name="Proxy", human_input_mode="NEVER",
    code_execution_config=False,
    is_termination_msg=lambda m: "TERMINATE" in m.get("content", ""))

# Gunakan round_robin untuk workflow yang deterministik
groupchat = GroupChat(
    agents=[planner, coder, reviewer, proxy],
    messages=[],
    max_round=9,  # 3 putaran x 3 agen = 9 round cukup
    speaker_selection_method="round_robin",
    allow_repeat_speaker=False,
)

manager = GroupChatManager(groupchat=groupchat, llm_config=llm_config)
proxy.initiate_chat(manager, message="Buat fungsi untuk membalik string di Python.")

Pertanyaan yang Sering Diajukan

Apa perbedaan AssistantAgent dan UserProxyAgent di AutoGen?

AssistantAgent adalah agen yang sepenuhnya digerakkan oleh LLM — ia berpikir, merespons, dan menghasilkan output berdasarkan system message dan conversation history. Sebaliknya, UserProxyAgent dirancang sebagai perantara antara manusia dan sistem, dengan kemampuan mengeksekusi kode secara langsung di mesin lokal. Dalam praktiknya, UserProxyAgent sering berjalan fully autonomous dengan human_input_mode="NEVER" dan bertugas sebagai “tangan” yang menjalankan instruksi dari AssistantAgent.

Bagaimana cara membatasi biaya API saat menjalankan group chat dengan banyak agen?

Ada beberapa strategi efektif: pertama, batasi max_round sesuai kebutuhan minimal; kedua, gunakan model yang lebih hemat seperti gpt-4o-mini untuk agen dengan tugas sederhana seperti routing; ketiga, aktifkan cache_seed di llm_config agar respons identik tidak memanggil API ulang. Contoh: llm_config = {"model": "gpt-4o", "cache_seed": 42} — AutoGen akan menyimpan cache hasil percakapan secara lokal di folder .cache/.

Apakah AutoGen bisa digunakan dengan model selain OpenAI?

Ya, AutoGen mendukung berbagai LLM provider melalui konfigurasi config_list. Kamu bisa menggunakan Anthropic Claude, Google Gemini, model lokal via Ollama (dengan endpoint kompatibel OpenAI), atau Azure OpenAI. Cukup sesuaikan base_url dan api_key di llm_config — misalnya untuk Ollama: {"model": "llama3", "base_url": "http://localhost:11434/v1", "api_key": "ollama"}.

Bagaimana cara menyimpan riwayat percakapan group chat untuk dianalisis?

import json
from autogen import GroupChat, GroupChatManager

# Setelah sesi selesai, akses history via groupchat.messages
groupchat = GroupChat(agents=[...], messages=[], max_round=20)
manager = GroupChatManager(groupchat=groupchat, llm_config=llm_config)

proxy.initiate_chat(manager, message="Tugas kamu di sini...")

# Simpan ke file JSON dengan encoding UTF-8 untuk mendukung karakter Indonesia
with open("chat_history.json", "w", encoding="utf-8") as f:
    json.dump(groupchat.messages, f, ensure_ascii=False, indent=2)

print(f"Total pesan: {len(groupchat.messages)}")

Apa itu nested chat di AutoGen dan kapan menggunakannya?

Nested chat adalah fitur di mana sebuah agen bisa memulai sub-percakapan internal dengan agen lain sebelum merespons ke group chat utama. Ini berguna ketika satu agen perlu “berkonsultasi” secara privat — misalnya agen Reviewer berkonsultasi ke agen SecurityExpert sebelum memberikan feedback ke group. Gunakan register_nested_chats() untuk mengimplementasikannya, dan pakai fitur ini hanya saat logika agen utama terlalu kompleks untuk dihandle dalam satu percakapan linier karena nested chat menambah jumlah panggilan API secara signifikan.

Kesimpulan

Multi-Agent System di AutoGen membuka paradigma baru dalam membangun aplikasi AI yang kompleks. Dengan memahami arsitektur ConversableAgent, memanfaatkan GroupChat untuk orkestra kolaborasi, mengintegrasikan tools eksternal, dan menambahkan human oversight yang tepat, kamu bisa membangun pipeline AI yang tangguh dan skalabel.

Kunci suksesnya terletak pada desain system message yang jelas untuk setiap agen, strategi terminasi yang eksplisit, dan pemilihan speaker selection method yang sesuai dengan karakteristik workflow kamu. Jika ingin membangun sistem seperti platform analitik otomatis atau asisten riset skala besar, pola multi-agent ini adalah fondasi yang tepat.

Selamat bereksperimen dengan AutoGen — mulai dari contoh sederhana, lalu tingkatkan kompleksitasnya sedikit demi sedikit! Komunitas developer Indonesia semakin berkembang, dan setiap baris kode yang kamu tulis adalah kontribusi nyata bagi ekosistem teknologi kita bersama.