SourceLearn 2026: Arsitektur Persistent Source Model, Self-Directed & Task-Guided Learning, serta Peningkatan Akurasi hingga +22.6 Poin Melampaui Hybrid RAG pada Autonomous AI Agents

1. Mengapa RAG, GraphRAG, dan Agent Memory Konvensional Mengalami Kebuntuan Kognitif?

Dalam pengembangan sistem autonomous AI agent modern, agen kerap dioperasikan pada satu lingkungan atau repositori data yang persisten dalam jangka panjang: misalnya satu repositori kode monolitik (software engineering agent), dokumentasi API perbankan/fintech (enterprise tool-use agent), atau basis pengetahuan regulasi hukum (compliance agent).

Meskipun agen telah menyelesaikan ratusan tugas pada basis pengetahuan yang sama, paradigma yang mendominasi saat ini masih memandang interaksi tersebut melalui kacamata yang sempit:

Gambar 1: Perbedaan mendasar antara Knowledge Access (RAG/GraphRAG), Agent Memory (AWM/Generative Memory), dan Source Learning (SourceLearn).

• Paradigma Knowledge Access (RAG, Long-Context, GraphRAG, RAPTOR): Pendekatan ini berfokus pada cara dokumen diindeks atau dipotong (chunking) dan bagaimana informasi diambil pada saat inferensi tugas ($t$). Namun, setiap kali ada tugas baru, agen memulai pencarian dari nol. Pemahaman mengenai relasi implisit, prasyarat fungsi, atau struktur tersembunyi tidak pernah diakumulasikan ke dalam model pemahaman yang persisten.
• Paradigma Agent Memory (AWM, Reflexion, Generative Agents): Memori agen menyimpan jejak interaksi masa lalu (trajectory, kesalahan, atau refleksi percakapan). Masalahnya, memori ini terikat erat pada instansiasi tugas individual. Ketika model menyimpan instruksi ad-hoc dari tugas sebelumnya, halusinasi atau informasi usang rentan merembes ke tugas masa depan tanpa dapat diverifikasi kembali ke dokumen otoritatif.
• Paradigma Source Learning (Source-Specific Competence): Menjadikan kompetensi pemahaman atas sumber data otoritatif sebagai objek pembelajaran tersendiri. Agen membangun pemahaman terstruktur yang dapat direvisi secara adaptif seiring waktu, memisahkan pemahaman tingkat tinggi dari bukti mentah, dan memvalidasi setiap perubahan kembali ke teks sumber otoritatif.

2. Formulasi Matematis: Memisahkan Bukti Fakta Otoritatif dari Pemahaman Kumulatif

Dalam formulasi formal makalah ini, misalkan kita memiliki sebuah sumber eksternal otoritatif $D$ (misalnya dokumentasi API, basis kode, atau koleksi dokumen) dan urutan tugas $(q, y) \sim \mathcal{P}_D$ yang seluruhnya berpijak pada sumber $D$.

Sistem berbasis akses pengetahuan konvensional (RAG) dapat dirumuskan secara matematis sebagai:

di mana $R(D, q)$ adalah modul retrieval yang menyajikan potongan konteks dari $D$ untuk kueri $q$, dan $F$ adalah LLM penyelesai tugas. Di sini terlihat jelas bahwa tidak ada kondisi memori kumulatif yang tersimpan antar tugas.

Sebaliknya, Source Learning memperkenalkan Persistent Source Model $M$ yang berevolusi berdasarkan akumulasi pengalaman studi mandiri dan riwayat penyelesaian tugas $H_t$:

Saat menghadapi tugas baru di masa depan, $M_t$ tidak menggantikan dokumen asli $D$, melainkan melengkapi bukti mentah $R(D, q)$:

Perbedaan peranan ini krusial: $R(D, q)$ menyuplai bukti faktual spesifik yang presisi, sedangkan $M_t$ menyediakan peta navigasi semantik, syarat-syarat batas yang eksplisit, mekanisme operasional, dan relasi dependensi antar entitas yang sebelumnya telah dipelajari.

3. Arsitektur SourceLearn: Konstruksi Awal, Grounded Reconstruction, dan Source-Model Activation

Siklus penuh evolusi model pemahaman pada SourceLearn dirangkum dalam persamaan komposisi:

Gambar 2: Diagram alir arsitektur SourceLearn mulai dari pembacaan provisi ($M_0$), pengayaan mandiri ($M_S$), pemurnian berpandukan tugas ($M_T$), hingga aktivasi konteks inferensi.

