Cara Menghentikan Mengasuh AI: Tips dan Trik

Intisari

Anda berhenti mengawasi agen AI dengan membangun tiga hal: pagar pengaman (kendala yang mencegah kegagalan fatal), observabilitas (log dan metrik yang memberi tahu Anda apa yang terjadi), dan pos pemeriksaan (jeda otomatis di mana manusia memverifikasi keputusan). Setelah ini diatur, agen Anda dapat berjalan secara mandiri selama berjam-jam, bukan hanya beberapa menit. Alat seperti Apidog membantu dengan memungkinkan Anda menentukan kontrak API yang tidak dapat dilanggar oleh agen, mengubah lapisan API Anda menjadi jaring pengaman.

Coba Apidog hari ini

Pendahuluan

Minggu lalu saya melihat seorang pengembang menghabiskan 4 jam mengawasi agen AI yang seharusnya menghemat waktunya. Setiap beberapa menit, dia akan menginterupsi, memperbaiki kesalahan, dan memulai ulang. Pada akhirnya, dia melakukan lebih banyak pekerjaan manual daripada jika dia menulis kodenya sendiri.

Ini adalah masalah pengawasan, dan ini adalah alasan #1 mengapa agen AI gagal memenuhi janjinya. Alatnya berfungsi. Modelnya mampu. Tetapi sebagian besar tim tidak pernah melewati fase pengawasan terus-menerus.

Inilah yang terjadi: sebagian besar pengaturan agen AI memperlakukan LLM seperti pengembang junior yang membutuhkan bimbingan untuk setiap tugas. Tetapi LLM bukanlah junior. Mereka lebih seperti magang yang sangat cepat, terkadang berhalusinasi, yang akan dengan percaya diri melakukan hal yang salah jika Anda tidak menetapkan batasan.

💡 Jika Anda membangun API atau bekerja dengan agen AI yang memanggil API, Apidog membantu Anda menentukan batasan tersebut. Dengan menentukan skema permintaan/respons yang tepat, Anda membuat kontrak yang tidak dapat dilanggar secara tidak sengaja oleh agen. Ini seperti memberi agen Anda peta daripada membiarkannya berkeliaran.

Definisikan kontrak API yang dapat diikuti agen AI Anda

Pada akhir panduan ini, Anda akan memiliki:

• Model mental untuk memikirkan otonomi agen
• Pola konkret untuk pagar pengaman, observabilitas, dan pos pemeriksaan
• Contoh kode yang dapat Anda salin ke proyek Anda hari ini
• Daftar periksa untuk mengevaluasi apakah agen siap berjalan tanpa pengawasan

Mengapa Agen Memerlukan Pengawasan Terus-Menerus

Agen AI gagal dengan cara yang dapat diprediksi. Memahami mode kegagalan ini adalah langkah pertama untuk memperbaikinya.

Mode Kegagalan 1: Pelebaran Ruang Lingkup

Anda meminta agen untuk “menambahkan autentikasi ke titik akhir API.” Agen menambahkan autentikasi. Kemudian menambahkan pembatasan laju. Lalu refaktor skema basis data. Lalu menghapus file yang dianggap tidak terpakai, padahal penting.

Agen terus berjalan karena tidak ada yang menyuruhnya berhenti. LLM tidak memiliki pengertian "selesai" bawaan. Mereka akan terus melakukan perubahan sampai batas token tercapai atau Anda menginterupsi.

Mode Kegagalan 2: Abstraksi yang Salah

Agen yang bertugas "meningkatkan penanganan kesalahan" mungkin hanya menambah blok try-catch di mana-mana. Secara teknis benar, tetapi implementasi menjadi tidak praktis.

Mode Kegagalan 3: Kegagalan Berjenjang

Kesalahan kecil di awal menjadi masalah besar di akhir. Agen tidak tahu itu gagal karena setiap langkah tampak masuk akal secara terpisah.

Mode Kegagalan 4: Kelelahan Sumber Daya

Agen bisa berulang tanpa henti—mengulang retry API, membuat sub-agen tanpa batas, atau menghasilkan kode hingga membengkakkan tagihan Anda. Tanpa batasan, agen tidak tahu kapan harus berhenti.

Kerangka Otonomi: Pagar Pengaman, Observabilitas, Pos Pemeriksaan

Atasi masalah di atas dengan tiga lapisan: pagar pengaman (mencegah kegagalan), observabilitas (mendeteksi kegagalan), pos pemeriksaan (memulihkan dari kegagalan).

Lapisan 1: Pagar Pengaman (Pencegahan)

Buat batasan keras pada perilaku agen melalui kode, bukan prompt.

Contoh Validasi Direktori File (Python):

import os
from pathlib import Path

ALLOWED_DIRECTORIES = {"src", "tests", "docs"}

def validate_file_path(path: str) -> bool:
    abs_path = Path(path).resolve()
    return any(
        str(abs_path).startswith(str(Path(d).resolve()))
        for d in ALLOWED_DIRECTORIES
    )

def agent_write_file(path: str, content: str):
    if not validate_file_path(path):
        raise ValueError(f"Tidak dapat menulis ke {path}: di luar direktori yang diizinkan")
    with open(path, 'w') as f:
        f.write(content)

Batasan Skema API dengan Apidog:

// apidog-schema.ts
export const CreateUserSchema = {
  type: 'object',
  required: ['email', 'name'],
  properties: {
    email: { type: 'string', format: 'email' },
    name: { type: 'string', minLength: 1, maxLength: 100 },
    role: { type: 'string', enum: ['user', 'admin', 'guest'] }
  },
  additionalProperties: false
}

function validateRequest(schema: object, data: unknown): void {
  const valid = ajv.validate(schema, data)
  if (!valid) {
    throw new Error(`Permintaan tidak valid: ${JSON.stringify(ajv.errors)}`)
  }
}

Batasan Anggaran Agen:

import time
from dataclasses import dataclass

@dataclass
class AgentBudget:
    max_steps: int = 50
    max_tokens: int = 100000
    max_time_seconds: int = 600  # 10 menit
    max_api_calls: int = 100

class BudgetEnforcer:
    def __init__(self, budget: AgentBudget):
        self.budget = budget
        self.start_time = time.time()
        self.steps = 0
        self.tokens_used = 0
        self.api_calls = 0

    def check(self) -> bool:
        elapsed = time.time() - self.start_time

        if self.steps >= self.budget.max_steps:
            raise RuntimeError(f"Batas langkah tercapai: {self.steps}")
        if self.tokens_used >= self.budget.max_tokens:
            raise RuntimeError(f"Batas token tercapai: {self.tokens_used}")
        if elapsed >= self.budget.max_time_seconds:
            raise RuntimeError(f"Batas waktu tercapai: {elapsed:.0f}s")
        if self.api_calls >= self.budget.max_api_calls:
            raise RuntimeError(f"Batas panggilan API tercapai: {self.api_calls}")

        return True

    def record_step(self, tokens: int, api_calls: int = 0):
        self.steps += 1
        self.tokens_used += tokens
        self.api_calls += api_calls
        self.check()

Lapisan 2: Observabilitas (Deteksi)

Log dan metrik terstruktur sangat penting agar Anda bisa memantau tanpa mengawasi setiap langkah.

Logging Terstruktur (Python):

import json
from datetime import datetime
from typing import Any

class AgentLogger:
    def __init__(self, log_file: str = "agent_trace.jsonl"):
        self.log_file = log_file
        self.entries = []

    def log(self, event: str, data: dict[str, Any] | None = None):
        entry = {
            "timestamp": datetime.utcnow().isoformat(),
            "event": event,
            "data": data or {}
        }
        self.entries.append(entry)
        with open(self.log_file, 'a') as f:
            f.write(json.dumps(entry) + '\n')

    def log_decision(self, decision: str, reasoning: str, confidence: float):
        self.log("decision", {
            "decision": decision,
            "reasoning": reasoning,
            "confidence": confidence
        })

    def log_action(self, action: str, params: dict, result: str):
        self.log("action", {
            "action": action,
            "params": params,
            "result": result[:200]
        })

    def log_error(self, error: str, context: dict):
        self.log("error", {
            "error": error,
            "context": context
        })

# Penggunaan
logger = AgentLogger()
logger.log_decision(
    decision="Tambahkan pembatasan laju ke API",
    reasoning="Endpoint saat ini tidak memiliki perlindungan terhadap penyalahgunaan",
    confidence=0.85
)
logger.log_action(
    action="write_file",
    params={"path": "src/middleware/rate-limit.ts"},
    result="Berhasil menulis 45 baris"
)

Dasbor Metrik (Python):

from collections import Counter
from dataclasses import dataclass, field

@dataclass
class AgentMetrics:
    actions_taken: Counter = field(default_factory=Counter)
    files_modified: list[str] = field(default_factory=list)
    api_calls: dict[str, int] = field(default_factory=dict)
    errors: list[str] = field(default_factory=list)
    decisions_by_confidence: dict[str, int] = field(default_factory=lambda: {
        "tinggi (>0.9)": 0,
        "sedang (0.7-0.9)": 0,
        "rendah (<0.7)": 0
    })

    def record_action(self, action: str):
        self.actions_taken[action] += 1

    def record_file_modification(self, path: str):
        if path not in self.files_modified:
            self.files_modified.append(path)

    def record_api_call(self, endpoint: str):
        self.api_calls[endpoint] = self.api_calls.get(endpoint, 0) + 1

    def record_error(self, error: str):
        self.errors.append(error)

    def record_decision(self, confidence: float):
        if confidence > 0.9:
            self.decisions_by_confidence["tinggi (>0.9)"] += 1
        elif confidence >= 0.7:
            self.decisions_by_confidence["sedang (0.7-0.9)"] += 1
        else:
            self.decisions_by_confidence["rendah (<0.7)"] += 1

    def summary(self) -> str:
        return f"""
Ringkasan Metrik Agen
=====================
Tindakan: {dict(self.actions_taken)}
File diubah: {len(self.files_modified)}
Panggilan API: {self.api_calls}
Kesalahan: {len(self.errors)}
Keputusan berdasarkan kepercayaan diri: {self.decisions_by_confidence}
"""

Lapisan 3: Pos Pemeriksaan (Pemulihan)

Pos pemeriksaan adalah jeda otomatis agar manusia dapat memverifikasi langkah kritis.

Pos Pemeriksaan Otomatis (Python):

from enum import Enum
from typing import Callable
from dataclasses import dataclass

class CheckpointTrigger(Enum):
    BEFORE_FILE_WRITE = "sebelum_menulis_file"
    BEFORE_API_CALL = "sebelum_memanggil_api"
    BEFORE_GIT_COMMIT = "sebelum_git_commit"
    BEFORE_DELETE = "sebelum_menghapus"
    AFTER_N_STEPS = "setelah_n_langkah"

@dataclass
class Checkpoint:
    trigger: CheckpointTrigger
    description: str
    data: dict
    requires_approval: bool = True

class CheckpointManager:
    def __init__(self, auto_approve: set[CheckpointTrigger] | None = None):
        self.auto_approve = auto_approve or set()
        self.pending: list[Checkpoint] = []

    def create_checkpoint(
        self, 
        trigger: CheckpointTrigger, 
        description: str, 
        data: dict
    ) -> bool:
        if trigger in self.auto_approve:
            return True
        checkpoint = Checkpoint(
            trigger=trigger,
            description=description,
            data=data
        )
        self.pending.append(checkpoint)
        return False

    def approve(self, checkpoint_id: int) -> None:
        if 0 <= checkpoint_id < len(self.pending):
            self.pending.pop(checkpoint_id)

    def reject(self, checkpoint_id: int) -> None:
        raise RuntimeError(f"Pos pemeriksaan ditolak: {self.pending[checkpoint_id]}")

# Penggunaan
checkpoints = CheckpointManager(
    auto_approve={CheckpointTrigger.BEFORE_FILE_WRITE}
)

if not checkpoints.create_checkpoint(
    trigger=CheckpointTrigger.BEFORE_DELETE,
    description="Akan menghapus direktori src/legacy/",
    data={"path": "src/legacy/", "files": ["old_handler.ts", "deprecated.ts"]}
):
    agent.pause("Menunggu persetujuan untuk menghapus file")

Membangun Agen Otonom dengan Apidog

Saat agen AI Anda berinteraksi dengan API, cegah permintaan salah bentuk dengan skema tegas. Gunakan Apidog untuk membuat kontrak API yang wajib diikuti agen Anda.

Langkah Implementasi:

1. Impor atau definisikan spesifikasi OpenAPI Anda di Apidog.
2. Hasilkan kode klien dengan validasi bawaan.
3. Berikan agen Anda klien yang divalidasi, bukan HTTP mentah.

// Alih-alih fetch mentah
const response = await fetch('/api/users', {
  method: 'POST',
  body: JSON.stringify(data)  // Tanpa validasi
})

// Gunakan klien hasil Apidog (dengan validasi)
import { UsersApi } from './generated/apidog-client'

const usersApi = new UsersApi()
const response = await usersApi.createUser({
  email: '[e-mail]',
  name: 'Test User',
  role: 'user'  // Harus enum valid
})

Ini menjadikan API Anda sebagai pagar pengaman: agen tidak bisa mengirim data tidak valid.

Hasilkan klien API yang divalidasi untuk agen AI Anda

Pola yang Terbukti dan Kesalahan Umum

Pola 1: Sandwich Persetujuan

Untuk operasi berisiko, lakukan persetujuan sebelum DAN sesudah.

def risky_operation(agent, operation):
    # Pra-persetujuan
    if not agent.checkpoint(f"Akan melakukan: {operation.description}"):
        return "Dibatalkan oleh pengguna"

    # Lakukan operasi
    result = operation.execute()

    # Pasca-persetujuan
    if not agent.checkpoint(f"Verifikasi hasil dari: {operation.description}"):
        operation.rollback()
        return "Digulirkan kembali oleh pengguna"

    return result

Pola 2: Ambang Kepercayaan Diri

Jangan biarkan agen bertindak jika confidence rendah.

MIN_CONFIDENCE = 0.75

def agent_decide(options: list[dict]) -> dict:
    best = max(options, key=lambda x: x.get('confidence', 0))

    if best['confidence'] < MIN_CONFIDENCE:
        # Eskalasi ke manusia
        return {
            'action': 'escalate',
            'reason': f"Opsi terbaik memiliki kepercayaan diri {best['confidence']:.2f} < {MIN_CONFIDENCE}",
            'options': options
        }

    return best

Pola 3: Operasi Idempoten

Rancang tindakan agen agar bisa diulang tanpa efek samping.

import hashlib
import os

def idempotent_write(path: str, content: str) -> bool:
    """Hanya tulis jika konten berubah."""
    content_hash = hashlib.sha256(content.encode()).hexdigest()

    existing_hash = None
    if os.path.exists(path):
        with open(path, 'r') as f:
            existing_hash = hashlib.sha256(f.read().encode()).hexdigest()

    if content_hash == existing_hash:
        logger.log_action("write_file", {"path": path}, "Dilewati - tidak ada perubahan")
        return False

    with open(path, 'w') as f:
        f.write(content)
    logger.log_action("write_file", {"path": path}, f"Menulis {len(content)} byte")
    return True

Kesalahan Umum yang Harus Dihindari

• Percaya pada prompt sebagai batasan. Batasan harus di kode/izin, bukan instruksi di prompt.
• Tidak ada rencana pemulihan. Pastikan setiap tindakan bisa dibatalkan (gunakan git/cadangan).
• Mengabaikan skor kepercayaan. Jika confidence rendah, eskalasi ke manusia.
• Pengawasan berlebihan. Bangun sistem otonom, bukan manual.
• Kurangnya spesifikasi keberhasilan. Berikan kondisi akhir (misal: "semua tes lulus").

---

Alternatif dan Perbandingan

