1. Anatomi Krisis Konteks pada Autonomous SWE Agents

Evolusi model bahasa besar dari sekadar single-turn code completion menjadi agen rekayasa perangkat lunak mandiri (autonomous Software Engineering agents seperti Devin, SWE-agent, SWE-smith, hingga DeepSWE) telah mentransformasi alur kerja pengembangan perangkat lunak modern. Agen tidak lagi hanya memprediksi baris sintaksis berikutnya; mereka mengeksekusi perintah terminal, mencari indeks kode (grep, find, AST parsing), membaca puluhan modul dependensi, menyusun hipotesis akar masalah (fault localization), menerapkan patch, dan menjalankan test runner secara berulang.

Namun, otonomi tingkat tinggi ini menuntut harga yang sangat mahal: ledakan interaction trace. Berdasarkan observasi empiris pada benchmark SWE-bench Verified (500 issue dunia nyata dari repositori Python skala besar), satu sesi penyelesaian issue rata-rata mengonsumsi 289.507 token input kumulatif. Setiap kali agen mengeksekusi perintah bash atau membaca potongan file sumber, seluruh riwayat interaksi sebelumnya dipasok kembali ke dalam prompt LLM.

Pendekatan mitigasi sebelumnya terbelah menjadi dua kutub yang sama-sama bermasalah:

• LLM-based Prompt Summarizers (misal AgentDiet, LLMLingua2): Memerlukan model LLM sekunder atau jaringan token classification tersendiri untuk memadatkan riwayat. Hal ini tidak hanya memerlukan beban komputasi training yang besar (LLMLingua2 membutuhkan 23 jam training pada RTX 4090; SWE-Pruner membutuhkan 4 jam pada 8x GPU A100-80GB), tetapi juga menambah puluhan detik latensi dan ribuan token tambahan per turn, membatalkan penghematan yang diharapkan.
• Heuristic Semantic Pruners (misal LongCodeZip, SeeRepo): Memangkas potongan fungsi berdasarkan asumsi sintaksis kode statis. Ketika agen membutuhkan konteks dinamis seperti traceback error atau perubahan state lingkungan pengujian, pemangkasan ini membuang bukti krusial dan meruntuhkan resolved rate secara drastis (LongCodeZip anjlok ke 64.50%).

2. Mengapa Render Optik Seragam Gagal Total: The All-Image Trap

Dengan pesatnya kemajuan model vision-language (VLM) seperti Gemini 3.8 Flash, GPT-5.6-Luna, dan Claude 4.5 Sonnet, muncul gagasan intuitif: mengapa tidak merender seluruh teks luaran shell dan observasi editor menjadi gambar bitmap? Bukankah token visual lebih efisien dalam mengompresi ribuan karakter teks (OCR-based optical compression)?

Tim peneliti Jingyu Xiao et al. melakukan studi awal yang mengungkap fakta mengejutkan: merender seluruh observasi menjadi gambar secara seragam (all-image setting) justru menjadi bencana besar bagi akurasi penyelesaian bug.

Mengapa kompresi gambar seragam gagal begitu fatal?

• Kehilangan Ketajaman Verbatim Karakter: Observasi terkini pada langkah $t$ membutuhkan presisi karakter mutlak: nomor baris traceback yang spesifik, nama pengenal variabel, parameter sintaksis, atau flag compiler. Ketika dirender menjadi bitmap, kompresi spasial mengaburkan detail halus ini, memicu halusinasi dan salah interpretasi.
• Loop Eksplorasi Membengkak: Karena agen tidak dapat membaca detail output secara pasti, agen terpaksa melakukan inspeksi ulang (redundant grep/cat). Akibatnya, jumlah langkah interaksi melonjak dari 12.56 menjadi 20.28 langkah, membakar token output 38.59% lebih banyak dan menghapus semua keuntungan efisiensi.

3. Arsitektur Dual-Mechanism TraceLite: Memadukan Optik Historis dan Teks Terkini

TraceLite menyelesaikan paradoks ini dengan membagi trajectory interaksi agen ${O_1, ldots, O_t}$ pada langkah $t$ ke dalam dua jendela asimetris:

Arsitektur ini didasarkan pada prinsip rekayasa yang sangat elegan:

1. Jendela Terkini ($mathcal{R}_t$, ukuran $w$ langkah): Semua observasi dalam jendela $w$ langkah terbaru (default $w = 3$ hingga $5$) dipertahankan dalam format teks resolusi tinggi asli (high-fidelity text). Agen memiliki akses karakter-demi-karakter tanpa distorsi terhadap respon perintah terakhir untuk menentukan aksi selanjutnya.
2. Jendela Historis ($mathcal{H}_t$): Begitu suatu observasi keluar dari jendela terkini ($i leq t - w$), TraceLite merendernya menjadi gambar monokrom resolusi terkontrol melalui operator $operatorname{Render}(O_i, k)$ dengan rasio kompresi $k = 2 imes$. Gambar ini dimasukkan ke dalam blok prompt multimodal. Karena fungsi observasi historis terutama memberikan kesadaran global atas file apa yang telah dibuka dan struktur repositori yang telah dipindai, representasi visual mempertahankan semantik makro ini secara sempurna dengan biaya token yang jauh lebih rendah daripada teks mentah.
3. Penyimpanan Teks Tool Calls Secara Utuh: Yang krusial, tool call historis tidak pernah dihapus atau diubah menjadi gambar. Nama perkakas, argumen pemanggilan, dan urutan eksekusi tetap berada dalam bentuk teks terstruktur. Ini menjamin agen selalu memiliki pemahaman kronologis yang deterministik atas apa yang telah dilakukannya.

4. Dual-Redundancy Removal: Overlap-Based Deduplication & Edit-Triggered Phase Cleanup

Selain kompresi optik historis, TraceLite mengidentifikasi bahwa trajektori agen rekayasa perangkat lunak memiliki redundansi intrinsik yang masif. Peneliti menemukan dua bentuk redundansi: content redundancy (tumpang tindih teks antar langkah) dan phase-level redundancy (observasi diagnosa yang tidak lagi berguna setelah kode diedit).

5. Evaluasi Empiris: SWE-bench Verified & DeepSWE

TraceLite dievaluasi secara ketat pada 400 task SWE-bench Verified dan benchmark rekayasa perangkat lunak jangka panjang DeepSWE, menggunakan backbone mutakhir GPT-5.6-Luna dan Gemini-3.8-Flash.

Temuan utama dari data empiris di atas membuktikan:

• Akurasi Resolusi Tertinggi Tanpa Degradasi: TraceLite mencatatkan resolved rate 78.25% (313 dari 400 masalah terpecahkan), melampaui full-trace baseline (78.00%) dan seluruh metode kompresi lainnya secara numerik.
• Efisiensi Biaya dan Token Signifikan: Mengurangi rata-rata konsumsi token input sebesar 33.05% (dari 289K menjadi 193K) dan menurunkan pengeluaran API sebesar 21.30% ($1.12 vs $1.42 per task).
• Keunggulan Latensi Masif: Dengan overhead hanya 0.438 detik per observasi, TraceLite beroperasi 10.4× lebih cepat dari AgentDiet dan 44.4× lebih cepat dari LongCodeZip, tanpa pernah memanggil API refleksi eksternal yang memboroskan token.

6. Implementasi Referensi: TraceLite Context Controller di TypeScript

Berikut adalah implementasi TypeScript produksi dari TraceLiteController yang mengintegrasikan pemartisian jendela geser optik, deduplikasi baris berbasis himpunan, dan pembersihan fase transisi edit untuk runtime agen otonom:

// Production Implementation: TraceLite Context Controller & Trace Pruning Engine
// Berdasarkan Arsitektur Chinese University of Hong Kong & Wuhan University (arXiv:2610.28612 - Oktober 2026)
//
// Karakteristik Inti:
// 1. Sliding Window Partitioning: R_t (Recent Window, exact text) vs H_t (Historical Window, optical render).
// 2. Overlap-Based Line Deduplication: Menghapus baris teks berulang antar langkah observasi berdekatan.
// 3. Edit-Triggered Phase Cleanup: Membersihkan payload observasi pra-edit begitu aksi modifikasi kode dieksekusi.
// 4. Zero-Auxiliary LLM: Beroperasi deterministik tanpa panggilan model sekunder atau retraining bobot.

export interface AgentToolCall {
  step: number;
  tool: 'bash' | 'file_search' | 'read_file' | 'edit_file' | 'run_tests';
  parameters: Record;
  timestamp: string;
}

export interface AgentObservation {
  step: number;
  toolCall: AgentToolCall;
  rawPayload: string;
  isEditAction: boolean;
  opticalRenderUri?: string; // Data URI / base64 hasil rendering optik
  tokenCostEstimate: number;
}

