Speculative Uncertainty (SU) 2026: Arsitektur Draft-Model Cross-Likelihood Scoring, Phase-Aware Span Disentanglement, dan Pre-Execution Veto Gate pada Autonomous Coding Agents

Dalam lanskap autonomous software engineering modern tahun 2026, autonomous coding agents (seperti Devin, SWE-agent, OpenHands, hingga Claude Code) telah berevolusi dari sekadar generator snippet menjadi orkestrator yang mampu mengeksekusi bash command, memodifikasi file AST, hingga menjalankan test suites secara mandiri. Namun, di balik benchmark kelulusan yang impresif, tim engineering di seluruh dunia berhadapan dengan satu pola kegagalan paling mahal: fenomena Confidently Wrong. Agen black-box menghasilkan rencana atau perintah destruktif dengan tingkat kepercayaan diri semu yang tinggi, memicu siklus execute-fail-retry berkepanjangan yang membakar token dan mengotori git history.

1. Dilema Kuantifikasi Ketidakpastian pada Black-Box Coding Agents

Mengapa mengukur ketidakpastian (uncertainty quantification) pada coding agent berskala produksi begitu sulit? Kendala utamanya berakar pada dua batasan fundamental arsitektur software engineering modern:

Pendekatan konvensional seperti Verbalized Confidence (meminta LLM menuliskan tingkat keyakinannya 0–100%) terbukti sangat buruk di ranah coding, mencatat metrik discriminative AUROC hanya berkisar 0.57 – 0.61 (hampir mendekati lemparan koin acak). Agen cenderung mengalami overkonfidensi sistemik ketika menghasilkan syntax command shell yang cacat.

2. Paradigma Inverted Speculative Decoding: Mengevaluasi Tanpa Logit Primer

Terobosan inti dari riset Grotov & Malykh (2026) adalah membalik arsitektur Speculative Decoding. Jika dalam speculative decoding konvensional model kecil bertindak sebagai generator draf dan model besar bertindak sebagai verifikator logit, maka dalam Speculative Uncertainty (SU) alur kerjanya dibalik:

3. Phase-Aware Span Disentanglement: Memisahkan Noise Penalaran dari Eksekusi Aksi

Kelemahan fatal metode kalibrasi umum adalah memperlakukan seluruh token dalam trajektori secara seragam. Dalam agentic coding, lintasan interaksi terbagi tajam ke dalam dua fase ortogonal:

1. Reasoning Span ($r_i$): Teks bebas refleksi atau pemikiran internal (misalnya tag <thought>). Fase ini secara alami memiliki entropi tinggi dan diversitas gaya bahasa yang luas. Divergensi logit di sini wajar terjadi dan mencerminkan eksplorasi ide.
2. Action Span ($a_i$): Perintah terstruktur yang dikirim ke runtime (misalnya JSON tool-call execute_bash({"command": "git checkout -b fix"})). Fase ini memiliki entropi deterministik yang rendah. Ketidaksepakatan kecil antara agen dan draft model pada fase ini merupakan indikator kuat adanya kesalahan sintaksis, nama file halusinasi, atau argumen invalid.

Jika kedua fase dicampur aduk (SU-Uniform), fluktuasi entropi pada fase reasoning akan menutupi (masking) sinyal deviasi kritis pada fase aksi, menurunkan kemampuan prediksi kegagalan hingga -6 AUROC. SU mengekstraksi 8 statistik per sinyal ($s, g, H$) untuk masing-masing fase secara independen sepanjang jendela lookback $k=3$ langkah, menghasilkan vektor fitur 50-dimensi $\phi(\mathcal{W}_i) \in \mathbb{R}^{50}$.

// Speculative Uncertainty (SU) & Draft-Model Veto Gate Kernel
// Berdasarkan Prinsip Arsitektur Riset arXiv:2609.05274 (September 2026)
// Inverted Speculative Decoding untuk Black-Box Agent Uncertainty Quantification

export type TokenPhase = 'reason' | 'action';

export interface TrajectoryToken {
  token: string;
  tokenId: number;
  phase: TokenPhase;
  draftLogProb: number;      // log q(y_t | x, y_ {
      if (values.length === 0) return;
      const n = values.length;
      let sum = 0;
      let min = Infinity;
      let max = -Infinity;

      for (let i = 0; i < n; i++) {
        const v = values[i];
        sum += v;
        if (v < min) min = v;
        if (v > max) max = v;
      }
      const mean = sum / n;

      let varSum = 0;
      let skewSum = 0;
      for (let i = 0; i < n; i++) {
        const diff = values[i] - mean;
        varSum += diff * diff;
        skewSum += diff * diff * diff;
      }
      const variance = varSum / Math.max(1, n - 1);
      const std = Math.sqrt(variance);
      const skewness = std > 0 ? (skewSum / n) / Math.pow(std, 3) : 0;

      // Trend: regresi linear kemiringan (slope) sederhana
      let trend = 0;
      if (n > 1) {
        let num = 0, den = 0;
        const xMean = (n - 1) / 2;
        for (let i = 0; i < n; i++) {
          num += (i - xMean) * (values[i] - mean);
          den += (i - xMean) * (i - xMean);
        }
        trend = den !== 0 ? num / den : 0;
      }

      const p10Count = Math.max(1, Math.floor(n * 0.1));
      const first10Mean = values.slice(0, p10Count).reduce((a, b) => a + b, 0) / p10Count;
      const last10Mean = values.slice(Math.max(0, n - p10Count)).reduce((a, b) => a + b, 0) / p10Count;

      features[baseIdx + 0] = mean;
      features[baseIdx + 1] = variance;
      features[baseIdx + 2] = max;
      features[baseIdx + 3] = min;
      features[baseIdx + 4] = skewness;
      features[baseIdx + 5] = trend;
      features[baseIdx + 6] = first10Mean;
      features[baseIdx + 7] = last10Mean;
    };

    // Reasoning Phase (0 - 23)
    summarizeSignal(reasonTokens.map(t => -t.draftLogProb), 0); // s_reason
    summarizeSignal(reasonTokens.map(t => t.draftTop1LogProb - t.draftLogProb), 8); // g_reason
    summarizeSignal(reasonTokens.map(t => t.draftEntropy), 16); // H_reason

    // Action Phase (24 - 47)
    summarizeSignal(actionTokens.map(t => -t.draftLogProb), 24); // s_action
    summarizeSignal(actionTokens.map(t => t.draftTop1LogProb - t.draftLogProb), 32); // g_action
    summarizeSignal(actionTokens.map(t => t.draftEntropy), 40); // H_action

    // Length Spans (48 - 49)
    features[48] = reasonTokens.length;
    features[49] = actionTokens.length;

    return features;
  }

  /**
   * Inferensi Pre-Execution Veto Gate
   * Menghitung probabilitas kegagalan eksekusi sebelum command dieksekusi di OS sandbox
   */
  public evaluateStepVeto(stepIndex: number, windowSteps: StepWindow[]): VetoGateDecision {
    const phi = this.extractPhaseAwareFeatures(windowSteps);
    let logit = this.bias;

    for (let i = 0; i < 50; i++) {
      logit += this.weights[i] * phi[i];
    }

    const failureLikelihood = 1 / (1 + Math.exp(-logit));
    const isVetoed = failureLikelihood >= this.vetoThreshold;

    // Evaluasi dominasi fase untuk panduan replan
    const actionRiskContribution = this.weights[26] * phi[26] + this.weights[34] * phi[34];
    const reasonRiskContribution = this.weights[2] * phi[2] + this.weights[10] * phi[10];

    let dominantFailurePhase: 'reason' | 'action' | 'neutral' = 'neutral';
    if (actionRiskContribution > reasonRiskContribution * 1.5) {
      dominantFailurePhase = 'action';
    } else if (reasonRiskContribution > actionRiskContribution * 1.5) {
      dominantFailurePhase = 'reason';
    }

    return {
      stepIndex,
      failureLikelihood: Number(failureLikelihood.toFixed(4)),
      isVetoed,
      threshold: this.vetoThreshold,
      dominantFailurePhase,
      recommendation: isVetoed
        ? (failureLikelihood > 0.88 ? 'ESCALATE_TO_ORACLE' : 'HALT_AND_REPLAN')
        : 'EXECUTE',
    };
  }
}

4. Analisis Komparasi Benchmark: SWE-bench Verified & DA-Code

Riset ini menguji performa model open-weight Qwen3-Coder-480B dan closed-source commercial frontier Claude 3.5 Sonnet yang dijalankan di bawah scaffold OpenHands. Evaluasi dilakukan pada benchmark industri terstandar: SWE-rebench, SWE-bench Verified, dan DA-Code:

5. Pre-Execution Veto Gate: Menghentikan Kerusakan Sebelum Eksekusi Runtime

Kekuatan praktis terbesar dari sinyal Speculative Uncertainty bukanlah sekadar angka metrik di atas kertas, melainkan kemampuannya dikonsumsi langsung oleh kebijakan downstream runtime. Riset ini mengimplementasikan kebijakan Pre-Execution Veto Gate:

• Pencegahan Siklus Execute-Fail-Retry: Saat model mengusulkan action $a_i$ dengan $P(\text{failure}) ge \tau_{\text{veto}}$, gate membatalkan panggilan tool sebelum sistem operasi mengeksekusinya. Agen langsung menerima umpan balik sintaksis untuk melakukan replanning lokal tanpa merusak state git atau membuang token eksekusi.
• Generalisasi Cross-Agent Zero-Shot: Draft model Qwen3-4B yang dilatih pada trajektori Qwen3-Coder-480B dapat langsung ditransfer untuk mengawasi agen tertutup Claude 3.5 Sonnet tanpa perlu retraining, mempertahankan nilai AUROC impresif sebesar 0.69 (jauh melampaui baseline tanpa supervisi sebesar 0.60).
• Overhead Latensi Minimal: Karena draft model berukuran kecil (4B parameter) dan dievaluasi dalam mode batch single-forward pass terhadap sequence token yang sudah ada, penambahan latensi per turn hanya berada pada kisaran <45 ms, jauh lebih cepat daripada memanggil API verifikator kedua.

6. Panduan Arsitektur & Rekomendasi Deployment untuk Software Engineering Teams

Bagi arsitek sistem dan tim AI engineering yang ingin mengintegrasikan Speculative Uncertainty ke dalam infrastruktur agentic coding mereka (baik berbasis Claude Code, OpenCode, maupun platform internal):