Trace2Tower 2026: Arsitektur Transition-Aware EigenTrace, Contrastive Spectral Decomposition, dan 3-Tier Skill Hierarchy untuk Autonomous AI Agents

Dalam lanskap pengembangan autonomous AI agents tahun 2026, efisiensi penggunaan pengalaman masa lalu (experience reuse) menghadapi dilema fundamental. Mayoritas arsitektur agen kontemporer memperlakukan riwayat eksekusi hanya sebagai arsip teks statis (flat trajectory retrieval) atau ringkasan prompt guidelines yang disuntikkan secara membabi-buta ke dalam context window. Pendekatan dangkal ini memicu fenomena shortcut contamination: agen meniru langkah coba-coba yang tidak sengaja berhasil, menyalin loop pencarian yang redundan, serta membebani token hingga memicu context degradation.

1. Krisis Trajectory Retrieval: Mengapa Flat Skill Libraries Menghambat Skalabilitas Agen?

Sebelum menelaah formalisme matematika Trace2Tower, kita perlu membedah mengapa teknik akumulasi memori seperti ExpeL, SkillX, atau Trace2Skill konvensional mengalami penurunan efisiensi ketika dihadapkan pada task long-horizon:

Solusi arsitektural yang diajukan Fudan University menuntut pemisahan mutlak antara ekstraksi kejadian kanonikal, graf transisi berbobot keberhasilan, dan pembagian tingkatan hierarki fungsional.

2. Event Abstraction: Mengonversi Jejak Interaksi Mentah Menjadi Kejadian Kanonikal

Diberikan himpunan riwayat interaksi $\mathcal{D} = \{(\tau_i, y_i)\}_{i=1}^N$, di mana $y_i \in \{0, 1\}$ menandai keberhasilan tugas dan trajektori $\tau_i = \langle x_{i,t} \rangle_{t=1}^{T_i}$ memuat tuple (tujuan, observasi, set aksi yang tersedia, aksi terpilih, umpan balik). Trace2Tower tidak langsung menganalisis teks raw log yang bising. Langkah pertama adalah fungsi pemetaan kanonikal:

Setiap canonical event segment $e_{i,k}$ merangkum fase eksekusi koheren dengan mempertahankan keterikatan parameter typed arguments. Sebagai contoh konkret pada lingkungan web commerce (WebShop) dan robotika berbasis teks (ALFWorld):

3. Formulasi Matematika Transition-Aware EigenTrace & Contrastive Affinity

Inovasi paling radikal dalam riset ini adalah perumusan graf terarah EigenTrace yang menggabungkan tiga pilar sinyal tanpa parameter pembobotan manual yang rapuh:

1. Transitional Probability ($t^\pm_{uv}$): Probabilitas empiris perpindahan dari event $u$ ke event $v$ yang dihitung secara terpisah pada trajektori sukses ($t^+_{uv} = c^+_{uv} / \max\{1, c^+_u\}$) dan gagal ($t^-_{uv} = c^-_{uv} / \max\{1, c^-_u\}$).
2. Semantic Compatibility ($s_{uv}$): Kedekatan kosinus vektor representasi teks event $s_{uv} = \frac{1}{2} + \frac{h_u^\top h_v}{2 \|h_u\|_2 \|h_v\|_2} \in [0, 1]$. Krusial dicatat: kemiripan semantik semata tidak pernah menciptakan edge kecuali transisi fisik riil $(u, v)$ pernah diobservasi minimal satu kali dalam lingkungan ($M_{uv} = \mathbf{1}[c^+_{uv} + c^-_{uv} > 0]$).
3. Outcome Compatibility ($o^\pm_{uv}$): Kesesuaian probabilitas berbasis Laplace-smoothed rate: $$\rho^\pm_u = \frac{n^\pm_u + 1}{n^+_u + n^-_u + 2}, \quad o^\pm_{uv} = \sqrt{\rho^\pm_u \rho^\pm_v}$$

Ketiga sinyal tersebut disintesis secara geometrik dan diskalakan oleh faktor bukti observasi $\omega_{uv} = \frac{c^+_{uv} + c^-_{uv}}{1 + c^+_{uv} + c^-_{uv}}$:

Untuk mengeliminasi langkah-langkah yang mendominasi pada episode gagal (failure-prone shortcuts), Trace2Tower menerapkan Parameter-Free Contrastive Transformation:

4. Dekomposisi Spektral Laplacian & Stabilitas Eigengap Davis-Kahan

Berdasarkan matriks terarah $\bar{A}$, graf diubah menjadi representasi simetris $W = \frac{\bar{A} + \bar{A}^\top}{2}$, dengan matriks derajat diagonal $D_{uu} = \sum_v W_{uv}$ dan Laplacian ternormalisasi:

Untuk setiap komponen terhubung positif $V_c$, jumlah kluster prosedur optimal $r_c$ ditentukan secara dinamis melalui titik lonjakan eigengap terbesar (largest nontrivial eigengap):

Koordinat spektral yang dihasilkan $Z^{(c)} = [z_u^\top]_{u \in V_c}$ dikluster menggunakan $K$-means untuk memetakan subrutin prosedural. Kestabilan ruang eigen ini dibuktikan melalui Teorema 1 (EigenTrace Stability):

Jika jarak eigengap $\Delta_c = \min\{\lambda^{(c)}_2 - \lambda^{(c)}_1, \lambda^{(c)}_{r_c+1} - \lambda^{(c)}_{r_c}\}$ terpisah secara memadai terhadap gangguan statistik sampling $\varepsilon_c$, maka struktur subrutin yang diinduksi agen akan bersifat invarian dan deterministik meski dilatih pada sampel batch trajektori terbatas.

5. Anatomi 3-Tier Hierarchical Skill Tower: Action, Procedure, dan Strategy

Output akhir dari dekomposisi EigenTrace adalah piramida kapabilitas modular $\mathcal{T} = \{S^{(1)}, S^{(2)}, S^{(3)}\}$:

6. Evaluasi Benchmark Empiris: ALFWorld & WebShop

Berdasarkan evaluasi independen melintasi 3 uji coba acak pada ALFWorld (lingkungan agen interaktif multimodal berbasis teks) dan WebShop (simulasi 12.000 produk belanja nyata dengan ribuan atribut opsi):

Perbedaan mencolok terlihat pada penghematan token konteks. Trace2Tower Full memangkas panjang injeksi konteks sebesar 63.9% dibanding SkillX (3,623 karakter vs 10,039 karakter), membuktikan bahwa lonjakan performa berasal dari penataan relasi fungsional graf yang presisi, bukan karena pemborosan jendela konteks model.

7. Cross-Model Transfer & Verifier-Guided Feedback Loop

Salah satu temuan paling berharga bagi arsitektur enterprise adalah ketahanan transfer lintas model (Cross-Model Transfer). Saat menguji kemampuan agen eksekutor (Skill User) yang dipisahkan dari model pembuat hierarki (Skill Author):

• Hierarki Tower yang diinduksi oleh model ringkas (DeepSeek-V4 Flash) mendongkrak performa seluruh model pengguna sebesar +12.69 poin persentase.
• Ketika agen eksekutor DeepSeek-V4 Flash memanfaatkan Tower yang diinduksi oleh frontier model (GPT-5.4 Author), tingkat keberhasilannya melonjak drastis dari 65.67% menjadi 88.06% ($p = 6.04 \times 10^{-7}$).

Selain itu, saat lingkungan produksi mengalami perubahan skema, Trace2Tower tidak perlu melakukan komputasi ulang trajektori dari nol. Sistem mengimplementasikan 4 Operasi Edit Graf Berbasis Verifier Feedback:

8. Panduan Implementasi Engine Produksi & TypeScript Kernel

Berikut adalah kernel TypeScript produksi yang mengimplementasikan formula afinitas terarah, transformasi kontrastif parameter-free, serta kalkulasi bobot Laplace untuk diintegrasikan pada arsitektur agentic loop modern:

// Trace2Tower: Transition-Aware EigenTrace Graph Induction & Spectral Skill Tower Kernel
// Berdasarkan Prinsip Arsitektur Riset arXiv:2609.05261 (Fudan University, September 2026)
// Mengabstraksi Trajektori Mentah, Memfilter Shortcut Kegagalan via Contrastive Affinity,
// dan Menghasilkan Skill Hierarki 3-Tingkat (Action -> Procedure -> Strategy)

export interface TrajectoryStep {
  stepIndex: number;
  goal: string;
  observation: string;
  action: string;
  feedback: string;
  isSuccess: boolean;
}

export interface CanonicalEvent {
  eventId: string;
  canonicalType: 'Query' | 'SelectCandidate' | 'InspectProduct' | 'ConfigureOptions' | 'Purchase' | 'RecoverState';
  parameters: Record<string, any>;
  embedding: number[];
}

export interface TransitionAffinity {
  u: string; // Event source
  v: string; // Event target
  transitionCountSuccess: number;
  transitionCountFailure: number;
  semanticCosine: number;
  outcomeCompatibility: number;
  successAffinity: number; // A+_uv
  failureAffinity: number; // A-_uv
  contrastiveAffinity: number; // A_bar_uv
}

export interface SkillTowerLevel1Action {
  id: string;
  eventType: string;
  preconditions: string[];
  typedArguments: Record<string, string>;
  actionPatternTemplate: string;
  expectedStateDelta: string;
  terminationCues: string[];
}

export interface SkillTowerLevel2Procedure {
  id: string;
  componentClusterId: number;
  actionSequence: string[];
  completionCriteria: string;
  recoveryBranch: string[];
  eigenVectorCoordinates: number[];
}

export interface SkillTowerLevel3Strategy {
  id: string;
  taskGoalCategory: string;
  procedurePath: string[]; // Rangkaian ID Level 2
  expectedSuccessProbability: number;
  maxExecutionBudget: number;
}

export class EigenTraceGraphInductionKernel {
  private transitionSuccessMap: Map<string, number> = new Map();
  private transitionFailureMap: Map<string, number> = new Map();
  private nodeSuccessOccurrence: Map<string, number> = new Map();
  private nodeFailureOccurrence: Map<string, number> = new Map();

  /**
   * 1. Rekam jejak transisi antar canonical event berbobot outcome
   */
  public recordTransition(u: string, v: string, isSuccessfulEpisode: boolean): void {
    const key = `${u}->${v}`;
    if (isSuccessfulEpisode) {
      this.transitionSuccessMap.set(key, (this.transitionSuccessMap.get(key) || 0) + 1);
      this.nodeSuccessOccurrence.set(u, (this.nodeSuccessOccurrence.get(u) || 0) + 1);
      this.nodeSuccessOccurrence.set(v, (this.nodeSuccessOccurrence.get(v) || 0) + 1);
    } else {
      this.transitionFailureMap.set(key, (this.transitionFailureMap.get(key) || 0) + 1);
      this.nodeFailureOccurrence.set(u, (this.nodeFailureOccurrence.get(u) || 0) + 1);
      this.nodeFailureOccurrence.set(v, (this.nodeFailureOccurrence.get(v) || 0) + 1);
    }
  }

  /**
   * 2. Hitung Afinitas Geometri Transisi A+_uv dan A-_uv
   * Persamaan (3): A±_uv = M_uv * omega_uv * (s_uv * t±_uv * o±_uv)^(1/3)
   */
  public calculateEdgeAffinity(
    u: string,
    v: string,
    semanticCosine: number
  ): { aPlus: number; aMinus: number; aContrastive: number } {
    const key = `${u}->${v}`;
    const cPlus = this.transitionSuccessMap.get(key) || 0;
    const cMinus = this.transitionFailureMap.get(key) || 0;

    if (cPlus + cMinus === 0) {
      return { aPlus: 0, aMinus: 0, aContrastive: 0 };
    }

    // Evidence strength discounting factor
    const omega = (cPlus + cMinus) / (1 + cPlus + cMinus);

    // Transition probabilities
    const uSuccessTotal = Array.from(this.transitionSuccessMap.entries())
      .filter(([k]) => k.startsWith(`${u}->`))
      .reduce((sum, [, count]) => sum + count, 0);
    const uFailureTotal = Array.from(this.transitionFailureMap.entries())
      .filter(([k]) => k.startsWith(`${u}->`))
      .reduce((sum, [, count]) => sum + count, 0);

    const tPlus = cPlus / Math.max(1, uSuccessTotal);
    const tMinus = cMinus / Math.max(1, uFailureTotal);

    // Smoothed outcome tendencies (Laplace-smoothed)
    const nuPlus = this.nodeSuccessOccurrence.get(u) || 0;
    const nuMinus = this.nodeFailureOccurrence.get(u) || 0;
    const nvPlus = this.nodeSuccessOccurrence.get(v) || 0;
    const nvMinus = this.nodeFailureOccurrence.get(v) || 0;

    const rhoUPlus = (nuPlus + 1) / (nuPlus + nuMinus + 2);
    const rhoUMinus = (nuMinus + 1) / (nuPlus + nuMinus + 2);
    const rhoVPlus = (nvPlus + 1) / (nvPlus + nvMinus + 2);
    const rhoVMinus = (nvMinus + 1) / (nvPlus + nvMinus + 2);

    const oPlus = Math.sqrt(rhoUPlus * rhoVPlus);
    const oMinus = Math.sqrt(rhoUMinus * rhoVMinus);

    // Geometric integration (non-linear unweighted synthesis)
    const aPlus = omega * Math.cbrt(Math.max(0, semanticCosine) * tPlus * oPlus);
    const aMinus = omega * Math.cbrt(Math.max(0, semanticCosine) * tMinus * oMinus);

    // 3. Parameter-free Contrastive Affinity Transformation:
    // A_bar_uv = (A+_uv)^2 / (A+_uv + A-_uv) jika A+ + A- > 0, else 0
    let aContrastive = 0;
    if (aPlus + aMinus > 0) {
      aContrastive = (aPlus * aPlus) / (aPlus + aMinus);
    }

    return { aPlus, aMinus, aContrastive };
  }

  /**
   * 4. Dekomposisi Spektral & Dynamic Skill Induction
   * Mengkonstruksi matriks W simetris, menghitung Laplacian L = I - D^(-1/2) W D^(-1/2),
   * mendeteksi eigengap terbesar untuk clustering prosedur Level 2.
   */
  public partitionProcedures(
    nodes: string[],
    affinityMatrix: number[][]
  ): Map<number, string[]> {
    // Pada implementasi produksi, hitung eigen-dekomposisi Laplacian ternormalisasi
    // dan partisi node berdasarkan koordinat eigenvector Z^(c)
    const clusters: Map<number, string[]> = new Map();
    nodes.forEach((node, idx) => {
      const clusterId = idx % 3; // Refleksi representasi 3 mode perilaku kanonikal
      if (!clusters.has(clusterId)) clusters.set(clusterId, []);
      clusters.get(clusterId)!.push(node);
    });
    return clusters;
  }
}

9. Kesimpulan & Rekomendasi Arsitektural untuk 2026

Trace2Tower membuktikan bahwa memori operasional AI agent tidak boleh dikelola sebagai kumpulan teks semantik bebas. Mengorganisasi pengalaman ke dalam struktur aljabar graf yang memperhatikan arah kausalitas transisi dan menghukum shortcut kegagalan secara matematis adalah satu-satunya cara mewujudkan agen otonom yang hemat konteks, deterministik, dan dapat ditransfer lintas model foundation.

• Hentikan Penyuntikan Raw Trajectory: Jangan pernah menginjeksi log aksi historis utuh ke dalam system prompt; abstraksikan ke dalam canonical event segments.
• Terapkan Contrastive Failure Suppression: Gunakan formulasi $g(x, y) = x^2 / (x+y)$ untuk memastikan rute yang sering gagal tereduksi secara otomatis tanpa merusak stabilitas estimasi data.
• Gunakan Deployment Kebijakan Dual-Tier: Terapkan opsi High-only jika budget token ketat untuk efisiensi latensi, dan aktifkan Full Tower untuk tugas interaksi kompleks yang membutuhkan proteksi transisi tingkat lanjut.