Second Thought 2026: Arsitektur Parallel Reasoning pada Reasoning Idle Window Agen Otonom, Asynchronous Trajectory Continuation, dan Reduksi 43% Token Decoding ReAct

Gambar 1: Alur Kerja Sistemik Second Thought (arXiv:2608.13667 Fig. 2)—Thread utama menjalankan loop Thought → Action → Observation. Seketika Thought selesai, Second Thought mem-fork 4 cabang (Check, Recall, Rehearse, Alternative) memanfaatkan prefix KV-cache bersama. Saat observasi O_t tiba, seluruh cabang dihentikan instan dan unit pikiran atomik dipanen tanpa menambah latensi critical path. SMU AI Lab / arXiv:2608.13667

1. Paradoks Scaling Inference-Time: Mengapa Menambah Token Berpikir Memperlambat Agen Otonom

Kemajuan model reasoning modern (seperti OpenAI o1/o3, DeepSeek-R1, hingga Gemini Flash Reasoning) membuktikan bahwa penskalaan komputasi inferensi (inference-time compute scaling) secara eksponensial meningkatkan akurasi pemecahan masalah kompleks. Namun, pada ranah software engineering dan manipulasi terminal, penskalaan ini membawa paradoks mendasar: setiap token penalaran tambahan dihasilkan secara sekuensial pada jalur kritis (critical path).

Pada loop ReAct klasik, agen beroperasi secara berulang melalui tiga tahapan:

• Fase Thought (τthink): Model menghasilkan penalaran eksplisit R_t untuk mengevaluasi riwayat keadaan (trajectory history) H_t dan merumuskan rencana tindakan berikutnya.
• Fase Action (τact): Model menserialisasi pemanggilan perkakas (tool invocation) A_t, seperti menjalankan perintah shell, membaca file, atau mengirim kueri SQL.
• Fase Observation (τobs): Lingkungan eksekusi (seperti sandbox Docker, terminal OS, atau REST API) memproses perintah dan mengembalikan luaran teks/status O_t.

Total latensi satu putaran adalah akumulasi sekuensial:

Kelemahan struktural ReAct terletak pada pembekuan penalaran deliberatif di luar fase Thought. Selama fase Action dan Observation, kapasitas komputasi model dibiarkan nonaktif sepenuhnya. Jendela waktu kontigu ini:

disebut oleh para peneliti sebagai Reasoning Idle Window. Pada tugas rekayasa perangkat lunak nyata (seperti menjalankan unit test, melakukan kompilasi proyek C++/Rust, atau melakukan indexing kode), W_t dapat berlangsung dari 2 detik hingga puluhan detik. Membiarkan jendela ini kosong adalah inefisiensi arsitektural yang masif.

2. Batasan Teknik Paralelisasi Konvensional: Tree-of-Thought vs Idle Window

Pendekatan penalaran paralel yang sudah ada—seperti Self-Consistency (Wang et al.), Tree-of-Thought (Yao et al.), atau Multi-Agent Debate—memparalelkan komputasi di dalam fase Thought itu sendiri dengan cara mengambil sampel horizontal beberapa rantai pemikiran kandidat secara bersamaan. Meskipun efektif memperluas ruang pencarian, teknik-teknik ini tidak dapat diterapkan langsung ke dalam jendela W_t karena tiga rintangan utama:

3. Arsitektur Second Thought: Trajectory Continuation & Prefix KV-Cache Sharing

Alih-alih menginstansiasi model eksternal, Second Thought memanfaatkan model yang sama untuk melanjutkan (continue) keadaannya sendiri. Begitu fase Thought R_t selesai pada thread utama:

1. Instant Forking via Prefix KV-Cache: Keempat cabang asinkron menerima snapshot riwayat percakapan yang identik: riwayat penuh H_t digabungkan dengan R_t yang baru saja terbentuk. Karena semua cabang berbagi prompt prefix yang sama persis dengan thread utama, prefix KV-cache digunakan kembali tanpa komputasi prefill ulang, menghemat bandwidth memori GPU hingga mendekati nol overhead inisialisasi.
2. Penonaktifan Native Thinking pada Cabang Pembantu: Cabang-cabang pembantu menonaktifkan tag penalaran internal model agar langsung memancarkan token pikiran eksplisit secepat mungkin sebelum jendela W_t tertutup oleh datangnya respon lingkungan.
3. Dekomposisi 4 Dimensi Penalaran Komplementer: Masing-masing cabang dipandu oleh instruksi khusus untuk mengeksplorasi dimensi kognitif ortogonal yang dirancang untuk menangkal kelemahan umum LLM.

