AutoCompact 2026: Arsitektur Proactive Context Compaction pada Long-Horizon Coding Agents, Eliminasi Context Bloat Tanpa Menunggu Window Overflow, dan Terobosan SFT + Outcome-Based RL

Gambar 1: Paradigma Pemadatan Konteks (arXiv:2610.02163 Fig. 1)—Pada length-triggered compaction, agen terus menumpuk pencarian berulang setelah bug terlokalisasi dan hanya merangkum saat batas konteks tercapai. AutoCompact memungkinkan model menentukan (1) kapan memadat proaktif, (2) apa yang harus dipertahankan dalam ringkasan working-state, dan (3) bagaimana melanjutkan eksekusi secara konsisten tanpa tersesat. arXiv:2610.02163

1. Paradoks Jendela Konteks Panjang: Mengapa Menjaga Semua Riwayat Justru Merugikan Agen?

Dengan ketersediaan model fondasi modern yang mendukung context window hingga 128K, 256K, bahkan 1M token, muncul asumsi umum dalam industri bahwa masalah konteks pada coding agents telah terpecahkan: biarkan saja seluruh eksekusi tersimpan tanpa kompresi. Namun, temuan empiris Zhang et al. (2026) membuktikan sebaliknya.

Dalam tugas rekayasa tingkat repositori, seorang agen koding harus melakukan triase bug, menjelajahi pohon direktori, menjalankan grep/find, membaca berkas definisi, menguji hipotesis penyebab, mengedit kode, dan menjalankan uji coba regresi (test suite). Seiring berjalannya tugas:

• Akumulasi Hipotesis Usang (Stale Hypotheses): Upaya perbaikan awal yang gagal dan berkas eksplorasi yang tidak relevan tetap berada dalam prompt, memicu model untuk berulang kali menguji ulang jalur buntu yang sama.
• Attention Dilution & Noise: Log terminal dan traceback ratusan baris menyita kapasitas komputasi self-attention, menyebabkan representasi kode target yang krusial terpinggirkan (lost in the middle).
• Siklus Rangkuman Pasif yang Terlambat: Pemadatan berbasis panjang hanya bertindak sebagai "pemadam kebakaran" ketika buffer memori habis, bukan sebagai strategi penyusunan progres modular.

2. Tiga Pilar Keputusan Proactive Context Compaction

AutoCompact melengkapi agen dengan aksi compact() yang dapat dipanggil kapan saja sebelum batasan jendela memaksanya. Keputusan pemadatan dipecah menjadi tiga pilar deterministik:

Gambar 2: Pengumpulan Data On-Policy Berpandu Judge (arXiv:2610.02163 Fig. 2)—Pada setiap langkah, judge meninjau proposal model hanya menggunakan riwayat eksekusi aktif. Koreksi online dilakukan langsung: (1) Trigger (24%), (2) What/State (53%), dan (3) How/Continuation (23%). Output yang telah diperbaiki dieksekusi ke lingkungan, sehingga trajektori berikutnya berkembang dari keputusan yang benar. arXiv:2610.02163

3. Pipeline Dua Tahap: Online Judge-Guided SFT dan Outcome-Based RL

Meminta model dasar untuk memanggil compact() secara proaktif adalah perilaku yang sangat jarang muncul secara spontan. Kebanyakan model terlatih untuk terus merespons sampai dipaksa berhenti. Oleh karena itu, arsitektur pelatihan AutoCompact dirancang dalam dua fase yang sinergis:

Fase 1: Online Corrective Data Collection & Supervised Fine-Tuning (SFT)

Model dasar (Qwen3-Coder-30B-A3B-Instruct) di-rollout pada 379 tugas SWE-rebench. Saat model mengajukan aksi, sebuah judge tingkat frontier (GPT-5.5-Codex) meninjau proposal tersebut:

• Trigger Correction (24%): Jika bug sudah terlokalisasi namun model masih ingin melakukan search_repo, judge mengganti proposal dengan compact().
• Working-state Correction (53%): Jika ringkasan konteks melupakan berkas target atau variabel penting, judge menyisipkan state yang hilang.
• Continuation Correction (23%): Jika setelah ringkasan model malah mencari lagi hal yang sudah dicatat, judge mengarahkan aksi ke langkah modifikasi kode (edit_file).

Kritikal: Koreksi ini diterapkan sebelum eksekusi lingkungan, berbeda dengan anotasi post-hoc yang tidak mengubah jalannya simulasi. Sebanyak 1.052 trajektori terkoreksi berhasil dihimpun untuk melatih AutoCompact-SFT.

