CliffCompaction 2026: Arsitektur Autocompaction Long-Horizon Coding Agents Tanpa Konteks Drift, Zero Summarization-of-Summary, dan Efisiensi Test-Time Scaling

Ketika autonomous coding agents didelegasikan untuk menyelesaikan perbaikan repositori berskala besar, mengoptimasi kernel komputasi performa tinggi, atau menelusuri bug multi-file yang rumit, trajektori eksekusi mereka dengan cepat membengkak melampaui ratusan ribu hingga jutaan token. Menghadapi batas context window dan lonjakan biaya inferensi, ekosistem AI selama ini terpecah ke dalam dua pendekatan klasik: sliding window yang membuang observasi masa lalu atau modul LLM summarization yang meringkas percakapan secara periodik. Namun, kedua metode ini menyimpan cacat arsitektural yang melumpuhkan: sliding window menghancurkan KV-cache prefix sehingga memicu biaya re-prefill berulang hingga 5-6 kali lipat, sedangkan summarization rekursif memicu erosi fakta sistemik (summary-of-summary compounding context drift).

1. Anatomi Krisis Konteks pada Long-Horizon Autonomous Coding

Untuk memahami signifikansi CliffCompaction, kita harus membedah ke mana sebenarnya token dan dolar dihabiskan dalam trajektori coding agent. Berdasarkan audit telemetri empiris pada Terminal-Bench 2.0 menggunakan model GLM-5.1 tanpa kompresi:

Dengan kata lain, 84% pemborosan token dan biaya inferensi disumbangkan oleh interaksi tool. Namun, penanganan konvensional terhadap lonjakan ini memicu paradoks ekonomi yang berbahaya:

• Sliding Window Menghancurkan Efisiensi KV-Cache

  Dalam model inferensi modern (vLLM, SGLang, Claude API, OpenAI API), token input yang tersimpan di prefix cache berharga 5 hingga 6 kali lipat lebih murah dibanding token input baru (uncached re-prefill). Ketika harness menggeser jendela konteks pada setiap turn, prefix cache batal (cache miss), memaksa komputasi re-prefill penuh pada seluruh konteks aktif. Penghematan memori di frontend justru meledakkan tagihan GPU di backend.

• LLM Summarization Memicu Context Drift Akumulatif

  Ketika ringkasan dibuat oleh LLM pembantu, fakta presisi (seperti nama variabel, path absolut, kode baris kesalahan, status exit code) mengalami kompresi lossy. Saat sesi berlangsung panjang dan ringkasan generasi kedua dibuat dari ringkasan generasi pertama (summary of summaries), terjadi degradasi eksponensial. Agen mulai berhalusinasi mengenai struktur kode yang telah diubahnya sendiri.

2. Tiga Prinsip Desain Fundamental CliffCompaction

CliffCompaction memecahkan dikotomi ini melalui pertukaran desain yang sangat diperhitungkan: mengorbankan recall riwayat masa lalu demi mempertahankan presisi (fidelity) 100% dan efisiensi KV-cache maksimal.

A. Never Compact a Compaction: Discarding-Compaction Rekursif

Setelah pemadatan ke-$(t-1)$, konteks agen $S_t$ terdiri dari riwayat terkompresi $C_{t-1}$ diikuti sesi aktif $L_t$ yang tumbuh di atasnya (dengan $C_0 = emptyset$). Ketika $S_t$ menyentuh batas ambang token $B$, proses kompresi ke-$t$ dipicu:

Perhatikan bahwa $C_{t-1}$ dibuang secara keseluruhan dari memori dan tidak pernah digabungkan ke dalam $C_t$. Setiap iterasi pemadatan hanya beroperasi pada sesi aktif orisinal yang baru ($L_t$). Karena tidak ada kompresi bersarang, context drift tidak dapat berakumulasi seiring waktu.

B. Pemfilteran Deterministik Berbasis Panjang & Preservasi Verbatim

CliffCompaction menolak parafrasa generatif dan memberlakukan 4 aturan reduksi deterministik:

• Tool Results: Hasil eksekusi di bawah 500 karakter dipertahankan secara utuh (verbatim). Output ringkas seperti pesan error compiler, status exit code, dan hasil grep sangat murah dan krusial. Hasil yang melampaui 500 karakter dibuang sepenuhnya; jika agen membutuhkan kembali isi file atau log tersebut, agen dapat membaca ulang melalui filesystem.
• Tool Calls: Mereduksi panggilan tool menjadi signature ringkas (nama tool, path file target, dan argumen esensial). Konten panjang yang di-inline pada file_write dibuang karena file sudah tersimpan di disk.
• Chain-of-Thought (Thoughts): Blok pemikiran asisten dipotong secara presisi pada batas 300 karakter pertama.
• K-Turn Retention & Root Invariants: System prompt dan prompt tugas pertama dipertahankan 100%. Selain itu, $K$ pasang interaksi turn terakhir ($2K$ pesan) dipertahankan utuh tanpa kompresi untuk menjamin kontinuitas penalaran jangka pendek.

