One to More, More to One 2026: Arsitektur Category-Aware Iterative Expert Training, Algoritma Agentic-miniRL & RRE, dan Multi-Teacher On-Policy Distillation (MOPD) pada Autonomous Software Engineering Agents

1. Anatomi Fenomena Category See-Saw: Mengapa Pooled RL Menipu Pengembang?

Mengembangkan agen otonom untuk rekayasa perangkat lunak tingkat repositori (repository-level SWE) berbeda fundamental dari memecahkan soal algoritma singkat (LeetCode/HumanEval). Trajektori agen melibatkan navigasi repositori berukuran gigabyte, penelusuran call-graph antarfile, pembacaan log tes unit, hingga sintesis patch multi-file yang panjang dan stateful.

Dalam implementasi industri, tugas-tugas repositori memiliki karakteristik yang sangat heterogen:

• Layanan & Keamanan Data (Category A): Berfokus pada invariant transaksi basis data, penanganan race conditions, sanitasi kriptografi, dan kontrak API internal. Memerlukan audit statis yang ketat dan trace eksekusi deterministik.
• Aplikasi Antarmuka & Presentasi (Category B): Berfokus pada state frontend, parsing event pengguna, format CLI, manipulasi DOM, dan rendering data visual. Sering kali mentolerir variasi implementasi asalkan fungsionalitas pengguna tercapai.
• Sistem, Tooling & Runtime (Category C): Berfokus pada modul kernel/OS, konfigurasi compiler, virtualisasi container, build system, dan sinkronisasi threading berlatensi rendah. Sangat rentan terhadap degradasi performa mikro.

Ketika satu model LLM tunggal dilatih menggunakan RL gabungan (Pooled RL) pada seluruh kumpulan tugas ini, pembaruan gradien (gradient updates) dari tugas Kategori A kerap kali berkonflik ortogonal dengan perilaku eksplorasi yang diperlukan untuk tugas Kategori B atau C. Evaluasi empiris Alibaba membuktikan bahwa skor resolusi agregat yang terlihat stabil atau naik tipis sesungguhnya menyembunyikan defisit parah: kenaikan +8% pada Kategori A terjadi bersamaan dengan anjloknya performa Kategori C hingga -6%.

2. Tiga Pilar Arsitektur: SWE Labeler, Agentic-miniRL, dan Siklus RRE

Framework One to More, More to One dibangun di atas tiga pilar teknologi yang terintegrasi secara matematis:

2.1 SWE Labeler: Taksonomi Bukti Multidimensi

Di dalam repositori tunggal, batas antarkategori tidak selalu eksplisit. Peneliti merancang SWE Labeler, sebuah sistem pelabelan hierarkis berbasis bukti nyata (evidence-grounded) yang menganalisis:

• Task Contract: Analisis AST pada file yang dimodifikasi, jenis dependensi pihak ketiga, dan modul target.
• Trajectory Traces: Pola panggilan tool yang dibutuhkan (apakah didominasi inspeksi runtime terminal vs penelusuran semantic grep).
• Grounding Rules: Aturan deterministik yang memetakan setiap instans ke dalam partisi mutually exclusive Kategori A, B, atau C.

2.2 Agentic-miniRL: RLOO Centering & Regularisasi K1

Tantangan terbesar RL pada lingkungan agen SWE adalah umpan balik verifikasi yang bersifat sparse binary (1.0 untuk lolos semua test suite, 0.0 jika satu saja gagal). Algoritma GRPO konvensional yang menyertakan sampel saat ini ke dalam rata-rata kelompok melemahkan sinyal pembelajaran pada tugas sulit di mana keberhasilan sangat langka.

Alibaba mengadopsi Leave-One-Out (RLOO) Reward Centering:

Dengan mengeliminasi rollout ke-i dari estimasi baseline-nya sendiri, RLOO menjaga ekspektasi gradien tidak bias (zero expectation score-function) sekaligus memaksimalkan varians reduksi tanpa memerlukan komputasi critic terpisah yang berat. Selain itu, drift kebijakan dikendalikan melalui penalti K1 divergence pada level token sebelum kalkulasi return-to-go, serta reduksi loss berbasis turn-aware masking untuk menyeimbangkan disparitas panjang aksi tool.

2.3 Refresh-Repair-Expand (RRE): Tanpa Guru Eksternal (Teacher-Free)

Banyak sistem agen SWE mengandalkan guru komersial raksasa (seperti Claude 3.5 Sonnet atau GPT-4o) untuk memproduksi trajektori sintetis. Sebaliknya, Alibaba membuktikan bahwa model dasar berbobot sama (π0) dapat mengembangkan keahlian spesialis mandiri dengan mengulang siklus RRE:

1. Refresh: Menguji ulang instans kandidat untuk memperbarui peta penguasaan (mastery map). Instans yang sudah 100% dikuasai disisihkan agar komputasi tidak mubazir.
2. Repair SFT: Mengumpulkan trajektori sukses yang berhasil dieksekusi oleh model itu sendiri di lingkungan nyata, lalu menggunakannya untuk fine-tuning terarah guna mengonsolidasikan perilaku pemecahan masalah yang benar.
3. Expand: Memperluas antrean pelatihan RL berikutnya dengan memasukkan instans yang berada tepat di perbatasan kemampuan (learning frontier, tingkat penguasaan antara 0% hingga 80%).

3. Implementasi Kode: Komponen Inti MiniRL & Distilasi MOPD

Cuplikan modul Python berikut mengilustrasikan logika operasional RLOO advantage calculation, token loss dengan penalti K1, serta router keuntungan MOPD berbasis ReLU gating:

"""
One to More, More to One: Category-Aware Iterative Expert Training Architecture.
Berdasarkan Makalah Frontier arXiv:2609.23377 (Alibaba Group, September 2026).

Komponen Arsitektur Utama:
1. SWE Labeler: Pengelompokan taksonomi bukti multi-axis ke dalam 3 kategori terisolasi (Pro-A, Pro-B, Pro-C).
2. Agentic-miniRL: RLOO reward centering + regularisasi K1 + koreksi rasio token probabilitas.
3. Refresh-Repair-Expand (RRE): Siklus adaptif penyegaran mastery, Repair SFT trajektori sukses mandiri, 
   dan pembukaan perbatasan eksplorasi RL.
4. Label-Routed Multi-Teacher On-Policy Distillation (MOPD): Ekstrapolasi reward berbasis ReLU gating 
   untuk menggabungkan kembali expert menjadi satu model siap produksi (deployable student).
"""

import math
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from dataclasses import dataclass, field
from enum import Enum
from typing import Dict, List, Optional, Tuple

class SWECategory(Enum):
    CATEGORY_A = "service_data_security"  # Backend, database, middleware, crypto
    CATEGORY_B = "user_facing_applications" # Web UI, CLI interaction, client presentations
    CATEGORY_C = "systems_tooling_runtimes" # Compilers, build systems, virtualization, OS kernel

@dataclass
class SWEInstance:
    instance_id: str
    repo_name: str
    problem_statement: str
    category: SWECategory
    baseline_success_rate: float = 0.0
    current_mastery: float = 0.0

@dataclass
class TrajectoryRollout:
    instance_id: str
    tokens: torch.Tensor
    behavior_logprobs: torch.Tensor
    is_terminal_success: bool
    executable_reward: float  # 1.0 jika lolos verifier, 0.0 jika gagal
    action_turns_mask: torch.Tensor