Fase 2: Joint Reinforcement Learning (GRPO) Tanpa Reward Shaping Khusus

Dari checkpoint SFT, model dilatih lebih lanjut pada SWE-Gym menggunakan Group Relative Policy Optimization (GRPO). Yang sangat menarik dari desain arsitektural ini adalah ketiadaan auxiliary loss atau reward shaping buatan untuk pemadatan. Satu-satunya reward adalah binary task success (1 jika seluruh pengujian lolos, 0 jika gagal).

Tantangan teknisnya: setiap pemanggilan compact() menulis ulang konteks (context prefix is rewritten), memutus sifat kausalitas autoregresif murni. Peneliti mengatasi ini dengan Trajectory Segment Splitting: membagi trajektori menjadi segmen-segmen di setiap titik penulisan ulang prefix. Semua segmen dalam satu trajektori berbagi relative advantage yang sama dari GRPO, sehingga keputusan memadat, teks ringkasan, dan aksi lanjutan menerima sinyal pembelajaran yang utuh.

4. Evaluasi Empiris: Dominasi pada SWE-bench Verified & SWE-PolyBench

Evaluasi komprehensif dilakukan pada dua tolak ukur rekayasa perangkat lunak standar industri: SWE-bench Verified (500 tugas Python) dan SWE-PolyBench Verified (multi-bahasa):

Data di atas menunjukkan lompatan masif: AutoCompact menembus 39.6% pada SWE-bench Verified, melampaui seluruh baseline yang mempertahankan riwayat penuh maupun kompresi panjang konvensional.

5. Dimensi Self-Consistency: Mengapa SFT Saja Tidak Cukup?

Salah satu temuan paling mencerahkan dari studi ini terletak pada summary self-consistency. Pada model SFT biasa, ringkasan sering kali menderita inkonsistensi logis: model mencatat bahwa masih terdapat SyntaxError, namun pada baris berikutnya justru menyarankan langkah "Finish; submit patch". Akibatnya agen gagal total saat evaluasi.

Gambar 3: Studi Kasus Konsistensi Mandiri pada SWE-bench Verified (django-13809)—(a) AutoCompact-SFT mencatat SyntaxError namun merencanakan Finish, menyebabkan kegagalan. (b) AutoCompact (pasca RL) mempertahankan konsistensi antara status kode dan rencana tindakan, menghasilkan patch yang berhasil diverifikasi. arXiv:2610.02163

Setelah Outcome-Based RL diterapkan, tingkat penghilangan state penting (missing key state) turun drastis dari 3.1% menjadi 0.2%, dan kelalaian aksi lanjutan (missing next action) anjlok dari 8.2% ke 2.2%. RL mendisiplinkan model bahwa sebuah ringkasan hanya bernilai jika tindakan setelahnya berhasil menyelesaikan masalah di lingkungan nyata.

6. Implementasi Produksi: Arsitektur AutoCompact Controller

Berikut adalah modul TypeScript enterprise-ready yang mengimplementasikan arsitektur kontroler kontekstual AutoCompact dengan segment splitting dan gate validasi kelanjutan rencana:

// Production Implementation: AutoCompact REPL Policy & Proactive Context Controller
// Berdasarkan Arsitektur SMU, NTU & Harvard (arXiv:2610.02163 - Oktober 2026)
//
// Karakteristik Inti:
// 1. Proactive compact() Action: Model dapat memicu pemadatan sebelum batas konteks terlampaui.
// 2. 3-Phase Decision Gate: (1) When to compact, (2) What to keep, (3) How to continue.
// 3. Segmented Context Management: Memecah rekaman eksekusi menjadi segmen linier saat prefix ditulis ulang.
// 4. Fallback Forced Compaction: Penanganan graceful jika batas threshold jendela tercapai.

export interface AgentAction {
  type: 'bash' | 'inspect' | 'edit' | 'test' | 'compact' | 'submit';
  payload: string;
  metadata?: Record;
}

export interface WorkingStateSummary {
  phase: 'localization' | 'implementation' | 'verification';
  targetFiles: string[];
  resolvedHypotheses: string[];
  activeEdits: string[];
  unresolvedErrors: string[];
  plannedNextAction: string;
}

export interface TrajectorySegment {
  segmentId: string;
  initialPrefixTokens: number;
  steps: Array<{
    turn: number;
    action: AgentAction;
    observation: string;
    tokenCount: number;
  }>;
  advantageReward?: number; // Shared across all segments in the trajectory under GRPO
}

export class AutoCompactController {
  private currentContextTokens: number = 0;
  private readonly maxContextTokens: number;
  private readonly forcedCompactionThreshold: number;
  private segments: TrajectorySegment[] = [];
  private currentSegment: TrajectorySegment;
  private activeWorkingState: WorkingStateSummary | null = null;

