Apa Itu AI Agent dan Bagaimana Cara Kerjanya

Jika kamu pernah membuat integrasi OpenAI API atau LLM di aplikasi backend, alurnya biasanya cukup simpel: menerima input teks dari pengguna, mengirimkan prompt ke API, lalu menampilkan balasan teks. Pendekatan ini berfungsi baik untuk use case sederhana seperti merangkum artikel, menjawab pertanyaan umum, atau menerjemahkan bahasa.

Namun ketika aplikasi membutuhkan eksekusi tugas yang kompleks—misalnya "Analisis data transaksi pelanggan X yang gagal dalam 24 jam terakhir, cari tahu penyebabnya dari log sistem, lalu kirim email pemberitahuan ke tim support"—LLM biasa akan langsung menemui jalan buntu. LLM pasif tidak memiliki akses langsung ke database aplikasi, tidak bisa membaca log server secara real-time, dan tidak bisa mengeksekusi fungsi backend secara otomatis.

Di sinilah AI Agent masuk. Pergeseran dari sekadar prompt engineering pasif menuju agentic workflow mengubah cara kita membangun aplikasi berbasis kecerdasan buatan. AI Agent bukan lagi sekadar pemroses teks, melainkan sistem otonom yang mampu berpikir, membuat rencana, memanggil tool internal backend, dan mengeksekusi tugas hingga selesai.

Artikel ini akan mengupas tuntas apa itu AI Agent, bagaimana arsitekturnya bekerja, alur siklus ReAct (Reasoning + Acting), serta bagaimana cara mengimplementasikannya dalam ekosistem PHP dan Laravel.

Apa Itu AI Agent?

AI Agent adalah sistem perangkat lunak berbasis Large Language Model (LLM) yang dirancang untuk mencapai tujuan tertentu (goal-driven) secara otonom. Berbeda dari chatbot konvensional, AI Agent dilengkapi dengan kemampuan membuat keputusan (reasoning), mengingat konteks eksternal (memory), dan berinteraksi dengan dunia luar melalui pemanggilan fungsi atau API (tool calling).

Jika LLM standar dianalogikan sebagai seorang konsultan yang hanya bisa menjawab pertanyaan berdasarkan pengetahuan di kepalanya, AI Agent adalah seorang staf eksekutif yang dibekali akses ke komputer, database, dan alat kerja untuk menyelesaikan tugas secara langsung.

Karakteristik Utama AI Agent

Sebuah sistem dapat dikategorikan sebagai AI Agent jika memiliki tiga karakteristik dasar:

1. Otonom (Autonomous & Goal-driven): Agent menerima sebuah instruksi akhir (goal), lalu menentukan sendiri langkah-langkah mikro yang perlu diambil tanpa perlu dipandu manusia pada setiap langkahnya.
2. Adaptif & Memiliki Pengindraan (Perceptive & Adaptive): Agent menerima balasan dari sistem eksternal (observation), menganalisis apakah langkah sebelumnya berhasil, dan menyesuaikan taktik jika terjadi error.
3. Memiliki Akses Alat (Tool-Enabled): Agent dapat memanggil fungsi eksternal seperti query database, HTTP request ke REST API, membaca berkas di disk, atau mengeksekusi script backend.

Perbedaan LLM Biasa vs AI Agent

Memahami perbedaan antara LLM pasif dan AI Agent sangat penting agar developer tidak salah memilih arsitektur saat membangun fitur AI.

Arsitektur & Komponen Utama AI Agent

Secara teknis, arsitektur AI Agent terdiri dari empat komponen utama yang saling terhubung dalam satu sistem terintegrasi.

1. Perception (Pengindraan / Input Processing)

Perception adalah pintu masuk tempat Agent menerima instruksi. Input ini bisa berupa prompt langsung dari pengguna di antarmuka obrolan, pesan dari message bus (seperti RabbitMQ atau Redis Queue), maupun panggilan webhook dari sistem eksternal.

