RECAST (arXiv:2610.10507): Arsitektur Adaptive Evidence Routing & Synthesis, Memecahkan Keterbatasan RAG via Sequential Decision Operations, SFT + GRPO, dan Peningkatan Akurasi +15.9%

1. Mengapa RAG Konvensional Gagal: Paradigma "Retrieved" vs "Computed" Evidence

Selama lebih dari setengah dekade, adopsi LLM pada sistem berbasis pengetahuan eksternal didominasi oleh formula standar RAG: dokumen dipecah menjadi chunks, dihitung vektor embedding-nya menggunakan model bi-encoder, dan diambil $k$-top fragmen paling mirip berdasarkan cosine similarity terhadap kueri pengguna.

Namun, di lingkungan enterprise yang kompleks—seperti analisis audit keuangan, integrasi multi-database, dan investigasi root-cause microservices—informasi yang dibutuhkan untuk menjawab pertanyaan krusial hampir tidak pernah tersaji secara harfiah dalam satu chunk dokumen. Pertimbangkan kasus berikut:

Model pencarian similarity hanya akan mengambil baris-baris dokumen yang mengandung frasa "belanja cloud", "kuartal 3", atau "kredit promo". Jawaban matematisnya tidak ada di dalam dokumen mentah tersebut. Jika LLM diumpankan puluhan potongan teks mentah ini secara sembarangan, model akan mengalami context clutter, halusinasi komputasi aritmatika, dan risiko kelalaian data kritis (Lost in the Middle phenomenon).

Bahkan varian modern seperti Agentic RAG yang dilengkapi fungsi tool-calling konvensional sering kali terjebak dalam loop pencarian dangkal tanpa arah. RECAST merumuskan ulang masalah ini: Konteks yang tepat bukanlah sesuatu yang dicari secara pasif, melainkan sesuatu yang dihitung secara aktif (Computed Context).

2. Arsitektur Tripartit RECAST: RouterLM, CompilerLM, dan AnswerLM

Framework RECAST memisahkan alur kerja pembuatan bukti menjadi tiga subsistem spesialis yang saling mengisolasi tanggung jawab (Separation of Concerns):

3. Formulasi Matematika & Training Pipeline: SFT + GRPO

Inti kecerdasan RECAST terletak pada bagaimana RouterLM dilatih untuk memandu eksplorasi pencarian dan komputasi tanpa memerlukan anotasi manusia berbiaya mahal. Proses training disusun dalam dua fase berurutan:

Fase A: Supervised Fine-Tuning (SFT) Initialization

RouterLM pertama kali di-bootstrapping dengan pasangan trajektori sintetik berkualitas tinggi yang memetakan kueri multi-sumber ke urutan aksi dekomposisi primitif. Tujuannya adalah menanamkan pemahaman semantik tentang tata bahasa pemanggilan operasi dan format keluaran JSON/XML terstruktur.

Fase B: Group Relative Policy Optimization (GRPO)

Setelah fase SFT, RouterLM disempurnakan menggunakan algoritma RL berbasis reward verifikasi hasil (RLVR) dengan varian GRPO (Group Relative Policy Optimization). Untuk setiap pertanyaan kueri $x$, model kebijakan saat ini $\pi_\theta$ menghasilkan kelompok trajektori keputusan sebanyak $G$ sampel $\{y_1, y_2, \dots, y_G\}$. Fungsi objektif dihitung secara relatif terhadap rerata grup:

Di mana estimasi keunggulan relatif $\hat{A}_i$ dihitung sebagai:

Komponen reward $R(y_i)$ dirancang sangat ketat dan berprinsip objektif:

• Reward Kebenaran Faktual ($R_{\text{acc}} \in \{0, 1\}$): Dinilai berdasarkan apakah AnswerLM menghasilkan jawaban yang persis cocok dengan ground truth ketika disuapkan bukti hasil trajektori $y_i$.
• Penalti Panjang Trajektori ($R_{\text{len}}$): Penalti linier kecil terhadap jumlah langkah router guna mendorong jalur routing yang paling efisien dan langsung.
• Format Verifiability ($R_{\text{fmt}}$): Penalti keras jika router menghasilkan sintaks atau nama variabel yang gagal dikompilasi oleh CompilerLM.

4. Tolok Ukur Kinerja & Analisis Benchmark Empiris

Peneliti mengevaluasi RECAST lintas 6 keluarga benchmark heterogen berskala besar yang mencakup penalaran tabel relasional, multi-hop question answering, analisis laporan keuangan, serta ekstraksi API.

Tiga temuan kunci dari data benchmark di atas:

1. Model 9B yang Dilatih Khusus Mengalahkan Model Frontier Raksasa: RouterLM berbasis Qwen3.5-9B yang di-tuning via GRPO melampaui Gemini 3.5 Flash RouterLM sebesar +5.0 poin, membuktikan bahwa spesialisasi kebijakan routing lebih krusial daripada sekadar kapasitas ukuran parameter umum.
2. Efisiensi Token Ekstrem (-82% Token Usage): Alih-alih menyuapkan ratusan kilobyte teks mentah ke AnswerLM, RECAST merangkum seluruh kalkulasi di level sandbox kode. AnswerLM hanya membaca rata-rata 3.250 token yang telah terbukti benar secara deterministik.
3. Ketahanan Terhadap Held-Out Benchmarks: Pada tiga benchmark yang belum pernah dilihat sama sekali selama fase pelatihan, RECAST mempertahankan margin keunggulan +15.0% atas baseline terkuat.

5. Implementasi Produksi: TypeScript Engine untuk RouterLM & CompilerLM

Berikut arsitektur implementasi sistem RECAST di lingkungan enterprise modern yang siap diintegrasikan dengan orkestrasi microservices dan sandboxed runtimes:

// Production Implementation: RECAST (Routing Evidence through Computation, Access, and Synthesized Tools)
// Mengimplementasikan Tripartit Sequential Evidence Construction (RouterLM -> CompilerLM -> AnswerLM) sesuai arXiv:2610.10507

export type EvidenceOpType = 'RETRIEVE_RAW' | 'FILTER_AGGREGATE' | 'CROSS_SOURCE_JOIN' | 'CODE_SYNTHESIZE' | 'ACCEPT_AND_TERMINATE';

export interface EvidenceItem {
  sourceId: string;
  sourceType: 'unstructured_text' | 'tabular_sql' | 'json_api' | 'code_ast';
  payload: unknown;
  confidenceScore: number;
}

export interface RouterDecision {
  step: number;
  operation: EvidenceOpType;
  queryOrCodeSpec: string;
  targetSources: string[];
  rationale: string;
  isTerminal: boolean;
}

export interface ExecutedEvidenceState {
  originalQuery: string;
  accumulatedEvidence: Map;
  routingTrace: RouterDecision[];
  totalTokensUsed: number;
  isComplete: boolean;
}

export interface RecastConfig {
  maxRoutingSteps: number;
  tokenBudgetLimit: number;
  minConfidenceThreshold: number;
}

export class RecastEvidenceRouterEngine {
  private config: RecastConfig;

  constructor(config?: Partial) {
    this.config = {
      maxRoutingSteps: config?.maxRoutingSteps ?? 6,
      tokenBudgetLimit: config?.tokenBudgetLimit ?? 8192,
      minConfidenceThreshold: config?.minConfidenceThreshold ?? 0.88,
    };
  }

  /**
   * RouterLM Loop: Memandu konstruksi bukti melalui keputusan sekuensial adaptif
   */
  public async executeEvidenceRoutingPipeline(
    userQuery: string,
    corpusCatalogs: string[],
    routerLMPredictor: (state: ExecutedEvidenceState) => Promise,
    compilerExecutor: (spec: string, context: Map) => Promise<{ data: unknown; tokenCost: number }>,
    answerLMPredictor: (query: string, evidencePayload: Record) => Promise
  ): Promise<{ finalAnswer: string; trace: RouterDecision[]; totalTokens: number; derivedEvidenceCount: number }> {
    const state: ExecutedEvidenceState = {
      originalQuery: userQuery,
      accumulatedEvidence: new Map(),
      routingTrace: [],
      totalTokensUsed: 0,
      isComplete: false,
    };

    let stepCount = 0;

    while (!state.isComplete && stepCount < this.config.maxRoutingSteps) {
      stepCount++;

      // 1. RouterLM memutuskan operasi berikutnya berdasarkan akumulasi bukti saat ini
      const decision = await routerLMPredictor(state);
      state.routingTrace.push(decision);

      if (decision.operation === 'ACCEPT_AND_TERMINATE' || decision.isTerminal) {
        state.isComplete = true;
        break;
      }

      // 2. CompilerLM menerjemahkan spesifikasi komputasi/retrieval menjadi eksekusi kode deterministik
      const executionResult = await compilerExecutor(decision.queryOrCodeSpec, state.accumulatedEvidence);
      
      const evidenceKey = `evidence_step_${stepCount}_${decision.operation.toLowerCase()}`;
      state.accumulatedEvidence.set(evidenceKey, executionResult.data);
      state.totalTokensUsed += executionResult.tokenCost;

      // 3. Early safety check terhadap budget limit
      if (state.totalTokensUsed > this.config.tokenBudgetLimit) {
        console.warn('[RECAST] Token budget limit exceeded. Forcing convergence to AnswerLM.');
        state.isComplete = true;
        break;
      }
    }

    // 4. Transformasi bukti yang telah diagregasi dan disintesis ke format AnswerLM
    const structuredEvidencePayload: Record = {};
    for (const [key, val] of state.accumulatedEvidence.entries()) {
      structuredEvidencePayload[key] = val;
    }

    // 5. AnswerLM menghasilkan jawaban final hanya dari bukti bersih terderivasi (Zero Context Bloat)
    const finalAnswer = await answerLMPredictor(state.originalQuery, structuredEvidencePayload);

    return {
      finalAnswer,
      trace: state.routingTrace,
      totalTokens: state.totalTokensUsed,
      derivedEvidenceCount: state.accumulatedEvidence.size,
    };
  }
}

6. Analisis Failure Modes & Playbook Mitigasi Produksi

Berdasarkan pengujian ekstensif, transisi dari RAG konvensional ke arsitektur RECAST menghadapi sejumlah potensi failure modes yang wajib dimitigasi oleh tim platform engineering:

7. Kesimpulan & Roadmap Arsitektur AI Enterprise 2026

Makalah RECAST (arXiv:2610.10507) menegaskan pergeseran paradigma fundamental dalam rekayasa konteks LLM: "Retrieval alone is obsolete for reasoning tasks." Era di mana kita hanya mengandalkan kemiripan vektor semata untuk menjawab pertanyaan bisnis kritis telah berakhir.

Dengan menggabungkan kebijakan routing terarah (SFT + GRPO), isolasi komputasi kode deterministik (CompilerLM), dan sintesis inferensi bersih (AnswerLM), arsitektur RECAST membuktikan bahwa model bahasa berbobot sedang (9B) dapat melampaui raksasa closed-source sembari memangkas lebih dari 80% biaya komputasi token. Bagi arsitek AI enterprise, RECAST menjadi blueprint esensial dalam membangun sistem pencarian generasi berikutnya yang tangguh, deterministik, dan bebas halusinasi.