  constructor(maxContextTokens: number = 262144, forcedCompactionThreshold: number = 16384) {
    this.maxContextTokens = maxContextTokens;
    this.forcedCompactionThreshold = forcedCompactionThreshold;
    this.currentSegment = {
      segmentId: `seg-${Date.now()}-0`,
      initialPrefixTokens: 0,
      steps: [],
    };
    this.segments.push(this.currentSegment);
  }

  /**
   * Menilai apakah agen perlu melakukan pemadatan konteks proaktif berdasarkan progres task
   */
  public evaluateProactiveTrigger(
    currentMilestoneReached: boolean,
    hasUnusedExplorationHistory: boolean
  ): boolean {
    // AutoCompact mempelajari kebijakan: jika milestone tercapai (misal: bug terisolasi)
    // dan riwayat eksplorasi mulai menumpuk, lakukan compact() tanpa menunggu window overflow
    if (currentMilestoneReached && hasUnusedExplorationHistory) {
      return true;
    }
    // Fallback length-triggered safety threshold
    if (this.currentContextTokens >= this.forcedCompactionThreshold) {
      return true;
    }
    return false;
  }

  /**
   * Menjalankan aksi compact(): Merangkum state aktif, membersihkan riwayat usang,
   * dan memulai segmen baru dengan prefix yang diperbarui
   */
  public executeCompaction(summary: WorkingStateSummary): string {
    this.activeWorkingState = summary;

    // Format # Auto Context Summary yang bersih dan deterministik
    const formattedSummary = [
      '# Auto Context Summary',
      `## Current Phase: ${summary.phase.toUpperCase()}`,
      `## Target Files: ${summary.targetFiles.join(', ')}`,
      `## Verified State: ${summary.activeEdits.join('; ') || 'None'}`,
      `## Remaining Issues: ${summary.unresolvedErrors.join('; ') || 'None'}`,
      `## Explicit Next Step: ${summary.plannedNextAction}`,
    ].join('\n');

    // Buat segmen baru karena prefix konteks ditulis ulang (context rewritten)
    // Sesuai Section 2.3: Segment splitting memungkinkan token model dilatih dengan GRPO
    const nextSegmentId = `seg-${Date.now()}-${this.segments.length}`;
    const newPrefixTokens = Math.ceil(formattedSummary.length / 4); // Estimasi token

    this.currentSegment = {
      segmentId: nextSegmentId,
      initialPrefixTokens: newPrefixTokens,
      steps: [],
    };
    this.segments.push(this.currentSegment);
    this.currentContextTokens = newPrefixTokens;

    return formattedSummary;
  }

  /**
   * Verifikasi self-consistency: Memastikan aksi berikutnya sejalan dengan plannedNextAction
   */
  public validateContinuation(nextAction: AgentAction): { isConsistent: boolean; reason: string } {
    if (!this.activeWorkingState) {
      return { isConsistent: true, reason: 'No active compacted summary.' };
    }

    // Mendeteksi anomali jika summary mencatat error belum selesai namun agen mencoba submit
    if (this.activeWorkingState.unresolvedErrors.length > 0 && nextAction.type === 'submit') {
      return {
        isConsistent: false,
        reason: 'Inkonsistensi: Masih terdapat error yang belum terselesaikan, namun agen mencoba submit patch.',
      };
    }

    return { isConsistent: true, reason: 'Aksi lanjutan konsisten dengan rencana summary.' };
  }
}

7. Implikasi Strategis untuk Masa Depan Autonomous Software Engineering

Riset AutoCompact membawa pelajaran arsitektural fundamental bagi para perancang sistem AI agen di era modern:

1. Model-Harness Co-Design Adalah Kunci: Memisahkan kompresi memori menjadi modul eksternal yang terisolasi terbukti inferior dibanding menyediakan tool compact() langsung ke dalam action space model dan melatihnya secara end-to-end.
2. Context Window Besar Bukan Pengganti Higienitas Penalaran: Menjejalkan 256.000 token riwayat mentah justru merusak atensi model pada hal-hal kritis. Pemadatan proaktif bertindak sebagai "refaktorisasi mental" yang mengembalikan fokus agen ke kondisi kerja terkini.
3. Supervisi Tindakan Pasca-Ringkasan: Kunci keberhasilan bukan sekadar merangkum masa lalu, melainkan memastikan bahwa trajektori tindakan yang mengikuti ringkasan tersebut secara taat asas mengeksekusi rencana kerja yang baru.