Agent Flight Recorder (AFR) 2026: Arsitektur Tamper-Evident Audit Trail, 8 Bidang Semantik, dan On-Chain Anchoring untuk Autonomous Tool-Using AI Agents

Dalam lanskap rekayasa kecerdasan buatan terdistribusi tahun 2026, autonomous tool-using agents (seperti Claude Code, Hermes Agent, SWE-agent, dan micro-agent fleats) telah berevolusi dari sekadar asisten percakapan pasif menjadi entitas otonom yang memegang kredensial infrastruktur, mengeksekusi ribuan perintah sistem berkas, mengelola migrasi basis data, dan mendelegasikan tugas ke sub-agen lain. Namun, lompatan kapabilitas ini memicu krisis sistemik baru: ketiadaan jejak audit yang anti-pemalsuan (tamper-evident) dan dapat diverifikasi pihak ketiga tanpa kompromi kepercayaan (zero-trust non-repudiation).

1. Dari Observabilitas Menuju Auditabilitas Pembuktian Hukum: Anatomi Kegagalan Sekuensial Agen

Sebagian besar tim rekayasa perangkat lunak mengandalkan stack observabilitas standar (seperti OpenTelemetry, Datadog, atau file log JSON biasa) untuk memantau agen AI. Ketika sebuah coding agent menghapus basis data produksi karena injeksi prompt tak langsung (indirect prompt injection) atau salah sasaran lingkungan (environment mis-targeting), log teks biasa gagal menjawab tiga pertanyaan hukum dan forensik yang paling mendasar:

• Ketiadaan Jaminan Integritas & Mutabilitas Post-Compromise: Jika host agen atau kontainer disusupi oleh penyerang, berkas log teks di disk lokal dapat disunting (edit), dipotong (delete), atau ditukar urutannya (reorder) oleh penyerang tanpa meninggalkan bukti matematis pemalsuan.
• Ambiguitas Rekonstruksi Kausalitas & Provenance: Log teks tidak memisahkan antara rencana yang diusulkan model (intent), aturan pembatas yang memvalidasinya (policy evaluation), persetujuan manusia yang mengotorisasinya, dan observasi nyata yang dihasilkan oleh OS.
• Sengketa Lintas Organisasi (Cross-Organizational Disputes): Ketika Agen Organisasi A mendelegasikan tugas kritis ke Agen Organisasi B, dan terjadi kerusakan finansial atau kebocoran data, tidak ada pihak yang dapat dipercaya sebagai "tanah netral" (neutral ground) jika masing-masing pihak memegang log privat miliknya sendiri.

Gambar 1: Arsitektur Telemetri Kriptografis Agent Flight Recorder (AFR) — Intersepsi Tool Call, 8 Bidang Semantik, Merkle Batching, dan Jangkar Publik di EVM Layer-2.

2. Standar Skema 8 Bidang Semantik Aksi Kanonikal

AFR merumuskan sebuah aksi agen bukan sebagai string bebas, melainkan objek data tingkat pertama dengan 8 ikatan semantik yang mencakup seluruh siklus hidup dari niat hingga dampak:

Untuk mencegah inkonsistensi representasi floating-point, variasi normalisasi Unicode, dan pengurutan kunci yang acak pada JSON biasa, seluruh payload di-serialize menggunakan Deterministic CBOR (RFC 8949 §4.2) sebelum di-hash dengan SHA-256.

3. Konstruksi Kriptografis Tiga Lapis: Hash Chain, Merkle Batching, dan Epoch Chaining

Arsitektur integritas AFR dibangun melalui komposisi tiga lapis ortogonal yang saling melengkapi:

[Lapis 1: Rantai Hash Linier (Total Ordering)]
Event e_0 ──(H(e_0))──► Event e_1 ──(H(e_1))──► Event e_2 ──► ... ──► Event e_{N-1}
(Menjamin urutan total dan mendeteksi penukaran baris atau pemotongan di tengah log)

[Lapis 2: Merkle Tree Epoch Batching (Compact Proofs)]
Leaf_0 (e_0)    Leaf_1 (e_1)    Leaf_2 (e_2)    Leaf_3 (e_3) ... Leaf_{N-1}
     └─────┬─────┘                   └─────┬─────┘
         Parent_0                        Parent_1
             └───────────────┬───────────────┘
                       Merkle Root (M_t)
(Menghasilkan bukti inklusi O(log N) untuk audit satu aksi tanpa membocorkan seluruh log)

[Lapis 3: Epoch Root Chaining & On-Chain Anchoring (Gap Detection)]
R_t = H( M_t  ||  R_{t-1} )
      │
      └──────► SMART CONTRACT DI ETHEREUM L2 (Base Sepolia)
               recordAnchor(epoch_t, R_t, H(R_{t-1})) ──► 32-byte permanent anchor!

Pemisahan struktural penting dilakukan antara Event Record (metadata fixed-size, hash payload, pointer predecessor) dan Event Payload (konten data aktual yang berpotensi sensitif). Struktur integritas hanya beroperasi pada Event Record. Payload aktual disimpan secara terpisah dan dapat dienkripsi menggunakan kunci simetris per-event yang diturunkan via HKDF dari master secret epoch ($K_t$). Dengan demikian, saat audit selektif diperlukan, operator hanya membagikan satu kunci dekripsi untuk aksi yang dipersengketakan, tanpa membocorkan kerahasiaan aksi lain dalam sistem.

4. Implementasi Referensi Kernel: Agent Flight Recorder Engine

Berikut adalah implementasi referensi produksi kernel AgentFlightRecorderEngine dalam TypeScript modern yang mengimplementasikan 8 bidang semantik, hashing deterministik, dan epoch root chaining:

// Agent Flight Recorder (AFR) Core Cryptographic Runtime & Merkle Anchor Engine
// Berdasarkan Arsitektur IEEE BCCA 2026 / arXiv:2609.01931
// Menegakkan Total Event Ordering, 8 Bidang Semantik, Merkle Epoch Batching, & L2 Anchoring

import { createHash, createHmac } from 'node:crypto';

export interface AgentSemanticPayload {
  // 1. Intent: Tindakan terstruktur yang diusulkan model (tanpa CoT internal)
  intent: {
    toolName: string;
    toolArguments: Record;
  };
  // 2. Policy Evaluation: Hasil evaluasi guardrail runtime
  policyEvaluation: {
    ruleId: string;
    verdict: 'ALLOW' | 'DENY' | 'ESCALATE';
    policyVersion: string;
  };
  // 3. Human Approval: Otorisasi manusia jika diwajibkan
  humanApproval?: {
    approverId: string;
    approvalToken: string; // Cryptographic bearer token
    timestamp: number;
  };
  // 4. Execution: Perintah konkret yang dikirim ke executor runtime
  execution: {
    dispatchedCommand: string;
    rawParams: Record;
    dispatchedAt: number;
  };
  // 5. Effects: Efek samping nyata & observasi lingkungan
  effects: {
    exitCode: number;
    stateDeltaHash: string;
    stdoutSample?: string;
    errorMessage?: string;
  };
  // 6. Context Provenance: Hash konten dokumen/RAG & ID lingkungan
  contextProvenance: {
    retrievalSourceHashes: string[];
    upstreamToolCallHashes: string[];
    environment: 'development' | 'staging' | 'production';
  };
  // 7. Code Provenance: Hash biner agen, wrapper tools, & skill packages
  codeProvenance: {
    agentBinaryHash: string;
    toolWrapperHashes: Record;
    skillPackageHash: string;
  };
  // 8. Delegation Provenance: Rantai otorisasi multi-agen ("who asked whom")
  delegationProvenance?: {
    delegatingAgentId: string;
    parentEventHash: string;
    delegatedScopeToken: string; // Signed delegation claim
  };
}

export interface EventRecord {
  eventId: string;
  sequenceNumber: number;
  timestamp: number;
  concurrencyGroup?: string;
  payloadHash: string;
  previousHash: string; // Layer 1: SHA-256 Hash Chain
}

export interface EpochCommitment {
  epochNumber: number;
  merkleRoot: string;      // Mt
  epochRoot: string;        // Rt = H(Mt || Rt-1)
  previousEpochRoot: string;
  leafCount: number;
  anchoredTxHash?: string;
}