2. Brain / Reasoning Engine (LLM)

Otak dari Agent adalah LLM itu sendiri (seperti GPT-4o, Claude 3.5 Sonnet, atau model open-weight seperti Llama 3). LLM bertugas menganalisis input, menentukan apakah tugas bisa langsung dijawab atau memerlukan tindakan teknis, serta memilih tool mana yang paling tepat untuk digunakan.

3. Memory System

Memori memungkinkan Agent mengingat informasi berharga sepanjang eksekusi:

• Short-Term Memory (Scratchpad): Menyimpan context window percakapan aktif dan riwayat keputusan dalam siklus ReAct yang sedang berjalan. Memori ini hilang begitu tugas selesai.
• Long-Term Memory: Menggunakan database eksternal—seperti Vector Database (Qdrant, Pinecone, pgvector) atau RDBMS (MySQL/PostgreSQL)—untuk menyimpan dokumen dan riwayat historis. Agent mengambil memori ini menggunakan pola RAG (Retrieval-Augmented Generation).

4. Tool Execution / Action Interface

Tools adalah fungsi-fungsi native pada backend aplikasi yang diekspos ke Agent dalam bentuk skema deklaratif (biasanya JSON Schema). LLM tidak mengeksekusi kode tersebut secara langsung di server; LLM hanya menghasilkan payload JSON yang berisi nama fungsi dan argumen yang ingin dipanggil. Backend kamu yang bertanggung jawab menerima payload tersebut, mengeksekusi kodenya secara aman, lalu mengembalikan hasilnya ke Agent.

Cara Kerja AI Agent: Siklus ReAct (Reasoning + Acting)

Salah satu pola paling populer dan efektif yang mendasari alur kerja AI Agent adalah ReAct Framework (Reasoning and Acting), yang diperkenalkan oleh Yao et al. (2022).

Dalam ReAct framework, Agent menggabungkan penalaran verbal (Thought) dan eksekusi tindakan (Action) secara bergantian.

Detail Langkah Siklus ReAct

1. Thought (Penalaran): Agent membaca goal dan riwayat scratchpad, lalu menuliskan analisis internalnya. Contoh: "Saya perlu mengecek status pembayaran pesanan #ORD-1092. Pertama, saya harus memanggil fungsi get_order_details."
2. Action (Tindakan): Agent mengirimkan struktur data pemanggilan fungsi ke backend. Contoh: {"tool": "get_order_details", "params": {"order_id": "ORD-1092"}}.
3. Observation (Pengamatan): Backend menerima panggilan tersebut, menjalankan fungsi PHP yang relevan (misal query ke database MySQL), lalu mengembalikan output data ke Agent. Contoh: {"status": "failed", "reason": "insufficient_balance"}.
4. Repeat / Final Answer: Agent membaca hasil pengamatan. Jika data masih belum cukup untuk menyelesaikan tugas, Agent akan kembali ke tahap Thought untuk memanggil tool lain. Jika sudah cukup, Agent akan menyusun Final Answer untuk pengguna.

Landscape Framework & Ekosistem

Saat ini ekosistem AI Agent didominasi oleh bahasa Python dan JavaScript/TypeScript, namun ekosistem PHP juga telah memiliki perkakas yang sangat matang untuk membangun AI Agent tingkat produksi.

• Ekosistem Python / TypeScript:
  • LangChain / LangGraph: Framework paling populer untuk orchestration agentic yang kompleks dan stateful multi-agent system.
  • CrewAI & AutoGen: Framework berfokus pada kolaborasi antar-agent (multi-agent orchestration).
• Ekosistem CLI & Coding Agents:
  • OpenCode, Claude Code, Aider: Tool pengembang berbasis CLI yang memanfaatkan pemanggilan fungsi untuk membaca, mengedit, dan mengeksekusi perintah di repository proyek secara langsung.