C. Amortized Cache Reuse & Cliff Invalidation Profile

Alih-alih memodifikasi konteks pada setiap langkah, CliffCompaction membiarkan konteks tumbuh secara organik. Selama fase pertumbuhan, prefix cache pada server inferensi tetap 100% valid. Invalidasi cache hanya terjadi satu kali tepat di tebing pemadatan (cliff), di mana konteks menyusut tajam ke lantai dasar sebelum mulai tumbuh kembali. Karena frekuensi tebing sangat jarang, biaya komputasi re-prefill teramortisasi secara sempurna di sepanjang trajektori.

3. Evaluasi Benchmark Empiris: Terminal-Bench 2.0 & SWE-bench Verified

Peneliti CMU menguji CliffCompaction pada beragam model frontier open-weight dan proprietary—termasuk Kimi K2.6, Kimi K2.5, GLM-5.1, GLM-5.3 Flash, serta integrasi Claude Code.

Wawasan Krusial: Pada Terminal-Bench 2.0, mengeliminasi observasi basi justru meningkatkan tingkat keberhasilan dari 59.16% menjadi 61.42% pada Kimi K2.6, sekaligus memotong biaya per tugas lebih dari separuhnya ($0.40 menjadi $0.19). Pada integrasi dengan Claude Code (harness komersial tertutup), CliffCompaction yang dipasang sebagai API Proxy eksternal mengalahkan sistem auto-compaction internal Claude Code sendiri (76.69% vs 70.97%), membuktikan bahwa arsitektur ini benar-benar independen dari struktur scaffold internal.

4. Demokratisasi Test-Time Scaling: Kimi K2.6 Menyaingi Claude Opus 4.7

Secara teori, Test-Time Scaling (menjalankan $k$ trajektori independen secara paralel lalu memilih kandidat terbaik via verifier) adalah cara paling efektif melompatkan penalaran model. Namun di dunia nyata, test-time scaling hampir tidak pernah dipakai di lingkungan produksi karena biayanya eksorbitan: melakukan 3 rollout penuh pada Terminal-Bench menelan biaya $91.65—jauh lebih mahal dibanding mengeksekusi model proprietary tunggal berbiaya $65.

CliffCompaction membalikkan kalkulus ekonomi ini secara total:

Dengan CliffCompaction pada ambang 16K, tiga eksekusi paralel Kimi K2.6 dipadukan dengan selektor Soft Group Verification (SGV) mencapai akurasi praktis 69.7% dengan total biaya hanya $58.01. Ini melampaui performa model proprietary termahal seperti GPT-5.3 Codex ($64.63, 64.7%) dan Claude Opus 4.6 (62.9%), serta menyamai Claude Opus 4.7 (69.4%) dengan biaya operasional yang jauh lebih terjangkau.

5. Rekor Pembelajaran Kontinu pada KernelBench: Sesi 1 Juta+ Token

Tantangan paling ekstrem bagi arsitektur kompresi konteks adalah continual learning (optimasi berulang pada problem tunggal) di mana agen menulis, mengompilasi, melakukan profiling, dan merevisi kode kernel GPU secara iteratif hingga melampaui 400 langkah (mencapai jutaan token akumulatif).

6. Implementasi Referensi Python: API-Proxy Interceptor

Berikut adalah implementasi referensi modul interceptor CliffCompaction yang kompatibel dengan protokol API OpenAI / Anthropic untuk dipasang di depan coding agent komersial apa pun:

"""
CliffCompaction: Cost-Efficient Compaction Proxy for Long-Horizon Coding Agents.
Berdasarkan formulasi riset CMU & Bosch Center for AI (arXiv:2609.26779, Tim Dettmers et al., 2026).

Komponen Arsitektur Utama:
1. Non-Recursive Cliff Compactor: S_{t+1} = C_t (+) L_{t+1}, dengan C_{t-1} dibuang total (Zero Summary-of-Summary).
2. Verbatim Truncation Filter: Preservasi verbatim tanpa parafrasa; Tool output > 500 chars di-drop; tool call direduksi ke signature.
3. KV-Cache Prefix Preservation: Pertumbuhan alami tanpa perubahan konteks hingga menyentuh ambang batas B (amortized re-prefill).
4. Scaffold-Agnostic Proxy Handler: Interseptor API OpenAI/Anthropic kompatibel Claude Code, Codex, & OpenHands.
"""

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