export class AgentFlightRecorderEngine {
  private lastEventHash: string = '0000000000000000000000000000000000000000000000000000000000000000';
  private sequenceCounter: number = 0;
  private currentEpochEvents: EventRecord[] = [];
  private currentEpochLeaves: string[] = [];
  private lastEpochRoot: string = '0000000000000000000000000000000000000000000000000000000000000000';
  private epochCounter: number = 0;

  constructor(private readonly epochBatchSize: number = 100) {}

  /**
   * Layer 1: Deterministic Serialization, Payload Hashing, & Hash Chaining
   */
  public recordEvent(payload: AgentSemanticPayload, concurrencyGroup?: string): {
    record: EventRecord;
    sealedEpoch?: EpochCommitment;
  } {
    this.sequenceCounter++;

    // Kanonikalisasi deterministik payload (RFC 8949 CBOR equivalent)
    const serializedPayload = JSON.stringify(payload, Object.keys(payload).sort());
    const payloadHash = createHash('sha256').update(serializedPayload).digest('hex');

    // Membentuk record event dengan total order hash-chaining
    const rawRecordToHash = `${this.sequenceCounter}:${payloadHash}:${this.lastEventHash}:${concurrencyGroup || ''}`;
    const eventHash = createHash('sha256').update(rawRecordToHash).digest('hex');

    const record: EventRecord = {
      eventId: `evt_${this.sequenceCounter}_${eventHash.slice(0, 10)}`,
      sequenceNumber: this.sequenceCounter,
      timestamp: Date.now(),
      concurrencyGroup,
      payloadHash,
      previousHash: this.lastEventHash,
    };

    this.lastEventHash = eventHash;
    this.currentEpochEvents.push(record);
    this.currentEpochLeaves.push(eventHash);

    // Layer 2: Periksa apakah batas epoch (Merkle batch) tercapai
    let sealedEpoch: EpochCommitment | undefined;
    if (this.currentEpochEvents.length >= this.epochBatchSize) {
      sealedEpoch = this.sealEpoch();
    }

    return { record, sealedEpoch };
  }

  /**
   * Layer 2: Merkle Tree Batching & Layer 3: Epoch Root Chaining
   */
  private sealEpoch(): EpochCommitment {
    this.epochCounter++;
    const merkleRoot = this.computeMerkleRoot(this.currentEpochLeaves);

    // Epoch Root Chaining: Rt = H(Mt || Rt-1)
    const epochRoot = createHash('sha256')
      .update(Buffer.concat([
        Buffer.from(merkleRoot, 'hex'),
        Buffer.from(this.lastEpochRoot, 'hex')
      ]))
      .digest('hex');

    const commitment: EpochCommitment = {
      epochNumber: this.epochCounter,
      merkleRoot,
      epochRoot,
      previousEpochRoot: this.lastEpochRoot,
      leafCount: this.currentEpochLeaves.length,
    };

    // Update state untuk epoch berikutnya
    this.lastEpochRoot = epochRoot;
    this.currentEpochEvents = [];
    this.currentEpochLeaves = [];

    return commitment;
  }

  private computeMerkleRoot(leaves: string[]): string {
    if (leaves.length === 0) return '0'.repeat(64);
    let level = [...leaves];

    while (level.length > 1) {
      const nextLevel: string[] = [];
      for (let i = 0; i < level.length; i += 2) {
        const left = level[i];
        const right = i + 1 < level.length ? level[i + 1] : left; // Duplikasi leaf ganjil
        const parent = createHash('sha256')
          .update(Buffer.concat([Buffer.from(left, 'hex'), Buffer.from(right, 'hex')]))
          .digest('hex');
        nextLevel.push(parent);
      }
      level = nextLevel;
    }

    return level[0];
  }
}

5. Analisis Ekonomi Anchoring: Mengapa Ethereum L2 Mengeliminasi Biaya Tanpa Mengorbankan Netralitas?

Salah satu kontribusi paling praktis dari paper ini adalah pemodelan biaya gas aktual pada testnet Base Sepolia melalui smart contract ringkas (~30 baris Solidity). Smart contract hanya menerima akar 32-byte ($R_t$) dan back-pointer hash ($H(R_{t-1})$) bersama nomor epoch.