• Ekosistem PHP / Laravel:
  • Prism PHP (echolabsdev/prism): Package terpopuler dan paling abstrak di ekosistem Laravel untuk berinteraksi dengan multi-provider LLM (OpenAI, Anthropic, Ollama, Gemini) serta menyediakan API yang bersih untuk Tool Calling.
  • OpenAI PHP Client (openai-php/client): SDK native PHP untuk berinteraksi langsung dengan OpenAI API jika kamu membutuhkan kontrol tingkat rendah (low-level control).

Implementasi Praktis AI Agent di PHP / Laravel

Mari kita bangun sebuah AI Agent sederhana menggunakan PHP dan framework Laravel. Agent ini bertugas sebagai Asisten Support Transaksi yang mampu mencari data pelanggan dan mengecek status transaksi yang bermasalah.

Dalam contoh ini, kita akan menggunakan Prism PHP (echolabsdev/prism) untuk abstraksi Tool Calling, serta membangun alur ReAct loop mandiri dengan pengaman max steps iteration.

1. Instalasi Package

Pastikan proyek Laravel kamu telah terpasang package Prism:

composer require echolabsdev/prism
php artisan prism:install

Atur API Key di berkas .env:

OPENAI_API_KEY=sk-proj-your-openai-api-key

2. Mendefinisikan Tools

Di Laravel, kita bisa membuat Tool menggunakan kelas native Prism. Kita buat dua tool: SearchCustomerTool dan GetTransactionStatusTool.

Create app/Tools/SearchCustomerTool.php:

<?php

namespace App\Tools;

use EchoLabs\Prism\Tool;
use App\Models\User;

class SearchCustomerTool
{
    public static function make(): Tool
    {
        return Tool::as('search_customer')
            ->for('Cari data ID dan informasi dasar pelanggan berdasarkan alamat email')
            ->withStringParameter('email', 'Email unik milik pelanggan')
            ->using(function (string $email): string {
                // Parameter validation
                if (! filter_var($email, FILTER_VALIDATE_EMAIL)) {
                    return json_encode([
                        'error' => true,
                        'message' => 'Format email tidak valid.',
                    ]);
                }

                $user = User::where('email', $email)->first(['id', 'name', 'email', 'status']);

                if (! $user) {
                    return json_encode([
                        'found' => false,
                        'message' => 'Pelanggan dengan email tersebut tidak ditemukan.',
                    ]);
                }

                return json_encode([
                    'found' => true,
                    'customer_id' => $user->id,
                    'name' => $user->name,
                    'email' => $user->email,
                    'account_status' => $user->status,
                ]);
            });
    }
}

Create app/Tools/GetTransactionStatusTool.php:

<?php

namespace App\Tools;

use EchoLabs\Prism\Tool;
use App\Models\Transaction;

class GetTransactionStatusTool
{
    public static function make(): Tool
    {
        return Tool::as('get_transaction_status')
            ->for('Ambil daftar transaksi terakhir berdasarkan customer_id')
            ->withNumberParameter('customer_id', 'ID integer milik pelanggan')
            ->using(function (int|string $customerId): string {
                $customerId = (int) $customerId;
                if ($customerId <= 0) {
                    return json_encode([
                        'error' => true,
                        'message' => 'Customer ID harus bernilai positif.',
                    ]);
                }

                $transactions = Transaction::where('user_id', $customerId)
                    ->latest()
                    ->take(3)
                    ->get(['id', 'amount', 'status', 'failure_reason', 'created_at']);

                if ($transactions->isEmpty()) {
                    return json_encode([
                        'found' => false,
                        'message' => 'Tidak ada riwayat transaksi untuk pelanggan ini.',
                    ]);
                }

                return json_encode([
                    'found' => true,
                    'transactions' => $transactions->toArray(),
                ]);
            });
    }
}

3. Membangun Agent Service & ReAct Loop Handler

Sekarang buat kelas service app/Services/CustomerSupportAgent.php yang mengatur alur iterasi ReAct loop dan mengamankan eksekusi dari risiko infinite loop.

<?php

namespace App\Services;

use App\Tools\GetTransactionStatusTool;
use App\Tools\SearchCustomerTool;
use EchoLabs\Prism\Enums\Provider;
use EchoLabs\Prism\Prism;
use EchoLabs\Prism\ValueObjects\Messages\AssistantMessage;
use EchoLabs\Prism\ValueObjects\Messages\SystemMessage;
use EchoLabs\Prism\ValueObjects\Messages\UserMessage;
use EchoLabs\Prism\ValueObjects\Messages\ToolResultMessage;
use EchoLabs\Prism\ValueObjects\ToolResult;
use Illuminate\Support\Facades\Log;
use RuntimeException;

class CustomerSupportAgent
{
    /**
     * Jalankan Agent dengan siklus ReAct & batasan batas langkah eksekusi.
     */
    public function run(string $userGoal, int $maxSteps = 5): string
    {
        $systemPrompt = <<<TEXT
Kamu adalah Asisten Support Teknis internal yang ramah dan teliti.
Tugas kamu adalah membantu menganalisis masalah pelanggan menggunakan tools yang tersedia.

Aturan Utama:
1. Selalu gunakan tool 'search_customer' terlebih dahulu untuk menemukan customer_id dari email.
2. Setelah mendapat customer_id, gunakan 'get_transaction_status' untuk mengecek riwayat transaksi.
3. Berikan jawaban akhir yang jelas, padat, dan solutif berdasarkan hasil pengamatan tools.
4. Jangan pernah mengarang data transaksi atau ID yang tidak dikembalikan oleh tools.
TEXT;

        $messages = [
            new SystemMessage($systemPrompt),
            new UserMessage($userGoal),
        ];

        $tools = [
            SearchCustomerTool::make(),
            GetTransactionStatusTool::make(),
        ];

        $stepCount = 0;

        while ($stepCount < $maxSteps) {
            $stepCount++;
            Log::info("AI Agent Iteration Step {$stepCount}");

            $response = Prism::text()
                ->using(Provider::OpenAI, 'gpt-4o')
                ->withMessages($messages)
                ->withTools($tools)
                ->withMaxSteps(1) // Jalankan 1 step penalaran per iterasi kontrol lokal
                ->generate();

            // Jika LLM mengembalikan teks balasan tanpa dipicu tool call tambahan
            if (! empty($response->text) && empty($response->toolCalls)) {
                Log::info("AI Agent berhasil menyelesaikan tugas pada step {$stepCount}");
                return $response->text;
            }

            // Simpan pesan balasan dari assistant ke riwayat percakapan (Scratchpad)
            if (! empty($response->text)) {
                $messages[] = new AssistantMessage($response->text);
            }

            // Jalankan Tool Call jika dipicu oleh LLM
            if (! empty($response->toolCalls)) {
                $toolResults = [];

                foreach ($response->toolCalls as $toolCall) {
                    Log::info("Agent memanggil tool: {$toolCall->name}", $toolCall->arguments);

                    $result = $this->executeTool($tools, $toolCall->name, $toolCall->arguments);

                    $toolResults[] = new ToolResult(
                        toolCallId: $toolCall->id,
                        toolName: $toolCall->name,
                        args: $toolCall->arguments,
                        result: $result
                    );
                }

                // Tambahkan hasil pengamatan (Observation) ke context window agent
                $messages[] = new ToolResultMessage($toolResults);
            }
        }

        // Pengaman jika Agent melebihi batas iterasi yang diizinkan
        Log::warning("AI Agent dihentikan: Mencapai batas maksimal {$maxSteps} langkah.");
        throw new RuntimeException("Agent gagal menyelesaikan tugas dalam {$maxSteps} langkah. Silakan coba perjelas instruksi kamu.");
    }

    /**
     * Eksekusi fungsi tool yang cocok secara aman.
     */
    private function executeTool(array $tools, string $name, array $arguments): string
    {
        foreach ($tools as $tool) {
            if ($tool->name() === $name) {
                try {
                    return $tool->handle($arguments);
                } catch (\Throwable $e) {
                    Log::error("Error eksekusi tool {$name}: " . $e->getMessage());
                    return json_encode([
                        'error' => true,
                        'message' => 'Terjadi kesalahan sistem saat menjalankan fungsi ini: ' . $e->getMessage(),
                    ]);
                }
            }
        }

        return json_encode([
            'error' => true,
            'message' => "Tool '{$name}' tidak ditemukan.",
        ]);
    }
}

Native ReAct Loop di Prism PHP vs Loop Manual

Sebagai catatan, Prism PHP secara bawaan (out of the box) mendukung siklus ReAct otonom internal saat kamu memanggil withMaxSteps(5) langsung pada eksekusi fluent tanpa perlu membuat while loop manual:

use EchoLabs\Prism\Prism;
use EchoLabs\Prism\Enums\Provider;

// Pendekatan Native Prism PHP (Otonom)
$response = Prism::text()
    ->using(Provider::OpenAI, 'gpt-4o')
    ->withSystemPrompt($systemPrompt)
    ->withPrompt($userGoal)
    ->withTools($tools)
    ->withMaxSteps(5) // Prism menangani pemanggilan tool dan ReAct loop secara internal
    ->generate();

return $response->text;

Implementasi while loop manual pada kelas CustomerSupportAgent di atas sengaja dihadirkan untuk memberikan ilustrasi transparan bagaimana pesan AssistantMessage, struktur pemanggilan ToolCall, serta objek ToolResult dan ToolResultMessage saling bertukar informasi di dalam memori scratchpad Agent.

4. Menjalankan Agent via Artisan Command / Controller

Kamu dapat memanggil service tersebut langsung dari Controller atau Artisan Command:

use App\Services\CustomerSupportAgent;

$agent = new CustomerSupportAgent();

$result = $agent->run(
    "Tolong periksa mengapa transaksi terakhir milik pelanggan dengan email 'budi@example.com' gagal."
);

echo $result;

Tantangan & Pitfalls Pengembangan AI Agent

Membangun AI Agent di lingkungan produksi memiliki kompleksitas yang jauh lebih tinggi daripada sekadar memanggil API pencetak teks. Berikut adalah beberapa masalah klasik yang sering ditemui developer beserta penjelasannya:

1. Infinite Loop (Agent Macet dalam ReAct Loop)

• Sebab: Ketika sebuah tool mengembalikan respon error, Agent terkadang bingung dan memanggil tool yang sama dengan parameter yang sama secara terus-menerus.
• Akibat: Aplikasi hanging, waktu eksekusi habis (timeout), dan kuota API LLM terkuras habis.
• Solusi: Selalu tetapkan batas ketat max_steps (misal 5–10 langkah). Berikan instruksi di system prompt agar Agent menghentikan proses dan melapor ke pengguna jika tool yang sama gagal dipanggil 2 kali berturut-turut.

2. Hallucination & Invalid Tool Parameters

• Sebab: LLM terkadang menghasilkan struktur JSON yang tidak sesuai dengan skema parameter yang diharapkan oleh fungsi backend (misalnya mengirimkan teks "dua puluh" pada parameter ber-tipe integer).
• Solusi: Terapkan tipe data ketat dan validasi parameter (seperti filter_var atau Laravel Form Request Validation) di dalam penanganan tool sebelum mengeksekusi logika bisnis atau database query.

3. Context Window Overflow & High Token Cost

• Sebab: Setiap iterasi dalam ReAct loop akan menumpuk riwayat percakapan (Thought, Action, dan hasil Observation). Jika sebuah tool mengembalikan data JSON mentah berukuran besar (misal 5.000 baris array database), ukuran prompt context akan melonjak drastis.
• Solusi: Potong (truncate) hasil keluaran tool sebelum dikirimkan kembali ke Agent, atau rangkum data berukuran besar menggunakan mekanisme RAG / Vector Database.

4. Keamanan & Prompt Injection (Unauthorized Action Execution)

• Sebab: Input dari pengguna yang jahat (prompt injection) bisa berusaha mengelabui Agent agar memanggil tool sensitif yang tidak seharusnya diakses.
• Solusi: Terapkan prinsip Least Privilege pada API key atau hak akses database yang digunakan oleh tool. Untuk aksi-aksi destruktif (seperti menghapus akun atau mentransfer uang), gunakan pola Human-in-the-Loop (wajibkan konfirmasi manual dari pengguna).

Best Practices Mengembangkan AI Agent di Production

Jika kamu berencana mendeploy fitur AI Agent ke server produksi, ikuti panduan praktis berikut:

1. Gunakan Asynchronous Queue Workers: Eksekusi AI Agent yang memerlukan beberapa langkah ReAct loop bisa memakan waktu antara 5 hingga 30 detik. Jangan jalankan proses ini secara synchronous di dalam HTTP Request controller. Gunakan Laravel Queue Worker (dengan Redis atau Database queue) dan kirimkan hasilnya ke antarmuka pengguna via WebSocket/Pusher atau Server-Sent Events (SSE). Untuk pengelolaan otomatisasi deployment dan CI/CD server Laravel, kamu bisa mempelajari panduan /cara-deploy-laravel-vps-github-actions serta pengorganisasian cabang di /workflow-git-laravel.
2. Strict Schema Validation: Pastikan setiap tool melakukan parsing dan validasi input yang aman. Jangan pernah mempercayai parameter yang dihasilkan oleh LLM begitu saja.
3. Truncate Tool Outputs: Batasi panjang respon dari tool (maksimal 500–1000 karakter). Jika tool membaca berkas atau log yang panjang, berikan ringkasannya saja ke Agent.
4. Implementasikan Comprehensive Logging & Observability: Catat setiap Thought, Action, dan Observation ke dalam sistem logging aplikasi (seperti Laravel Log channel atau OpenTelemetry). Ini sangat krusial untuk proses debugging saat Agent membuat keputusan yang keliru.
5. Human-in-the-Loop untuk Action Destruktif: Pisahkan tools menjadi dua kategori: Read-only tools (aman dieksekusi otonom) dan Write/Delete tools (membutuhkan sinyal konfirmasi manusia sebelum dieksekusi).

Penutup

AI Agent mewakili evolusi penting dalam arsitektur perangkat lunak berbasis kecerdasan buatan. Dengan menggabungkan daya penalaran LLM, memori terstruktur, dan eksekusi tool backend, kita dapat membangun sistem otomasi yang sangat cerdas dan adaptif.

Bagi developer PHP dan Laravel, kehadiran library modern seperti Prism PHP dan SDK OpenAI memudahkan kita dalam mengadopsi pola arsitektur ini secara elegan tanpa harus meninggalkan keunggulan ekosistem backend PHP yang stabil dan tepercaya.

Mulailah dengan membangun AI Agent berskala kecil yang menangani tugas read-only sederhana, batasi max steps eksekusi dengan aman, dan rasakan bagaimana agentic workflow dapat meningkatkan kapabilitas aplikasi kamu.

Referensi Tepercaya

• Yao, S., et al. (2022). ReAct: Synergizing Reasoning and Acting in Language Models. arXiv:2210.03629.
• Prism PHP Documentation: https://prism.echolabs.dev
• OpenAI API Reference - Function Calling & Agents: https://platform.openai.com/docs/guides/function-calling
• Anthropic Claude Documentation - Tool Use: https://docs.anthropic.com/en/docs/build-with-claude/tool-use