Memory Portability 2026: Apakah Memori AI Agent Bertahan Saat Model Di-Upgrade? Evaluasi Kritis KG-Fixed, Compressed Notes, dan Mixed RAG Embeddings

Dalam rekayasa sistem agen otonom (autonomous AI agents), meng-upgrade model fondasi atau model embedding telah menjadi rutinitas operasional bulanan: beralih dari satu rilis checkpoint ke versi yang lebih cerdas, lebih murah, atau berlatensi lebih rendah. Namun, terdapat asumsi implisit yang berbahaya di kalangan tim engineering: asumsi bahwa memori persisten yang telah dikumpulkan agen di masa lalu akan dapat dibaca dan dipahami dengan kualitas yang sama oleh model baru. Riset empiris terkontrol terbaru oleh Ankit Goyal dan Jaideep Ray (arXiv:2609.05339, September 2026) membongkar kelemahan fatal asumsi ini dan menyajikan bukti kuantitatif pertama mengenai Memory Portability pada arsitektur AI agent modern.

1. Dekomposisi 4 Peran Komponen dalam Arsitektur Memori Agen

Sebuah sistem memori agen bukanlah entitas monolitik tunggal, melainkan interaksi antara empat subsistem independen dengan siklus hidup yang berbeda:

• Actor ($A$): Entitas atau agen yang secara aktif berinteraksi dengan lingkungan, mengeksekusi instruksi, dan memproduksi jejak operasional (interaction trajectory).
• Writer ($W$): Model bahasa yang bertugas menyarikan, menyaring, atau memadatkan pengalaman mentah ke dalam format memori jangka panjang (misal: meringkas percakapan menjadi scratchpad atau mengekstrak triplets).
• Reader ($R$): Model bahasa (yang dapat berbeda dari $W$, terutama setelah upgrade platform) yang di kemudian hari membaca memori tersebut untuk menjawab pertanyaan atau mengambil keputusan tindakan.
• Embedder ($E$): Model representasi vektor yang mengubah fragmen teks atau entitas menjadi vektor berdimensi tinggi untuk pencarian kemiripan semantik (dense vector retrieval).

Ketika tim engineering melakukan "upgrade model", salah satu atau beberapa dari komponen ini berubah. Pertanyaan intinya: apakah pembaca baru $R_{new}$ dapat memanfaatkan memori yang ditulis oleh $W_{old}$ menggunakan indeks yang dibangun oleh $E_{old}$?

2. Empat Format Memori Produksi dan Titik Rentan Komparatif

Riset arXiv:2609.05339 mengevaluasi 4 paradigma format memori yang umum diimplementasikan di industri:

3. Metrik Pengukuran: RPAS dan Cost-to-Recover (CTR)

Untuk mengukur kemampuan bertahan memori tanpa bias, penelitian memperkenalkan dua metrik formal:

• Retained Performance After Swap (RPAS): Mengukur persentase performa yang dipertahankan ketika reader $B$ mewarisi memori yang dibuat oleh writer $A$ dibandingkan saat reader $B$ membaca memori yang ia bangun sendiri:
  RPAS(A → B) = Score(Reader_B | Memory_A) / Score(Reader_B | Memory_B)
• Cost-to-Recover (CTR): Total biaya komputasi (dalam token dan kalkulasi inferensi) yang dihabiskan untuk mereparasi atau menyelaraskan kembali memori hingga performa reader mencapai kembali ambang batas tertentu (90%, 95%, atau 99% dari baseline).

4. Analisis Data Empiris: Efek Pergantian Writer & Reader

Pengujian dilakukan secara ketat pada 48 riwayat interaksi sintetik kompleks dengan randomized answer codes untuk mencegah kontaminasi memori pre-training, menggunakan dua model open-weights sub-10B:

Perhatikan perbedaan dramatis antara KG-fixed dan NOTES: KG-fixed tidak terpengaruh sama sekali oleh pergantian model (Δ rata-rata hanya $+0.0004 pm 0.0020$). Mengapa? Karena fakta dikonstruksi dalam bentuk entitas dan relasi formal, sehingga pembaca baru mengekstrak informasi melalui parsing skema deterministik, bukan menafsirkan retorika bebas.