@dataclass
class AgentMessage:
    role: str  # 'system', 'user', 'assistant', 'tool'
    content: Optional[str] = None
    tool_calls: Optional[List[Dict[str, Any]]] = None
    tool_call_id: Optional[str] = None
    thinking: Optional[str] = None
    is_prior_compaction: bool = False

class CliffCompactor:
    def __init__(
        self,
        token_threshold_b: int = 32000,
        recent_turn_pairs_k: int = 4,
        max_tool_result_chars: int = 500,
        max_thinking_chars: int = 300,
        max_tool_signature_chars: int = 150
    ):
        self.b_threshold = token_threshold_b
        self.k_recent = recent_turn_pairs_k
        self.max_tool_result = max_tool_result_chars
        self.max_thinking = max_thinking_chars
        self.max_tool_sig = max_tool_signature_chars

    def extract_tool_signature(self, tool_call: Dict[str, Any]) -> str:
        """Mereduksi tool call menjadi signature nama dan parameter inti tanpa payload besar."""
        name = tool_call.get("function", {}).get("name", "unknown_tool")
        raw_args = tool_call.get("function", {}).get("arguments", "{}")
        # Ekstraksi path atau parameter kunci jika ada
        path_match = re.search(r'["'](?:path|file|command)["']s*:s*["']([^"']+)["']', raw_args)
        target = path_match.group(1) if path_match else ""
        sig = f"{name}({target})" if target else f"{name}(...)"
        return sig[:self.max_tool_sig]

    def compact_turns(self, turns: List[AgentMessage]) -> Tuple[List[AgentMessage], List[AgentMessage]]:
        """
        Algoritma 1: CliffCompaction Core.
        Membuang kompresi lama C_{t-1}, memotong thinking, memangkas tool result > 500 chars,
        dan menjaga K pasang turn terakhir secara utuh (verbatim).
        """
        k_turns_count = self.k_recent * 2
        if len(turns) <= k_turns_count:
            return [], turns

        old_turns = turns[:-k_turns_count]
        recent_turns = turns[-k_turns_count:]

        compacted_parts: List[str] = []

        for m in old_turns:
            # Aturan 1: Buang riwayat kompresi sebelumnya (Never compact a compaction)
            if m.is_prior_compaction:
                continue

            # Aturan 2: Assistant messages -> pangkas thinking & ringkas tool calls
            elif m.role == "assistant":
                part_lines = []
                if m.thinking:
                    truncated_think = m.thinking[:self.max_thinking].strip()
                    part_lines.append(f"[THOUGHT]: {truncated_think}...")
                if m.tool_calls:
                    sigs = [self.extract_tool_signature(tc) for tc in m.tool_calls]
                    part_lines.append(f"[TOOL_CALLS]: {', '.join(sigs)}")
                if part_lines:
                    compacted_parts.append("\n".join(part_lines))

            # Aturan 3: Tool results -> pertahankan jika <= 500 karakter, buang jika > 500 karakter
            elif m.role == "tool":
                content = m.content or ""
                if len(content) <= self.max_tool_result:
                    compacted_parts.append(f"[TOOL_RESULT {m.tool_call_id or ''}]: {content.strip()}")
                else:
                    # Output besar (misal read_file 2000 baris) dibuang karena dapat dibaca ulang on-demand
                    compacted_parts.append(f"[TOOL_RESULT {m.tool_call_id or ''}]: ")

        # Bungkus partisi terkompresi sebagai single flat block
        c_block = AgentMessage(
            role="user",
            content="=== CLIFFCOMPACTION HISTORY (VERBATIM EXCERPTS) ===\n" + "\n---\n".join(compacted_parts),
            is_prior_compaction=True
        )

        return [c_block], recent_turns

    def process_context(
        self,
        messages: List[AgentMessage],
        approx_token_count: int
    ) -> List[AgentMessage]:
        """
        Evaluasi ambang batas B. Jika terlampaui, trigger tebing kompresi (Cliff).
        Konteks awal (System prompt & task prompt) dipertahankan 100%.
        """
        if approx_token_count < self.b_threshold or len(messages) <= 2:
            return messages

        system_msg = messages[0]
        task_msg = messages[1]
        trajectory = messages[2:]

        c_block_list, recent_turns = self.compact_turns(trajectory)

        new_context = [system_msg, task_msg]
        new_context.extend(c_block_list)
        new_context.extend(recent_turns)
        return new_context

7. Rekomendasi Arsitektural untuk Tim AI Engineering & Platform 2026

Bagi organisasi yang sedang membangun infrastruktur AI coding assistants, autonomous QA bots, atau multi-agent scaffolding, terobosan dari riset CliffCompaction memberikan 3 panduan rekayasa esensial: