Mitigasi Kegagalan Deployment AI Agent: Circuit Breaker & Canary

Tantangan Deployment Autonomous AI Agent di Production

Autonomous AI agent berbeda dengan microservices deterministik standar. Pola interaksi multi-step reasoning, dynamic tool invocation, dan sifat nondeterministik model LLM memperkenalkan failure mode baru: runaway loops (agen memanggil tool atau LLM secara rekursif tanpa henti), lonjakan konsumsi token tak terkendali, dan degradasi akurasi logika tool routing pasca-deployment.

Untuk mengamankan sistem produksi, pipeline deployment memerlukan dua pilar mitigasi utama: Circuit Breaker di level aplikasi untuk terminasi loop eksekusi secara instan, serta Canary Deployment di level infrastruktur yang dievaluasi langsung menggunakan metrik kuantitatif seperti token cost rate dan tool failure rate.

Implementasi Circuit Breaker untuk Mencegah Runaway Execution

Pola circuit breaker tradisional (Closed, Open, Half-Open) perlu disesuaikan dengan konteks AI agent. Selain melacak HTTP failure, circuit breaker untuk agent harus membatasi batas rekursi langkah (recursion depth) dan budget token per session.

Implementasi stateful wrapper di layer middleware Python berikut memotong eksekusi ketika ambang batas token atau kegagalan berulang tercapai:

import time
from typing import Callable, Any

class AgentCircuitBreakerOpenException(Exception):
    pass

class AgentCircuitBreaker:
    def __init__(self, failure_threshold: int = 3, reset_timeout: float = 60.0, max_tokens_per_call: int = 4000):
        self.failure_threshold = failure_threshold
        self.reset_timeout = reset_timeout
        self.max_tokens_per_call = max_tokens_per_call
        self.failure_count = 0
        self.state = "CLOSED"
        self.last_state_change = time.time()

    def __call__(self, func: Callable) -> Callable:
        def wrapper(*args, **kwargs) -> Any:
            now = time.time()
            if self.state == "OPEN":
                if now - self.last_state_change > self.reset_timeout:
                    self.state = "HALF-OPEN"
                else:
                    raise AgentCircuitBreakerOpenException("Circuit breaker OPEN: AI Agent execution blocked.")

            try:
                # Inisiasi eksekusi dengan runtime tracking
                result = func(*args, **kwargs)
                
                # ponytail: token usage parsed from response metadata directly
                usage = getattr(result, "usage", None)
                if usage and usage.total_tokens > self.max_tokens_per_call:
                    raise ValueError(f"Token budget exceeded: {usage.total_tokens} > {self.max_tokens_per_call}")

                if self.state == "HALF-OPEN":
                    self.state = "CLOSED"
                    self.failure_count = 0
                return result

            except Exception as err:
                self.failure_count += 1
                if self.failure_count >= self.failure_threshold:
                    self.state = "OPEN"
                    self.last_state_change = now
                raise err

        return wrapper

State Transition Rule

• CLOSED: Request diarahkan ke agent secara normal. Jika tool error, recursive limit error, atau token budget breach terjadi berturut-turut melebihi failure_threshold, state bergeser ke OPEN.
• OPEN: Semua eksekusi agent langsung dihentikan sebelum HTTP call ke model provider terjadi. Request dikembalikan ke fallback handler (misal: template respons statis atau human-in-the-loop queue).
• HALF-OPEN: Setelah reset_timeout berlalu, sebagian kecil request diizinkan lewat. Jika berhasil, state kembali ke CLOSED; jika gagal, timer reset dimulai kembali di state OPEN.

Strategi Canary Deployment Berbasis Metrik LLM

Deployment versi prompt, routing model, atau tool definition baru tidak boleh langsung menerima 100% trafik. Pola canary deployment membagi trafik produksi (misal: 90% stable, 10% canary) menggunakan service mesh seperti Istio atau Ingress Controller.

Metrik Kritis Evaluasi Canary Agent

1. Tool Execution Failure Rate: Persentase pemanggilan fungsi (function calling) yang menghasilkan schema parse error atau database exception. Ambang batas kritis: > 2%.
2. Token Burn Rate / Cost per Request: Rasio konsumsi prompt dan completion token terhadap rata-rata baseline versi stable. Kenaikan drastis menandakan prompt regression atau hallucinated loops. Ambang batas kritis: > 25% kenaikan tak terduga.
3. Recursion Depth Breaches: Jumlah session yang mencapai limit maximum tool calls (misalnya 10 iterasi) tanpa mencapai final answer.

Otomatisasi Rollback Menggunakan Prometheus Alertmanager

Evaluasi canary dilakukan secara otomatis. Metrik runtime diekspos melalui endpoint /metrics dan dikikis oleh Prometheus. Ketika metrik canary melanggar Service Level Objectives (SLO), Prometheus Alert memicu webhook rollback ke CI/CD orchestrator (misalnya Argo Rollouts atau Kubernetes Deployment patch).

groups:
  - name: ai_agent_canary_alerts
    rules:
      - alert: AgentHighCostCanary
        expr: |
          sum(rate(ai_agent_tokens_total{deployment="canary"}[5m]))
          /
          sum(rate(ai_agent_requests_total{deployment="canary"}[5m])) > 3500
        for: 2m
        labels:
          severity: critical
          action: automated_rollback
        annotations:
          summary: "Canary deployment token consumption exceeds threshold"
          description: "Canary deployment memproses lebih dari 3500 token/request selama 2 menit berturut-turut."

      - alert: AgentToolExecutionErrors
        expr: |
          sum(rate(ai_agent_tool_errors_total{deployment="canary"}[5m]))
          /
          sum(rate(ai_agent_tool_calls_total{deployment="canary"}[5m])) > 0.05
        for: 3m
        labels:
          severity: critical
          action: automated_rollback
        annotations:
          summary: "Canary tool error rate above 5%"

Alertmanager merutekan label action: automated_rollback langsung ke webhook endpoint pipeline yang menjalankan perintah pembatalan deployment:

kubectl rollout undo deployment/ai-agent-deployment -n production

Observabilitas: OpenTelemetry Distributed Tracing untuk Agent Loop

Logging baris tunggal tidak cukup untuk mendiagnosis agen mandiri. Setiap interaksi memerlukan distributed tracing dengan OpenTelemetry span yang mencatat siklus Thought -> Action -> Observation.

• Root Span: Mewakili user session atau incoming request. Mencatat metadata user ID, conversation ID, dan target intent.
• Child Spans (LLM Calls): Mencatat raw prompt templates, raw JSON outputs, latency per token, input token count, dan output token count.
• Child Spans (Tool Execution): Mencatat nama tool yang dipanggil, argumen eksekusi, execution time, dan status error tool backend.

Visualisasi DAG (Directed Acyclic Graph) pada tool tracing seperti Jaeger memungkinkan engineer melihat titik spesifik di mana agent terjebak dalam circular reasoning sebelum circuit breaker memutus koneksi.

Sistematisasi Postmortem Pasca-Insiden AI Agent

Ketika insiden kegagalan deployment atau runaway cost terjadi, dokumen postmortem harus mendokumentasikan anomali deterministik dan nondeterministik secara terstruktur:

Menerapkan circuit breaker aplikasi yang ketat dan canary deployment berbasis observabilitas token mengurangi risiko finansial dan operasional secara signifikan saat merilis pipeline AI agent otonom ke lingkungan produksi skala besar.