A. Konstruksi Awal Provisi ($M_0$)

Alih-alih langsung mencoba menghafal seluruh detail, sistem memecah sumber $D$ menjadi region-region koheren (modul kode, sub-bab dokumentasi, struktur hierarki). Instruksi generik $\Pi_0$ mengarahkan model untuk mencatat entitas utama ($e$), relasi kunci, prosedur pokok, dan batasan operasional, sembari mengabaikan detail trivia yang mudah dicari via BM25/vektor. Model $M_0$ yang dihasilkan sengaja bersifat provisi.

B. Prinsip Grounded Source Reconstruction (Eq. 5)

Salah satu pilar terpenting dalam SourceLearn adalah prinsip rekonstruksi berjangkar sumber (grounded reconstruction). Ketika ada sinyal pembelajaran $\xi$ (baik dari refleksi mandiri maupun kegagalan tugas), agen tidak pernah menempelkan observasi mental atau teks spekulatif secara langsung ke dalam memori persisten. Sebaliknya:

Sistem membaca ulang wilayah sumber terkait $D_R$ dengan bimbingan observasi $O_R$. Hanya pemahaman yang secara sah didukung oleh bukti teks sumber otoritatif yang dapat dikomit ke dalam model persisten. Jika suatu hipotesis tidak terbukti dalam teks sumber, hipotesis tersebut dibuang.

C. Source-Model Activation ($A_B(M, q)$)

Seiring bertumbuhnya sumber, model pemahaman $M$ dapat melampaui alokasi token konteks (context budget) $B$. Oleh karena itu, modul aktivasi memfilter sub-region model yang relevan secara topologis tanpa memecah koherensi internal:

4. Dual Learning Loops: Self-Directed Source Learning vs Task-Guided Source Learning

1. Self-Directed Source Learning (Siklus Inspect – Study – Consolidate)

Sebelum agen menerima kueri pengguna di lingkungan produksi, agen dapat melakukan eksplorasi mandiri secara proaktif atas dokumentasi atau basis kode:

• Model-Conditioned Inspection (Eq. 9): Untuk setiap entitas $e$, agen membaca ulang sumber $S_e$ bersama pemahaman saat ini $m_e$: $O_e = \operatorname{Observe}(S_e, m_e)$. Fokusnya bukan merangkum kembali, melainkan mencari: "Apa yang saat ini gagal dijelaskan dengan baik oleh representasi kita?" (misalnya syarat batas pengecualian yang masih implisit).
• Adaptive Source Study (Eq. 10): Planner memilih aksi studi $\Gamma_b$:
  • Deepen(e, q_study): Memperdalam aspek mekanisme internal atau kondisi batas pada satu entitas.
  • Connect(e_i, e_j, q_study): Menautkan relasi dependensi lintas entitas yang selama ini terisolasi.
• Evidence Consolidation: Pola read-many, write-once. Seluruh observasi sementara digabungkan dan divalidasi ke dokumen sumber sebelum committed menjadi $M_S$.

2. Task-Guided Source Learning (Refinement & Policy Aggregation)

Penggunaan nyata oleh pengguna menghadirkan sinyal empiris: bagian mana dari dokumentasi yang benar-benar esensial dan bagaimana representasi harus ditata. Tahap ini memiliki dua kanal:

5. Evaluasi Empiris Lintas 5 Benchmark & 3 LLM Backends

Eksperimen dilakukan secara masif melintasi lima dataset terstandar: MultiDoc2Dial (dokumen administratif kompleks), NarrativeQA (naskah buku dan film panjang), SWE-QA (tanya-jawab repositori GitHub perangkat lunak nyata), APIBench (pemanggilan tool-calling API), dan AppWorld (agen interaktif mengoperasikan smartphone virtual multi-aplikasi).

Tabel 1: Ringkasan hasil empiris utama. SourceLearn mendominasi performa di hampir semua kategori. Pada DeepSeek-V4.1-Flash dan GPT-5.6-Luna, SourceLearn unggul mutlak di kelima benchmark.

6. Mengapa Source Model Bukan Sekadar Ringkasan Teks Terkompresi? Analisis Ablasi & Struktur Kognitif

Kritik umum terhadap arsitektur memori baru adalah: "Bukankah ini hanya ringkasan teks dokumen yang dikompresi?" Riset ini menjawab keraguan tersebut secara empiris melalui telaah struktur dan studi ablasi mendalam.

