Ecdysis 2026: Arsitektur Batch-Level Failure Aggregation, Failure-Driven Collaborative Refinement (FDCR), dan Self-Evolving Runtime Harnesses pada Autonomous LLM Agents

Dalam lanskap rekayasa AI agents tahun 2026, paradigma optimasi telah bergeser secara radikal. Jika era 2024–2025 berfokus secara eksklusif pada prompt engineering statis dan post-training weight tuning (RLHF/DPO), era modern membuktikan bahwa determinan terpenting keberhasilan autonomous agent di dunia nyata adalah Runtime Harness: lapisan orkestrasi software yang membungkus model dasar (LLM) untuk mengelola registri tools, manipulasi state lingkungan, sanitasi konteks token, dan penanganan kegagalan eksekusi.

1. Paradoks Self-Evolution: Mengapa Coding Agent Merusak Runtime Harness Sendiri?

Ketika sebuah model LLM otonom diberikan hak untuk memodifikasi kode scaffolding-nya sendiri berdasarkan umpan balik kegagalan eksekusi (paradigma agent-modifying-agent), ekspektasi teoritis memprediksi peningkatan kualitas harness secara konvergen. Namun, uji coba empiris terhadap enam kombinasi domain dan model Qwen3 membeberkan realitas yang kontras:

Perhatikan bahwa Self-Evolution serial konvensional (43.33%) tertinggal jauh di bawah konfigurasi manusia (50.28%). Mengapa hal ini terjadi? Tim peneliti Ecdysis membedah fenomena ini ke dalam dua cacat struktural yang fatal:

• Model-Specific Accommodation Trap: Ketika agen mengalami kegagalan pada satu task (misalnya halusinasi format JSON tanggal atau kebingungan parsing parameter), coding agent yang memperbaiki harness cenderung menyisipkan aturan prompt ad-hoc atau penanganan khusus yang sangat sempit. Ini adalah akomodasi spesifik model, bukan reparasi harness. Penambahan aturan lokal ini mencemari context window, memicu instruction collision, dan menyebabkan regresi berat pada task lain yang sebelumnya berhasil.
• Granularitas Update Serial & Redundansi Mahal: Jika sepuluh task gagal karena satu bug harness yang sama (misalnya kegagalan penanganan sinyal SIGPIPE pada subproses CLI), metode serial akan memanggil coding agent sepuluh kali terpisah. Setiap panggilan memodifikasi codebase harness secara parsial, memicu kompilasi berulang, evaluasi regresi redundan, dan pemborosan biaya API token hingga 300%.

2. Arsitektur Inti Ecdysis: Dekomposisi Sistematis Siklus Hidup Harness

Diambil dari istilah biologi ecdysis (proses pergantian eksoskeleton pada artropoda untuk memungkinkan pertumbuhan tubuh tanpa terhimpit cangkang lama), framework Ecdysis merestrukturisasi proses adaptasi harness menjadi sistem dua tahap yang terisolasi secara disiplin:

// Ecdysis Runtime Harness Self-Evolution Engine (TypeScript Reference Implementation)
// Mengimplementasikan Batch-Level Cross-Instance Failure Aggregation,
// Multi-Role Collaborative Refinement (Analyst, Critic, Engineer),
// serta Atomic Harness Contract Verification sesuai spesifikasi arXiv:2609.11677 (Yue et al., 2026)

export interface ExecutionTrajectory {
  taskId: string;
  success: boolean;
  score: number;
  durationMs: number;
  tokenUsage: { prompt: number; completion: number };
  toolCallTraces: Array<{
    toolName: string;
    arguments: Record;
    output: string;
    isError: boolean;
  }>;
  terminalStateReason: string;
}

export interface StructuredFailureRecord {
  taskId: string;
  failureCategory: 'tool_protocol_violation' | 'context_drift' | 'infinite_retry' | 'state_mismatch';
  triggeringAction: string;
  errorMessage: string;
  lastValidEnvironmentState: Record;
}

export interface FailureGroup {
  groupId: string;
  patternSignature: string;
  affectedTaskIds: string[];
  records: StructuredFailureRecord[];
  isCrossTaskSystemic: boolean; // Wajib true jika mencakup >= 2 task independen
}

export interface HarnessModificationSpec {
  specId: string;
  targetSubsystem: 'tool_registry' | 'context_sanitizer' | 'error_grounding' | 'loop_guard';
  rationale: string;
  proposedDiff: string;
  safeguardAssertions: string[];
  approvedByRoles: {
    analyst: boolean;
    critic: boolean;
    engineer: boolean;
  };
}

export class EcdysisHarnessEvolutionEngine {
  private failureThreshold: number = 0.5; // Skor di bawah ini dihitung sebagai failure

  /**
   * 1. Batch-Level Cross-Instance Failure Aggregation
   * Mengelompokkan kegagalan dari seluruh batch task untuk mengisolasi cacat sistemik
   */
  public aggregateFailures(trajectories: ExecutionTrajectory[]): FailureGroup[] {
    const failedTrajectories = trajectories.filter((t) => !t.success || t.score < this.failureThreshold);
    const groupsMap = new Map();

    for (const traj of failedTrajectories) {
      const record = this.extractStructuredFailure(traj);
      const signature = `${record.failureCategory}::${record.triggeringAction}`;

      if (!groupsMap.has(signature)) {
        groupsMap.set(signature, []);
      }
      groupsMap.get(signature)!.push(record);
    }

    const failureGroups: FailureGroup[] = [];
    let groupIndex = 1;

    for (const [signature, records] of groupsMap.entries()) {
      const distinctTasks = Array.from(new Set(records.map((r) => r.taskId)));
      failureGroups.push({
        groupId: `grp-fail-${groupIndex++}`,
        patternSignature: signature,
        affectedTaskIds: distinctTasks,
        records,
        // Ecdysis Rule: Kegagalan sistemik harness dibuktikan jika muncul di >= 2 tugas berbeda
        isCrossTaskSystemic: distinctTasks.length >= 2,
      });
    }

    // Prioritaskan grup kegagalan sistemik yang muncul lintas task
    return failureGroups.sort((a, b) => (b.isCrossTaskSystemic ? 1 : 0) - (a.isCrossTaskSystemic ? 1 : 0));
  }

  /**
   * 2. Failure-Driven Collaborative Refinement (FDCR) Multi-Role Consensus
   */
  public async executeFDCR(
    group: FailureGroup,
    currentHarnessCode: string
  ): Promise {
    if (!group.isCrossTaskSystemic) {
      console.log(`[ECDYSIS_ISOLATION] Skipping group ${group.groupId}: Single-instance failure is likely model deficiency.`);
      return null;
    }

    // Role 1: Analyst menganalisis pola kegagalan dan mengajukan patch minimal terarah
    const analystProposal = {
      targetSubsystem: 'error_grounding' as const,
      rationale: `Cacat sistemik pada ${group.patternSignature}: Tool executor mengembalikan raw stderr tanpa petunjuk remediable state.`,
      proposedDiff: `+ formatRemediableToolError(errorContext, schemaRules);`,
      approved: true,
    };

    // Role 2: Critic memeriksa risiko over-fitting, false-blocking, dan regresi performa
    const criticReview = {
      isOverfittedToSpecificModel: false,
      violatesRuntimeContract: false,
      introducesLatencySpike: false,
      approved: true,
    };

    // Role 3: Engineer merumuskan spesifikasi akhir & safeguard unit assertion
    if (analystProposal.approved && criticReview.approved) {
      return {
        specId: `HMS-${nanoid(8)}`,
        targetSubsystem: analystProposal.targetSubsystem,
        rationale: analystProposal.rationale,
        proposedDiff: analystProposal.proposedDiff,
        safeguardAssertions: [
          'assert(toolOutput.hasRemediableClue === true)',
          'assert(executionTimeOverheadMs < 5.0)',
          'assert(historicalPassingTasksRegressed === 0)',
        ],
        approvedByRoles: {
          analyst: true,
          critic: true,
          engineer: true,
        },
      };
    }

    return null;
  }

  private extractStructuredFailure(traj: ExecutionTrajectory): StructuredFailureRecord {
    const lastErrorTrace = [...traj.toolCallTraces].reverse().find((t) => t.isError);
    return {
      taskId: traj.taskId,
      failureCategory: lastErrorTrace ? 'tool_protocol_violation' : 'state_mismatch',
      triggeringAction: lastErrorTrace?.toolName || 'unknown_dispatch',
      errorMessage: lastErrorTrace?.output || traj.terminalStateReason,
      lastValidEnvironmentState: { durationMs: traj.durationMs },
    };
  }
}

A. Batch-Level Cross-Instance Failure Aggregation

Alih-alih merevisi kode setelah setiap kegagalan individual, Ecdysis menjalankan seluruh batch tugas training dengan harness yang dibekukan ($H_{i-1}$) dan mengumpulkan seluruh trajektori eksekusi $mathcal{T}_i$. Untuk setiap trajektori $ au$, sistem mengevaluasi sinyal biner kegagalan:

Semua trajektori yang gagal dikonversi menjadi record terstruktur yang memuat identitas task, riwayat pemanggilan tool, pesan galat, dan status lingkungan terakhir. Ecdysis menerapkan Cross-Task Regularity Filter yang ketat: kelompok kegagalan hanya diproses untuk modifikasi harness jika pola tersebut muncul di minimal dua task berbeda ($| ext{distinctTasks}| ge 2$). Kegagalan unik pada satu task diabaikan dari siklus modifikasi harness karena probabilitas tertingginya adalah defisiensi stokastik internal model LLM, bukan cacat arsitektur runtime.

B. Failure-Driven Collaborative Refinement (FDCR)

Setelah kelompok kegagalan sistemik teridentifikasi, Ecdysis memisahkan fase diagnosis dan perencanaan dari fase penulisan kode melalui protokol multi-role kolaboratif dengan transkrip bersama:

• Peran Analyst (Root Cause Discovery): Membedah transkrip kegagalan lintas-task untuk menemukan titik lemah sistemik (misalnya skema validasi tool yang terlalu kaku atau ketiadaan remediable hint saat tool gagal). Analyst merumuskan proposal perubahan minimal yang hanya menyentuh subsistem target.
• Peran Critic (Adversarial Red-Teaming): Menguji proposal Analyst terhadap bukti kegagalan historis. Critic bertugas mendeteksi pemicu yang terlalu luas (overly broad triggers), risiko pemblokiran aksi yang valid (false blocking), potensi pelanggaran kontrak runtime, dan ancaman regresi pada task yang sebelumnya lulus.
• Peran Engineer (Synthesized Specification & Safeguard): Mengintegrasikan konsensus dari Analyst dan Critic menjadi sebuah Harness Modification Specification (HMS) formal, lengkap dengan serangkaian safeguard assertion sebelum diserahkan kepada agen pengkode untuk implementasi patch.

3. Hasil Evaluasi Empiris: Lompatan Akurasi dan Efisiensi Komputasi

Pengujian formal dilakukan pada lima model LLM frontier yang beragam (Qwen3-8B, Qwen3-14B, Qwen3-32B, MiniMax-M2.7 230B MoE, dan Llama-3.1-8B) dengan tolok ukur lingkungan dinamis yang menuntut interaksi multi-langkah: $ au^2$-Bench ($ au^2$-Airline dan $ au^2$-Retail) serta AgentBench.

Tiga temuan kunci dari data empiris di atas membuktikan keunggulan arsitektur Ecdysis:

1. Eliminasi Regresi Acak: Metrik $Pass^3$ (probabilitas sebuah agent berhasil menyelesaikan tugas tiga kali berturut-turut pada seed yang berbeda) melonjak dari 29.00% pada Self-Evolution biasa menjadi 45.00% pada Ecdysis. Ini membuktikan bahwa modifikasi harness yang dihasilkan Ecdysis bersifat deterministik dan kokoh, bukan sekadar kebetulan sampling yang rapuh.
2. Efisiensi Biaya dan Waktu Pelatihan: Berkat Batch-Level Aggregation, Ecdysis memangkas waktu end-to-end training harness hingga 1.84x lebih cepat pada $ au^2$-Airline (4.403 detik vs 8.100+ detik) dan mengurangi biaya API dari $8.484 menjadi $2.485 / $5.763.
3. Penghematan Token Inferensi: Berlawanan dengan metode modifikasi naif yang terus menambah teks panjang pada system prompt, harness yang dioptimasi Ecdysis memangkas konsumsi token hingga 10.157 M (vs 11.567 M pada SE). Harness yang bersih dan terstruktur membantu model menyelesaikan tugas dengan jumlah giliran pemanggilan tool yang lebih sedikit tanpa terjebak dalam circular retry loop.

4. Implikasi Desain dan Panduan Implementasi untuk Platform AI 2026

Bagi tim arsitektur enterprise yang membangun platform coding assistant, agentic workflow automation, maupun autonomous research swarms, temuan Ecdysis menghadirkan pedoman rekayasa konkret:

• Hentikan 'Online Hot-Patching' pada Single Failures: Jangan pernah membiarkan agen supervisor mengedit system prompt atau wrapper fungsi setiap kali ada satu interaksi pengguna yang gagal di production. Terapkan batch collection: kumpulkan minimal 20-50 failure traces, kelompokkan berdasarkan kesamaan struktur, dan hanya lakukan pembaruan harness untuk cacat yang terbukti berulang lintas skenario.
• Terapkan Red-Teaming Critic Otomatis: Setiap perubahan kode harness (misalnya penambahan filter regex, validasi skema parameter, atau injeksi context memory) wajib melalui pemeriksaan Critic otomatis untuk mengevaluasi apakah perubahan tersebut berpotensi memblokir alur kerja yang sah atau memicu overhead latensi.
• Ukur Regresi dengan Metrik Pass^K: Jangan puas dengan metrik $Pass@1$ yang rentan terhadap noise probabilistik. Gunakan metrik konsistensi $Pass^3$ atau $Pass^5$ untuk memastikan bahwa perbaikan harness benar-benar meningkatkan determinisme penalaran agen.

5. Kesimpulan

Ecdysis membuktikan bahwa batas kemampuan autonomous agent tidak semata-mata dikurung oleh parameter model LLM, melainkan oleh integritas dan kedewasaan runtime harness yang melingkupinya. Dengan membuang ilusi perbaikan instan berbasis kegagalan tunggal dan menggantikannya dengan agregasi batch berbasis bukti serta kolaborasi terstruktur antar peran diagnostik, kita membuka era baru: self-evolving autonomous agents yang tidak hanya mampu belajar dari kesalahan, namun mampu merekayasa ulang lingkungan eksekusinya secara aman, terukur, dan bebas dari regresi.