Sebaliknya, pada NOTES, jangan pernah merata-ratakan efek migrasi. Terjadi asimetri tajam: beralih dari model penulis berkualitas rendah ke pembaca berkualitas tinggi justru mengecewakan model pembaca baru (turun 13.28 persen poin), karena model pembaca tidak dapat memulihkan fakta yang tidak pernah ditulis oleh model penulis lama.

5. Jebakan 50/50 Mixed Index pada RAG dan Inkompatibilitas Ruang Vektor

Skenario paling umum dalam arsitektur RAG produksi: tim merilis model embedding baru (misal: bge-large-en-v1.5 menggantikan v1.0). Karena jutaan chunk lama tersimpan di vector database, tim memilih strategi lazy migration: dokumen baru di-embed dengan v1.5, sedangkan dokumen lama dibiarkan dengan v1.0, lalu query di-embed dengan v1.5.

Pengujian empiris membuktikan bahwa strategi ini adalah bencana tersembunyi bagi keandalan sistem:

Indeks 50/50 campuran hanya mampu menangkap +4.96 pp dari potensi kenaikan +11.90 pp yang seharusnya diperoleh melalui full re-embedding. Sebanyak 7 persen poin performa terbuang percuma karena fungsi jarak kosinus (cosine distance) kehilangan konsistensi metrik saat membandingkan vektor dari dua manifold representasi yang tidak sejajar.

6. Dekomposisi Diagnostik: Di Mana Informasi Sebenarnya Hilang?

Mengapa agen mengalami lupa atau kegagalan penalaran setelah migrasi? Peneliti membedah total kehilangan performa (end-to-end loss decomposition) ke dalam tiga sumber utama:

Temuan ini memberikan kejelasan arsitektural yang sangat berharga:

• Pada sistem NOTES: Sebanyak 80% defisit akurasi terjadi di hulu (upstream) pada saat konstruksi catatan oleh model pembuat. Jika model pembuat mengabaikan sebuah angka atau parameter konfigurasi penting saat meringkas, model pembaca secanggih apa pun tidak akan pernah bisa menebaknya.
• Pada sistem RAG: Sebanyak 81% defisit akurasi didorong oleh kegagalan temu-balik. Model pembaca sebenarnya memiliki kapabilitas kognitif yang memadai, namun chunk yang memuat jawaban tidak pernah berhasil diekstraksi masuk ke dalam konteks prompt.

7. Evaluasi Reparasi Memori: Kegagalan Fatal Store-Only Repair

Dapatkah kita mereparasi catatan memori yang rusak dengan menugaskan model baru untuk "membersihkan dan menulis ulang" (memory consolidation/refinement)? Riset menguji dua mekanisme reparasi:

1. Store-Only Repair: Model baru hanya diberikan catatan lama yang tersimpan untuk disintesis ulang tanpa akses ke transkrip mentah asli. Hasil: 0 dari 48 kasus uji (0%) berhasil mencapai target pemulihan 90%. Menulis ulang catatan yang cacat hanya menghasilkan halusinasi baru atau mempertahankan kekosongan fakta.
2. Raw-Retained Repair: Model baru diberikan akses ke transkrip riwayat mentah asli (raw trajectory log). Hasil: 34 dari 48 kasus uji (70.8%) berhasil dipulihkan hingga mencapai target akurasi 90%, dengan median cost pemulihan yang sangat realistis ($0.76 per riwayat).

// Agent Memory Migration Controller & Versioned Embedding Space Guard
// Berdasarkan Prinsip Arsitektur Riset arXiv:2609.05339 (September 2026)
// Mengisolasi Ruang Vektor, Mencegah Mixed Index Drift, dan Menjamin Schema-Grounded Transfer

import { createHash } from 'node:crypto';

