Procedural Graphs 2026: Arsitektur (Procedure, Relation, Procedure) Triplets, Generative Subgraph Guidance, dan Self-Evolving Offline Topology Refinement untuk Autonomous LLM Agents

Dalam lanskap rekayasa AI agents berskala enterprise, fenomena infinite loop, kegagalan urutan eksekusi (out-of-order tool invocation), serta penyimpangan tujuan (objective drift) menjadi momok paling merusak pada tugas horizon panjang. Riset mutakhir dari tim Google Cloud AI Research (arXiv:2609.09153, September 2026) memperkenalkan Procedural Graphs (PG): sebuah paradigma arsitektur eksekusi terstruktur yang mentransformasikan pengetahuan prosedural implisit menjadi graf relasional berbobot atribut dinamis.

1. Jebakan Generasi Tanpa Batas & Kegagalan Retrival Naif

Mayoritas agen otonom saat ini (seperti ReAct atau CoT standar) memilih aksi berikutnya secara bebas melalui akumulasi konteks riwayat obrolan yang kian membengkak. Ketika trajektori mencapai puluhan atau ratusan langkah, agen rentan mengalami amnesia prosedural:

• Inversi Urutan Eksekusi (Action Order Inversion): Agen memanggil tool penyerahan hasil akhir (misal: submit_answer) tanpa terlebih dahulu menjalankan verifikasi prasyarat (verify_checksum atau check_constraints), memicu kegagalan fatal yang tidak dapat dipulihkan.
• Kegagalan Retrieval Berbasis Kemiripan Semantik (Top-k Similarity Blindness): Sistem memori RAG biasa yang mengambil cuplikan pedoman hanya berdasarkan kemiripan teks kueri kerap kehilangan relasi kausalitas urutan. Mengambil instruksi submit tanpa simpul pendahulunya mengaburkan prasyarat validitas eksekusi.
• Siklus Kesalahan Berulang (Unproductive Loop Entrapment): Saat menghadapi kegagalan API atau parameter invalid, model cenderung mengulang pemanggilan fungsi yang sama secara berulang tanpa eksplorasi jalur pemulihan (fallback paths).

2. Representasi Formal: Struktur Directed Attributed Graph

Secara matematis, sebuah Procedural Graph didefinisikan sebagai graf berarah dan berbobot atribut:

Di mana setiap simpul $u, v \in \mathcal{V}$ mengabstraksikan fungsi perkakas (tool), keterampilan operasional (skill), tahapan penalaran internal, atau status kemajuan tugas. Sisi berarah $e = (u, r, v) \in \mathcal{E}$ menyatakan bahwa prosedur $v$ diizinkan (admissible) dijalankan setelah prosedur $u$ di bawah relasi $r \in \mathcal{R}$.

Pemetaan atribut $\Phi$ mengikat setiap sisi transisi dengan 3 bidang semantik tekstual kanonikal:

3. Mekanisme Online Inference: Locate, Extract, & Generate

Alih-alih menginjeksi seluruh graf secara utuh ke dalam system prompt (yang memicu token bloat dan mengalihkan atensi model), runtime Procedural Graph mengoperasikan skema dinamis tiga tahap pada setiap langkah keputusan $t$:

1. Locate (Lokalisasi Simpul Aktif): Mencocokkan aksi atau observasi terakhir agen $a_{t-1}$ dengan simpul dalam graf $\mathcal{V}$ melalui fungsi kecocokan deterministik:
   u_t = \mathrm{Match}(a_{t-1}, \mathcal{V}), \quad u_1 = \texttt{Start}
2. Extract (Ekstraksi Subgraf Tetangga h-Hop): Mengekstrak lingkungan lokal terarah $\mathcal{N}_h(u_t)$ hingga kedalaman $h$ langkah (optimal pada $h=2$). Jika simpul tidak ditemukan, sistem beralih ke representasi global secara aman:
   \mathcal{G}_t = \begin{cases} \mathcal{N}_h(u_t), & u_t \neq \varnothing \\ \mathcal{G}, & \text{fallback global} \end{cases}
3. Generate (Sintesis Panduan Situasional): Model bahasa pemandu $\Psi$ menerjemahkan topologi lokal $\mathcal{G}_t$, kueri tugas pengguna $q$, dan jendela riwayat keputusan terakhir $\mathcal{T}_{t-w:t}$ menjadi teks panduan langkah $g_t$:
   g_t = \Psi(\mathcal{G}_t, q, \mathcal{T}_{t-w:t})

4. Siklus Self-Evolution Offline & Rejection Memory

Kekuatan utama Procedural Graph terletak pada kemampuannya untuk berevolusi secara mandiri tanpa rekayasa manual berkelanjutan. Melalui siklus evolusi 4 tahap, graf secara iteratif memutasi struktur topologi dan atributnya:

Peran Rejection Memory $\mathcal{M}_{\text{rej}}$ sangat krusial: banyak sistem self-improving gagal di lingkungan produksi karena model refiner terus-menerus mengusulkan modifikasi topologi buruk yang sama secara melingkar. Dengan membekukan jejak kegagalan, agen dijamin hanya bergerak menuju lintasan performa monotonically non-decreasing.

5. Tolok Ukur Benchmark Empiris: Dominasi 21 dari 24 Pengujian

Penelitian ini menguji Procedural Graphs di 7 tolok ukur terkemuka dengan 4 keluarga fondasi model frontier (Gemini 3.5 Flash, Gemini 3.1 Pro, Claude Sonnet 4.6, dan Grok 4.1 Fast):

Ablasi Mekanisme Injeksi: Mengapa Subgraf Terlokalisasi Menang Mutlak

Eksperimen ablasi pada Gemini 3.5 Flash mengungkap temuan kritis bagi insinyur harness:

• Injeksi Mentah Seluruh Graf (Full Graph Raw Injection): Meningkatkan performa pada dialog terstruktur (MultiChallenge naik dari 80.27% ke 86.60%), namun merusak tugas embodied fisik (ALFWorld anjlok dari 72.58% ke 70.34%).
• Generasi Seluruh Graf (Full Graph Generative): Mengakibatkan degradasi drastis pada ALFWorld (jatuh ke 54.48%) dengan ledakan konsumsi token hingga 3.4x lipat (96.360 vs 28.064 token) akibat hilangnya fokus operasional model.
• Generatif Subgraf Terlokalisasi (Localized Subgraph Generative): Meraih efisiensi optimal dan skor tertinggi di seluruh dimensi (ALFWorld 81.53%, GDPval 63.99) dengan konsumsi token yang terukur.

6. Blueprint Implementasi: Runtime Engine TypeScript

Berikut adalah arsitektur implementasi produksi runtime Procedural Guidance Engine lengkap dengan lokalisasi $h$-hop dan gerbang validasi offline yang dapat langsung diintegrasikan ke dalam harness agen otonom:

// Procedural Graph (PG) Engine & Inference Runtime Handler
// Berdasarkan Prinsip Arsitektur Riset Google Cloud AI Research (arXiv:2609.09153, September 2026)
// Struktur Triplet: G = (V, R, E, Phi) + Localized h-hop Generative Extraction

export type RelationType = 'PRECEDES' | 'LEADS_TO' | 'CONDITIONED_ON' | 'FALLBACK_TO' | 'VERIFIES';

export interface EdgeAttributes {
  condition: string; // Kapan transisi ini valid dieksekusi
  guidance: string;  // Petunjuk situasional cara bertindak
  pitfalls: string;  // Jebakan anti-pattern yang harus dihindari
}

export interface ProceduralNode {
  id: string;
  type: 'TOOL' | 'SKILL' | 'REASONING_STEP' | 'STATE_CHECK';
  name: string;
}

export interface ProceduralEdge {
  source: string;
  target: string;
  relation: RelationType;
  attributes: EdgeAttributes;
}

export interface ProceduralGraph {
  nodes: Map<string, ProceduralNode>;
  edges: ProceduralEdge[];
}

export interface TrajectoryStep {
  step: number;
  action: string;
  observation: string;
  status: 'SUCCESS' | 'FAILURE' | 'PENDING';
}

/**
 * 1. Online Inference: Localized Subgraph Extractor (h-hop neighborhood)
 * Mengisolasi simpul aktif dan subgraf 2-hop terarah guna mencegah context pollution.
 */
export class ProceduralGuidanceEngine {
  constructor(private graph: ProceduralGraph) {}

  public locateActiveNode(recentAction: string): string | null {
    for (const [id, node] of this.graph.nodes.entries()) {
      if (recentAction.toLowerCase().includes(node.name.toLowerCase())) {
        return id;
      }
    }
    return null;
  }

  public extractNHopNeighborhood(activeNodeId: string | null, hops: number = 2): ProceduralEdge[] {
    if (!activeNodeId || !this.graph.nodes.has(activeNodeId)) {
      // Fallback ke subgraf global jika pemetaan simpul tidak terdeteksi
      return this.graph.edges.slice(0, 10);
    }

    const visitedEdges = new Set<ProceduralEdge>();
    let currentFrontier = new Set<string>([activeNodeId]);

    for (let h = 0; h < hops; h++) {
      const nextFrontier = new Set<string>();
      for (const edge of this.graph.edges) {
        if (currentFrontier.has(edge.source)) {
          visitedEdges.add(edge);
          nextFrontier.add(edge.target);
        }
      }
      currentFrontier = nextFrontier;
    }

    return Array.from(visitedEdges);
  }

  public synthesizeSituationalGuidance(
    subgraph: ProceduralEdge[],
    taskQuery: string,
    history: TrajectoryStep[]
  ): string {
    if (subgraph.length === 0) {
      return 'Procedural State: Unconstrained standard exploration mode.';
    }

    const proceduralRules = subgraph.map((e, idx) => {
      const src = this.graph.nodes.get(e.source)?.name || e.source;
      const tgt = this.graph.nodes.get(e.target)?.name || e.target;
      return `[${idx + 1}] Transisi: (${src}) --[${e.relation}]--> (${tgt})\n     Kondisi : ${e.attributes.condition}\n     Panduan  : ${e.attributes.guidance}\n     Jebakan  : ${e.attributes.pitfalls}`;
    }).join('\n');

    return `=== PROCEDURAL GRAPH LOCAL GUIDANCE (h=2 HOPS) ===\nKonteks Kueri: "${taskQuery}"\nLangkah Terakhir: "${history[history.length - 1]?.action || 'START'}"\n\nAturan Urutan Prosedural yang Valid:\n${proceduralRules}\n======================================================`;
  }
}

/**
 * 2. Offline Self-Evolution Engine: Topology Refiner dengan Rejection Memory
 */
export interface GraphEditOperation {
  op: 'ADD_NODE' | 'ADD_EDGE' | 'DELETE_EDGE' | 'UPDATE_ATTRIBUTES';
  payload: any;
}

export class OfflineGraphRefiner {
  private rejectionMemory: Set<string> = new Set();

  public evaluateAndCommit(
    currentGraph: ProceduralGraph,
    candidateEdits: GraphEditOperation[],
    validationScore: number,
    baselineScore: number
  ): { committed: boolean; reason: string } {
    const editSignature = JSON.stringify(candidateEdits);

    // Cek apakah mutasi topologi pernah ditolak sebelumnya
    if (this.rejectionMemory.has(editSignature)) {
      return {
        committed: false,
        reason: 'Rejected: Topologi mutasi ini identik dengan kandidat yang gagal pada evaluasi sebelumnya.',
      };
    }

    // Gerbang Validasi: Komit jika skor validasi tidak mengalami degradasi
    if (validationScore >= baselineScore) {
      return {
        committed: true,
        reason: `Committed: Validasi stabil/meningkat (${validationScore.toFixed(2)} vs baseline ${baselineScore.toFixed(2)}).`,
      };
    }

    // Simpan ke memori penolakan untuk mencegah siklus proposal berulang
    this.rejectionMemory.add(editSignature);
    return {
      committed: false,
      reason: `Rejected: Penurunan performa (${validationScore.toFixed(2)} < ${baselineScore.toFixed(2)}). Disimpan ke Rejection Memory.`,
    };
  }
}

7. Panduan Implementasi Lapangan untuk Tim AI Engineering

Bagi arsitek sistem yang membangun platform autonomous multi-agent di skala enterprise, temuan riset ini menggarisbawahi 3 imperatif arsitektur mutlak:

1. Hentikan Ketergantungan pada Semantic Top-K Vector Retrieval untuk Prosedur: Vektor kemiripan kosinus tidak memahami dependensi kausal ("A harus selesai sebelum B dapat dipanggil"). Gunakan graf topologi terarah untuk mendefinisikan prasyarat alur kerja perkakas.
2. Terapkan Pembatasan Ruang Lingkup 2-Hop: Jangan pernah memasukkan seluruh SOP atau diagram alir ke dalam prompt agen saat mengeksekusi aksi. Berikan hanya tetangga terarah terdekat ($h=2$) guna menjaga atensi model tetap tajam.
3. Kunci Evolusi Graf dengan Rejection Memory: Saat mengimplementasikan loop self-improvement otomatis, wajib catat setiap usulan mutasi yang gagal meningkatkan skor validasi agar sistem tidak berulang kali terjebak dalam siklus degradasi yang sama.