Gambar 2: Studi Kasus Bug-Fixing Komparatif (arXiv:2608.13667 Fig. 1)—Kiri: Vanilla ReAct terjebak pada kueri pencarian yang gagal dan merusak backward compatibility (memerlukan git revert yang mahal). Kanan: Second Thought secara paralel menguji asumsi, mengingat batasan arsitektur, dan menyiapkan fallback kueri sehingga perbaikan tuntas dalam putaran yang jauh lebih sedikit. Kasus Nyata SWE-Bench Pro

4. Taksonomi 4 Dimensi Penalaran: Check, Recall, Rehearse, dan Alternative

Para peneliti merancang 4 dimensi penalaran yang secara spesifik menargetkan bias kognitif dan kegagalan umum agen otonom pada lintasan panjang (long-horizon trajectories):

5. Protokol Atomic Thoughts & Pemanenan Robust saat Observasi Tiba

Kunci keberhasilan implementasi Second Thought terletak pada penanganan interupsi non-deterministik. Karena lingkungan dapat merespons dalam 100 milidetik atau 15 detik, output cabang penalaran harus tetap memiliki nilai semantik yang valid bahkan jika eksekusi dipotong di tengah kalimat.

Second Thought memberlakukan dua kontrak struktural ketat:

• Pembatasan Panjang Unit (≤ 25 Kata): Setiap pemikiran dibatasi maksimal 25 kata dan dilarang membuat referensi silang ke unit lain dalam stream yang sama. Setiap unit berdiri sendiri sebagai satu wawasan atomik.
• Pembungkus XML Eksplisit (<thought> ... </thought>): Parser hanya memanen unit yang tag penutupnya telah terbentuk sempurna sebelum sinyal pembatalan tiba. Token yang belum ditutup langsung dibuang tanpa meninggalkan residu format yang merusak context window.
• Plafon Pemanenan (Max 5 Thoughts/Dimensi): Jumlah pemikiran yang disuntikkan ke putaran berikutnya dibatasi maksimal 5 unit per dimensi. Ini mencegah pembengkakan context window secara eksponensial (context pollution).

Pada putaran t + 1, thread utama membaca riwayat lengkap secara sekuensial: penalaran sebelumnya R_t, tindakan A_t, hasil observasi lingkungan O_t, dan blok second thoughts yang berhasil dipanen. Dengan demikian, model memasuki fase berpikir putaran berikutnya dengan wawasan tambahan yang siap dikonsumsi seketika tanpa jeda.

6. Evaluasi Empiris: 3 LLM Reasoning, 3 Tolak Ukur Standar, dan Penghematan Token 43%

Para peneliti mengevaluasi Second Thought pada tiga model reasoning frontier dari keluarga arsitektur yang berbeda: DeepSeek-V4-Flash, Qwen3.6-Plus, dan MiniMax-M3, diuji pada tiga tolak ukur evaluasi agen dunia nyata:

• SWE-Bench Pro: 150 repositori rekayasa perangkat lunak nyata dengan batas 100 putaran dan verifikasi suite test fail-to-pass.
• Terminal-Bench 2.1: 89 tugas administrasi sistem, data pipeline, dan build perangkat lunak di dalam container CLI Linux.
• τ3-bench: 97 skenario multi-turn layanan pelanggan perbankan dengan interaksi dialog pengguna dan penarikan kebijakan tak terstruktur.

Temuan Empiris Krusial:

• Penurunan Jumlah Putaran Universal: Second Thought menurunkan rata-rata putaran tugas pada seluruh 9 pasangan model-benchmark tanpa pengecualian. Agen lebih jarang tersesat, lebih cepat mendeteksi asumsi yang salah, dan langsung mengeksekusi rencana cadangan saat alat mengembalikan error.
• Efek Substitusi Penalaran (Reasoning Substitution Effect): Pada 6 konfigurasi, decoding token pada thread utama berkurang hingga 43%. Pemikiran atomik yang dihasilkan di latar belakang mensubstitusi kebutuhan agen untuk melakukan penalaran sekuensial yang panjang di putaran berikutnya.
• Keunggulan Melawan Baseline Sequential Compute-Matched (s1): Dibandingkan dengan agen kontrol yang dipaksa menghabiskan budget komputasi penalaran setara secara sekuensial di thread utama (baseline s1), Second Thought meraih Pass@1 yang jauh lebih tinggi dengan decoding sekuensial 1.3× hingga 3.2× lebih sedikit. Memperpanjang CoT secara sekuensial terbukti rawan overthinking dan halusinasi berputar-putar, sementara percabangan asinkron menjaga pemikiran tetap fokus dan relevan.
• Akselerasi Latensi Nyata (Wall-Clock Latency): Pengujian replay jam dinding (paired wall-clock replay) mengonfirmasi bahwa efisiensi putaran ini membuahkan penurunan latensi tugas riil sebesar 10.9% pada median waktu penyelesaian.

7. Cetak Biru Arsitektur: Implementasi Harness Second Thought Siap Pakai

Berikut adalah implementasi referensi produksi harness Second Thought Engine yang mengintegrasikan forking asinkron 4 dimensi, pemanenan sinyal abort, dan parsing atomik bertag XML:

// Production Implementation: Second Thought Asynchronous Parallel Reasoning Harness
// Berdasarkan Arsitektur SMU AI Lab (arXiv:2608.13667 - Zhensu Sun, David Lo et al.)
//
// Karakteristik Inti:
// 1. Idle Window Capitalization: W_t = tau_act + tau_obs dieksploitasi untuk 4 cabang penalaran
// 2. Trajectory Continuation via Shared Prefix KV-Cache: Tanpa re-encoding prompt awal
// 3. 4 Dimensi Penalaran Komplementer: Check, Recall, Rehearse, Alternative
// 4. Atomic Thoughts Streaming: Unit penalaran <= 25 kata bertag <thought>...</thought>
// 5. Thought Harvesting on Observation: Pembatalan instan saat O_t tiba & capping 5 thoughts/dimensi

export type ReasoningDimension = 'CHECK' | 'RECALL' | 'REHEARSE' | 'ALTERNATIVE';

export interface AtomicThought {
  dimension: ReasoningDimension;
  content: string;
  turnIndex: number;
  timestampMs: number;
}

export interface EnvironmentAction {
  toolName: string;
  parameters: Record<string, any>;
  rawCommand?: string;
}

export interface EnvironmentObservation {
  turnIndex: number;
  stdout: string;
  stderr?: string;
  exitCode: number;
  executionDurationMs: number;
}

export interface TurnTrajectory {
  turnIndex: number;
  thought: string;
  action: EnvironmentAction;
  observation?: EnvironmentObservation;
  harvestedSecondThoughts?: AtomicThought[];
}

export interface BranchInstruction {
  dimension: ReasoningDimension;
  systemPrompt: string;
}

export class SecondThoughtEngine {
  private readonly maxThoughtsPerDimension = 5;
  private readonly maxWordsPerThought = 25;

  private readonly branchInstructions: Record<ReasoningDimension, string> = {
    CHECK: 'Audit the reasoning R_t for fragile unverified assumptions. Output atomic <thought> tags (<=25 words) identifying assumptions that may break.',
    RECALL: 'Resurface high-level constraints and specifications from H_t that risk context attrition. Output atomic <thought> tags (<=25 words).',
    REHEARSE: 'Pre-compute contingency plans for possible action failure or empty returns. Output atomic <thought> tags (<=25 words) with concrete fallbacks.',
    ALTERNATIVE: 'Formulate orthogonal fix strategies to prevent premature commitment. Output atomic <thought> tags (<=25 words) suggesting alternate paths.'
  };

  /**
   * Mengekstrak unit pikiran atomik yang valid dari buffer streaming
   */
  public parseAtomicThoughts(rawStream: string, dimension: ReasoningDimension, turn: number): AtomicThought[] {
    const regex = /<thought>([\s\S]*?)<\/thought>/g;
    const thoughts: AtomicThought[] = [];
    let match: RegExpExecArray | null;

    while ((match = regex.exec(rawStream)) !== null) {
      const cleanContent = match[1].trim();
      const wordCount = cleanContent.split(/\s+/).length;

      // Filter struktural: Abaikan unit yang melebihi batas kata atau kosong
      if (cleanContent.length > 0 && wordCount <= this.maxWordsPerThought + 5) {
        thoughts.push({
          dimension,
          content: cleanContent,
          turnIndex: turn,
          timestampMs: Date.now(),
        });
      }

      if (thoughts.length >= this.maxThoughtsPerDimension) {
        break;
      }
    }

    return thoughts;
  }

  /**
   * Menjalankan siklus eksekusi ReAct dengan Second Thought Asynchronous Parallel Fork
   */
  public async executeTurnWithSecondThought(
    history: TurnTrajectory[],
    currentThought: string,
    action: EnvironmentAction,
    executeInEnvironment: (act: EnvironmentAction) => Promise<EnvironmentObservation>,
    llmBranchSampler: (dimension: ReasoningDimension, history: TurnTrajectory[], thought: string, abortSignal: AbortSignal) => Promise<string>
  ): Promise<TurnTrajectory> {
    const currentTurn = history.length + 1;
    const abortController = new AbortController();

    // 1. Mulai Jendela Menganggur (Reasoning Idle Window W_t)
    const dimensions: ReasoningDimension[] = ['CHECK', 'RECALL', 'REHEARSE', 'ALTERNATIVE'];
    
    // Fork 4 cabang komplementer secara asynchronous (non-blocking terhadap eksekusi environment)
    const branchPromises = dimensions.map(async (dim) => {
      try {
        const rawOutput = await llmBranchSampler(dim, history, currentThought, abortController.signal);
        return this.parseAtomicThoughts(rawOutput, dim, currentTurn);
      } catch (err: any) {
        if (err.name === 'AbortError') {
          return []; // Interupsi normal saat observasi tiba
        }
        console.warn(`[SecondThought] Error on branch ${dim}:`, err.message);
        return [];
      }
    });

    // 2. Eksekusi Action di Environment (Critical Path)
    const observation = await executeInEnvironment(action);

    // 3. Thought Harvesting: Segera batalkan cabang inferensi yang sedang berjalan
    abortController.abort();

    // Ambil hasil parsial yang berhasil diselesaikan sebelum interupsi
    const branchResults = await Promise.allSettled(branchPromises);
    const harvestedThoughts: AtomicThought[] = [];

    for (const res of branchResults) {
      if (res.status === 'fulfilled') {
        harvestedThoughts.push(...res.value);
      }
    }

    // 4. Return Turn Trajectory lengkap yang telah diperkaya Second Thoughts
    return {
      turnIndex: currentTurn,
      thought: currentThought,
      action,
      observation,
      harvestedSecondThoughts: harvestedThoughts,
    };
  }

  /**
   * Memformat Second Thoughts ke dalam konteks turn berikutnya
   */
  public formatThoughtsForNextTurn(thoughts: AtomicThought[]): string {
    if (thoughts.length === 0) return '';

    const grouped: Record<string, string[]> = {};
    for (const t of thoughts) {
      if (!grouped[t.dimension]) grouped[t.dimension] = [];
      grouped[t.dimension].push(t.content);
    }

    let block = '\n<second_thoughts>\n';
    for (const [dim, items] of Object.entries(grouped)) {
      block += `  [${dim}]\n`;
      for (const item of items) {
        block += `    - ${item}\n`;
      }
    }
    block += '</second_thoughts>\n';
    return block;
  }
}

8. Kesimpulan & Implikasi bagi Arsitektur Autonomous Coding Agents Masa Depan

Riset Second Thought (arXiv:2608.13667) membuktikan bahwa optimasi agen AI tidak melulu harus bergantung pada peningkatan ukuran parameter model atau pelatihan reinforcement learning yang mahal. Terdapat ruang optimasi inferensi yang sangat besar pada lapisan arsitektur harness sistem itu sendiri.

Dengan mengonversi Reasoning Idle Window yang sebelumnya pasif menjadi inkubator penalaran asinkron yang produktif, sistem rekayasa perangkat lunak mandiri (seperti Coding CLI, CI/CD remediation bots, dan Customer Support Automation) dapat memangkas biaya komputasi sekuensial hingga 43%, mengurangi putaran buntu, dan menghadirkan agen AI yang jauh lebih responsif, tangguh, dan ekonomis untuk skala produksi industri modern.