Turbo Harness 2026: Arsitektur Instance-Adaptive Harness Optimization, Daur Ulang Search Archive Menjadi Actionable Playbook, dan Optimalisasi Dynamic Patching Agen Otonom

Dalam evolusi rekayasa agen AI (agentic engineering) tahun 2026, fokus riset frontier telah bergeser dari sekadar melatih model pondasi mentah menuju optimalisasi harness runtime—lapisan perangkat lunak eksekusi yang mengatur konteks, alur kerja (workflow orchestration), manajemen memori, pemilihan alat, dan protokol verifikasi mandiri. Namun, seluruh pendekatan optimasi harness otomatis sebelumnya bertumpu pada satu asumsi fatal: menghasilkan satu harness global tunggal untuk seluruh instance tugas.

1. Dilema Global Harness: Mengapa Satu Scaffold Tidak Pernah Optimal untuk Semua Kasus?

Secara formal, optimasi harness konvensional (seperti Meta-Harness atau Harness-R1) mencari harness global $H^star$ yang memaksimalkan ekspektasi imbalan $r$ di seluruh distribusi tugas $mathcal{T}$:

Dalam skenario dunia nyata, fungsi tujuan ini memaksakan kompromi sub-optimal (least-common-denominator compromise). Pertimbangkan kasus pengujian software engineering pada SWE-bench:

• Bug Regresi (Regression Issues): Agen sangat membutuhkan instruksi untuk menginspeksi riwayat git (git log --oneline -20 dan git diff HEAD~1..HEAD) guna mengidentifikasi mutasi kode terakhir yang memicu kerusakan.
• Bug Logika Baru (Logic / Type Errors): Menginspeksi riwayat commit justru memboroskan token context window dan alokasi langkah agen; agen seharusnya langsung membaca alur kontrol file terkait.
• Tugas Terminal Interaktif: Memaksakan pemanggilan tool tertentu (tool_choice: "required") secara global merupakan anti-pattern yang menurunkan akurasi suite sebesar 6.7%, namun pada task spesifik tertentu seperti inspeksi biner extract-elf, pemaksaan tool justru wajib agar agen tidak terjebak dalam halusinasi teks.

Ketika tim pengembang mengoptimalkan harness secara global, algoritma pencarian mengevaluasi ratusan variasi harness, mencatat ribuan baris log eksekusi, kegagalan, dan keberhasilan parsial. Namun, begitu $H^star$ terpilih, seluruh data kaya (exhaust archive) ini dibuang. Turbo Harness mendefinisikan ulang formulasi masalah menjadi optimasi adaptif per-instance:

2. Arsitektur Sistem Turbo Harness: Dari Search Exhaust ke Playbook & Editor RL

Arsitektur Turbo Harness dirancang dengan prinsip efisiensi komputasi ekstrem tanpa overhead inferensi berlapis. Alur kerja terdiri dari dua fase utama:

Formulasi Pelatihan Editor dengan Group Relative Policy Optimization (GRPO)

Untuk setiap instance $x$ pada batch pelatihan, editor $pi_ heta$ mengambil sampel $G$ kandidat patch ${p_{x,g}}_{g=1}^G$. Masing-masing patch diaplikasikan ke harness global $H_{x,g} = H^star oplus p_{x,g}$ dan dievaluasi langsung oleh agen eksekusi $M$ yang dibekukan (frozen execution model) untuk menghasilkan reward $R_{x,g}$. Fungsi objektif pembaruan parameter editor $ heta$ didefinisikan sebagai:

Di mana rasio probabilitas token adalah $ ho_{i,t} = rac{pi_ heta(p_{i,t} mid x, H^star, mathcal{P}, p_{i,<t})}{pi_{ heta_{ ext{old}}}(p_{i,t} mid x, H^star, mathcal{P}, p_{i,<t})}$ dan keunggulan (advantage) $hat{A}_i$ dihitung relatif terhadap rata-rata reward kelompok untuk instance $x$ yang sama.

3. Analisis Benchmark Empiris Lintas 7 Domain Evaluasi

Para peneliti menguji Turbo Harness pada tujuh tolok ukur standar industri yang mencakup tugas interaktif, rekayasa perangkat lunak skala repositori, dan skrip terminal jangka panjang:

Temuan Empiris Kunci:

• Efisiensi Komputasi Ekstrem pada SWE-smith-MR: Menggunakan Gemini 3.7 Flash, Turbo Harness menurunkan jumlah langkah eksekusi rata-rata dari 23.1 menjadi 8.7 langkah per isu. Biaya API anjlok dari $0.310 menjadi hanya $0.046 per isu (penghematan 85.2%) karena agen langsung diarahkan ke root cause tanpa berputar-putar dalam file explorer.
• Menembus Batas Human-Crafted Harness pada Terminal-Bench-2.1: Pada pengujian tugas terminal berdurasi panjang, Meta-Harness sebelumnya kalah dari harness buatan manusia seperti Terminus-Kira (50.5% vs 52.3%). Dengan adaptasi per-instance, Turbo Harness mengklaim posisi puncak di angka 55.5% pass rate sekaligus menurunkan konsumsi token input dari 3.15M menjadi 2.65M.

4. Mengapa RL dan Playbook Harus Bersinergi? (Ablation Analysis)

Pertanyaan krusial dalam studi ablasi adalah: apakah peningkatan performa murni berasal dari pelatihan RL, atau hanya karena tersedianya dokumen Playbook? Pengujian ablasi pada SWE-smith-MR mengungkap fakta menarik:

Tanpa pelatihan RL, model kecil tidak memiliki kemampuan penalaran selektif untuk memutuskan strategi mana dalam Playbook yang harus diterapkan pada situasi tertentu, bahkan seringkali salah menyuntikkan instruksi yang merusak alur eksekusi. Pelatihan RL dengan GRPO mengajari model editor kecil untuk bertindak sebagai meta-decision router yang presisi, menandingi kapabilitas model raksasa berbayar (Claude Opus 4.6 yang mencatat 61.3%).

5. Implementasi Referensi TypeScript: Turbo Harness Runtime Engine

Berikut adalah modul TypeScript tingkat produksi yang mengimplementasikan arsitektur runtime Turbo Harness, mencakup seleksi Playbook berbasis kondisi, sintesis patch diff, dan eksekusi dengan fail-safe boundary:

// Production Implementation: Turbo Harness Adaptive Engine & Playbook Matcher
// Berdasarkan Arsitektur arXiv:2609.40330 (Rutgers / Red Hat / MIT-IBM - Oktober 2026)
//
// Karakteristik Inti:
// 1. Daur ulang Search Archive menjadi Playbook terstruktur (sukses & anti-patterns).
// 2. Satu kali forward pass per-instance via Harness Editor SLM (Qwen3.5-9B).
// 3. Dynamic AST/Unified-Diff patching terhadap Global Harness H* dengan fallback protektif.

export interface PlaybookStrategy {
  id: string;
  category: 'workflow_routing' | 'budget_reallocation' | 'tool_constraint' | 'verification_gate';
  condition: string;          // Prasyarat konteks (misal: "git regression bug", "high-branching AST")
  recommendedEdit: string;     // Pola injeksi aksi atau workflow
  antiPatternWarning?: string; // Edit yang terbukti menurunkan performa global
  empiricalWinRate: number;    // Delta performa historis dari search archive
}

export interface TaskInstance {
  instanceId: string;
  repository: string;
  problemStatement: string;
  fileHints?: string[];
  isRegressionCandidate: boolean;
  maxBudgetSteps: number;
}

export interface HarnessPatchProposal {
  patchId: string;
  targetSection: string;       // Bagian scaffold H* yang dimodifikasi
  diffContent: string;         // Format unified diff
  rationale: string;
  referencedPlaybookId?: string;
}

export interface ExecutableHarness {
  harnessId: string;
  version: string;
  workflowPrompt: string;
  availableTools: string[];
  maxStepsPerPhase: Record;
  enforceToolChoice: boolean;
}

export class TurboHarnessRuntimeEngine {
  private globalHarness: ExecutableHarness;
  private playbook: PlaybookStrategy[];

  constructor(globalHarness: ExecutableHarness, playbookArchive: PlaybookStrategy[]) {
    this.globalHarness = globalHarness;
    this.playbook = playbookArchive;
  }

  /**
   * Menyeleksi strategi Playbook yang paling relevan untuk instance tertentu
   */
  public selectPlaybookContext(task: TaskInstance): PlaybookStrategy[] {
    return this.playbook.filter(strategy => {
      if (task.isRegressionCandidate && strategy.condition.includes('regression')) return true;
      if (task.repository.includes('django') && strategy.category === 'budget_reallocation') return true;
      return strategy.empiricalWinRate > 0.15;
    });
  }

  /**
   * Mensimulasikan satu kali forward pass dari RL-trained Harness Editor (pi_theta)
   */
  public generateInstancePatch(task: TaskInstance): HarnessPatchProposal {
    const relevantPlaybook = this.selectPlaybookContext(task);

    if (task.isRegressionCandidate) {
      return {
        patchId: `patch-${task.instanceId}-reg`,
        targetSection: 'workflow_guidance',
        diffContent: [
          '@@ -1,3 +1,6 @@',
          ' ## Recommended Workflow',
          '- Analyze codebase by reading files',
          '+ For regression bugs, check git history first to identify recent diffs',
          '+ Execute: git log --oneline -20 && git diff HEAD~1..HEAD --stat',
          ' ## Source Inspection',
        ].join('\n'),
        rationale: 'Injeksi eksplorasi riwayat git spesifik untuk regresi commit sebelum menyentuh file sumber.',
        referencedPlaybookId: relevantPlaybook.find(p => p.condition.includes('regression'))?.id,
      };
    }

    if (task.maxBudgetSteps < 30) {
      return {
        patchId: `patch-${task.instanceId}-tight`,
        targetSection: 'phase_budget',
        diffContent: [
          '@@ -10,3 +10,3 @@',
          '- maxExplorationSteps: 15',
          '+ maxExplorationSteps: 6',
          '+ maxVerificationSteps: 12',
        ].join('\n'),
        rationale: 'Reallokasi jatah step dari eksplorasi awal ke verifikasi akhir di bawah batasan komputasi ketat.',
        referencedPlaybookId: 'strat-budget-realloc-v2',
      };
    }

    // Default: no-op patch mempertahankan H*
    return {
      patchId: `patch-${task.instanceId}-noop`,
      targetSection: 'none',
      diffContent: '',
      rationale: 'H* global sudah optimal untuk tipe task umum.',
    };
  }

  /**
   * Menerapkan patch instance-specific ke H* dengan Atomic Fallback Gate
   */
  public compileInstanceHarness(task: TaskInstance): { harness: ExecutableHarness; isAdapted: boolean; fallbackTriggered: boolean } {
    const proposal = this.generateInstancePatch(task);

    if (!proposal.diffContent || proposal.targetSection === 'none') {
      return { harness: { ...this.globalHarness }, isAdapted: false, fallbackTriggered: false };
    }

    try {
      const adapted = JSON.parse(JSON.stringify(this.globalHarness)) as ExecutableHarness;

      // Injeksi adaptasi sesuai targetSection
      if (proposal.targetSection === 'workflow_guidance') {
        adapted.workflowPrompt += '\n\n' + proposal.diffContent.split('\n').filter(l => l.startsWith('+')).map(l => l.slice(1).trim()).join('\n');
        adapted.version += '-adapted-reg';
      } else if (proposal.targetSection === 'phase_budget') {
        adapted.maxStepsPerPhase = {
          exploration: 6,
          execution: 12,
          verification: 12,
        };
        adapted.version += '-adapted-budget';
      }

      return { harness: adapted, isAdapted: true, fallbackTriggered: false };
    } catch (err) {
      // Safety Fallback: jika patching gagal atau korup, fallback 100% aman ke H*
      return { harness: { ...this.globalHarness }, isAdapted: false, fallbackTriggered: true };
    }
  }
}

6. Panduan Implementasi Arsitektur untuk Tim Rekayasa Agen AI

Bagi organisasi enterprise dan startup AI yang sedang mengembangkan agen koding otonom, sistem customer experience, atau bot terminal, temuan Turbo Harness menawarkan pedoman strategis:

• Jangan Buang Jejak Eksplorasi (Preserve the Search Exhaust): Setiap kali Anda menjalankan optimasi prompt atau arsitektur multi-agent (evaluasi SWE-bench, benchmark internal), simpan jejak kegagalan dan keberhasilan. Data tersebut merupakan bahan mentah berharga untuk melatih modul adaptif tanpa biaya ekstraksi baru.
• Gunakan Pola "Global Baseline + Instance Patch" (Bukan Sintesis Nol): Meminta model menghasilkan seluruh kode harness dari nol pada setiap task memicu latensi tinggi dan tingkat kegagalan sintaks yang besar. Pola patch diff menjamin waktu pemrosesan instan dan keamanan runtime fallback.
• Reallokasi Anggaran Langkah (Step Budget Reallocation): Sesuaikan batas langkah sub-fase (misal eksplorasi vs verifikasi) sesuai tingkat kompleksitas masalah. Mengurangi waktu penjelajahan pada bug sederhana menghemat jutaan token berbayar di lingkungan produksi.