T1 2026: Arsitektur Terminal Agent Reinforcement Learning, Token-In-Token-Out (TITO), Rollout Routing Replay (R3), dan Dense Verification Reward untuk Long-Horizon Tasks

Dalam evolusi kecerdasan buatan terapan, pergeseran dari sekadar single-turn conversational assistant menuju Autonomous Long-Horizon Agent menandai garis demarkasi paling radikal dekade ini. Model tidak lagi cukup hanya menghasilkan kode yang lolos uji mata manusia; mereka dituntut untuk mengoperasikan shell sistem operasi secara persisten, mengeksekusi puluhan hingga ratusan perintah terminal berturut-turut, menavigasi kegagalan runtime, dan membuktikan keabsahan solusinya melalui verifikasi deterministik lingkungan nyata.

1. Krisis Sinkronisasi Sparse MoE: Runtuhnya Asumsi Klasik On-Policy RL

Reinforcement Learning pada model arsitektur Mixture-of-Experts skala raksasa menghadapi tantangan numerik yang jauh lebih kejam dibanding model padat (dense models). Pada model T1 (berbasis Qwen3.5-122B-A10B), bobot expert menyumbang 116.0 miliar dari total 121.4 miliar parameter. Pada setiap layer, 8 expert dipilih dari total 256 candidate experts via router diskret:

Ketika agent mengeksekusi tugas panjang dalam sandbox terminal (misalnya melakukan bisection pada ratusan commit git, merekonstruksi bug C++, memodifikasi Makefile, dan mengompilasi ulang), terjadi akumulasi diskrepansi yang merusak stabilitas training. Riset Yang et al. membongkar dua anomali sistemik yang selama ini membuat RL pada coding agent gagal konvergen:

2. Solusi Dual-Axis T1: Token-In-Token-Out (TITO) & Rollout Routing Replay (R3)

Tim peneliti T1 menyelesaikan kedua masalah tersebut melalui pemisahan ortogonal: TITO mengunci sumbu representasi token, sedangkan R3 mengunci sumbu pemilihan expert.

A. Token-In-Token-Out (TITO): Bit-Exact Stream Preservation

Alih-alih mentransfer string teks mentah antar giliran (turns), harness Terminus-2 dan trainer T1 secara ketat berkomunikasi menggunakan token identifiers biner murni. Template percakapan dikonfigurasi append-only sehingga tidak ada token penalaran historis yang di-prune atau diubah formatnya.

Sebuah trajektori disusun menjadi satu rangkaian token terpadu dengan loss mask biner $mathcal{M}$:

Dengan auditor boundary case yang ketat, pengukuran produksi pada 1.402 sampel multi-turn membuktikan bahwa drift rate di dalam zona loss bernilai tepat 0.000%:

B. Rollout Routing Replay (R3): Replaying Expert Selections

Pada arsitektur MoE standar, layer training menghitung pemilihan Top-K dari logit live-nya sendiri. Di bawah R3, pemilihan Top-K digantikan oleh lookup topologi biner dari riwayat rollout ($M^{rec}$), sementara normalisasi probabilitas tetap dilakukan di atas logit live:

Mekanisme ini menghadirkan dua keuntungan arsitektur yang fundamental:

• Eliminasi Disparitas Routing: Expert yang menerima gradien backpropagation identik 100% dengan expert yang mengeksekusi token pada sandbox Daytona.
• Preservasi Gradien Router: Karena fungsi softmax tetap beroperasi pada logit live $h(x)$, parameter router $mathcal{W}_{router}$ tetap dapat dioptimalkan tanpa memutus graph komputasi autograd.

3. Dense Process Verification Reward: Melampaui Sparse Binary Feedback

Dalam reinforcement learning untuk coding agent, pendekatan naif memberikan reward biner: +1 jika seluruh tugas selesai sempurna, dan 0 jika gagal. Namun, satu batch rollout pada 512 sandbox Linux menghabiskan ratusan jam CPU/GPU sandbox. Membayar komputasi sebesar itu hanya untuk memperoleh 1-bit informasi per trajektori terbukti menjadi penyebab utama kegagalan eksperimen awal T1 (di mana model tidak pernah melampaui performa SFT dasarnya).

T1 merevolusi formula reward dengan memanfaatkan Dense Process Reward yang diekstrak langsung dari unit assertion verifier yang held-out. Setiap tugas memiliki suite pengujian internal yang memverifikasi sub-kondisi (misal: apakah file konfigurasi dibuat, apakah dependensi terkompilasi, apakah port listening, apakah test suite lolos):

Di mana $M$ adalah konstanta skala global tetap (bukan dinormalisasi per-batch). Keputusan arsitektur ini krusial: normalisasi per-batch akan membuat satu trajektori ekstrem mengubah pembagi bagi seluruh batch, mendistorsi ekspektasi value function. Dengan skala global $M$, setiap tugas yang lebih sulit secara inheren memberikan sinyal reward absolut yang lebih kaya kepada jaringan Critic.

Arsitektur Critic Terjadwal & Critic Warm-Up

Jaringan Critic pada T1 adalah duplikat penuh 122B MoE (di mana language modeling head diganti dengan scalar value head). Untuk menghemat alokasi hardware, Actor dan Critic berbagi GPU yang sama secara bergantian (time-multiplexed) dengan memory footprint masing-masing dibatasi ketat di 95 GiB.

• Critic Warm-Up Satu Epoch: Critic dilatih terlebih dahulu selama 1 epoch penuh pada dataset TMax-15k sebelum Actor mengambil langkah pembaruan pertama. Ini melesatkan Explained Variance ($R^2_{EV}$) dari defisit negatif ($-0.40$) langsung ke kisaran +0.80 s.d. +0.85, mengeliminasi bias estimasi Generalized Advantage Estimation (GAE).
• Pembaruan Asimetris (Critic First): Pada setiap step PPO, Critic diperbarui terlebih dahulu dan menyerahkan nilai estimasi pre-update kepada Actor. Learning rate Critic dipatok pada $5 imes 10^{-6}$ (5x lebih agresif dibanding Actor pada $1 imes 10^{-6}$) karena tugas Critic adalah regresi nilai terawasi, bukan pembaruan kebijakan probabilistik.

4. Analisis Hasil Empiris: Terminal-Bench 2.1, LHTB & Keunggulan Domain

Evaluasi komparatif dilakukan secara strictly held-out: seluruh tugas evaluasi terisolasi dan tidak memiliki irisan dengan korpus pelatihan sintesis RST-38k maupun T1-15k. Pengujian dijalankan di dalam container Daytona cloud berkapasitas disk 10 GiB dengan limit 60 tool-call turns dan timeout eksekusi 3.600 detik.

Dekomposisi Sumber Peningkatan Kinerja

Dari total lompatan +20.2 poin persentase dari base model (43.8% $ o$ 64.0%), tahap Supervised Fine-Tuning (SFT) hanya menyumbang 5.6 poin persentase. Selebihnya, 14.6 poin persentase (72.3% dari total keuntungan) disumbangkan murni oleh Reinforcement Learning.

Pada pengujian domain spesifik:

• Software Debugging: T1 mencapai 100.0% sukses (mengungguli GPT-5.6 Sol di 80.0%). Kemampuan memeriksa stack trace, mengisolasi file penyebab, dan memverifikasi patch secara berulang menjadi sifat alami berkat dense assertion feedback.
• System Administration: T1 mencatat 88.9% dibanding 55.6% untuk baseline komersial—membuktikan keandalan navigasi filesystem, konfigurasi systemd, dan manajemen izin Unix.

5. Implementasi Arsitektur: Assembler TITO & R3 Router Cache

Berikut adalah spesifikasi referensi TypeScript tingkat produksi yang mendemonstrasikan bagaimana harness agentik modern menyelaraskan aliran token, mengunci routing mask MoE, dan mengalkulasi dense process rewards:

// T1 Reinforcement Learning Synchronization Engine (TypeScript Reference Architecture)
// Mengimplementasikan Token-In-Token-Out (TITO), Rollout Routing Replay (R3), dan Dense Verifier Assertions
// Sesuai Spesifikasi Arsitektur arXiv:2609.11042 (Yang et al., September 2026)

export interface MoERoutingChoice {
  layerIndex: number;
  tokenPosition: number;
  selectedExperts: number[]; // e.g. 8 experts out of 256
  routerWeights: number[];
}

export interface RolloutTurn {
  turnIndex: number;
  promptTokenIds: number[];
  generatedTokenIds: number[];
  toolObservationTokenIds: number[];
  routingRecord: MoERoutingChoice[];
}

export interface TaskVerificationAssertion {
  id: string;
  command: string;
  passed: boolean;
  exitCode: number;
  executionMs: number;
}

export interface TrajectoryVerificationReport {
  taskId: string;
  totalAssertions: number;
  passedAssertions: number;
  assertions: TaskVerificationAssertion[];
  denseReward: number; // passedAssertions / globalScale M
}

/**
 * 1. Token-In-Token-Out (TITO) Alignment Assembler
 * Memperbaiki turn boundary drift secara bit-exact dan menerapkan loss masking.
 */
export class TitoAssembler {
  /**
   * Menggabungkan multi-turn token trajectory tanpa memicu de-tokenization / re-encoding drift.
   * Tool output diberi mask 0 (no gradient), sedangkan generated tokens diberi mask 1 (loss-bearing).
   */
  public static assembleTrajectory(turns: RolloutTurn[]): {
    flatTokenIds: number[];
    lossMask: number[];
    routingLookup: Map;
  } {
    const flatTokenIds: number[] = [];
    const lossMask: number[] = [];
    const routingLookup = new Map();

    for (let t = 0; t < turns.length; t++) {
      const turn = turns[t];

      // 1. Injeksi Prompt / Initial Context (Mask = 0)
      if (t === 0) {
        for (const tid of turn.promptTokenIds) {
          flatTokenIds.push(tid);
          lossMask.push(0);
        }
      }

      // 2. Injeksi Generated Action Tokens (Mask = 1, Loss Bearing)
      const actionStartPos = flatTokenIds.length;
      for (let i = 0; i < turn.generatedTokenIds.length; i++) {
        const tid = turn.generatedTokenIds[i];
        const currentPos = flatTokenIds.length;
        flatTokenIds.push(tid);
        lossMask.push(1);

        // Petakan routing MoE persis pada posisi token ini
        const tokenRoutings = turn.routingRecord.filter((r) => r.tokenPosition === i);
        routingLookup.set(currentPos, tokenRoutings);
      }

      // 3. Injeksi Tool Observation / Terminal Output (Mask = 0)
      // Turn boundary repair: pastikan stream token observasi tidak merusak prefix token berikutnya
      for (const tid of turn.toolObservationTokenIds) {
        flatTokenIds.push(tid);
        lossMask.push(0);
      }
    }

    return { flatTokenIds, lossMask, routingLookup };
  }
}

/**
 * 2. Rollout Routing Replay (R3) Validator
 * Mengisolasi router gradient path sembari mencegah training-inference mismatch.
 */
export class RolloutRoutingReplayManager {
  private routingBuffer = new Map();

  public recordStepRouting(trajectoryId: string, choices: MoERoutingChoice[]): void {
    const existing = this.routingBuffer.get(trajectoryId) || [];
    this.routingBuffer.set(trajectoryId, [...existing, ...choices]);
  }

  /**
   * Menghitung normalized expert probabilities dengan replaying recorded routing mask
   * Softmax dihitung ulang di atas live logits tetapi hanya pada himpunan selectedExperts yang tercatat.
   */
  public computeReplayedRouterWeights(
    liveLogits: Float32Array,
    recordedExperts: number[]
  ): { activeIndices: number[]; normalizedWeights: number[] } {
    let maxLogit = -Infinity;
    for (const expIdx of recordedExperts) {
      if (liveLogits[expIdx] > maxLogit) maxLogit = liveLogits[expIdx];
    }

    let sumExp = 0.0;
    const expVals: number[] = [];
    for (const expIdx of recordedExperts) {
      const v = Math.exp(liveLogits[expIdx] - maxLogit);
      expVals.push(v);
      sumExp += v;
    }

    const normalizedWeights = expVals.map((v) => v / (sumExp || 1.0));
    return { activeIndices: recordedExperts, normalizedWeights };
  }
}

/**
 * 3. Dense Process Verifier Reward Calculator
 * Mengonversi assertion individual menjadi continuous scalar reward pada skala global konstan.
 */
export class DenseProcessRewardEvaluator {
  constructor(private globalScaleM: number = 10.0) {}

  public evaluateTrajectoryReward(report: TrajectoryVerificationReport): number {
    if (report.totalAssertions === 0) return 0.0;

    // Reward dihitung dari jumlah absolut assertion yang lulus, bukan persentase
    // Ini memastikan task yang lebih kompleks memberikan sinyal gradien yang proporsional
    const rawReward = report.passedAssertions / this.globalScaleM;

    // Bounded reward range [0.0, 1.5] untuk stabilitas Actor-Critic
    return Math.min(Math.max(rawReward, 0.0), 1.5);
  }
}

6. Implikasi Industri & Rekomendasi NEWSAINT

Keberhasilan T1 membuktikan bahwa model open-weight dengan arsitektur sparse MoE dapat melampaui raksasa komersial tertutup pada eksekusi terminal otonom jika dan hanya jika harness pelatihan menghormati hukum integritas sistem. Tiga panduan esensial bagi para arsitek AI agent:

1. Tinggalkan Token Re-encoding pada Multi-Turn RL: Jangan pernah mengubah token array menjadi teks string lalu meng-encode ulang saat transisi turn. Selalu operasikan representasi ID biner asli (TITO) agar posisi token pembawa loss tidak tergeser akibat variasi whitespace atau template delimiter.
2. Rekam dan Putar Ulang Router Mask (R3) untuk Model MoE: Pada arsitektur dengan sparse routing (seperti Qwen3.5, Mixtral, atau DeepSeek), pastikan inference sampler merekam indeks expert yang terpilih pada setiap token. Gunakan rekaman tersebut sebagai constraint mask pada pass latihan untuk mencegah hilangnya sinyal gradien pada expert yang salah.
3. Ubah Tes Unit Menjadi Sinyal Dense Reward: Evaluasi biner (pass/fail) membuang 99% sinyal komputasi lingkungan. Rancang verifier yang mengekspos jumlah assertion yang berhasil secara granular pada skala pembagi global yang konstan ($M$), dan latih jaringan Critic terlebih dahulu (Warm-Up) sebelum memperbarui bobot kebijakan agent.