Gambar 3: Ablasi tahapan belajar (kiri) dan dual pathways Task-Guided (kanan). Menghapus salah satu tahapan selalu menurunkan akurasi.

Gambar 4: Pergeseran komposisi representasi dari sekadar fakta/atribut menjadi aturan (rules) dan prosedur, serta pelonjakan explicit conditions (30% → 82%).

Temuan Kunci Dinamika Kognitif:

1. Transisi dari Fakta Pasif ke Prosedur & Aturan Aktif: Pada $M_0$, representasi didominasi oleh deskripsi umum dan atribut pasif. Seiring berlangsungnya Self-Directed dan Task-Guided learning menuju $M_T$, representasi bergeser menjadi pemodelan aturan kausalitas (causal rules), penanganan pengecualian (exceptions), dan alur prosedur eksekusi.
2. Eksplisitasi Syarat Batas (Applicability Conditions): Unit representasi yang memuat syarat batas eksplisit melonjak tajam dari ~30% pada $M_0$ menjadi 65% hingga 82% pada $M_T$. Agen belajar bahwa dalam sistem produksi, mengetahui kapan suatu fungsi boleh dipanggil jauh lebih bernilai daripada sekadar mengetahui apa fungsi tersebut.
3. Korelasi Langsung dengan Akurasi: Cakupan klaim sumber yang dibutuhkan tugas meningkat dari 23.2% di $M_0$ menjadi 40.0% di $M_T$. Ketika seluruh klaim tugas terwakili dalam model $M$, akurasi penyelesaian melonjak hingga 86.6% (dibandingkan 67.5% saat tidak terwakili).

7. Desain Arsitektur Produksi: Persistent Source Model Harness (TypeScript Enterprise)

Berikut adalah implementasi referensi produksi berstandar enterprise yang merealisasikan pemisahan antara Persistent Source Model, Grounded Reconstruction Gate, dan Dynamic Region Activation:

// Production Architecture: SourceLearn Persistent Source Model & Dual-Loop Learning
// Berdasarkan Prinsip Arsitektur Riset arXiv:2610.02150 (Oktober 2026 - Georgia Tech, UIUC, UCLA)
// Pemisahan Tegas: Persistent Understanding (Source Model M) vs Direct Evidence Retrieval R(D, q)

export interface SourceEntity {
  id: string;
  name: string;
  category: 'overview' | 'attribute' | 'rule' | 'procedure' | 'constraint';
  properties: Record;
  governingConditions: string[]; // Explicit applicability boundaries
  crossEntityRelations: Array<{
    targetEntityId: string;
    relationType: 'depends_on' | 'overrides' | 'extends' | 'conflicts_with';
  }>;
  groundedSourcePointers: string[]; // Pointers to authoritative document regions
}

export interface PersistentSourceModel {
  sourceId: string;
  version: number;
  entities: Map;
  representationPolicy: string; // Learned representation policy Π1
  totalTokens: number;
}

export class SourceLearnHarness {
  private sourceModel: PersistentSourceModel;
  private readonly maxContextBudget: number; // Token budget B (e.g., 4000 tokens)

  constructor(sourceId: string, maxContextBudget: number = 4000) {
    this.maxContextBudget = maxContextBudget;
    this.sourceModel = {
      sourceId,
      version: 0,
      entities: new Map(),
      representationPolicy: 'Standard entity-relation extraction focusing on explicit governing conditions.',
      totalTokens: 0,
    };
  }

  /**
   * Source-Model Activation A_B(M, q):
   * Memilih subgraf pemahaman yang relevan dengan kueri tanpa melebihi budget B
   */
  public activateModelContext(query: string): string {
    if (this.sourceModel.totalTokens <= this.maxContextBudget) {
      return this.serializeModel(this.sourceModel);
    }
    // Region-based dynamic activation
    return this.selectTopRegionsByRelevance(query, this.maxContextBudget);
  }

  /**
   * Self-Directed Source Learning: Cycle Inspect -> Study -> Consolidate
   */
  public async executeSelfDirectedCycle(authoritativeDoc: string): Promise {
    // 1. Model-Conditioned Source Inspection (Observe)
    const provisionalGaps = await this.inspectModelAgainstSource(authoritativeDoc);

    // 2. Adaptive Source Study (Deepen & Connect)
    const studyObservations: string[] = [];
    for (const gap of provisionalGaps) {
      if (gap.type === 'UNRESOLVED_MECHANISM') {
        const obs = await this.studyDeepen(gap.entityId, gap.query, authoritativeDoc);
        studyObservations.push(obs);
      } else if (gap.type === 'FRAGMENTED_RELATION') {
        const obs = await this.studyConnect(gap.entityIdA, gap.entityIdB, gap.query, authoritativeDoc);
        studyObservations.push(obs);
      }
    }

    // 3. Evidence Consolidation (Grounded Reconstruction - Read Many, Write Once)
    await this.groundedReconstructAndCommit(studyObservations, authoritativeDoc);
  }

