JITMEM 2026: Arsitektur Just-in-Time Memory, Read-Time Curation Tanpa Information Loss, dan Eliminasi Long-Horizon Credit Assignment pada Autonomous LLM Agents

Dalam arsitektur Autonomous AI Agents kontemporer, kemampuan memanfaatkan pengalaman masa lalu (agentic memory) untuk menyelesaikan tugas-tugas masa depan merupakan faktor penentu antara agen mainan dan sistem rekayasa perangkat lunak otonom tingkat produksi. Namun, selama bertahun-tahun komunitas AI terbelenggu dalam satu dogma desain: Write-Time Memory Curation. Begitu sebuah tugas selesai, sistem langsung mengekstrak refleksi verbal, merangkum alur kerja, atau menyusun pustaka skill (seperti pada Reflexion, Expel, ReasoningBank, dan SkillOS) yang kemudian disimpan ke dalam basis data vektor. Pada riset frontier terbaru arXiv:2609.27334 yang dipublikasikan oleh Salesforce AI Research, UC San Diego, dan University of Washington (23 September 2026), tim peneliti membongkar cacat fundamental paradigma ini dan memperkenalkan solusi radikal: JITMEM (Just-in-Time Memory).

1. Anatomi Kegagalan Write-Time Curation pada Sistem Agen

Untuk memahami signifikansi JITMEM, kita harus meninjau siklus hidup memori konvensional. Dalam pendekatan write-time curation, agen mengeksekusi tugas $x_t$, menghasilkan riwayat lintasan $\xi_t = (o_1, a_1, \dots, o_n, a_n)$, dan saat tugas berakhir:

Pendekatan ini memiliki 3 kelemahan mematikan yang tidak dapat dihindari:

• Premature & Irreversible Information Loss: Ringkasan yang dibuat bersifat statis dan independen dari kueri masa depan (query-independent). Jika ringkasan mencatat strategi navigasi namun membuang detail tata letak objek sekunder, maka saat tugas masa depan membutuhkan tata letak objek sekunder tersebut, informasi itu telah hilang selamanya dan tidak dapat dipulihkan.
• Satu Trajektori, Beragam Kebutuhan Prosedural: Sebuah eksekusi tugas di dunia nyata tidak hanya memuat satu pelajaran tunggal. Trajektori yang sama dapat memberikan pelajaran tentang cara mengabaikan produk palsu bagi satu kueri, namun memberikan pelajaran tentang cara memilih opsi warna bagi kueri lain. Mengompresinya menjadi satu artefak kaku di awal menghancurkan fleksibilitas representasi.
• Long-Horizon Credit-Assignment Hell: Melatih model untuk menulis ringkasan yang baik sangat sulit karena nilai dari keputusan penyimpanan pada langkah $s$ baru dapat dinilai ketika tugas masa depan $t > s$ mengambilnya. Keterlambatan sinyal ini memaksa sistem seperti SkillOS mengelompokkan tugas secara artifisial (task grouping) agar reward dapat dihitung.

2. Arsitektur JITMEM: Deferring Curation to Read Time

JITMEM mengadopsi teori neurosains kognitif (Schacter & Addis, 2007) yang menyatakan bahwa memori episodik manusia bersifat rekonstruktif, bukan replayed. Pengalaman masa lalu direkonstruksi secara dinamis sesuai kebutuhan dan konteks tujuan saat ini.

Sistem JITMEM terdiri dari 4 komponen modular:

3. Formulasi Matematika: Eliminasi Credit-Assignment Delay via GRPO

Kelemahan paling kronis dari kurasi memori terlatih sebelumnya adalah ketergantungan pada rantai umpan balik bertingkat. Pada JITMEM, karena payload $p_t$ dikonsumsi seketika pada tugas yang sama $t$, maka reward $r_t \in [0, 1]$ yang diterima oleh eksekutor adalah fungsi langsung dari payload $p_t$:

Kurator memori $\pi_\phi$ dioptimalkan menggunakan Group Relative Policy Optimization (GRPO). Untuk setiap tugas $x_t$, kurator membangkitkan sebuah kelompok berisi $G$ variasi payload kandidat $\{p_t^{(1)}, p_t^{(2)}, \dots, p_t^{(G)}\}$. Eksekutor mencoba tugas tersebut untuk masing-masing payload dan mengembalikan skor keberhasilan $r_t^{(i)}$.

Keunggulan relatif (normalized advantage) dihitung melalui normalisasi z-score kelompok:

Fungsi objektif loss diperbarui melalui:

Desain elegan ini menghapus total kebutuhan akan jaringan kritikus (value network) serta melenyapkan rekayasa scaffolding buatan seperti pengelompokan tugas sintetis yang membebani komputasi pelatihan.

4. Evaluasi Benchmark Empiris: ALFWorld, WebShop, dan τ²-bench

Pengujian komprehensif dilakukan pada tiga lingkungan agentik standar industri dengan membandingkan JITMEM terhadap agen tanpa memori (No Memory) serta baseline kurasi write-time tercanggih (ReasoningBank, MemP, dan SkillOS):

Tabel benchmark di atas menyajikan temuan luar biasa:

• Keunggulan Kurator Untrained: Bahkan varian JITMEM-base (kurator berbasis prompt tanpa pelatihan RL) telah melampaui metode write-time terlatih (60.5 vs 55.7 di ALFWorld). Ini membuktikan secara definitif bahwa keuntungan utama berasal dari waktu kurasi (read-time vs write-time), bukan semata-mata tuning bobot.
• Multi-Turn Tool Use (τ²-bench): Pada pengujian multi-turn dialog layanan pelanggan τ²-bench (Airline, Retail, Telecom), JITMEM mencatat kenaikan micro average menjadi 75.6% (vs 71.7% ReasoningBank). Peningkatan terbesar dicapai pada domain Telecom (+11.0 poin absolut dari 61.6% ke 72.6%) di mana tugas menuntut verifikasi kepatuhan kebijakan (policy verification) multi-langkah yang rumit.
• Efisiensi Token Konteks & Langkah: Pada ALFWorld dengan eksekutor GPT-5.4, JITMEM hanya membutuhkan rata-rata 9.8K token input (dibandingkan 19.7K pada ReasoningBank dan 22.4K pada SkillOS) serta memangkas langkah interaksi dari 17.8 langkah menjadi hanya 11.6 langkah per tugas. Penghematan token mencapai 56.2%!
• Cross-Executor Zero-Shot Transfer: Kurator yang dilatih sekali saja menggunakan eksekutor open-weights Qwen3-8B dapat langsung ditransfer untuk memandu eksekutor komersial frontier seperti Gemini-2.5-Pro dan GPT-5.4 tanpa fine-tuning ulang, dengan margin transfer hanya berjarak 1.4 poin dari kurator yang dilatih secara native.

5. Analisis Ablasi: Validasi Teorema Kurasi Adaptif

Rangkaian studi ablasi pada arXiv:2609.27334 memberikan verifikasi ketat terhadap masing-masing keputusan desain:

6. Implementasi Produksi: Blueprint JitMemEngine Python

Di bawah ini adalah implementasi referensi arsitektur JitMemEngine lengkap yang mencakup Memory Bank lossless, BM25 Task Retriever, Task-Adaptive Read-Time Curator, dan kalkulator loss GRPO berjarak temporal nol:

"""
JitMemEngine: Arsitektur Just-in-Time Memory & Task-Adaptive Read-Time Curation.
Berdasarkan formulasi riset Salesforce AI Research (arXiv:2609.27334, Zhou et al., September 2026).

Komponen Arsitektur Utama:
1. Lossless Raw Trajectory Bank: Menyimpan riwayat (x, \xi, r) tanpa kompresi prematur pada write-time.
2. Lightweight Task-Only BM25 Retriever: Mengambil top-k jejak mentah berdasar kemiripan deskripsi tugas x_t.
3. Task-Adaptive Read-Time Curator (\pi_\phi): Mengonstruksi ringkasan prosedural kondisional spesifik tugas x_t.
4. Immediate-Reward GRPO Trainer: Eliminasi delayed credit-assignment via zero temporal gap reward signal.
5. Quality-Gated Storage Policy (LLM-as-Judge): Hanya memvalidasi jejak sukses murni ke memory bank.
"""