export interface TraceLiteConfig {
  recentWindowSize: number; // Parameter w (default: 3 atau 5)
  compressionRatio: number; // Parameter k (default: 2 atau 4)
  lineDeduplicationThreshold: number; // Jarak langkah untuk deteksi baris tumpang tindih
}

export class TraceLiteController {
  private recentWindowSize: number;
  private compressionRatio: number;
  private observations: AgentObservation[] = [];
  private hasPerformedCodeEdit: boolean = false;
  private lastEditStep: number = -1;

  constructor(config?: Partial) {
    this.recentWindowSize = config?.recentWindowSize ?? 3;
    this.compressionRatio = config?.compressionRatio ?? 2;
  }

  /**
   * 1. Menambahkan observasi baru dan menjalankan pipeline reduksi TraceLite
   */
  public processStep(toolCall: AgentToolCall, rawPayload: string): AgentObservation {
    const currentStep = toolCall.step;
    const isEdit = toolCall.tool === 'edit_file';

    const newObs: AgentObservation = {
      step: currentStep,
      toolCall,
      rawPayload,
      isEditAction: isEdit,
      tokenCostEstimate: Math.ceil(rawPayload.length / 3.8),
    };

    // Deteksi transisi fase: Localization/Diagnosis -> Edit/Validation
    if (isEdit && !this.hasPerformedCodeEdit) {
      this.hasPerformedCodeEdit = true;
      this.lastEditStep = currentStep;
      this.triggerEditPhaseCleanup();
    }

    // Terapkan line-level overlap removal terhadap observasi aktif di jendela terkini
    this.applyOverlapRemoval(newObs);

    this.observations.push(newObs);

    // Jalankan Optical Compression untuk observasi yang keluar dari recent window
    this.applyHistoricalOpticalCompression(currentStep);

    return newObs;
  }

  /**
   * 2. Overlap-Based Removal: L(O_i) ∩ L(O_s) != ∅
   * Menghapus baris duplikat dari observasi sebelumnya di recent window
   */
  private applyOverlapRemoval(newObs: AgentObservation): void {
    const newLines = new Set(
      newObs.rawPayload
        .split('\n')
        .map(l => l.trim())
        .filter(l => l.length > 5) // Abaikan baris kosong atau tanda kurung tunggal
    );

    // Periksa observasi dalam jendela terkini
    const windowStart = Math.max(0, this.observations.length - this.recentWindowSize);
    for (let i = windowStart; i < this.observations.length; i++) {
      const priorObs = this.observations[i];
      if (!priorObs.rawPayload) continue;

      const priorLines = priorObs.rawPayload.split('\n');
      const filteredLines = priorLines.filter(line => {
        const trimmed = line.trim();
        // Pertahankan baris jika tidak diduplikasi oleh observasi terbaru
        return !(trimmed.length > 5 && newLines.has(trimmed));
      });

      if (filteredLines.length < priorLines.length) {
        priorObs.rawPayload = filteredLines.join('\n');
        priorObs.tokenCostEstimate = Math.ceil(priorObs.rawPayload.length / 3.8);
      }
    }
  }

  /**
   * 3. Edit-Triggered History Cleanup:
   * Menghapus payload observasi pencarian/eksplorasi sebelum titik pengeditan pertama
   */
  private triggerEditPhaseCleanup(): void {
    for (const obs of this.observations) {
      if (obs.step < this.lastEditStep) {
        // Payload observasi diagnosa sudah usang; gantikan dengan tombstone kompak
        // Riwayat tool call tetap dipertahankan agar kronologi aksi tidak hilang
        obs.rawPayload = '[Payload removed by TraceLite: Pre-edit diagnosis phase completed]';
        obs.opticalRenderUri = undefined;
        obs.tokenCostEstimate = 12;
      }
    }
  }

