MPT & Decentralized Swarms (arXiv:2610.22322): Market-Based Post-Training, Bidding Credit Assignment, dan Eliminasi Central Orchestrator pada Multi-Agent LLM

1. Kegagalan Struktural Sistem Multi-Agen LLM Konvensional: Ilusi Manajer Terpusat

Dalam lanskap rekayasa kecerdasan artifisial, sistem multi-agen modern seperti MetaGPT, ChatDev, AutoGen, hingga framework kolaboratif enterprise umumnya mengadopsi struktur orkestrasi kaku:

• Hierarki Manajer Tunggal (Centralized Dispatcher): Sebuah model sentral bertugas memecah instruksi pengguna, memilih sub-agen berikutnya, dan memantau status eksekusi.
• Alur Kerja Deterministik (Hardcoded Graph Workflows): Agen generator diwajibkan berkomunikasi hanya dengan agen verifikator dalam urutan sequential yang telah dipatenkan sejak kode ditulis.
• Orkestrasi Terpisah dari Pelatihan Kebijakan (Decoupled Optimization): Parameter model masing-masing agen dilatih secara independen (misalnya melalui SFT atau RL individual), sementara aturan kapan agen tersebut harus aktif diasumsikan statis atau dioptimalkan hanya pada saat inferensi melalui graph search.

Pemisahan ini menciptakan bottleneck yang melumpuhkan kemampuan swarms pada horizon tugas yang panjang (long-horizon). Di dunia nyata, agen yang efektif di awal sesi mungkin tidak lagi relevan ketika lingkungan telah berubah. Jika orkestrasi dikunci, agen tidak memiliki mekanisme umpan balik untuk mengetahui apakah partisipasinya menguntungkan atau justru menghambat rekan-rekannya. Selain itu, jika sang "Manajer" terpusat mengalami halusinasi atau degradasi penalaran, seluruh kawanan agen akan langsung terjebak dalam kegagalan kaskade (cascading failure).

GAMBAR 1: Siklus Makro & Mikro Market-based Post-Training (MPT). (a) Alur pemecahan tugas Iron Pickaxe dari instruksi hingga selesai tanpa supervisor. (b) Proses penawaran independen (bidding) antar agen spesialis untuk mengamankan hak eksekusi giliran.

2. Arsitektur MPT: Pasangan Aksi dan Penawaran Nilai (Bidding)

Alih-alih mengandalkan router eksternal, MPT mendesain setiap agen $i in {1, dots, N}$ sebagai entitas otonom yang dikendalikan oleh kebijakan $pi_{ heta_i}$. Pada setiap giliran keputusan $t$, alih-alih langsung memuntahkan aksi, seluruh agen yang tersedia mengamati konteks lokal $h_{i,t}$ dan secara simultan menerbitkan nilai penawaran (bid) skalar:

Nilai penawaran $b_i$ merefleksikan tingkat keyakinan dan kesiapan agen untuk berkontribusi secara produktif terhadap keadaan saat ini:

1. Alokasi Giliran Tanpa Wasit: Agen dengan penawaran tertinggi ($b_t = max_i b_{i,t}$) memenangkan giliran dan mengeksekusi aksinya ke lingkungan. Jika terjadi kesamaan nilai (tie), pemenang dipilih acak seragam. Jika seluruh agen menawar $0$, giliran dilewati.
2. Koneksi Simultan dengan Pembagian Kredit: Besaran tawaran pemenang $b_t$ tidak hanya menentukan siapa yang mengeksekusi giliran, tetapi juga mengatur secara presisi berapa porsi reward masa depan yang wajib ditransfer ke agen-agen yang bekerja sebelumnya.

3. Formula Bidding-Based Credit Assignment: Algoritma Rantai Ember (Bucket Brigade)

Tantangan terbesar dalam melatih kawanan agen terdesentralisasi adalah credit assignment: ketika tugas multi-tahap selesai dan reward terminal $R$ diberikan di langkah $T$, bagaimana kita tahu agen mana yang benar-benar berkontribusi dan agen mana yang sekadar numpang lewat?