Konsumsi gas rata-rata per pemanggilan fungsi anchor() adalah 91.800 gas (71.680 gas untuk cold-storage write pertama dan 91.976 gas untuk transaksi warm selanjutnya). Tabel berikut merinci perbandingan biaya antara Ethereum L1 (30 Gwei, ETH $2.500) dengan L2 Rollup (0.01 Gwei):

Dengan biaya hanya $2.30 per 100.000 event pada epoch default 100 event, anchoring ke L2 publik memungkinkan enterprise mana pun memiliki sistem akuntabilitas permanen dengan latensi kompromi hanya ~1.6 menit tanpa membebani neraca keuangan infrastruktur.

6. Evaluasi Empiris: Overhead Kinerja, Deteksi Serangan, dan Presisi Forensik

Evaluasi empiris dilakukan melalui 5 konfigurasi ablasi kumulatif: Baseline (JSON dumps tanpa integritas), Schema (CBOR terstruktur), Chain (+ Hash Chain), Merkle (+ Merkle Batching 100 event), dan Full (+ On-Chain Anchoring).

A. Overhead Waktu dan Penyimpanan (Per-Event Overhead)

Pada workload 10.000 tool calls di mesin Apple Silicon (16 GB RAM), konfigurasi Schema (CBOR) justru lebih cepat pada median dibanding JSON Baseline (6.0 μs vs 20.3 μs) karena encoding biner menghindari parsing rekursif nested dictionary Python. Seluruh stack integritas (Full) hanya menambahkan latensi median ~47.6 μs dan 512 bytes per event. Latensi ini berada jauh di bawah latensi I/O sistem operasi (yang berkisar 5–50 ms), menjadikannya nyaris tanpa beban (zero perceptual overhead) pada agen nyata.

B. Matriks Deteksi Tampering (Edit, Delete, Reorder, Fork)

Perhatikan temuan krusial pada tabel di atas: serangan Equivocation (Fork Attack)—di mana operator yang curang atau host yang disusupi menyajikan dua riwayat log berbeda yang sama-sama valid secara internal kepada dua pihak berbeda—mustahil dideteksi oleh Hash Chain maupun Merkle Tree lokal (0% deteksi). Hanya lapisan On-Chain Anchoring yang mampu membongkar serangan fork secara deterministik (100% deteksi), karena akar epoch yang telah ditambatkan di blockchain tidak dapat ditarik kembali atau digandakan.

C. Presisi Investigasi Forensik Multi-Step

Dalam skenario simulasi serangan injeksi prompt tidak langsung (Scenario A), pencarian log teks berbasis regex biasa (grep) menghasilkan presisi hanya 1.3% (0.013) pada evaluasi guardrail karena banyaknya string serupa yang tidak relevan. Pada pencarian rantai delegasi antar-agen, regex menghasilkan presisi hanya 7.7% (0.077). Sebaliknya, skema semantik terstruktur AFR menghasilkan presisi 1.0 (100%) dan recall 1.0 (100%) seketika pada seluruh kueri forensik.

7. Panduan Rekayasa & Cetak Biru Adopsi Industri

Bagi arsitek sistem yang mengoperasikan autonomous agents di lingkungan production berisiko tinggi (finansial, healthcare, otomasi DevOps), adopsi Agent Flight Recorder memberikan cetak biru standar:

1. Pisahkan Telemetri Audit dari Log Debugging: Jangan campur aduk rekaman audit berkekuatan hukum dengan trace debugging biasa. Audit trail wajib memiliki skema kanonikal, hashing deterministik, dan immutability.
2. Keluarkan Chain-of-Thought (CoT) dari Payload Terbuka: Simpan hanya niat terstruktur (structured intent) dan observasi nyata. Hal ini melindungi kekayaan intelektual (IP) prompt rekayasa dan mematuhi kepatuhan privasi (GDPR/EU AI Act Article 12).
3. Implementasikan Asynchronous L2 Epoch Anchoring: Gunakan batch size 100–500 event per epoch dan jalankan transaksi blockchain secara non-blocking di background worker untuk menjaga latensi nol pada eksekusi agen.
4. Tegakkan Token Delegasi Kriptografis: Pastikan pemanggilan sub-agen selalu menyertakan token delegasi bertanda tangan (signed scope claim) yang ditautkan ke hash event induk (parent event hash).