AMV-Guard (arXiv:2610.31446): Action-Conditioned Memory Verification untuk Long-Lived LLM Agents — Mengatasi Risiko Memori Usang Melalui Sequential Stopping, Kalibrasi Risiko, dan Adaptive Value of Information (VOI)

Dalam lanskap autonomous AI agents yang beroperasi lintas sesi (long-lived persistent agents), ketergantungan pada memori historis adalah pedang bermata dua. Ketika agen mengeksekusi tindakan ireversibel di dunia nyata—seperti mengeksekusi transfer perbankan, menerbitkan pesanan logistik, atau memodifikasi konfigurasi infrastruktur cloud—memori yang usang (stale memory) dapat seketika bertransformasi menjadi kerugian sistemik yang fatal.

1. Ilusi Keandalan Memori: Mengapa Retrieval Saja Tidak Cukup

Sebagian besar riset memori agen LLM—mulai dari MemGPT, A-Mem, hingga mekanisme memory graph kontemporer—berfokus pada optimalisasi internal memori: meningkatkan akurasi retrieval, mendeteksi rekonsiliasi kontradiksi, atau memperbarui timestamp. Namun, pada saat agen berada di ambang eksekusi tindakan (point of action), evaluasi intrinsik memori semata terbukti runtuh. Bahkan ketika bukti pembaruan berhasil di-retrieve, model frontier terbaik hanya mencatatkan akurasi 55.2% pada benchmark memori terinvalidasi, dan agen kerap kali mengeksekusi tindakan berbahaya sebelum menyadari bahwa mereka seharusnya menolak bertindak (abstain).

Perhatikan sebuah contoh motivasional yang fundamental:

Eksperimen di atas membuktikan aksioma utama penelitian ini: apakah sebuah memori aman untuk dijadikan dasar tindakan bukanlah atribut dari memori itu sendiri, melainkan hasil interaksi antara tingkat kepercayaan memori, biaya verifikasi, dan besaran kerugian jika tindakan tersebut keliru.

2. Dekonstruksi Formal: Relevant vs Action-Supporting vs Critical

Salah satu kontribusi teoritis terpenting dari arXiv:2610.31446 adalah memperjelas batas konseptual yang selama ini dicampuradukkan oleh komunitas AI:

• Relevant Memory: Klaim memori yang memiliki kesamaan semantik dengan tugas yang diberikan. Ini adalah himpunan terluar yang dihasilkan oleh algoritma vector similarity retrieval atau dense retrieval.
• Action-Supporting Memory: Himpunan bagian dari memori relevan yang secara kausal menopang premis logis dari tindakan kandidat $P(a)$. Nilai parameter tool atau izin eksekusi diturunkan secara langsung dari klaim ini.
• Critical Memory: Himpunan bagian tersempit dan paling vital, di mana jika klaim memori tersebut salah di dunia nyata, kerugian eksekusi ($L(a, z)$) akan berubah secara material.

Sistem retrieval umum hanya mampu mengidentifikasi himpunan terluar (relevant). Menghabiskan kuota verifikasi untuk memverifikasi seluruh memori relevan memboroskan latensi dan biaya API secara ekstrem. Sebaliknya, arsitektur verifikasi cerdas harus membatasi verifikasi hanya pada lapisan terdalam: critical premises.

3. Proposisi Matematis 1: Tiga Rezim Keputusan Konsekuensi Tindakan

Penulis memformulasikan keputusan terminal agen sebagai ruang biner $mathcal{D}(a) = { ext{PROCEED}(a), ext{ABSTAIN}}$, dengan kerugian $L(d, z)$. Misalkan probabilitas bahwa premis memori salah adalah $p in (0, 1)$, biaya abstain adalah $kappa > 0$, dan biaya verifikasi adalah $c ge 0$ dengan keandalan simetris verifier $r in (0.5, 1.0]$. Jika eksekusi di bawah premis yang salah menimbulkan kerugian $ heta > 0$, maka probabilitas a posteriori setelah observasi konfirmasi ($p^+$) dan refutasi ($p^-$) adalah:

Dari formulasi ini lahirlah Proposisi 1 (Consequence Induces Three Regimes): terdapat ambang batas teratur $ heta_1 le heta_2$ sedemikian rupa sehingga:

1. Jika konsekuensi tindakan rendah ($ heta < heta_1$), keputusan optimal adalah langsung PROCEED tanpa membuang biaya verifikasi.
2. Jika konsekuensi tindakan berada pada zona menengah ($ heta_1 le heta < heta_2$), keputusan optimal adalah menjalankan query VERIFY.
3. Jika konsekuensi tindakan melampaui ambang batas kritis ($ heta ge heta_2$), keputusan optimal adalah langsung ABSTAIN.

Wawasan yang sangat mendalam di balik poin ketiga: pada verifier yang tidak sempurna ($r < 1$), terdapat tingkat bahaya di mana bahkan jika verifier memberikan konfirmasi positif, posterior error $p^+$ masih terlalu tinggi untuk menjustifikasi risiko eksekusi. Oleh karena itu, tindakan paling rasional bagi agen berisiko tinggi adalah menolak mengeksekusi secara langsung tanpa membuang biaya verifikasi!

4. Jebakan Naive Value of Information (Remark 1)

Pendekatan intuitif yang kerap diadopsi insinyur adalah mengukur nilai verifikasi berdasarkan seberapa besar ia mereduksi risiko ekspektasian tindakan kandidat:

Para peneliti membuktikan secara matematis dalam Remark 1 bahwa formulasi naif ini bersifat degeneratif (rusak secara fundamental). Mengapa? Karena berdasarkan hukum probabilitas total dan sifat martingal dari ekspektasi Bayesian:

Akibatnya, $ ext{VOI}_{ ext{naive}}(q) equiv -lambda C(q) le 0$ selalu bernilai negatif! Jika agen menggunakan rumus ini dengan aturan "verifikasi jika VOI > 0", agen tidak akan pernah menjalankan verifikasi apa pun.

Informasi baru tidak memiliki nilai ekonomi intrinsik terhadap tindakan yang statis; informasi hanya berharga jika ia memiliki kapasitas untuk mengubah keputusan terminal agen (misalnya dari PROCEED menjadi ABSTAIN atau REPLAN). Oleh karena itu, AMV-Guard menggantikan risiko tindakan statis dengan screened stopping value $V_{ ext{stop}}(b, a)$:

5. Arsitektur Runtime AMV-Guard

AMV-Guard beroperasi sebagai verification gate transparan yang menyaring setiap tindakan eksternal (commit action) sebelum dieksekusi ke lingkungan fisik.

Pipeline ini terdiri dari tiga modul utama yang bekerja secara orkestratif:

6. Evaluasi Empiris: ToolSandbox dan AppWorld

Untuk membuktikan performa arsitektur ini di dunia nyata, para peneliti mengujinya pada dua lingkungan eksekusi stateful standar industri: ToolSandbox (3.520 instance beku dengan 10 famili perturbasi memori tersembunyi) dan AppWorld (100 tugas mutasi state kompleks lintas aplikasi email, perbankan, dan e-commerce).

Gambar 3: Pareto Frontier tingkat bahaya versus pemanggilan verifikasi (arXiv:2610.31446). Gambar 4: Pareto Frontier loss total vs biaya komputasi verifikasi (arXiv:2610.31446).

7. Temuan Riset dan Analisis Performa Kritis

Pengujian ekstensif lintas backbone model (Qwen3.5-35B-A3B, Qwen3.5-27B, dan DeepSeek-V4.1-Flash) mengungkapkan sejumlah temuan kunci bagi rekayasa sistem agen masa depan:

• Eliminasi Absolut Gate Harmful: Dibandingkan dengan Always Proceed (yang memicu 66.67% tindakan berbahaya) dan Always Verify (23.67% tindakan berbahaya karena verifier berisik), AMV-Guard secara deterministik mengunci 0.00% Gate Harmful. Sistem tidak pernah mengeksekusi aksi di mana premis yang diperlukan berada dalam kondisi invalid.
• Efisiensi Biaya Verifikasi 33.9%: Menggantikan kebijakan statis dengan dynamic adaptive VOI memangkas biaya pemanggilan query dari 1.843 menjadi 1.219 (penurunan 33.9%), sekaligus meningkatkan Proceed Coverage dari 38.83% menjadi 44.17%. Hal ini membuktikan bahwa verifikasi adaptif membebaskan agen untuk bertindak ketika risiko rendah, alih-alih paranoid memverifikasi segalanya.
• Ketahanan Generalisasi Out-of-Domain (AppWorld Transfer): Pada transfer zero-shot ke benchmark AppWorld tanpa fine-tuning arsitektur, modul inti AMV-Guard berhasil menurunkan biaya verifikasi sebesar 21.3% (dari 2.655 ke 2.090) dengan mempertahankan tingkat Gate Harmful terendah di angka 7.89% (dibandingkan Always Proceed sebesar 18.95% dan EnvProbe 17.37%).

8. Implementasi Kode Produksi: Runtime Engine AMV-Guard

Berikut adalah implementasi referensi TypeScript produksi dari modul inferensi sequential stopping, kalibrasi logistik Platt/Beta, dan kalkulasi one-step VOI:

// Production Implementation: AMV-Guard Runtime Engine
// Implements Proposition 1 Regimes, Calibrated Risk, and Adaptive One-Step VOI

export type ActionRegime = 'PROCEED' | 'VERIFY' | 'ABSTAIN';

export interface MemoryClaim {
  id: string;
  statement: string;
  timestamp: number;
  sourceTrustScore: number; // [0, 1]
  modelConfidence: number; // Raw model logit / probe confidence [0, 1]
  recencyHours: number;
  contradictionFlag: boolean;
}

export interface Premise {
  id: string;
  claimId: string;
  dependencyType: 'direct' | 'transitive' | 'joint';
  parameterTarget: string;
  calibratedViolationProbability: number; // p_i in [0, 1]
}

export interface CandidateAction {
  actionId: string;
  toolName: string;
  arguments: Record;
  impactCostTheta: number; // \theta: Biaya malapetaka eksekusi di bawah premis salah
  abstentionCostKappa: number; // \kappa: Penalti penolakan bertindak
  premises: Premise[];
}

export interface Verifier {
  id: string;
  resolvesPremiseIds: string[];
  executionCost: number; // c >= 0
  symmetricReliability: number; // r in (0.5, 1.0]
}

export class AMVGuardEngine {
  constructor(
    private lambdaCostScale = 1.0,
    private deltaLossThreshold = 10.0,
    private epsilonHarmBound = 0.05
  ) {}

  public calibratePremiseFailureProbability(claim: MemoryClaim): number {
    const recencyPenalty = Math.min(1.0, claim.recencyHours / (24 * 30));
    const logitConf = Math.log(Math.max(1e-5, claim.modelConfidence) / Math.max(1e-5, 1 - claim.modelConfidence));
    const z = -0.85 - (1.42 * logitConf) + (2.15 * recencyPenalty) - (1.80 * claim.sourceTrustScore) + (claim.contradictionFlag ? 2.5 : 0.0);
    return Math.max(0.001, Math.min(0.999, 1.0 / (1.0 + Math.exp(-z))));
  }

  public computeStoppingValue(candidate: CandidateAction): { vStop: number; rExpected: number; hHarm: number } {
    let pAnyViolation = 0.0;
    for (const p of candidate.premises) {
      pAnyViolation = 1.0 - (1.0 - pAnyViolation) * (1.0 - p.calibratedViolationProbability);
    }
    const rExpected = pAnyViolation * candidate.impactCostTheta;
    const hHarm = pAnyViolation;
    const isAdmissible = rExpected <= Math.min(this.deltaLossThreshold, candidate.abstentionCostKappa) &&
                         hHarm <= this.epsilonHarmBound;
    return { vStop: isAdmissible ? rExpected : candidate.abstentionCostKappa, rExpected, hHarm };
  }

  public computeOneStepVOI(candidate: CandidateAction, verifier: Verifier, currentVStop: number): number {
    const targetPremise = candidate.premises.find(p => verifier.resolvesPremiseIds.includes(p.id));
    if (!targetPremise) return -this.lambdaCostScale * verifier.executionCost;

    const p = targetPremise.calibratedViolationProbability;
    const r = verifier.symmetricReliability;
    const pConfirm = (1.0 - p) * r + p * (1.0 - r);
    const pRefute = 1.0 - pConfirm;

    const pPlus = (p * (1.0 - r)) / pConfirm;
    const pMinus = (p * r) / pRefute;

    const vStopConfirm = this.computeStoppingValue({
      ...candidate,
      premises: candidate.premises.map(pm => pm.id === targetPremise.id ? { ...pm, calibratedViolationProbability: pPlus } : pm)
    }).vStop;

    const vStopRefute = this.computeStoppingValue({
      ...candidate,
      premises: candidate.premises.map(pm => pm.id === targetPremise.id ? { ...pm, calibratedViolationProbability: pMinus } : pm)
    }).vStop;

    const grossVOI = currentVStop - (pConfirm * vStopConfirm + pRefute * vStopRefute);
    return grossVOI - (this.lambdaCostScale * verifier.executionCost);
  }

  public evaluate(candidate: CandidateAction, verifiers: Verifier[]): { regime: ActionRegime; selectedVerifier?: Verifier } {
    const { vStop, rExpected, hHarm } = this.computeStoppingValue(candidate);
    let bestV: Verifier | undefined;
    let maxVOI = -Infinity;

    for (const v of verifiers) {
      const voi = this.computeOneStepVOI(candidate, v, vStop);
      if (voi > maxVOI) {
        maxVOI = voi;
        bestV = v;
      }
    }

    if (maxVOI > 0 && bestV) return { regime: 'VERIFY', selectedVerifier: bestV };
    if (rExpected <= Math.min(this.deltaLossThreshold, candidate.abstentionCostKappa) && hHarm <= this.epsilonHarmBound) {
      return { regime: 'PROCEED' };
    }
    return { regime: 'ABSTAIN' };
  }
}

9. Kesimpulan Arsitektural untuk Rekayasa AI Agent

Riset AMV-Guard menandai perubahan paradigma mendasar dalam desain sistem agen otonom. Masa di mana sistem agen memperlakukan memori sebagai repositori pasif telah berakhir. Dalam sistem otonom kelas enterprise:

1. Memori Tidak Boleh Dipercaya Secara Membabi Buta: Tingkat kepercayaan memori historis harus dikalibrasi secara berkala terhadap keusangan waktu dan riwayat sumber.
2. Kondisikan Verifikasi pada Konsekuensi: Verifikasi adalah keputusan ekonomi. Nilai verifikasi dihitung bukan dari seberapa penasaran sistem terhadap memori, melainkan apakah hasil observasi dapat menyelamatkan sistem dari keputusan fatal.
3. Sediakan Opsi Abstain Eksplisit: Agen yang aman harus memiliki kemampuan untuk menolak bertindak ketika ketidakpastian tinggi dan verifikasi tidak mampu menjamin keselamatan. Menolak bertindak secara terencana jauh lebih berharga daripada kegagalan katastropik di lingkungan produksi.