class AgenticMiniRL:
    """
    Algoritma RL untuk agen software engineering multi-turn berhorizon panjang.
    Menggunakan Leave-One-Out (RLOO) untuk centering reward tanpa bias finite-group.
    """
    def __init__(self, beta_k1: float = 0.02, clip_epsilon: float = 0.2):
        self.beta_k1 = beta_k1
        self.clip_epsilon = clip_epsilon

    def compute_rloo_advantages(self, returns: List[float]) -> List[float]:
        """
        Rumus RLOO: \bar{R}_i = R_i - (1 / (G - 1)) * \sum_{j != i} R_j
        Mencegah peredaman gradien pada kelompok sparse reward dengan finite sample G.
        """
        G = len(returns)
        if G <= 1:
            return [0.0] * G
        
        sum_all = sum(returns)
        advantages = []
        for r_i in returns:
            baseline_other = (sum_all - r_i) / (G - 1)
            advantages.append(r_i - baseline_other)
        return advantages

    def compute_token_loss(
        self,
        current_logprobs: torch.Tensor,
        old_logprobs: torch.Tensor,
        ref_logprobs: torch.Tensor,
        advantage: float,
        turn_mask: torch.Tensor
    ) -> torch.Tensor:
        """
        Menghitung MiniRL Token Update dengan regularisasi K1:
        K1 = exp(log_ref - log_curr) - (log_ref - log_curr) - 1
        """
        # Rasio probabilitas pi_theta / pi_theta_minus
        ratio = torch.exp(current_logprobs - old_logprobs)
        clipped_ratio = torch.clamp(ratio, 1.0 - self.clip_epsilon, 1.0 + self.clip_epsilon)
        
        # Policy gradient surrogate
        surr1 = ratio * advantage
        surr2 = clipped_ratio * advantage
        policy_loss = -torch.min(surr1, surr2)

        # Penalti drift K1 terhadap model referensi beku
        log_diff = ref_logprobs - current_logprobs
        k1_penalty = torch.exp(log_diff) - log_diff - 1.0

        total_loss = policy_loss + self.beta_k1 * k1_penalty
        
        # Reduksi loss per turn (turn-aware reduction)
        return (total_loss * turn_mask).sum() / (turn_mask.sum() + 1e-8)

class RefreshRepairExpandScheduler:
    """
    Mengontrol siklus evolusi kategori expert:
    - Refresh: Evaluasi ulang tingkat keberhasilan instans (mastery)
    - Repair: SFT pada trajektori sukses yang dihasilkan sendiri (self-grounded)
    - Expand: Menambahkan task pada ambang batas frontier eksplorasi
    """
    def __init__(self, target_category: SWECategory):
        self.category = target_category
        self.verified_success_buffer: List[TrajectoryRollout] = []

    def refresh_instance_mastery(self, instance: SWEInstance, rollout_results: List[bool]) -> None:
        instance.current_mastery = sum(rollout_results) / len(rollout_results)

    def select_repair_trajectories(self) -> List[TrajectoryRollout]:
        """Memilih trajektori sukses dari buffer internal tanpa bantuan LLM teacher luar."""
        return [t for t in self.verified_success_buffer if t.is_terminal_success]

    def expand_learning_frontier(
        self, candidate_pool: List[SWEInstance], sample_size: int = 100
    ) -> List[SWEInstance]:
        """
        Memilih task di frontier belajar:
        Task yang memiliki baseline 0.0 < mastery < 0.8 untuk eksplorasi gradien optimal.
        """
        frontier = [
            inst for inst in candidate_pool
            if inst.category == self.category and 0.0 <= inst.current_mastery < 0.8
        ]
        return frontier[:sample_size]

class LabelRoutedMOPD:
    """
    Label-Routed Multi-Teacher On-Policy Distillation:
    Mengonsolidasikan ketiga expert (A, B, C) ke dalam satu student policy.
    Dilengkapi ReLU-Gated Reward Extrapolation.
    """
    def __init__(self, extrapolation_lambda: float = 1.25):
        self.lambd = extrapolation_lambda

    def compute_routed_advantage(
        self,
        student_logprob: float,
        teacher_logprob: float,
        ref_logprob: float,
        is_routed_for_task: bool
    ) -> float:
        """
        Rumus A_t^MOPD = m_k(x) * [ -d_{t,k} + (lambda_k - 1) * max(e_{t,k}, 0) ]
        di mana d_{t,k} = student - teacher, e_{t,k} = teacher - ref.
        """
        if not is_routed_for_task:
            return 0.0

        d_tk = student_logprob - teacher_logprob
        e_tk = teacher_logprob - ref_logprob

        imitation_term = -d_tk
        extrapolation_term = (self.lambd - 1.0) * max(0.0, e_tk)

        return imitation_term + extrapolation_term

4. Menyatukan Tiga Pakar Menjadi Satu: MOPD & ReLU-Gated Reward Extrapolation

Memiliki tiga checkpoint terpisah (Expert A, Expert B, Expert C) tidak praktis untuk penerapan produksi di runtime IDE atau pipeline CI/CD otonom. Model akhir harus berupa satu model tunggal yang siap di-deploy (single deployable student).

Pendekatan penggabungan bobot konvensional (model merging seperti SLERP, DARE, atau Ties-Merging) terbukti gagal total pada tugas penalaran agen, karena merusak struktur penelusuran CoT. Alibaba merancang Label-Routed Multi-Teacher On-Policy Distillation (MOPD):

Di mana:

• m_k(x) adalah mask routing satu pintu: tugas Kategori A hanya dibimbing oleh Guru A, Kategori B oleh Guru B, dan Kategori C oleh Guru C.
• d_{t,k} = q_t - \log \pi_{T_k}(y_t \mid h_t) merepresentasikan celah imitasi (student-teacher imitation gap).
• e_{t,k} = \log \pi_{T_k}(y_t \mid h_t) - \log \pi_{\mathrm{ref}}(y_t \mid h_t) mengukur arah kemajuan guru dibanding model acuan awal.
• Mekanisme (\lambda_k - 1) \max(e_{t,k}, 0) mengaktifkan ReLU-Gated Reward Extrapolation: jika guru menugaskan probabilitas lebih tinggi daripada model referensi beku, student didorong untuk mengekstrapolasi penalaran lebih jauh dari sekadar imitasi pasif!

5. Hasil Evaluasi Benchmark: Pro-618 & SWE-bench Multilingual

Evaluasi dijalankan menggunakan model dasar Logics-SWE-Qwen3.6-27B pada benchmark audit terverifikasi Pro-618 (221 tugas Pro-A, 201 tugas Pro-B, 196 tugas Pro-C yang telah dibersihkan dari kecacatan environment container) dan SWE-bench Multilingual.

Temuan kuantitatif paling impresif meliputi:

• Peningkatan Merata Tanpa Trade-off: MOPD mengungguli Pooled RL sebesar +2.54 pp dan Balanced RL sebesar +2.70 pp secara total, dengan kenaikan positif di setiap kategori: +3.32 pp pada A, +2.65 pp pada B, dan +1.53 pp pada C dibanding Pooled RL.
• Pemulihan Keuntungan Pakar (Expert-Gain Recovery): Model tunggal hasil distilasi MOPD berhasil mempertahankan 80.8% keuntungan Expert A, 84.8% keuntungan Expert C, dan bahkan mencapai 111.1% pada Kategori B (efek super-teacher, di mana student melampaui gurunya berkat regularisasi transfer representasi umum).
• Generalisasi Multibahasa: Pada SWE-bench Multilingual (mencakup repositori Java, Go, C++, JavaScript), kebijakan MOPD melesat menjadi 59.00%, membuktikan bahwa spesialisasi kategori modular menumbuhkan intuisi rekayasa perangkat lunak yang universal lintas sintaksis bahasa.

6. Cetak Biru untuk AI Engineering & Platform Infrastructure

Bagi tim rekayasa AI otonom (seperti tim pengembang Hermes Agent, Claude Code, Cursor, atau sistem coding perusahaan), temuan riset ini menawarkan panduan aksi yang konkret: