Mengizinkan model bahasa besar (LLM) menjalankan perkakas eksekusi kode (seperti linter, git, compiler, dan editor berkas) secara otonom membawa risiko operasional tinggi. Pola self-scaffolding memungkinkan agen merancang struktur eksekusi dan perbaikan mandiri, namun kegagalan penalaran sering memicu runaway loops, pemborosan token, atau modifikasi repositori yang destruktif. Artikel ini membahas cara membangun canary release pipeline untuk agen koding dengan instrumentasi OpenTelemetry dan mitigasi berbasis sandbox quarantine.

Arsitektur Canary Deployment untuk Agentic Coding

Penerapan agen koding tidak boleh langsung menggantikan alur kerja CI/CD atau dev environment utama. Canary deployment membagi beban tugas perbaikan atau sintesis kode ke dua target terpisah: versi stabil (baseline) dan versi agen baru (canary).

Komponen inti canary pipeline mencakup:

  • Traffic Router / Task Dispatcher: Mendistribusikan persentase tertentu (misalnya 10%) dari tiket refactoring, bug fixing, atau pull request ke runner canary.
  • Ephemeral Isolated Sandbox: Menjalankan agen dalam container runtime (seperti microVM atau gVisor-based Docker containers) dengan read-only rootfs dan izin terbatas pada volume repositori tujuan.
  • Canary Evaluation Gate: Memantau telemetri real-time untuk memutus siklus loop agen sebelum menghasilkan commit yang merusak.

Observabilitas Tool Failure dan Token Spike dengan OpenTelemetry

Agen koding berinteraksi dengan lingkungannya via tool calls. Dua indikator kegagalan utama yang wajib dipantau adalah lonjakan eksekusi tool gagal (non-zero exit code) dan konsumsi token per siklus.

Gunakan OpenTelemetry Tracing dan Metrics SDK untuk mencatat setiap iterasi penalaran dan eksekusi alat:

import time
from opentelemetry import metrics, trace

tracer = trace.get_tracer("agent.runtime")
meter = metrics.get_meter("agent.metrics")

tool_error_counter = meter.create_counter(
    "agent.tool.execution_errors",
    description="Jumlah kegagalan eksekusi tool oleh agen",
    unit="1",
)

token_cost_counter = meter.create_counter(
    "agent.token.consumption",
    description="Total token input/output yang dikonsumsi",
    unit="token",
)

def execute_agent_tool(tool_name: str, command: list, session_id: str) -> int:
    with tracer.start_as_current_span("execute_tool") as span:
        span.set_attribute("agent.session_id", session_id)
        span.set_attribute("tool.name", tool_name)
        
        exit_code = run_in_sandbox(command)
        span.set_attribute("tool.exit_code", exit_code)
        
        if exit_code != 0:
            tool_error_counter.add(1, {"tool.name": tool_name, "session_id": session_id})
            span.set_status(trace.StatusCode.ERROR, f"Tool {tool_name} failed with exit code {exit_code}")
            
        return exit_code

Metrik ini kemudian dipantau di alert engine. Apabila rate(agent.tool.execution_errors[2m]) melampaui batas toleransi (misalnya > 15%), canary deployment harus otomatis dihentikan.

Deteksi File Modification Loop dan Automated Rollback

Salah satu mode kegagalan paling kritis pada skema self-scaffolding adalah oscillation loop: agen mengedit berkas A untuk memperbaiki tes B, tes B memicu error di berkas C, lalu agen mengedit kembali berkas A secara berulang-ulang hingga batas konteks habis.

Untuk menghentikan anomali ini, gunakan middleware interceptor pada berkas/git runtime:

from collections import Counter
from dataclasses import dataclass, field

@dataclass
class LoopDetector:
    threshold_same_file_edits: int = 5
    file_mutation_history: Counter = field(default_factory=Counter)

    def register_modification(self, file_path: str) -> bool:
        self.file_mutation_history[file_path] += 1
        if self.file_mutation_history[file_path] >= self.threshold_same_file_edits:
            return False  # Loop berbahaya terdeteksi
        return True

def handle_write_file(detector: LoopDetector, file_path: str, content: str, session_id: str):
    if not detector.register_modification(file_path):
        trigger_canary_abort(session_id, reason=f"File oscillation limit reached on: {file_path}")
        raise RuntimeError("Execution terminated: runaway mutation loop.")
    
    write_to_working_directory(file_path, content)

Saat loop terdeteksi, trigger automated rollback langsung membatalkan workspace via git reset --hard HEAD dan menghentikan container canary untuk membatasi konsumsi API token tambahan.

Sandbox Quarantine dan Runbook Postmortem

Jika agen memicu safety breach, threshold token harian, atau error loop, sistem harus menahan sandbox untuk analisis forensik daripada langsung menghancurkannya.

1. Prosedur Quarantine

  • Isolasi Jaringan: Putus akses egres container secara instan melalui manipulasi network namespace atau update kebijakan CNI (Container Network Interface).
  • State Snapshot: Jalankan commit pada filesystem sandbox dan simpan diff git terakhir ke bucket observabilitas terisolasi.
  • Cabut Kredensial: Revoke API token sementara atau ephemeral GitHub app installation token yang dialokasikan khusus untuk run tersebut.

2. Postmortem Runbook

  1. Ekstraksi Jejak Percakapan: Ambil span OpenTelemetry beserta prompt input, metadata parsing JSON, dan log stderr eksekusi tool.
  2. Klasifikasi Kegagalan: Tentukan apakah anomali disebabkan oleh kegagalan parsing format tool call, halusinasi argumen CLI, atau dependensi lingkungan yang tidak lengkap di dalam sandbox.
  3. Patch Evaluasi: Masukkan kasus kegagalan ini ke dalam baseline test suite (eval harness) sebelum meluncurkan pembaruan prompt atau versi model pada canary berikutnya.