Bellman Language Models (arXiv:2610.24871): Discretize-Then-Decide, Eliminasi Redundant LLM Invocations hingga 98%, dan Optimal Control pada Agentic Workflows

Dalam setiap siklus turn pada autonomous agentic workflow, sebuah realitas yang mencolok namun jarang dipertanyakan adalah bagaimana model fondasi berskala besar dipanggil berulang kali untuk menyelesaikan keputusan yang sebenarnya bersifat repetitif dan mendekati saturasi. Agen AI di lingkungan produksi—mulai dari sistem reservasi, customer support, hingga pipeline DevOps—terus-menerus membuang ribuan token dan puluhan detik latensi hanya untuk mendeduksi ulang pemanggilan tool standar yang strukturnya sudah pernah dilalui jutaan kali.

1. Paradoks Agen Otonom: Saturasi Ruang Keputusan vs Inefisiensi Autoregresif

Hampir seluruh arsitektur agen modern berbasis Large Language Model (LLM)—baik yang menggunakan prompt monolitik, framework ReAct, maupun tree-search—mengandalkan mekanisme in-context derivation pada setiap langkah eksekusi. Ketika pengguna meminta agen untuk memeriksa saldo akun atau mereset kuota data seluler, model membaca ulang seluruh riwayat percakapan dari awal konteks, mengaktifkan miliaran parameter neural, dan menghasilkan token JSON pemanggilan tool dengan probabilitas heuristik.

Namun, observasi empiris paper arXiv:2610.24871 membuktikan bahwa pada lingkungan agen terikat (bounded workflows), ruang keputusan (decision space) agen sangat cepat mencapai titik jenuh (saturation). Setelah menjalankan beberapa puluh atau ratus sesi interaksi, agen praktis tidak lagi menemui state baru yang esensial. Setiap state transisi yang ditemui hanyalah kombinasi diskret dari intent pengguna, slot entitas yang terisi, dan status hasil tool sebelumnya.

Memperlakukan setiap langkah transisi tersebut sebagai masalah inferensi teks bebas bukan hanya memboroskan komputasi (flops) dan biaya token hingga ribuan dolar per hari, tetapi juga memperkenalkan non-determinism yang berbahaya: halusinasi format JSON, argumen parameter yang meleset, dan risiko kegagalan langkah yang mestinya deterministik.

2. Paradigma "Discretize, Then Decide": Rekonstruksi Trajektori Agen Menjadi MDP

Solusi yang diajukan oleh Vatsa & Eiers bertumpu pada dekomposisi mendasar: memisahkan Keputusan Kebijakan (Policy Decision) dari Sintesis Konten Teks Bebas (Content Generation) melalui proses Discretize, Then Decide:

• State Discretization: Mengubah observasi teks panjang, riwayat chat, dan keluaran tool menjadi representasi status kanonikal diskret $s \in \mathcal{S}$. Token teks yang bervariasi secara leksikal (misalnya nama pelanggan atau nomor telepon) dipetakan ke dalam abstraksi slot kanonikal, sehingga percakapan yang berbeda substansi leksikalnya namun identik secara struktural akan dipetakan ke status MDP yang sama.
• Empirical Transition & Cost Estimation: Dari kumpulan log eksekusi historis atau hasil simulasi awal (rollout), sistem mengestimasi probabilitas transisi empiris $\hat{P}(s' \mid s, a)$ dan estimasi biaya per aksi $\hat{C}(s, a)$ (kombinasi latensi waktu, biaya API, dan token cost). Pengumpulan data ini dilakukan sampai tidak ada state baru yang muncul dan distribusi probabilitas konvergen.
• Dynamic Programming Optimization (Bellman Equation): Begitu MDP diskret terbentuk, sistem menyelesaikan kebijakan optimal $\pi^*(s)$ sekali saja di awal menggunakan pemrograman dinamis klasik (Value Iteration atau Policy Iteration).
• Runtime Controller Envelope: Di fase produksi, kebijakan yang telah dioptimasi berjalan sebagai controller di sekitar LLM. Jika state saat ini $s$ telah terpecahkan (solved) dan memiliki aksi pasti (seperti pemanggilan tool atau template jawaban), controller mengeksekusinya seketika tanpa menyentuh model LLM. Hanya ketika sistem menemui state asing yang belum pernah diobservasi ($s \notin \mathcal{S}_{solved}$) atau membutuhkan penalaran teks terbuka yang fleksibel, kontrol dikembalikan (fall back) ke LLM fondasi.

3. Formulasi Matematis Bellman Optimality pada LLM Agent Controller

Model matematika di balik Bellman Language Models mengadopsi formulasi klasik Richard Bellman untuk Infinite-Horizon Discounted Markov Decision Processes:

Di mana:

• $s \in \mathcal{S}$ adalah state agen diskret (abstraksi intent, status slot entitas, dan sinyal tool).
• $a \in \mathcal{A}(s)$ adalah aksi kandidat (eksekusi tool tertentu dengan parameter slot, respon template terverifikasi, atau eskalasi ke LLM).
• $C(s, a)$ merepresentasikan biaya total: bobot gabungan antara latensi eksekusi (detik), biaya komputasi/token ($), dan penalti kesalahan aksi.
• $\gamma \in (0, 1)$ adalah faktor diskon yang memastikan konvergensi nilai masa depan (pada evaluasi paper digunakan $\gamma = 0.95$).

Dengan algoritma Value Iteration, nilai $V(s)$ diperbarui secara rekursif hingga $\max_s |V_{k+1}(s) - V_k(s)| < \epsilon$. Karena ruang state diskret pada agen terikat berkisar antara puluhan hingga beberapa ratus state, proses penyelesaian ini membutuhkan waktu kurang dari 120 milidetik pada prosesor standar dan menghasilkan garansi teoretis bahwa kebijakan yang dipilih adalah kebijakan dengan biaya terendah yang meminimalkan langkah kegagalan.

4. Evaluasi Empiris Komprehensif: $\tau^2$-Bench Telecom & InventoryBench

Peneliti menguji efektivitas BLM pada dua domain benchmark agentic yang sangat menuntut: $\tau^2$-bench Telecom (interaksi kompleks multi-turn customer support telekomunikasi dengan ratusan tools) dan InventoryBench (manajemen rantai pasok dinamis). Hasil pengujian empiris menghasilkan angka yang luar biasa:

Fakta bahwa controller diskret murni tanpa model LLM sama sekali (no model controller) mampu menyelesaikan 79% dari seluruh skenario $ au^2$-bench telecom membuktikan betapa redundannya memanggil model penalaran raksasa untuk langkah-langkah yang sejatinya deterministik. Dan ketika dipasangkan secara hibrida, BLM mengubah model open-source 27B yang awalnya tidak reliabel (29%) menjadi setara atau bahkan melampaui performa model proprietary tercanggih di dunia (96%), sekaligus memangkas 93% ongkos inferensi.

5. Batas Penerapan: Kapan BLM Unggul dan Mengapa BLM Gagal pada Open-Ended Synthesis

Sebagai artikel teknis yang mematuhi standar anti-slop, penting untuk memahami batasan fundamental dari pendekatan ini. Peneliti secara jujur mengeksplorasi domain di mana Bellman Language Models tidak memberikan keuntungan yang signifikan:

6. Implementasi Referensi: Bellman Language Model Controller di TypeScript

Berikut adalah modul TypeScript implementasi arsitektur BLM yang siap diintegrasikan ke dalam gateway inferensi, multi-agent orchestrator, atau runtime agen otonom:

// Production Implementation: Bellman Language Model (BLM) Controller Harness
// Berdasarkan formulasi formal paper arXiv:2610.24871 (Adarsh Vatsa & William Eiers)
// Mengimplementasikan:
// 1. State Discretization & Canonical Feature Extraction (Discretize, Then Decide)
// 2. Empirical Transition Matrix & Cost Model Estimator P_hat(s' | s, a) & C_hat(s, a)
// 3. Dynamic Programming Bellman Value Iteration: V*(s) = min_a [ C(s, a) + gamma * sum(P(s'|s,a)*V*(s')) ]
// 4. Hybrid Routing: Deterministic Controller Fast-Path vs Foundation LLM Escalation
// 5. Online State Saturation & Transition Cache Updates

export interface AgentObservation {
  turnIndex: number;
  lastUserMessage?: string;
  lastToolResult?: Record;
  activeIntent: string;
  slotValues: Record;
  contextTokensCount: number;
}

export interface CandidateAction {
  actionId: string;
  actionType: 'tool_call' | 'templated_reply' | 'escalate_llm' | 'terminate';
  targetTool?: string;
  staticPayload?: Record;
  estimatedCostUsd: number;
}

export interface StateTransitionSample {
  stateKey: string;
  actionId: string;
  nextStateKey: string;
  observedCost: number;
  successOutcome: boolean;
}

export class BellmanLanguageModelController {
  private transitionCounts: Map>> = new Map();
  private actionCosts: Map> = new Map();
  private stateValues: Map = new Map();
  private optimalPolicy: Map = new Map();
  private actionRegistry: Map = new Map();
  private discountFactorGamma: number = 0.95;
  private convergenceThreshold: number = 1e-4;
  private stateVisitCounts: Map = new Map();
  private saturationThreshold: number = 10; // State dianggap jenuh setelah 10 observasi konsisten

  constructor(discountFactor: number = 0.95) {
    this.discountFactorGamma = discountFactor;
  }

  /**
   * 1. Discretization Engine: Memetakan observasi teks/JSON ke dalam state diskret kanonikal
   */
  public discretizeState(obs: AgentObservation): string {
    const sortedSlots = Object.keys(obs.slotValues)
      .sort()
      .map(k => `${k}:${obs.slotValues[k]}`)
      .join(';');
    
    const toolSignal = obs.lastToolResult ? Object.keys(obs.lastToolResult).sort().join(',') : 'none';
    const stateRepresentation = `INTENT=${obs.activeIntent}|SLOTS=[${sortedSlots}]|TOOL_SIG=${toolSignal}`;
    
    // Hash state sederhana untuk kunci state diskret yang deterministik
    let hash = 0;
    for (let i = 0; i < stateRepresentation.length; i++) {
      hash = (hash << 5) - hash + stateRepresentation.charCodeAt(i);
      hash |= 0;
    }
    return `state_${Math.abs(hash).toString(16)}`;
  }

  public registerAction(action: CandidateAction): void {
    this.actionRegistry.set(action.actionId, action);
  }

  /**
   * 2. Ingest Trajectory: Mencatat transisi empiris dari logs produksi atau eksekusi LLM
   */
  public recordTransition(sample: StateTransitionSample): void {
    const { stateKey, actionId, nextStateKey, observedCost } = sample;

    // Track visit
    this.stateVisitCounts.set(stateKey, (this.stateVisitCounts.get(stateKey) || 0) + 1);

    // Track transitions
    if (!this.transitionCounts.has(stateKey)) {
      this.transitionCounts.set(stateKey, new Map());
    }
    const stateActions = this.transitionCounts.get(stateKey)!;
    if (!stateActions.has(actionId)) {
      stateActions.set(actionId, new Map());
    }
    const nextStates = stateActions.get(actionId)!;
    nextStates.set(nextStateKey, (nextStates.get(nextStateKey) || 0) + 1);

    // Track costs
    if (!this.actionCosts.has(stateKey)) {
      this.actionCosts.set(stateKey, new Map());
    }
    const stateActionCosts = this.actionCosts.get(stateKey)!;
    const currentCostData = stateActionCosts.get(actionId) || { totalCost: 0, count: 0 };
    currentCostData.totalCost += observedCost;
    currentCostData.count += 1;
    stateActionCosts.set(actionId, currentCostData);
  }

  /**
   * 3. Solve Bellman Optimality Equation via Value Iteration
   * V*(s) = min_a [ C_hat(s, a) + gamma * sum_{s'} P_hat(s' | s, a) * V*(s') ]
   */
  public solvePolicy(): { iterations: number; maxDelta: number; policySize: number } {
    const allStates = Array.from(this.transitionCounts.keys());
    let delta = Infinity;
    let iterations = 0;

    while (delta > this.convergenceThreshold && iterations < 1000) {
      delta = 0;
      iterations++;

      for (const s of allStates) {
        const currentV = this.stateValues.get(s) || 0;
        const availableActions = this.transitionCounts.get(s);
        if (!availableActions || availableActions.size === 0) continue;

        let bestActionCost = Infinity;
        let bestActionId = '';

        for (const [actionId, nextStateMap] of availableActions.entries()) {
          // Expected cost
          const costData = this.actionCosts.get(s)?.get(actionId);
          const immediateCost = costData && costData.count > 0 
            ? costData.totalCost / costData.count 
            : 1.0;

          // Expected future value
          let totalNextCount = 0;
          for (const count of nextStateMap.values()) totalNextCount += count;

          let expectedFutureValue = 0;
          for (const [nextStateKey, count] of nextStateMap.entries()) {
            const prob = count / totalNextCount;
            const nextV = this.stateValues.get(nextStateKey) || 0;
            expectedFutureValue += prob * nextV;
          }

          const qValue = immediateCost + this.discountFactorGamma * expectedFutureValue;
          if (qValue < bestActionCost) {
            bestActionCost = qValue;
            bestActionId = actionId;
          }
        }

        if (bestActionId !== '') {
          this.stateValues.set(s, bestActionCost);
          this.optimalPolicy.set(s, bestActionId);
          delta = Math.max(delta, Math.abs(currentV - bestActionCost));
        }
      }
    }

    return { iterations, maxDelta: delta, policySize: this.optimalPolicy.size };
  }

  /**
   * 4. Hybrid Routing Decision: Evaluasi apakah state telah teroptimasi atau perlu eskalasi ke LLM
   */
  public routeDecision(obs: AgentObservation): {
    strategy: 'CONTROLLER_DISPATCH' | 'ESCALATE_TO_LLM';
    action?: CandidateAction;
    stateKey: string;
    visitCount: number;
    reason: string;
  } {
    const stateKey = this.discretizeState(obs);
    const visitCount = this.stateVisitCounts.get(stateKey) || 0;
    const solvedActionId = this.optimalPolicy.get(stateKey);

    // Kriteria pengalihan cepat: state pernah diobservasi dengan frekuensi cukup dan memiliki aksi optimal
    if (solvedActionId && visitCount >= this.saturationThreshold) {
      const action = this.actionRegistry.get(solvedActionId);
      if (action && action.actionType !== 'escalate_llm') {
        return {
          strategy: 'CONTROLLER_DISPATCH',
          action,
          stateKey,
          visitCount,
          reason: `State ${stateKey} telah tersaturasi (${visitCount} runs). Aksi optimal deterministik dieksekusi tanpa inferensi LLM.`,
        };
      }
    }

    return {
      strategy: 'ESCALATE_TO_LLM',
      stateKey,
      visitCount,
      reason: `State ${stateKey} belum tersaturasi (visit: ${visitCount}) atau memerlukan open generative synthesis. Eskalasi ke foundation model.`,
    };
  }
}

7. Rekomendasi Arsitektur untuk Engineering Team di 2026

Berdasarkan data empiris paper arXiv:2610.24871, kami merumuskan 4 panduan mutlak bagi tim AI engineering yang ingin mengadopsi BLM di lingkungan produksi:

1. Audit Laju Saturasi State (State Saturation Rate): Sebelum terus-menerus menaikkan kuota API token untuk sistem agen Anda, petakan log interaksi produksi selama 14 hari ke belakang. Jika lebih dari 65% langkah eksekusi agen berkutat pada topologi state yang sama, sistem Anda adalah kandidat ideal untuk controller BLM.
2. Gunakan Model Kecil (SLM) dengan Pendamping BLM Controller: Daripada membebankan seluruh task kepada model raksasa (seperti Claude Opus atau GPT-5), gunakan model 8B–27B yang didampingi BLM controller. Anda akan memperoleh reliabilitas 96%+ dengan biaya 10x lebih murah daripada model frontier tanpa controller.
3. Terapkan Mekanisme Fail-Safe Escalation: Pastikan controller memiliki threshold ambiguitas yang jelas ($visitCount < au_{sat}$). Jika state belum cukup teramati atau distribusi probabilitas transisi memiliki entropi tinggi, delegasikan secara mulus kembali ke foundation LLM.
4. Pisahkan Eksekusi Aksi dari Generasi Bahasa: Jangan biarkan LLM merumuskan payload JSON dan template teks dalam satu langkah monolitik. Eksekusi tool deterministik melalui controller, dan gunakan model bahasa hanya ketika dibutuhkan adaptasi frasa komunikasi yang dinamis kepada pengguna akhir.