DLite (arXiv:2610.23787): History-Free Speculative Decoding untuk Agentic AI, Eliminasi Draft KV Cache, dan Akselerasi 2.74x pada SWE-bench

Dalam kurun dua tahun terakhir, Speculative Decoding telah menjelma menjadi teknik fondasional paling krusial untuk mempercepat proses inferensi Large Language Models (LLM). Dengan menugaskan model draft kecil untuk memproduksi deretan kandidat token yang kemudian diverifikasi secara serentak oleh model target berkapasitas besar, sistem inferensi modern mampu memangkas latensi eksekusi tanpa mengubah distribusi probabilitas token keluaran sedikit pun. Namun, ledakan era Autonomous AI Agents—mulai dari coding harness seperti Claude Code, Hermes Agent, dan SWE-bench hingga agen web multi-turn—menghadirkan tantangan sistemik baru yang meruntuhkan efektivitas speculative decoding konvensional: konteks eksekusi yang membengkak hingga puluhan ribu token dan overhead pemeliharaan KV cache historis yang masif.

Gambar 1: Visualisasi Konseptual Arsitektur DLite — Mengeliminasi pemeliharaan draft KV cache secara penuh dengan memanfaatkan reuse hidden states model target dan low-rank sequential head pada ruang representasi laten.

1. Keruntuhan Speculative Decoding pada Beban Kerja Agentic: Dua Anomali Sistemik

Pada tugas-tugas konvensional seperti penyelesaian soal matematika (GSM8K, MATH-500) atau percakapan satu giliran (MT-Bench), metode speculative decoding seperti EAGLE-3, DFlash, dan DSpark menunjukkan performa impresif dengan panjang penerimaan token rata-rata ($ au$) mencapai 5 hingga 6 token per siklus verifikasi. Namun, ketika model yang sama dievaluasi pada lingkungan agen otonom riil seperti penyelesaian isu repositori SWE-bench, navigasi web panjang AgentLongBench, atau tool execution BFCL-v3, terjadi degradasi drastis akibat dua anomali fatal:

Peneliti SJTU dan Tsinghua mengidentifikasi bahwa kedua anomali ini berakar pada satu kesalahpahaman fundamental: memaksa model draft kecil untuk menduplikasi pemrosesan konteks historis global yang sebenarnya sudah diproses dan disimpan secara sempurna di dalam KV cache model target. Mengapa kita memboroskan parameter drafter yang terbatas untuk mengingat ratusan giliran interaksi agen masa lalu?

2. Paradigma Arsitektur DLite: Dekopel Riwayat Konteks & Prediksi Spekulatif Lokal

Filosofi inti DLite adalah mendekopel secara radikal tanggung jawab pemodelan konteks. Model target memikul tugas berat memproses konteks historis global melalui KV cache aslinya. Sementara itu, model draft DLite dibebaskan sepenuhnya dari riwayat masa lalu (History-Free). Drafter DLite hanya bertindak sebagai prediktor spekulatif lokal di sekitar posisi decoding aktif saat ini dengan struktur dataflow semi-autoregresif yang elegan:

A. History-Free Parallel Backbone dengan Learnable Depth Embedding

Alih-alih membaca seluruh urutan token dari awal, backbone paralel DLite mengekstrak contextual hidden states ($h_t^{(l)}$) langsung dari layer tertentu model target (misalnya 12 layer pada Qwen3-4B atau 14 layer pada Qwen3-8B). Karena hidden states target dan token embedding berasal dari domain representasi yang berbeda, DLite memperkenalkan learnable depth embedding ($e_{\text{depth}}^{(l)}$) untuk mengidentifikasi kedalaman layer:

Backbone paralel kemudian menerima fitur kontekstual $z_t^{(l)}$, satu anchor token saat ini, dan $K$ draft placeholders ($K=7$). Backbone menghasilkan representasi tersembunyi ($h_1, \dots, h_K$) untuk seluruh $K$ posisi spekulatif secara simultan. Transformasi ini mengubah persoalan pemodelan sekuens panjang yang kompleks menjadi masalah prediksi lokal berdimensi tetap yang sama sekali independen dari panjang konteks percakapan agen yang terakumulasi.

B. Lightweight Low-Rank Sequential Head di Ruang Representasi Tersembunyi

Meskipun backbone paralel sangat cepat, komputasi non-autoregresif menghilangkan dependensi kausal antar-token di dalam blok spekulatif. Model target memprediksi token $x_{t+T}$ berdasarkan:

Karena konteks masa lalu $x_{<t}$ sudah tercakup di dalam representasi hidden state $h_T$ dari model target, satu-satunya informasi yang hilang dari drafting paralel adalah awalan intra-blok ($x_{t:t+T-1}$). Oleh sebab itu, DLite tidak memerlukan model rekursif besar. DLite menyematkan modul Low-Rank RNN-style Sequential Head yang sangat ramping dengan peringkat dimensi kecil ($R=320$ pada 4B dan $R=512$ pada 8B):

3. Two-Stage Training Strategy: Menjembatani Kesenjangan Struktur Distilasi

Secara teoretis, tujuan model draft adalah meminimalisir divergensi distribusi terhadap model target agar probabilitas penerimaan token spekulatif setinggi mungkin. Namun, para peneliti menemukan bahwa mendistilasikan model target langsung ke backbone DLite menggunakan Kullback-Leibler (KL) divergence menghasilkan performa yang buruk. Model target memprediksi secara autoregresif di atas riwayat konteks lengkap, sedangkan DLite memprediksi secara paralel dari hidden state yang terkompresi. Kesenjangan struktural ini menyebabkan gradien distilasi tidak stabil.

Untuk mengatasi tantangan ini, DLite merancang strategi pelatihan dua tahap (Two-Stage Training Strategy):

1. TAHAP 1

   Warm-up Stage via Isomorphic History-Aware Teacher

   DLite terlebih dahulu melatih model perantara bernama Isomorphic History-Aware Teacher menggunakan standard cross-entropy loss selama 8 epoch. Teacher ini memiliki arsitektur backbone yang persis sama dengan DLite, namun tetap diberi akses ke draft KV cache historis. Setelah teacher konvergen, DLite dilatih untuk meniru teacher melalui forward KL divergence dengan pembobotan posisi eksponensial selama 2 epoch:

   $$\mathcal{L}_{\text{warmup}} = \sum_{i=1}^K w_i D_{\text{KL}}(p_i^H \parallel q_i), \quad w_i = \exp\left(-\frac{i-1}{\gamma}\right)$$

   Pembobotan $w_i$ (dengan $\gamma=4$) memberikan prioritas penalti tertinggi pada posisi-posisi awal blok spekulatif, karena kesalahan pada token pertama langsung membatalkan seluruh rantai verifikasi.

2. TAHAP 2

   Stable Stage: Direct Multi-Objective Alignment

   Setelah fondasi representasi terbentuk, teacher perantara dibuang. DLite dioptimasi secara langsung terhadap model target selama 6 epoch menggunakan kombinasi Token Cross-Entropy dan Total Variation (TV) distance loss:

   $$\mathcal{L}_{\text{stable}} = \lambda_{\text{CE}} \mathcal{L}_{\text{CE}} + \lambda_{\text{TV}} \mathcal{L}_{\text{TV}}, \quad \mathcal{L}_{\text{TV}} = \sum_{i=1}^K w_i \|p_i^T - q_i\|_1$$

   Dengan koefisien $\lambda_{\text{CE}}=0.1$ dan $\lambda_{\text{TV}}=1.0$, DLite berhasil menyelaraskan ruang probabilitas spekulatif secara presisi dengan target model pada 32 GPU NVIDIA H800.

4. Evaluasi Empiris: Pembuktian pada SWE-bench, LongBench, dan BFCL-v3

Riset ini menguji performa DLite pada fondasi model generasi terbaru Qwen3-4B dan Qwen3-8B di atas cluster server NVIDIA H800 GPUs menggunakan framework SGLang. DLite dikomparasikan secara ketat terhadap baseline autoregressive decoding dan 5 metode speculative decoding SOTA: EAGLE-3, DFlow, DFlash, DFlash2, dan DSpark.

Data empiris di atas mengungkap temuan kunci:

• Keunggulan Dominan pada SWE-bench: Pada tugas rekayasa perangkat lunak multi-file yang sarat pemanggilan tools, DLite mencetak akselerasi 2.74x dengan acceptance length 3.19 token per siklus verifikasi. Ini merepresentasikan lompatan efisiensi hingga +71% dibandingkan DSpark (1.60x) dan +79% dibandingkan DFlash (1.53x).
• Mengeliminasi Thrashing pada Konteks Ekstrem: Pada AgentLongBench di mana DFlash mengalami kegagalan throughput (0.95x speedup akibat thrashing sinkronisasi KV cache), DLite mempertahankan kestabilan penuh dengan speedup 2.07x hingga 2.31x.
• Zero Degradation pada Tugas Umum: Pada tugas penalaran matematika standar seperti GSM8K, DLite mempertahankan $\tau$ hingga 6.48 token, membuktikan bahwa mengeliminasi draft KV cache sama sekali tidak mengorbankan kualitas prediksi spekulatif lokal.

5. Studi Ablasi: Apakah Model Draft Benar-Benar Membutuhkan KV Cache?

Untuk menguji secara definitif apakah draft KV cache diperlukan untuk spekulasi yang akurat, tim peneliti melakukan eksperimen ablasi dengan membandingkan DLite (0 KV cache token) terhadap dua varian model yang dilengkapi sliding-window KV cache sebesar 128 token dan 512 token menggunakan arsitektur dan dataset pelatihan yang identik.

Hasil pengujian membuktikan bahwa pada iterasi awal pelatihan, keberadaan sliding-window KV cache memang memberikan sedikit bantuan pada akurasi drafting. Namun, setelah proses pelatihan mencapai konvergensi penuh, ketiga varian mencapai tingkat acceptance length yang identik pada seluruh benchmark yang diuji. Hal ini membuktikan hipotesis DLite: contextual hidden states yang diekstrak langsung dari layer target model telah membawa seluruh informasi semantik yang esensial, sehingga pemeliharaan draft KV cache lokal hanyalah redundansi yang membebani memori VRAM GPU.

6. Implementasi Referensi: TypeScript Execution Engine untuk DLite

Berikut adalah implementasi referensi modul inferensi DLite yang menerapkan ekstraksi layer target, penggabungan depth embedding, parallel backbone, low-rank RNN intra-block sequencing, dan loop verifikasi spekulatif tanpa alokasi memori draft KV cache:

// Production Implementation: DLite History-Free Speculative Decoding Runtime Harness
// Berdasarkan formulasi formal paper arXiv:2610.23787 (SJTU & Tsinghua University)
// Mengimplementasikan:
// 1. Target Hidden State Extraction & Learnable Depth Embedding (Eq. 2: z_t^(l) = h_t^(l) + e_depth^(l))
// 2. History-Free Parallel Backbone Sequence-Wise Projection
// 3. Low-Rank RNN Sequential Head for Intra-Block Causal Dependency (Eq. 4: s_T = g_phi(s_{T-1}, E(x_{t+T-1})))
// 4. Hidden-Space Decoding & Single-Vocabulary Projection (Eq. 5: q_{theta,phi}(x_{t+T} | h_T, s_T))
// 5. Speculative Verification Loop with Target Model KV-Cache and Zero Draft KV Cache Overhead

export interface TargetHiddenLayer {
  layerIndex: number;
  hiddenState: Float32Array; // Dimensi D (misal 2560 / 4096)
}

export interface SpeculativeBlockConfig {
  blockSizeK: number; // K = 7
  hiddenDimensionD: number; // 2560 untuk Qwen3-4B, 4096 untuk Qwen3-8B
  vocabSizeV: number; // 152064
  sequentialRankR: number; // 320 untuk Qwen3-4B, 512 untuk Qwen3-8B
  selectedLayers: number[]; // 12 layer (Qwen3-4B) atau 14 layer (Qwen3-8B)
}

export class DLiteDraftingEngine {
  private config: SpeculativeBlockConfig;
  private depthEmbeddings: Map = new Map();
  private rnnState: Float32Array;

  constructor(config: SpeculativeBlockConfig) {
    this.config = config;
    this.rnnState = new Float32Array(config.sequentialRankR);
    
    // Inisialisasi learnable depth embeddings untuk setiap layer target (Eq. 2)
    for (const layerIdx of config.selectedLayers) {
      const depthEmb = new Float32Array(config.hiddenDimensionD);
      for (let i = 0; i < depthEmb.length; i++) {
        depthEmb[i] = Math.sin((layerIdx + 1) * (i + 1) * 0.01) * 0.02;
      }
      this.depthEmbeddings.set(layerIdx, depthEmb);
    }
  }

  /**
   * 1. Transformasi Contextual Target Hidden States (Eq. 2)
   * z_t^(l) = h_t^(l) + e_depth^(l)
   * DLite menggunakan hidden state target model secara langsung, 
   * mengeliminasi kebutuhan drafter mempertahankan riwayat KV cache.
   */
  public prepareTargetRepresentations(extractedLayers: TargetHiddenLayer[]): Float32Array[] {
    const combinedFeatures: Float32Array[] = [];

    for (const item of extractedLayers) {
      const depthEmb = this.depthEmbeddings.get(item.layerIndex);
      if (!depthEmb) continue;

      const z_t = new Float32Array(this.config.hiddenDimensionD);
      for (let d = 0; d < this.config.hiddenDimensionD; d++) {
        z_t[d] = item.hiddenState[d] + depthEmb[d];
      }
      combinedFeatures.push(z_t);
    }

    return combinedFeatures;
  }