export type MemoryFormat = 'lc_raw' | 'rag_chunk' | 'compressed_notes' | 'kg_fixed';

export interface RawTrajectoryEvent {
  eventId: string;
  timestamp: number;
  actorRole: 'user' | 'assistant' | 'tool_environment';
  content: string;
  metadata?: Record;
}

export interface FixedSchemaEntity {
  id: string;
  category: string;
  attributes: Record;
  canonicalHash: string;
  extractedByModel: string;
  schemaVersion: number;
}

export interface VectorChunkRecord {
  chunkId: string;
  rawEventId: string;
  textSnippet: string;
  embeddingVector: number[];
  embedderModelId: string;
  embedderDimension: number;
}

export interface ModelWriterSpec {
  modelId: string;
  contextWindow: number;
  temperature: number;
}

export interface MigrationAuditResult {
  sourceModel: string;
  targetModel: string;
  format: MemoryFormat;
  rpasScore: number; // Retained Performance After Swap
  reconstructableFromRaw: boolean;
  mixedIndexViolations: number;
}

export class AgentMemoryMigrationKernel {
  private rawEventStore: Map = new Map();
  private fixedSchemaGraph: Map = new Map();
  private vectorIndicesByModel: Map = new Map();

  /**
   * 1. Immutable Raw Event Append-Only Logger
   * Wajib disimpan untuk skenario perbaikan memori (recovering lost facts).
   * Riset membuktikan repair berbasis store-only memiliki 0% recovery,
   * sedangkan raw-retained history memulihkan hingga 70.8% kasus.
   */
  public recordRawEvent(sessionId: string, event: Omit): void {
    const events = this.rawEventStore.get(sessionId) || [];
    const eventId = createHash('sha256')
      .update(`${sessionId}:${event.timestamp}:${event.content}`)
      .digest('hex')
      .slice(0, 16);

    events.push({ ...event, eventId });
    this.rawEventStore.set(sessionId, events);
  }

  /**
   * 2. Strict Schema Normalization (KG-fixed)
   * Menyimpan memori dalam skema bertipe statis yang independen dari model penulis.
   * Menghasilkan transfer nyaris tanpa degradasi (Δ = +0.0004).
   */
  public commitFixedSchemaEntity(
    sessionId: string,
    category: string,
    attributes: Record,
    writerModel: string,
    schemaVersion = 1
  ): FixedSchemaEntity {
    const entities = this.fixedSchemaGraph.get(sessionId) || [];
    const canonicalPayload = JSON.stringify({ category, attributes, schemaVersion });
    const canonicalHash = createHash('sha256').update(canonicalPayload).digest('hex');

    const entity: FixedSchemaEntity = {
      id: `ent-${entities.length + 1}`,
      category,
      attributes,
      canonicalHash,
      extractedByModel: writerModel,
      schemaVersion,
    };

    entities.push(entity);
    this.fixedSchemaGraph.set(sessionId, entities);
    return entity;
  }

  /**
   * 3. Embedding Space Isolation (Anti-Mixed-Index Guard)
   * Mengisolasi index berdasarkan embedderModelId. Riset membuktikan mencampur
   * embedding lama (v1.0) dan baru (v1.5) dalam indeks 50/50 kehilangan 7 pp akurasi.
   */
  public appendVectorChunk(
    embedderId: string,
    chunk: Omit
  ): void {
    const index = this.vectorIndicesByModel.get(embedderId) || [];
    index.push({ ...chunk, embedderModelId: embedderId });
    this.vectorIndicesByModel.set(embedderId, index);
  }

  /**
   * 4. Safe Query Routing
   * Memastikan embedding query hanya ditransaksikan ke index dengan model embedder yang identik.
   */
  public queryIndexStrict(
    queryVector: number[],
    embedderId: string,
    topK = 5
  ): VectorChunkRecord[] {
    const targetIndex = this.vectorIndicesByModel.get(embedderId);
    if (!targetIndex || targetIndex.length === 0) {
      throw new Error(`[EMBEDDING_SPACE_MISMATCH] Indeks untuk model ${embedderId} tidak ditemukan.`);
    }

    // Cosine similarity deterministik
    return targetIndex
      .map(chunk => ({
        chunk,
        score: this.cosineSimilarity(queryVector, chunk.embeddingVector)
      }))
      .sort((a, b) => b.score - a.score)
      .slice(0, topK)
      .map(entry => entry.chunk);
  }

  /**
   * 5. Raw-to-Target Memory Re-synthesis (Zero-Loss Migration)
   * Membangun ulang representasi pembaca baru langsung dari raw event transcript.
   */
  public recompileMemoryForTargetModel(
    sessionId: string,
    targetModel: ModelWriterSpec,
    format: MemoryFormat
  ): { targetPayload: string; factsPreservedRatio: number } {
    const rawEvents = this.rawEventStore.get(sessionId) || [];
    if (rawEvents.length === 0) {
      throw new Error(`[MIGRATION_ERROR] Raw event transcript untuk session ${sessionId} tidak ditemukan.`);
    }

    if (format === 'kg_fixed') {
      const entities = this.fixedSchemaGraph.get(sessionId) || [];
      return {
        targetPayload: JSON.stringify(entities, null, 2),
        factsPreservedRatio: 0.999, // KG-fixed retains ~100% accuracy
      };
    }

    if (format === 'lc_raw') {
      const rawText = rawEvents.map(e => `[${e.actorRole.toUpperCase()}]: ${e.content}`).join('\n');
      return {
        targetPayload: rawText,
        factsPreservedRatio: 1.0,
      };
    }

    // Untuk format NOTES / RAG, kembalikan sintesis terstruktur dengan peringatan kopling
    const summaryHeader = `// Synthesized with ${targetModel.modelId} from raw ${rawEvents.length} events\n`;
    const synthesizedNotes = rawEvents.map(e => `- ${e.actorRole}: ${e.content.slice(0, 100)}`).join('\n');
    return {
      targetPayload: summaryHeader + synthesizedNotes,
      factsPreservedRatio: 0.85,
    };
  }

  private cosineSimilarity(a: number[], b: number[]): number {
    let dot = 0;
    let normA = 0;
    let normB = 0;
    for (let i = 0; i < a.length; i++) {
      dot += a[i] * b[i];
      normA += a[i] * a[i];
      normB += b[i] * b[i];
    }
    return dot / (Math.sqrt(normA) * Math.sqrt(normB) + 1e-9);
  }
}

8. Panduan Desain Sistem bagi Arsitek AI Agent 2026

Berdasarkan fakta empiris di atas, tim rekayasa perangkat lunak enterprise harus menerapkan empat prinsip pertahanan memori berikut:

• 1. Standarisasi Knowledge Graph Berskema Tetap (KG-Fixed) untuk Fakta Kritis: Jangan mengandalkan ringkasan teks bebas untuk menyimpan entitas kunci pengguna (preferensi, status otorisasi, parameter infrastruktur). Ekstrak ke skema JSON/relasional dengan tipe data yang ketat.
• 2. Isolasi Mutlak Ruang Embedding (No Lazy Mixing): Jangan pernah mencampur chunk dengan versi model embedding yang berbeda dalam satu namespace pencarian vektor. Terapkan strategi Shadow Re-indexing di background sebelum mengarahkan traffic query ke model baru.
• 3. Terapkan Event Sourcing / Cold Storage untuk Raw Trajectories: Jangan pernah menghapus transkrip interaksi asli hanya karena Anda sudah memiliki ringkasan memori ringkas. Simpan raw log dalam object storage murah (S3/Cloudflare R2) sebagai sumber kebenaran tunggal untuk memungkinkan reparasi dan re-sintesis memori di masa depan.
• 4. Uji Arah Migrasi Secara Spesifik (Directional Testing): Sebelum memutakhirkan model agen dalam produksi, hitung metrik RPAS secara terarah ($W_{prod} o R_{candidate}$) untuk memastikan tidak ada penurunan asimetris pada pemahaman konteks lama.