Pendekatan	Otonomi	Risiko	Terbaik untuk
Pengkodean manual	Tidak ada	Rendah	Pekerjaan kompleks, kritis
Pemrograman berpasangan dengan AI	Rendah	Rendah	Pembelajaran, eksplorasi
Agen yang diawasi	Sedang	Sedang	Tugas rutin
Agen otonom dengan pagar pengaman	Tinggi	Terkontrol	Operasi massal, migrasi
Agen otonom penuh	Sangat tinggi	Tinggi	Alur kerja terpercaya, teruji dengan baik

Target ideal: "otonom dengan pagar pengaman" untuk efisiensi dan risiko minimal.

---

Kasus Penggunaan Dunia Nyata

Migrasi basis kode: Tim memigrasi 200 endpoint REST ke GraphQL dengan agen otonom. Pagar pengaman mencegah perubahan skema, pos pemeriksaan wajib sebelum penghapusan, dan migrasi selesai dalam 3 hari tanpa insiden produksi.

Pembuatan dokumentasi: Agen otomatis menghasilkan dokumentasi API hanya dari direktori yang diizinkan. Pos pemeriksaan sebelum publikasi. Review mingguan, tidak perlu tulis manual.

Cakupan pengujian: Agen menulis pengujian berdasarkan analisis kode. Batasan anggaran cegah overflow, confidence threshold untuk review manual. Cakupan naik dari 60% ke 85% dalam sebulan.

Ringkasan

Poin utama:

• Agen AI gagal dengan pola yang dapat diprediksi: pelebaran ruang lingkup, abstraksi salah, kegagalan berjenjang, kelelahan sumber daya
• Tiga lapisan solusi: pagar pengaman (pencegahan), observabilitas (deteksi), pos pemeriksaan (pemulihan)
• Pagar pengaman harus diimplementasikan melalui kode, bukan prompt
• Observabilitas = log/metrics terstruktur, bukan pengawasan manual
• Pos pemeriksaan = intervensi manusia hanya di titik kritis
• Skema API dari Apidog menjadikan API Anda pagar pengaman

Langkah Anda selanjutnya:

1. Identifikasi tugas AI yang paling berulang.
2. Definisikan pagar pengaman: apa yang dilarang dilakukan agen?
3. Tambahkan logging terstruktur.
4. Buat pos pemeriksaan untuk operasi berisiko tinggi.
5. Jalankan 30 menit, tinjau log.

Tujuannya bukan menghilangkan manusia, tapi menempatkan intervensi pada keputusan tingkat tinggi, bukan koreksi detail.

Bangun pagar pengaman API untuk agen AI Anda - gratis

FAQ

Apa perbedaan antara agen AI dan asisten AI?

Asisten hanya merespons permintaan, menunggu instruksi Anda berikutnya. Agen mengambil tujuan, merencanakan, dan mengeksekusi langkah untuk mencapainya. Agen berjalan hingga pos pemeriksaan/selesai.

Bagaimana saya tahu jika agen siap otonom?

Jalankan dalam mode diawasi 10 sesi. Jika intervensi <2 per sesi dan hanya klarifikasi, sudah siap. Jika masih sering, tambahkan pagar pengaman.

Apa risiko terbesar agen otonom?

Kegagalan berjenjang yang tidak terdeteksi. Pos pemeriksaan memutus rantai kesalahan ini.

Apakah pola ini bisa digunakan dengan semua LLM?

Ya, pagar pengaman/observabilitas/pos pemeriksaan agnostik model. Implementasinya bisa berbeda, tapi konsep sama.

Seberapa besar observabilitas memperlambat agen?

Hampir tidak terasa. Delay datang dari pos pemeriksaan (menunggu manusia), bukan logging.

Bagaimana jika agen membuat keputusan yang tidak saya setujui?

Tolak di pos pemeriksaan, agen batal/rollback. Sertakan preferensi Anda ke instruksi agar agen belajar gaya Anda.

Mulai dengan agen diawasi atau otonom?

Selalu mulai dengan diawasi. Gunakan pos pemeriksaan pada semua aksi besar, lalu perlahan kurangi.

Bagaimana Apidog membantu agen AI?

Apidog menghasilkan klien API tervalidasi. Jika agen mengirim data salah bentuk, request langsung ditolak sebelum ke backend—mencegah kelas bug ini sepenuhnya.