Mengadaptasi prinsip ekonomi bucket brigade yang digagas John Holland, MPT memformulasikan propagasi nilai akumulasi $v_t$ dan kredit pelatihan lokal $ ilde{r}_t$ secara rekursif mundur:

Mari kita bedah elegansi mekanika ini:

• Agen yang bertindak di giliran $t$ mengantongi nilai $v_t$ yang merupakan kombinasi dari reward langsung lingkungan $hat{r}_t$ ditambah nilai yang ditransfer oleh pemenang giliran berikutnya ($b_{t+1} cdot v_{t+1}$).
• Agen tersebut menyimpan porsi sebesar $(1 - b_t)$ sebagai kredit pembaruan gradien kebijakannya sendiri ($ ilde{r}_t$), dan meneruskan sisa porsi $b_t$ ke agen yang bekerja sebelum dirinya!
• Dengan demikian, reward yang diperoleh di langkah masa depan $t + k$ menyumbang ke kredit giliran $t$ dengan bobot perkalian diskon alami $prod_{j=t+1}^{t+k} b_j$.

Pembaruan parameter aksi dilakukan menggunakan REINFORCE dengan per-agent mean baseline $ar{r}_i$:

di mana $mathcal{W}_i$ adalah himpunan giliran di mana agen $i$ memenangkan lelang. Agen hanya diperbarui pada token aksi dari giliran yang ia menangkan.

4. Belajar Swa-Orkestrasi Melalui Perbandingan Kontrafaktual (Bradley-Terry Preference)

Bagaimana agen belajar kapan harus menawar tinggi dan kapan harus menahan diri? Agen memerlukan umpan balik kausal: "Apakah lintasan tugas akan berakhir lebih baik jika agen lain yang bertindak di giliran ini?"

MPT memecahkan dilema ini dengan teknik komparasi kontrafaktual pada contested turns (giliran di mana runner-up memberikan penawaran bukan nol):

1. Cabang Orisinal (Original Branch): Agen terpilih memenangkan giliran dan mengeksekusi aksinya hingga episode selesai. Total return yang diperoleh dicatat.
2. Cabang Alternatif (Alternative Branch): State lingkungan dan agen pada giliran kontes dipulihkan kembali (restored checkpoint). Penawaran agen terpilih di-resample ke bawah hingga berada di bawah penawaran runner-up, sehingga runner-up mengambil alih kemudi. Cabang ini dijalankan hingga tuntas.
3. Optimasi Preferensi Bradley-Terry: Cabang dengan akumulasi reward tertinggi dinobatkan sebagai respon pemenang ($y_w$), sementara respon penawaran yang kalah diberi label ($y_l$).

Melalui fungsi loss ini, agen secara bertahap belajar untuk meredam egonya: jika memaksakan diri bertindak di situasi yang bukan keahliannya menurunkan kesuksesan kelompok, agen akan menekan nilai bid-nya mendekati nol di masa mendatang.

5. Pembuktian Empiris: Minecraft, Navigasi Robotik, dan Deep Research

Peneliti mengevaluasi MPT pada tiga domain tugas dengan karakteristik yang sangat berbeda, membandingkannya dengan model RL monolitik (Single Policy) pada matched training FLOPs (menghitung seluruh biaya komputasi penawaran, rollouts kontrafaktual, dan inferensi model):

Fenomena paling memukau terlihat pada evolusi perilaku partisipasi selama fase training:

• Transisi Alami Giliran Kerja: Sebelum fase RL, agen Logger mendominasi 80% giliran di seluruh episode. Namun setelah MPT berjalan, Logger secara otomatis membatasi dirinya di fase awal pengumpulan kayu. Di langkah ke-120, partisipasi Logger turun menjadi 45%, sementara Miner melonjak dari 10% ke 40%, dan Smith naik ke 15% untuk menempa ingot dan pickaxe.
• Adaptasi Kilat ke Sasaran Baru (Continual Learning): Saat dipindahkan untuk membuat item baru yang belum pernah dilatih (Torch dan Stone Bricks), swarm MPT beradaptasi 2x lebih cepat pada komputasi $10^{18}$ FLOPs dibanding baseline monolitik.
• Ketahanan Terhadap Agent Dropout: Ketika sebagian agen dimatikan secara tiba-tiba (dropout) pada saat inferensi, populasi agen yang lebih besar (hingga 12 agen) mempertahankan tingkat keberhasilan tugas yang jauh lebih stabil karena agen lain secara spontan menaikkan bid untuk mengisi kekosongan peran.

6. Implementasi TypeScript Produksi: Market Auction & Credit Propagator

Berikut adalah modul controller TypeScript yang siap pakai untuk mengintegrasikan mekanisme lelang MPT ke dalam runtime orkestrasi agen multi-model:

// Production Implementation: Decentralized Market Auction & Bucket Brigade Credit Engine
// Berdasarkan formulasi formal arXiv:2610.22322 (Harvard & MIT CSAIL)
// Mengimplementasikan:
// 1. Independent Auction & Bidding Arbitration (Max Bid Selection without Central Manager)
// 2. Bucket Brigade Credit Assignment (v_t = r_t + b_{t+1} * v_{t+1}, r~_t = (1 - b_t) * v_t)
// 3. Counterfactual Branch Sampling & Bradley-Terry Preference Pair Generation
// 4. Fault-Tolerant Agent Dropout Handling & Continuous Adaptation Gating

export interface AgentBidPayload {
  agentId: string;
  role: string;
  bid: number; // b_i in [0.0, 1.0]
  proposedAction: string;
  localStateDigest: string;
}

export interface TurnExecutionRecord {
  turn: number;
  selectedAgentId: string;
  selectedBid: number; // b_t
  runnerUpBid: number;
  environmentReward: number; // r^_t
  isContested: boolean;
  contextHistory: string;
  actionOutput: string;
}

export class DecentralizedMarketSwarm {
  private turnHistory: TurnExecutionRecord[] = [];
  private accumulatedValues: number[] = [];
  private localCredits: Map = new Map();

  constructor(
    private readonly agentPool: string[],
    private readonly discountFactor: number = 0.99
  ) {
    this.agentPool.forEach(id => this.localCredits.set(id, []));
  }

  /**
   * 1. Swa-Orkestrasi Melalui Lelang Terdesentralisasi
   * Setiap agen secara independen menentukan nilai penawaran partisipasinya b_i in [0, 1]
   */
  public arbitrateTurn(turn: number, bids: AgentBidPayload[]): AgentBidPayload {
    if (bids.length === 0) {
      throw new Error("Swarm empty: tidak ada penawar aktif");
    }

    // Urutkan bid menurun
    const sorted = [...bids].sort((a, b) => b.bid - a.bid);
    const winner = sorted[0];
    const runnerUp = sorted[1] || { bid: 0.0 };

    // Cek apakah giliran diperebutkan (contested turn)
    const isContested = runnerUp.bid > 0.0;

    // Catat frame awal
    this.turnHistory.push({
      turn,
      selectedAgentId: winner.agentId,
      selectedBid: winner.bid,
      runnerUpBid: runnerUp.bid,
      environmentReward: 0.0,
      isContested,
      contextHistory: winner.localStateDigest,
      actionOutput: winner.proposedAction,
    });

    return winner;
  }

  /**
   * Daftarkan feedback reward lingkungan dari giliran t
   */
  public recordTurnOutcome(turnIndex: number, reward: number): void {
    if (this.turnHistory[turnIndex]) {
      this.turnHistory[turnIndex].environmentReward = reward;
    }
  }

  /**
   * 2. Bidding-Based Credit Assignment (Bucket Brigade Protocol)
   * Menyebarkan reward mundur dari T ke 1:
   * v_t = r^_t + b_{t+1} * v_{t+1}
   * r~_t = (1 - b_t) * v_t
   */
  public calculateCreditAssignment(): { turnIndex: number; agentId: string; credit: number }[] {
    const T = this.turnHistory.length;
    this.accumulatedValues = new Array(T + 1).fill(0);
    const results: { turnIndex: number; agentId: string; credit: number }[] = [];

    // v_{T+1} = 0
    this.accumulatedValues[T] = 0;

    // Propagasi mundur (backward pass)
    for (let t = T - 1; t >= 0; t--) {
      const rec = this.turnHistory[t];
      const nextBid = t + 1 < T ? this.turnHistory[t + 1].selectedBid : 0.0;
      const nextVal = this.accumulatedValues[t + 1];

      // v_t = r^_t + b_{t+1} * v_{t+1}
      const vt = rec.environmentReward + (nextBid * nextVal);
      this.accumulatedValues[t] = vt;

      // r~_t = (1 - b_t) * v_t
      const localCredit = (1.0 - rec.selectedBid) * vt;
      results.unshift({
        turnIndex: t,
        agentId: rec.selectedAgentId,
        credit: localCredit,
      });

      this.localCredits.get(rec.selectedAgentId)?.push(localCredit);
    }

    return results;
  }

  /**
   * 3. Evaluasi Kontrafaktual Giliran Terpilih
   * Membandingkan hasil cabang asli vs cabang kontrafaktual untuk membentuk
   * pasangan preferensi Bradley-Terry (y_winner, y_loser)
   */
  public generateBiddingPreferencePair(contestedTurnIndex: number, counterfactualReturn: number) {
    const originalRecord = this.turnHistory[contestedTurnIndex];
    if (!originalRecord || !originalRecord.isContested) {
      return null;
    }

    const originalReturnFromTurn = this.accumulatedValues[contestedTurnIndex];

    if (Math.abs(originalReturnFromTurn - counterfactualReturn) < 1e-4) {
      return null; // Return setara, dibuang untuk menjaga kestabilan gradien
    }

    const preferred = originalReturnFromTurn > counterfactualReturn ? "ORIGINAL_BID" : "RUNNER_UP_BID";
    return {
      turn: contestedTurnIndex,
      agentId: originalRecord.selectedAgentId,
      winningResponse: preferred === "ORIGINAL_BID" ? originalRecord.selectedBid : originalRecord.runnerUpBid - 0.01,
      losingResponse: preferred === "ORIGINAL_BID" ? originalRecord.runnerUpBid - 0.01 : originalRecord.selectedBid,
      margin: Math.abs(originalReturnFromTurn - counterfactualReturn),
    };
  }
}

7. Implikasi Strategis bagi Rekayasa AI Enterprise 2026

Hasil penelitian ini memberikan pesan yang sangat tegas bagi para insinyur AI dan perancang arsitektur sistem otonom:

1. Tinggalkan Router Sentral untuk Alur Kerja Kompleks: Jangan menyia-nyiakan token dan latensi untuk memelihara satu "LLM Supervisor" yang mencoba memahami seluruh konteks dunia. Biarkan agen-agen spesialis menilai relevansi peran mereka sendiri melalui mekanisme lelang lokal.
2. Gunakan Bidding Sebagai Filter Komputasi: Dengan memanfaatkan skalar penawaran $b_i$, sistem dapat memotong eksekusi alat (tool calling) yang sia-sia dan menghemat biaya inferensi hingga lebih dari 50% di lingkungan multi-agen.
3. Terapkan Pembagian Kredit Kausal (Bucket Brigade): Saat melatih agen spesialis dengan RL, pastikan agen awal yang menyiapkan data atau membersihkan environment mendapatkan bagian reward yang adil dari agen akhir yang menyelesaikan transaksi.
4. Desentralisasi Menjamin Skalabilitas Tanpa Batas: Kawanan agen yang belajar berkolaborasi secara otonom dapat diperbesar populasinya (scale-up) atau dikurangi saat server sibuk tanpa perlu merombak ulang grafik alur kerja atau prompt sistem.