from dataclasses import dataclass, field
from typing import List, Dict, Any, Optional, Tuple
import math
import re

@dataclass
class Trajectory:
    task_id: str
    task_description: str
    steps: List[Dict[str, str]]  # [{'observation': '...', 'action': '...'}]
    reward: float  # 1.0 = success, 0.0 = failure
    judge_verified: bool = False

@dataclass
class CuratedPayload:
    target_task: str
    relevant_experience_ids: List[str]
    extracted_strategies: List[str]
    actionable_guidance: str
    raw_prompt_payload: str

class RawTrajectoryBank:
    """
    Episodic Memory Bank yang mempertahankan observasi dan aksi secara lossless.
    Menolak abstraksi atau parafrase pada fase write-time.
    """
    def __init__(self, quality_filter_enabled: bool = True):
        self.bank: List[Trajectory] = []
        self.quality_filter = quality_filter_enabled

    def update(self, trajectory: Trajectory) -> bool:
        # Aturan Kualitas: Hanya menerima jejak yang diverifikasi sukses oleh LLM-as-Judge
        if self.quality_filter and not trajectory.judge_verified:
            return False
        self.bank.append(trajectory)
        return True

    def get_all(self) -> List[Trajectory]:
        return self.bank

class BM25TaskRetriever:
    """
    Retriever leksikal ringan yang diindeks HANYA pada deskripsi tugas x,
    mencegah bias panjangnya riwayat observasi/aksi dalam proses retrieval.
    """
    def __init__(self, memory_bank: RawTrajectoryBank):
        self.memory_bank = memory_bank

    def _tokenize(self, text: str) -> List[str]:
        return re.findall(r'\w+', text.lower())

    def retrieve(self, query_task: str, top_k: int = 3) -> List[Trajectory]:
        trajectories = self.memory_bank.get_all()
        if not trajectories:
            return []

        query_tokens = set(self._tokenize(query_task))
        scored: List[Tuple[float, Trajectory]] = []

        for traj in trajectories:
            task_tokens = self._tokenize(traj.task_description)
            if not task_tokens:
                continue
            # Simple TF-IDF / BM25 lexical overlap surrogate
            overlap = sum(1 for t in task_tokens if t in query_tokens)
            score = overlap / (len(task_tokens) + 1e-5)
            scored.append((score, traj))

        scored.sort(key=lambda x: x[0], reverse=True)
        return [item[1] for item in scored[:top_k]]

class TaskAdaptiveMemoryCurator:
    """
    Kurator Memori Read-Time (\pi_\phi).
    Menghasilkan ringkasan actionable briefing yang dikondisikan pada target task x_t
    dan top-k raw trajectories \hat{\xi}_t.
    """
    def __init__(self, model_name: str = "qwen3-8b"):
        self.model_name = model_name

    def format_curator_prompt(self, task_description: str, retrieved_traces: List[Trajectory]) -> str:
        prompt = (
            "\n"
            "You are a Memory Curator. You will be given a task that an AI agent needs to solve, "
            "along with retrieved past experiences from similar successful tasks.\n"
            "Your job: synthesize these raw memories into a concise, actionable briefing that will "
            "help the agent solve the current task.\n"
            "Rules:\n"
            "1. Extract procedural strategies that worked (action order, tool combinations).\n"
            "2. Give specific guidance for THIS task.\n"
            "3. Do not copy concrete transient IDs or instance-specific values.\n"
            "Be concise - the agent has limited context.\n\n"
            f": {task_description}\n"
            "### Retrieved Raw Memories:\n"
        )
        for i, trace in enumerate(retrieved_traces, 1):
            prompt += f"Memory {i} (Task: {trace.task_description}):\n"
            for step in trace.steps:
                prompt += f"  Obs: {step.get('observation', '')[:120]} -> Act: {step.get('action', '')}\n"
        return prompt

    def curate(self, task_description: str, retrieved_traces: List[Trajectory]) -> CuratedPayload:
        prompt = self.format_curator_prompt(task_description, retrieved_traces)
        # Pada produksi, prompt dikirim ke model \pi_\phi (e.g. Qwen3-8B)
        # Di sini kita simulasikan output struktural yang dihasilkan kurator
        guidance = (
            f"Fokus pada urutan investigasi untuk '{task_description}'. "
            "Gunakan verifikasi status sebelum mutasi data."
        )
        return CuratedPayload(
            target_task=task_description,
            relevant_experience_ids=[t.task_id for t in retrieved_traces],
            extracted_strategies=["Prioritas pembacaan state sebelum eksekusi payload mutasi"],
            actionable_guidance=guidance,
            raw_prompt_payload=f"## Task-Adaptive Experience Briefing\n{guidance}"
        )

class JitMemRLTrainer:
    """
    Pelatihan Kurator via Group Relative Policy Optimization (GRPO).
    Keunggulan Fundamental: Gap temporal antara generasi payload kurator (p_t)
    dan reward eksekusi (r_t) adalah NOL. Tidak membutuhkan value network atau task grouping.
    """
    def __init__(self, group_size_g: int = 4, epsilon_clip: float = 0.2):
        self.g = group_size_g
        self.eps = epsilon_clip

    def compute_grpo_loss(
        self,
        candidate_rewards: List[float],
        candidate_log_probs: List[float],
        ref_log_probs: List[float]
    ) -> float:
        """
        L_GRPO = - 1/G * \sum_{i=1}^G \hat{A}_i * \log \pi_\phi(p_t^{(i)} | x_t, \hat{\xi}_t)
        dengan keunggulan direct credit assignment tanpa delay waktu.
        """
        mean_r = sum(candidate_rewards) / len(candidate_rewards)
        variance = sum((r - mean_r) ** 2 for r in candidate_rewards) / len(candidate_rewards)
        std_r = math.sqrt(variance) + 1e-8

        # Hitung normalized advantages \hat{A}_i
        advantages = [(r - mean_r) / std_r for r in candidate_rewards]

        total_loss = 0.0
        for adv, log_p, ref_p in zip(advantages, candidate_log_probs, ref_log_probs):
            ratio = math.exp(log_p - ref_p)
            # PPO/GRPO clipped surrogate objective
            surr1 = ratio * adv
            surr2 = max(min(ratio, 1.0 + self.eps), 1.0 - self.eps) * adv
            total_loss -= min(surr1, surr2)

        return total_loss / len(candidate_rewards)

7. Kesimpulan: Pergeseran Paradigma Menuju Reconstructive Memory

Penemuan yang dihadirkan oleh JITMEM (arXiv:2609.27334) menandai pergeseran paradigma fundamental dalam rekayasa memori agen otonom. Upaya selama bertahun-tahun untuk menciptakan generator "skill", "refleksi", dan "aturan umum" yang kaku pada fase penulisan ternyata merupakan kompromi prematur yang membuang informasi berharga dan memperumit pelatihan reinforcement learning.

Dengan mempertahankan data mentah dalam memori episodik dan mengalokasikan kapasitas komputasi untuk merekonstruksi panduan secara just-in-time sesuai kueri yang sedang dihadapi, agen AI tidak hanya mencapai tingkat keberhasilan yang jauh lebih tinggi (+16 poin), tetapi juga menghasilkan konteks eksekusi yang jauh lebih bersih, hemat token, dan dapat ditransfer lintas model tanpa batas. Bagi para perancang harness dan sistem agen enterprise, mengadopsi Read-Time Curation adalah lompatan evolusioner wajib menuju agen otonom generasi berikutnya.