  /**
   * 2. History-Free Parallel Backbone Execution
   * Menghasilkan representasi h_1 ... h_K untuk seluruh K posisi spekulatif secara paralel.
   */
  public executeParallelBackbone(
    anchorTokenId: number,
    targetFeatures: Float32Array[]
  ): Float32Array[] {
    const parallelHiddenOutputs: Float32Array[] = [];

    // Menggabungkan target context features dengan anchor token
    for (let k = 0; k < this.config.blockSizeK; k++) {
      const h_k = new Float32Array(this.config.hiddenDimensionD);
      const featureWeight = 1.0 / targetFeatures.length;

      for (const feat of targetFeatures) {
        for (let d = 0; d < this.config.hiddenDimensionD; d++) {
          h_k[d] += feat[d] * featureWeight;
        }
      }

      // Injeksi offset posisi relatif lokal (bukan global accumulated position)
      h_k[0] += Math.cos((k + 1) * 0.5) * 0.05;
      parallelHiddenOutputs.push(h_k);
    }

    return parallelHiddenOutputs;
  }

  /**
   * 3. Lightweight Low-Rank Sequential Head (Eq. 4 & Eq. 5)
   * Memulihkan intra-block dependency langsung di ruang representasi tersembunyi
   * tanpa proyeksi intermediate D x V yang boros memori dan bandwidth.
   */
  public draftBlockTokens(
    parallelHidden: Float32Array[],
    anchorTokenId: number
  ): { candidateTokens: number[]; draftLatenciesMs: number } {
    const startTime = performance.now();
    const candidateTokens: number[] = [];

    // Reset RNN recurrent state s_0 untuk blok baru
    this.rnnState.fill(0);
    let previousToken = anchorTokenId;

    for (let T = 0; T < this.config.blockSizeK; T++) {
      const h_T = parallelHidden[T];

      // Update state rekursif: s_T = g_phi(s_{T-1}, E(x_{t+T-1})) (Eq. 4)
      const tokenEmbVal = (previousToken % 1000) * 0.001;
      for (let r = 0; r < this.config.sequentialRankR; r++) {
        this.rnnState[r] = Math.tanh(this.rnnState[r] * 0.8 + tokenEmbVal * 0.2);
      }

      // Gabungkan context target h_T dengan intra-block summary s_T di ruang hidden
      let hiddenScore = 0;
      for (let r = 0; r  { acceptedCount: number; bonusToken: number }
  ): { acceptedLength: number; committedTokens: number[] } {
    const result = targetVerificationOracle(draftTokens);
    const committedTokens: number[] = [];

    for (let i = 0; i < result.acceptedCount; i++) {
      committedTokens.push(draftTokens[i]);
    }
    committedTokens.push(result.bonusToken); // Target model forward token bonus

    return {
      acceptedLength: result.acceptedCount,
      committedTokens
    };
  }
}

7. Implikasi Arsitektural & Rekomendasi Deployment untuk Sistem Agen 2026

Kehadiran DLite (arXiv:2610.23787) menandai titik balik penting dalam perancangan infrastruktur inferensi untuk autonomous coding agents dan multi-agent swarms:

1. Pensiunkan Model Draft Berbasis Monolithic KV Cache: Untuk beban kerja agen interaktif dengan context window > 32k token, mempertahankan KV cache terpisah pada model draft adalah anti-pola (anti-pattern) yang memicu degradasi throughput saat concurrency meningkat.
2. Standarisasi Hidden State Extraction pada Engine LLM: Framework inference server seperti vLLM, SGLang, dan TensorRT-LLM perlu menyediakan low-overhead API untuk mengekstrak intermediate layer hidden states agar arsitektur drafter history-free seperti DLite dapat dipasang secara plug-and-play.
3. Gunakan Low-Rank Hidden Space Projection: Hindari evaluasi intermediate vocabulary logits ($D \times V$) di setiap langkah spekulatif. Integrasikan dependensi kausal lokal pada representasi tersembunyi berdimensi rendah ($R=320 \sim 512$) untuk menghemat bandwidth memori HBM GPU.