DRACO 2026: Arsitektur Outcome-Blind Credit Assignment, Dynamic Per-Trajectory Rubrics, dan Closed-Form Step Advantage Reallocation pada Long-Horizon AI Agents

Dalam lanskap frontier Reinforcement Learning untuk autonomous tool-using agents, pendekatan RLVR (Reinforcement Learning from Verifiable Rewards) telah menjadi pilar utama di balik lompatan model penalaran matematika dan penulisan kode terisolasi. Namun, ketika model diterjunkan ke lingkungan dunia nyata—seperti riset komprehensif, orkestrasi perbankan multi-aplikasi, atau otomasi tugas enterprise yang berlangsung puluhan langkah—asumsi keberadaan sebuah program unit-test oracle otomatis runtuh. Sebagian besar ranah agen beroperasi dalam rezim outcome-blind, di mana sinyal kebenaran mutlak (ground-truth reward) mustahil diperoleh saat waktu pelatihan.

1. Dilema Alokasi Kredit & Kegagalan Uniform Advantage pada GRPO

Pada algoritma Group Relative Policy Optimization (GRPO; DeepSeek-AI, 2024), sebuah model kebijakan (policy model) menghasilkan sekelompok lintasan (rollout group) $\{y_1, y_2, \dots, y_G\}$ untuk sebuah instruksi tugas $x$. Setiap lintasan dievaluasi menghasilkan skalar reward tunggal $R(y_i)$, yang kemudian distandarisasi di tingkat grup menjadi skalar keuntungan (advantage):

Dalam implementasi GRPO standar, skalar $A(y_i)$ ini dikalikan secara seragam (uniform advantage) ke setiap token yang dipancarkan oleh lintasan tersebut:

Pemberian kredit seragam ini menyimpan kelemahan fatal pada agen long-horizon yang menempuh puluhan langkah interaksi alat (tool-calling steps):

• False Credit pada Trajektori Menang (Winners): Sebuah lintasan yang berhasil sering kali memuat langkah-langkah redundan, loop API yang tidak perlu, atau panggilan alat acak yang kebetulan berhasil karena keberuntungan. Dengan bobot seragam $A(y) > 0$, langkah-langkah buruk ini ikut diperkuat (reinforced).
• Unfair Blame pada Trajektori Kalah (Losers): Sebaliknya, pada lintasan yang gagal, agen mungkin mengeksekusi 18 langkah dekomposisi dan eksekusi SQL yang sempurna, namun gagal di langkah ke-19 karena kesalahan kecil pada parsing format tanggal. Dengan $A(y) < 0$, GRPO standar menekan seluruh 19 langkah secara identik, merusak penalaran valid yang telah dipelajari model.
• Saturasi Rubrik Statis: Jika menggunakan rubrik statis yang telah ditentukan sebelumnya, kriteria penilaian akan cepat mengalami saturasi (mencapai batas atas ~80% dalam 20 step pertama), sehingga gradien kehilangan daya beda (loss of variance).

2. Arsitektur Dynamic Per-Trajectory Rubrics & Discriminative Dropout

Untuk memecahkan masalah evaluasi kaku pada domain tanpa verifier, DRACO mengadopsi mekanisme sintesis rubrik dinamis tiga tahap yang digerakkan oleh model evaluator (frozen judge):

Inovasi krusial DRACO terletak pada Discriminative Dropout: sebuah kriteria hanya dipertahankan apabila terdapat minimal satu anggota rollout group yang gagal memenuhi kriteria tersebut. Kriteria yang dilalui dengan sempurna oleh semua rollout langsung dipangkas, memastikan bahwa fungsi reward hanya mengukur batas variansi aktif yang menantang kebijakan model saat ini.

Reward lintasan dihitung secara outcome-blind berdasarkan fraksi kelulusan kriteria yang berlaku (applicable):

3. Closed-Form Step Advantage Reallocation: Formulasi & Teorema Konservasi

Ketika judge mengevaluasi lintasan terhadap kriteria rubrik yang lolos discriminative dropout, judge wajib mencantumkan sitasi langkah (step citations)—yaitu nomor blok kode/langkah alat $t$ yang bertanggung jawab atas status pass atau fail kriteria tersebut.

DRACO tidak melatih modul neural baru untuk mendistribusikan advantage (yang rawan reward hacking dan overhead latensi), melainkan menerapkan aturan analitis tertutup (closed-form redistribution):

Langkah 1: Mengukur Kualitas Langkah ($q_t$)

Jika $p_t$ dan $f_t$ adalah jumlah kriteria lulus dan gagal yang menyitir langkah $t$, maka kualitas langkah didefinisikan sebagai:

Untuk langkah yang tidak disitir oleh kriteria manapun, langkah tersebut mewarisi nilai rata-rata kualitas $\bar{q}$ dari seluruh langkah yang disitir.

Langkah 2: Menghitung Bobot Pelestari Tanda ($w_t$)

Arah dorongan gradien keseluruhan lintasan ditentukan oleh tanda $A(y)$. Untuk memastikan langkah yang gagal pada trajektori menang tidak diperkuat, dan sebaliknya langkah yang bagus pada trajektori kalah tidak ditekan, DRACO merumuskan bobot:

Langkah 3: Menghitung Advantage Langkah ($A_t$) & Total-Push Conservation

Setiap token di dalam langkah $t$ menerima advantage teralokasi $A_t$ yang sama, dengan menormalisasi panjang token $n_t$ agar setiap langkah dinilai berdasarkan kualitas keputusannya, bukan jumlah kata atau panjang outputnya (length independence):

4. Hasil Evaluasi Empiris: AppWorld, Tau-Bench, dan Frontier Models

Eksperimen dilakukan dengan melatih adapter LoRA pada model dasar Qwen3.6-27B dan Qwen2.5-32B-Instruct menggunakan 8 GPU NVIDIA H100 pada dataset AppWorld (90 tugas pelatihan). Evaluasi dilakukan pada set uji AppWorld (test-normal dan test-challenge) serta transfer zero-shot ke Tau-Bench Banking:

Temuan penting dari data empiris di atas meliputi:

1. Mengalahkan Pelatihan Berbasis Verifier: DRACO meraih 85.3% TGC, unggul +5.3 poin dibandingkan model yang dilatih menggunakan reward ground-truth verifier langsung (80.0%). Hal ini membuktikan bahwa sinyal atribusi proses multi-kriteria memberikan gradien yang jauh lebih padat dan informatif daripada sinyal biner terminal (lulus/gagal).
2. Ledakan Scenario Goal Completion (SGC): Pada metrik SGC di mana semua tugas dalam satu skenario terintegrasi wajib selesai tanpa galat, DRACO melonjak dari 41.1% ke 70.6% (+29.5 poin).
3. Efisiensi Biaya Signifikan: Model Qwen3.6-27B yang dilatih dengan DRACO mendekati performa model frontier komersial (Claude Sonnet 4.6) dengan biaya evaluasi hanya $8.27 per pengujian penuh, dibandingkan $18.81 pada Claude Sonnet 4.6 dan $32.71 pada Claude Opus 4.7.
4. Viabilitas Self-Judge: Mengganti frontier judge (GPT-5.4) dengan model kebijakan itu sendiri (Qwen3.6-27B) menggunakan aturan konsensus k=3 unanimity voting tetap menghasilkan 81.1% TGC—menghilangkan ketergantungan pada API komersial eksternal selama loop pelatihan RL berlangsung.

5. Implementasi Referensi Kernel: DracoCreditEngine (TypeScript)

Berikut adalah implementasi referensi lengkap kernel DRACO dalam TypeScript yang mengkapsulasi alur Discriminative Dropout, Outcome-Blind Reward Calculation, dan Closed-Form Step Advantage Reallocation:

// DRACO: Distributing Rubric-based Advantage for Credit Optimization Kernel
// Spesifikasi Arsitektur Berdasarkan IBM Research (arXiv:2609.04094, September 2026)
// Menghitung Closed-Form Step Credit Reallocation dalam GRPO Tanpa Verifier Programmatic

export interface StepCitation {
  stepIndex: number;
  tokenCount: number;
}

export interface RubricCriterion {
  id: string;
  description: string;
  isPassed: boolean;
  isApplicable: boolean;
  citedSteps: number[]; // Indeks langkah yang bertanggung jawab atas vonis kriteria
}

export interface TrajectoryRollout {
  trajectoryId: string;
  totalTokens: number;
  steps: Array<{
    stepIndex: number;
    tokenCount: number;
    toolName: string;
    actionPayload: string;
  }>;
  rubrics: RubricCriterion[];
  rawReward?: number;
  trajectoryAdvantage?: number; // Advantage GRPO standar A(y)
}

export interface StepAdvantageResult {
  stepIndex: number;
  stepQuality: number; // q_t: rasio kelulusan kriteria yang menyitir langkah t
  signPreservingWeight: number; // w_t: bobot pelestari arah gradien
  stepAdvantage: number; // A_t: advantage terdiferensiasi per token pada langkah t
  tokenCount: number;
}

export class DracoCreditEngine {
  /**
   * 1. Discriminative Dropout: Menghapus kriteria yang dilalui (pass) oleh seluruh anggota rollout group.
   * Kriteria yang tidak memiliki variansi kegagalan tidak memberikan sinyal pembeda pada GRPO.
   */
  public applyDiscriminativeDropout(group: TrajectoryRollout[]): string[] {
    const failedCriteriaIds = new Set();

    for (const rollout of group) {
      for (const rubric of rollout.rubrics) {
        if (rubric.isApplicable && !rubric.isPassed) {
          failedCriteriaIds.add(rubric.id);
        }
      }
    }

    // Hanya kriteria yang gagal pada minimal 1 anggota kelompok yang dipertahankan
    return Array.from(failedCriteriaIds);
  }

  /**
   * 2. Menghitung Nilai Reward Outcome-Blind:
   * R(y) = P / (P + F) dinormalisasi terhadap kriteria yang applicable.
   */
  public calculateTrajectoryReward(rollout: TrajectoryRollout, activeCriteriaIds: Set): number {
    let passedCount = 0;
    let failedCount = 0;

    for (const rubric of rollout.rubrics) {
      if (!activeCriteriaIds.has(rubric.id) || !rubric.isApplicable) continue;
      if (rubric.isPassed) {
        passedCount++;
      } else {
        failedCount++;
      }
    }

    const totalDecisions = passedCount + failedCount;
    return totalDecisions === 0 ? 0.5 : passedCount / totalDecisions;
  }

  /**
   * 3. Closed-Form Step Advantage Reallocation:
   * Memetakan A(y) menjadi A_t per langkah dengan menjamin Total-Push Conservation:
   * sum_{t} (n_t * A_t) = N * A(y)
   */
  public reallocateStepAdvantage(
    rollout: TrajectoryRollout,
    trajectoryAdvantage: number,
    activeCriteriaIds: Set
  ): StepAdvantageResult[] {
    const numSteps = rollout.steps.length;
    const totalStepTokens = rollout.steps.reduce((acc, s) => acc + s.tokenCount, 0);

    // Hitung pass (p_t) dan fail (f_t) per langkah t
    const stepPassCount = new Map();
    const stepFailCount = new Map();

    for (const rubric of rollout.rubrics) {
      if (!activeCriteriaIds.has(rubric.id) || !rubric.isApplicable) continue;

      for (const stepIdx of rubric.citedSteps) {
        if (rubric.isPassed) {
          stepPassCount.set(stepIdx, (stepPassCount.get(stepIdx) || 0) + 1);
        } else {
          stepFailCount.set(stepIdx, (stepFailCount.get(stepIdx) || 0) + 1);
        }
      }
    }

    // Hitung step quality q_t
    const stepQualities: number[] = [];
    let sumCitedQualities = 0;
    let citedStepsCount = 0;

    for (let t = 0; t < numSteps; t++) {
      const p = stepPassCount.get(t) || 0;
      const f = stepFailCount.get(t) || 0;
      if (p + f > 0) {
        const q = p / (p + f);
        stepQualities.push(q);
        sumCitedQualities += q;
        citedStepsCount++;
      } else {
        stepQualities.push(-1); // Penanda langkah yang tidak disitir
      }
    }

    // Default q_bar untuk langkah yang tidak disitir oleh kriteria manapun
    const qBar = citedStepsCount > 0 ? sumCitedQualities / citedStepsCount : 0.5;

    // Hitung bobot pelestari tanda (sign-preserving weights w_t)
    const isWinner = trajectoryAdvantage >= 0;
    const stepWeights: number[] = [];

    for (let t = 0; t < numSteps; t++) {
      const q = stepQualities[t] === -1 ? qBar : stepQualities[t];
      // Jika winner trajectory (A >= 0): w_t = 2 * q_t
      // Jika loser trajectory (A < 0):  w_t = 2 * (1 - q_t)
      const w = isWinner ? 2 * q : 2 * (1 - q);
      stepWeights.push(w);
    }

    // Hitung denominator tertimbang token: sum_j (n_j * w_j)
    let weightedTokenSum = 0;
    for (let j = 0; j < numSteps; j++) {
      weightedTokenSum += rollout.steps[j].tokenCount * stepWeights[j];
    }

    // Jika seluruh bobot 0 atau tidak ada sitasi, fallback ke GRPO standar (A_t = A(y))
    const results: StepAdvantageResult[] = [];
    for (let t = 0; t < numSteps; t++) {
      const n_t = rollout.steps[t].tokenCount;
      const w_t = stepWeights[t];
      const q_t = stepQualities[t] === -1 ? qBar : stepQualities[t];

      let a_t = trajectoryAdvantage;
      if (weightedTokenSum > 0) {
        // Rumus DRACO Eq. (6): A_t = (N * w_t / sum_j(n_j * w_j)) * A(y)
        a_t = (totalStepTokens * w_t / weightedTokenSum) * trajectoryAdvantage;
      }

      results.push({
        stepIndex: t,
        stepQuality: Number(q_t.toFixed(4)),
        signPreservingWeight: Number(w_t.toFixed(4)),
        stepAdvantage: Number(a_t.toFixed(6)),
        tokenCount: n_t,
      });
    }

    return results;
  }
}

6. Panduan Implementasi untuk Tim Rekayasa AI Enterprise

Bagi arsitek sistem dan praktisi AI yang membangun agen otonom di ranah produksi yang tidak memiliki unit-test verifier, arsitektur DRACO memberikan 4 prinsip esensial: