1. Anatomi Masalah: Mengapa Recursive Self-Improvement Agen Ilmiah Kerap Mengalami Dead-End?

Eksplorasi penemuan ilmiah berbasis AI (Autonomous Scientific Discovery) menuntut sistem untuk merumuskan hipotesis $h$, menerjemahkannya ke dalam kode program $p$, mengeksekusinya di lingkungan komputasi riil, dan mengevaluasi hasilnya terhadap metrik ilmiah $u(p)$. Visi utamanya adalah Recursive Self-Improvement (RSI), di mana agen belajar dari eksperimen masa lalunya sendiri untuk melahirkan terobosan ilmiah baru tanpa supervisi manusia.

Namun, para peneliti dari Huawei Technologies, Leiden University, dan University of Groningen menemukan dua hambatan fundamental yang melumpuhkan sistem agen saat ini:

Gambar 1: Dua dilema sistem agen ilmiah konvensional. Atas: Hasil eksperimen buruk tidak menjelaskan apakah hipotesis atau implementasi kodenya yang gagal, memicu pembuangan hipotesis menjanjikan secara prematur. Bawah: Skor program agregat yang rendah menyembunyikan sub-komponen bernilai tinggi yang dibutuhkan agen lain (Sumber: Meng et al., arXiv:2610.20431).

2. Arsitektur SwarmRSI: Shared Research State Graph $\mathcal{G}_t$

Untuk memecahkan isolasi tersebut, SwarmRSI mengorganisasikan agen-agen ilmiah ke dalam struktur swarm terdistribusi yang terhubung ke satu graf status riset bersama (Shared Research State Graph) $\mathcal{G}_t$.

Setiap langkah riset $t$ tidak lagi dimulai dari nol atau sekadar prompt memory linier, melainkan mengekstrak tuple status:

Di mana $\mathcal{H}_t$ adalah kumpulan hipotesis aktif, $\mathcal{P}_t$ adalah himpunan program executable valid, $\mathcal{E}_t$ adalah bukti eksperimental (output eksekusi, log trace, metrik per-instance), dan yang terpenting: $\mathcal{U}_t$ adalah Unresolved Research Needs (kebutuhan implementasi yang belum terselesaikan, seperti butuh optimasi latensi, butuh loss function alternatif, dsb).

Gambar 2: Arsitektur Eksekusi SwarmRSI. Shared research graph mempertahankan silsilah hipotesis-program, bukti eksekusi, dan permintaan perbaikan. Siklus eksekusi memandu mutasi terarah, rekombinasi komplementer, dan audit kode/saintifik otomatis (Sumber: Meng et al., arXiv:2610.20431).

3. Feedback-Guided Swarm Mutation: Memisahkan H-Mutation dan P-Mutation

Inovasi pertama SwarmRSI dalam mencegah hilangnya ide potensial adalah memisahkan mutasi menjadi dua dimensi orthogonal:

4. Complementary Swarm Recombination: Rebase dan Instance-Aware Crossover

Dalam penelitian ilmiah, kemajuan sering kali dicapai bukan dengan merancang segalanya dari nol, melainkan dengan meminjam fondasi solid dari tim lain. SwarmRSI memformalkan prinsip ini ke dalam dua operator rekombinasi:

A. Hypothesis Rebase

Jika sebuah hipotesis $h_t$ memiliki kendala implementasi yang macet (unresolved implementation needs), agen menelusuri graf $\mathcal{G}_t$ untuk mencari program basis $b_t$ yang dikembangkan oleh agen lain yang memiliki mekanisme cocok. Operasi Rebase memindahkan hipotesis $h_t$ untuk diimplementasikan di atas $b_t$:

B. Program Crossover Berdasarkan Keunggulan Per-Instance

Alih-alih crossover acak pada string kode, SwarmRSI membandingkan profil utilitas per-subtugas $u_k(p)$. Program donor $\mathcal{D}(p_t)$ dipilih dari program-program valid yang mengalahkan program induk $p_t$ pada setidaknya satu instance $k$, diurutkan berdasarkan keunggulan terbesar $\Delta_t(d)$:

Program anakan baru mewarisi sub-rutin donor pada instance di mana donor tersebut menang, dan mempertahankan komponen induk di area lainnya.

5. Recursive Swarm Evolution: Penjadwalan Dinamis dengan Discounted-UCB Index

Kapan swarm harus mengeksplorasi hipotesis baru ($H$), dan kapan harus mereparasi/mengoptimalkan kode program ($P$)? Jika penjadwalan dilakukan secara statis (misal bergantian H-P-H-P), agen akan membuang komputasi saat salah satu jalur mengalami kebuntuan.

SwarmRSI mempertahankan Hypothesis Frontier $\mathcal{F}_H$ dan Program Frontier $\mathcal{F}_P$. Keputusan pemilihan frontier $f \in \{H, P\}$ dikendalikan oleh indeks Discounted-UCB yang diperkaya dengan Saturated Request Pressure $\psi_f$:

Komponen perumus indeks:

• $\hat{\mu}_f = G_f / C_f$: Keberhasilan mutakhir (reward gain per unit token cost), terdiskon dengan faktor $\rho = 0.9$ agar peka terhadap tren eksperimen terkini.
• $\beta \sqrt{\frac{\log(\dots)}{N_f}}$: Bonus eksplorasi bandit untuk frontier yang jarang dipilih.
• $\gamma \psi_f$: Tekanan permintaan jenuh $\psi_f = \min(U_f, K) / K$ (dengan $K=4$). Ketika eksekusi program banyak melempar permintaan perbaikan (deepen request), tekanan pada frontier $P$ melonjak drastis, memicu swarm untuk memprioritaskan perbaikan bug sebelum merumuskan hipotesis baru.

6. Hasil Evaluasi Empiris Komprehensif

SwarmRSI diuji secara ekstensif pada 3 benchmark rekayasa sains dan machine learning berskala besar menggunakan backbone DeepSeek-V4-Pro dan Gemini 3.1 Pro Preview.

Tabel 1: Evaluasi pada 6 Tugas Analisis Single-Cell OpenProblems

Tabel 2: Performa NatureBench (90 Tugas Ilmiah Lintas 6 Domain)

Gambar 3: Diagnostik Pencarian SwarmRSI. (a) Failure recovery: proporsi implementasi yang sempat gagal namun berhasil diperbaiki hingga mencetak skor terbaik baru (mencapai >60%). (b) Proporsi hipotesis yang lolos audit dan menghasilkan peningkatan. (c, d) Trajektori utilitas best-so-far dibandingkan AIDE dan Arbor (Sumber: Meng et al., arXiv:2610.20431).

7. Studi Ablasi: Komponen Mana yang Paling Krusial?

Melalui uji ablasi terkontrol pada 90 tugas NatureBench (Tabel 3 paper), peneliti mengisolasi kontribusi masing-masing mekanisme:

• Menghapus P-mutation: Match-SOTA anjlok dari 44.4% menjadi 31.1% (-13.3 pp). Ini membuktikan bahwa kemampuan mereparasi kode tanpa mengubah hipotesis adalah pilar paling vital dalam menjaga stabilitas pencarian.
• Menghapus H-mutation: Match-SOTA turun menjadi 34.4% (-10.0 pp). Memperbaiki kode saja tanpa bisa mengevolusi hipotesis akan menyebabkan agen terjebak di local minima algoritma.
• Menghapus Dynamic H/P Selection (Diganti Alternasi Statis): Match-SOTA merosot ke 35.6% dan mean gain $g$ mengalami kejatuhan terdalam dari 12.8 ke 4.6. Alokasi komputasi yang adaptif terhadap request pressure terbukti menjadi pembeda utama antara agen cerdas dan brute-force loop.
• Menghapus Recombination (Rebase & Crossover): Surpass-SOTA terpangkas separuh dari 15.6% ke 7.8%, membuktikan bahwa solusi ilmiah terobosan memerlukan sintesis komponen lintas agen.

8. Arsitektur Kode Produksi: SwarmRSI Controller dalam TypeScript

Berikut adalah implementasi clean-architecture dari controller SwarmRSI yang mengintegrasikan status graph $\mathcal{G}_t$, Discounted-UCB scheduling, dan pemilih donor crossover:

// Production Implementation: SwarmRSI (Recursive Self-Improvement Scientific Swarm Controller)
// Berdasarkan formulasi formal arXiv:2610.20431 (Huawei Technologies, Leiden Univ, Univ of Groningen)
// Mengimplementasikan: Shared Research State Graph G_t, Feedback-Guided H/P Mutator,
// Rebase & Instance-Aware Crossover Recombiner, serta Discounted-UCB Index Scheduling.

export interface ScientificHypothesis {
  id: string;
  rationale: string;
  modelingMechanism: string;
  targetInstances: string[];
  createdStep: number;
}

export interface ScientificProgram {
  id: string;
  hypothesisId: string;
  parentProgramId?: string;
  codeSource: string;
  perInstanceUtility: Record; // u_k(p)
  aggregateUtility: number;                   // u(p)
  runtimeAudit: {
    isSyntaxValid: boolean;
    executedSuccessfully: boolean;
    hasStaticReferences: boolean;
    divergentOutputs: boolean;
  };
}

export interface ExecutionRecord {
  step: number;
  testedHypothesis: ScientificHypothesis;
  parentProgram?: ScientificProgram;
  candidateProgram: ScientificProgram;
  outcomeUtility: number;
  auditPassed: boolean;
  unresolvedRequests: Array<'deepen' | 'broaden' | 'rebase_incumbent'>;
}

export interface FrontierStatistics {
  discountedSelectionCount: number; // N_f
  discountedRewardGains: number;    // G_f
  discountedCostTokens: number;     // C_f
  waitingEligibleTurns: number;     // W_f
}

export class SwarmRSIController {
  private researchGraph: ExecutionRecord[] = [];
  private hypothesisFrontier: Map = new Map();
  private programFrontier: Map = new Map();
  private incumbentProgram: ScientificProgram | null = null;

  // Hyperparameters sesuai Tabel 4 & Algoritma 1 paper arXiv:2610.20431
  private readonly rho = 0.9;     // Discount factor
  private readonly beta = 0.5;    // Exploration weight
  private readonly gamma = 0.25;  // Request-pressure weight
  private readonly K_sat = 4;     // Saturated request ceiling
  private readonly waitThreshold = 8; // W eligible turns

  private hStats: FrontierStatistics = { discountedSelectionCount: 0, discountedRewardGains: 0, discountedCostTokens: 0, waitingEligibleTurns: 0 };
  private pStats: FrontierStatistics = { discountedSelectionCount: 0, discountedRewardGains: 0, discountedCostTokens: 0, waitingEligibleTurns: 0 };

  constructor(initialDrafts: ScientificProgram[]) {
    for (const prog of initialDrafts) {
      this.programFrontier.set(prog.id, prog);
      if (!this.incumbentProgram || prog.aggregateUtility > this.incumbentProgram.aggregateUtility) {
        this.incumbentProgram = prog;
      }
    }
  }

  /**
   * 1. Dynamic H/P Selection Controller via Discounted-UCB Index
   * S_f = \hat{\mu}_f + \beta * sqrt(ln(1 + N_H + N_P) / N_f) + \gamma * \psi_f
   */
  public selectNextFrontier(unresolvedHRequests: number, unresolvedPRequests: number): 'H' | 'P' {
    // Priority Rule 1: Waiting turns exceeded threshold W
    if (this.hStats.waitingEligibleTurns >= this.waitThreshold) return 'H';
    if (this.pStats.waitingEligibleTurns >= this.waitThreshold) return 'P';

    // Priority Rule 2: Untried frontiers
    if (this.hStats.discountedSelectionCount === 0) return 'H';
    if (this.pStats.discountedSelectionCount === 0) return 'P';

    const totalSelections = this.hStats.discountedSelectionCount + this.pStats.discountedSelectionCount;
    const psi_H = Math.min(unresolvedHRequests, this.K_sat) / this.K_sat;
    const psi_P = Math.min(unresolvedPRequests, this.K_sat) / this.K_sat;

    const mu_H = this.hStats.discountedCostTokens > 0 ? this.hStats.discountedRewardGains / this.hStats.discountedCostTokens : 0;
    const mu_P = this.pStats.discountedCostTokens > 0 ? this.pStats.discountedRewardGains / this.pStats.discountedCostTokens : 0;

    const score_H = mu_H + this.beta * Math.sqrt(Math.log(1 + totalSelections) / this.hStats.discountedSelectionCount) + this.gamma * psi_H;
    const score_P = mu_P + this.beta * Math.sqrt(Math.log(1 + totalSelections) / this.pStats.discountedSelectionCount) + this.gamma * psi_P;

    if (score_H >= score_P) {
      this.hStats.waitingEligibleTurns = 0;
      this.pStats.waitingEligibleTurns += 1;
      return 'H';
    } else {
      this.pStats.waitingEligibleTurns = 0;
      this.hStats.waitingEligibleTurns += 1;
      return 'P';
    }
  }

  /**
   * 2. Complementary Swarm Recombination: Crossover Donors Selection
   * Memilih sub-komponen program donor berdasarkan max instance advantage Delta_t(d)
   */
  public selectCrossoverDonors(parent: ScientificProgram): ScientificProgram[] {
    const donors: Array<{ program: ScientificProgram; maxAdvantage: number }> = [];

    for (const [id, candidate] of this.programFrontier.entries()) {
      if (id === parent.id) continue;
      let maxAdv = 0;
      for (const [subtaskKey, util] of Object.entries(candidate.perInstanceUtility)) {
        const parentUtil = parent.perInstanceUtility[subtaskKey] || 0;
        if (util > parentUtil) {
          const diff = util - parentUtil;
          if (diff > maxAdv) maxAdv = diff;
        }
      }
      if (maxAdv > 0) {
        donors.push({ program: candidate, maxAdvantage: maxAdv });
      }
    }

    donors.sort((a, b) => b.maxAdvantage - a.maxAdvantage);
    return donors.slice(0, 2).map(d => d.program);
  }

  /**
   * 3. State Update & Research Record Retention
   */
  public registerAttempt(record: ExecutionRecord, tokenCost: number, chosenFrontier: 'H' | 'P') {
    this.researchGraph.push(record);
    const prevIncumbent = this.incumbentProgram?.aggregateUtility || 0;
    const gain = Math.min(1.0, Math.max(0, record.outcomeUtility - prevIncumbent));
    const normalizedCost = Math.max(1, tokenCost / 1000);

    if (record.candidateProgram.aggregateUtility > prevIncumbent && record.auditPassed) {
      this.incumbentProgram = record.candidateProgram;
      this.programFrontier.set(record.candidateProgram.id, record.candidateProgram);
    }

    // Update frontier statistics with discount rho = 0.9
    const updateStats = (stats: FrontierStatistics, isSelected: boolean) => {
      stats.discountedSelectionCount = this.rho * stats.discountedSelectionCount + (isSelected ? 1 : 0);
      stats.discountedRewardGains = this.rho * stats.discountedRewardGains + (isSelected ? gain : 0);
      stats.discountedCostTokens = this.rho * stats.discountedCostTokens + (isSelected ? normalizedCost : 0);
    };

    updateStats(this.hStats, chosenFrontier === 'H');
    updateStats(this.pStats, chosenFrontier === 'P');
  }
}

9. Rekomendasi Rekayasa Sistem Agen AI 2026: Implikasi Strategis

Makalah SwarmRSI meletakkan standar baru bagi bagaimana para arsitek AI dan tim riset enterprise membangun agen otonom:

1. Jangan Pernah Membuang Trajektori Negatif: Eksperimen yang melempar error atau menghasilkan skor buruk bukan sampah komputasi; itu adalah audit evidence yang memberi tahu agen lain jalur mana yang tidak boleh diulang dan komponen mana yang perlu direparasi.
2. Pisahkan Logika Ideasi dari Logika Implementasi: Agen perencana (Planner) dan agen koder (Coder) harus memiliki siklus hidup evaluasi terpisah. Kesalahan sintaksis tidak boleh membatalkan kelayakan hipotesis.
3. Manfaatkan Sub-Komponen Modular Lintas Eksekusi: Desain arsitektur agen harus mampu membedah skrip ke dalam modul-modul independen (data loader, loss function, feature extractor) sehingga fungsi yang unggul pada subset data dapat dicangkokkan (crossover) ke program lain.
4. Gunakan Saturated Request Pressure untuk Bandit Scheduling: Menghitung UCB murni hanya berdasarkan reward historis adalah kesalahan fatal dalam sistem agen karena reward sering kali sparse (jarang). Memasukkan metrik saturasi permintaan kebutuhan tak terpenuhi ($\psi_f$) memberikan sensitivitas real-time terhadap kemacetan pipeline.