  /**
   * Task-Guided Source Learning: Failure-Guided Refinement + Cross-Task Policy Aggregation
   */
  public async processTaskOutcome(
    taskQuery: string,
    agentAnswer: string,
    groundTruth: string,
    isCorrect: boolean,
    authoritativeDoc: string
  ): Promise {
    if (!isCorrect) {
      // Pathway A: Failure-guided local refinement
      const missingRequirements = await this.diagnoseMissingRequirements(
        taskQuery, groundTruth, authoritativeDoc
      );
      if (missingRequirements.length > 0) {
        await this.refineLocalEntities(missingRequirements, authoritativeDoc);
      }
    }

    // Pathway B: Cross-task representation learning (Extract lesson ℓt & aggregate to Π1)
    const lesson = await this.extractRepresentationLesson(taskQuery, agentAnswer, isCorrect);
    this.sourceModel.representationPolicy = this.aggregatePolicy(
      this.sourceModel.representationPolicy, lesson
    );
  }

  private async inspectModelAgainstSource(doc: string): Promise {
    return [{ type: 'UNRESOLVED_MECHANISM', entityId: 'auth_flow', query: 'Token expiry edge case' }];
  }

  private async studyDeepen(entityId: string, q: string, doc: string): Promise {
    return `Deepened understanding for ${entityId} based on authoritative excerpt.`;
  }

  private async studyConnect(eA: string, eB: string, q: string, doc: string): Promise {
    return `Connected relation between ${eA} and ${eB}.`;
  }

  private async groundedReconstructAndCommit(observations: string[], doc: string): Promise {
    this.sourceModel.version += 1;
  }

  private async diagnoseMissingRequirements(q: string, gt: string, doc: string): Promise {
    return ['explicit_retry_limit_condition'];
  }

  private async refineLocalEntities(reqs: string[], doc: string): Promise {
    this.sourceModel.version += 1;
  }

  private async extractRepresentationLesson(q: string, ans: string, correct: boolean): Promise {
    return 'Preserve explicit condition boundaries for transactional state transitions.';
  }

  private aggregatePolicy(current: string, lesson: string): string {
    return `${current}; Rule: ${lesson}`;
  }

  private serializeModel(model: PersistentSourceModel): string {
    return JSON.stringify(Array.from(model.entities.values()));
  }

  private selectTopRegionsByRelevance(query: string, budget: number): string {
    return 'Selected relevant sub-graph bounded by context budget.';
  }
}

8. Panduan Rekayasa untuk Pengembang AI Agents 2026

Bagi software engineer dan AI architect yang merancang autonomous coding agents, customer service agents, atau internal enterprise copilots, makalah SourceLearn (arXiv:2610.02150) menyajikan prinsip-prinsip desain penting:

• Hentikan Anggapan Bahwa Chunking RAG Statis Cukup: Mengandalkan top-k cosine similarity pada vector database statis menjamin bahwa agen Anda akan mengulang kesalahan yang sama setiap hari pada repositori kode Anda. Sumber otoritatif yang menetap harus dipelajari secara aktif.
• Terapkan Grounded Reconstruction Gate: Jangan biarkan agen menyimpan raw thoughts atau refleksi tanpa verifikasi ke persistent memory. Setiap perubahan pada pemahaman modul harus dibaca ulang terhadap file sumber asli untuk mencegah akumulasi halusinasi laten.
• Pisahkan Model Pemahaman ($M$) dari Bukti Spesifik ($R(D,q)$): Gunakan model persisten untuk memberikan pemahaman tingkat tinggi mengenai arsitektur, dependensi, dan prasyarat operasional, sembari tetap melakukan retrieval langsung untuk detail numerik atau baris kode spesifik.
• Agregasi Kebijakan Representasi Lintas Tugas ($\Pi_1$): Ketika agen gagal menjalankan tool atau keliru memodifikasi modul karena parameter tertentu tidak terdokumentasi rapi, induksikan aturan representasi tersebut ke seluruh entitas lain di dalam repositori.