  /**
   * 4. Historical Optical Compression:
   * Mengonversi observasi yang keluar dari recent window (i <= t - w) menjadi gambar kompak
   */
  private applyHistoricalOpticalCompression(currentStep: number): void {
    const cutoffStep = currentStep - this.recentWindowSize;
    for (const obs of this.observations) {
      if (obs.step <= cutoffStep && !obs.opticalRenderUri && obs.rawPayload.length > 200) {
        // Observasi historis dirender secara visual (rasterized image representation)
        // Mempertahankan struktur semantik dan layout kode dengan biaya token visual yang jauh lebih rendah
        obs.opticalRenderUri = this.renderTextToOpticalPayload(obs.rawPayload, this.compressionRatio);
        // Kosongkan raw text payload untuk menghemat konteks prompt LLM
        obs.rawPayload = `[Optical observation snapshot preserved: step_${obs.step}.png]`;
        // Token cost visual standar per gambar berkisar ~85-170 visual tokens
        obs.tokenCostEstimate = 110;
      }
    }
  }

  /**
   * Simulasi rasterizer teks ke representasi optical canvas (PNG/WebP canvas matrix)
   */
  private renderTextToOpticalPayload(text: string, ratio: number): string {
    // Pada implementasi produksi, fungsi ini memanggil skia / canvas / sharp
    // untuk merender teks dengan font monospace dan resolusi terkontrol (misal 512x288)
    return `data:image/webp;base64,optical_trace_k${ratio}_${nanoid(12)}`;
  }

  /**
   * 5. Merakit Prompt Multimodal Teroptimasi untuk LLM Backbone
   */
  public assemblePromptContext(): Array<{ role: 'user' | 'assistant'; content: unknown }> {
    const messages: Array<{ role: 'user' | 'assistant'; content: unknown }> = [];

    for (const obs of this.observations) {
      // 1. Tool Call selalu disertakan dalam bentuk teks terstruktur
      messages.push({
        role: 'assistant',
        content: JSON.stringify({
          action: obs.toolCall.tool,
          params: obs.toolCall.parameters,
        }),
      });

      // 2. Observasi: Gabungkan konten gambar optik historis atau teks verbatim terkini
      if (obs.opticalRenderUri) {
        messages.push({
          role: 'user',
          content: [
            { type: 'text', text: `Observation Step ${obs.step} (Optical Snapshot):` },
            { type: 'image_url', image_url: { url: obs.opticalRenderUri } },
          ],
        });
      } else {
        messages.push({
          role: 'user',
          content: `Observation Step ${obs.step}:\n${obs.rawPayload}`,
        });
      }
    }

    return messages;
  }

  public getTelemetry(): { totalSteps: number; estimatedTokens: number; prunedByEdit: boolean } {
    const estimatedTokens = this.observations.reduce((acc, curr) => acc + curr.tokenCostEstimate, 0);
    return {
      totalSteps: this.observations.length,
      estimatedTokens,
      prunedByEdit: this.hasPerformedCodeEdit,
    };
  }
}

7. Rekomendasi Rekayasa untuk Tim AI Engineering di 2026

Berdasarkan data empiris paper arXiv:2610.28612, berikut adalah 4 rekomendasi implementasi praktis untuk tim engineering yang membangun autonomous coding agents berskala enterprise:

1. Hindari Jebakan "All-Vision Compression": Meskipun VLM modern memiliki input visual yang murah, jangan pernah mengubah seluruh konteks aktif interaksi menjadi gambar. Selalu kunci jendela teks beresolusi tinggi (minimal $w = 3$ langkah terakhir) agar agen tidak kehilangan karakter presisi pada file path dan stack trace.
2. Terapkan Phase Transitions Boundary pada Context Management: Jangan memperlakukan riwayat interaksi sebagai aliran homogen. Identifikasi titik transisi fase kritis (seperti saat pertama kali agen beralih dari membaca file ke menulis baris kode). Potong atau ringkas muatan observasi diagnosa pra-edit karena nilai epistemiknya telah diinternalisasi ke dalam berkas kode.
3. Pertahankan Riwayat Tool Call dalam Format Teks Terstruktur: Saat memadatkan luaran observasi yang besar (output shell/terminal), pastikan perintah yang memicunya (tool call) tetap utuh dalam representasi teks terstruktur. Model bahasa membutuhkan grafik aksi yang deterministik untuk mengetahui file apa saja yang telah dimodifikasi sebelumnya.
4. Gunakan Deduplikasi Baris Ringan Sebelum Memanggil LLM Kompresor: Sebelum mempertimbangkan model kompresor LLM yang lambat dan mahal, terapkan pemfilteran baris duplikat berbasis himpunan ($L(O_i) cap L(O_s)$). Deduplikasi deterministik ini berjalan dalam mikrodetik dan mengeliminasi hingga 20% token redundan dari perintah shell berulang.