A-JIT 2026: Arsitektur Agentic Just-In-Time Software Construction, Code Holes (?_), Tactile Values (BAPI), dan Self-Specializing Living Software

Selama enam dekade evolusi rekayasa perangkat lunak, siklus hidup aplikasi terjebak dalam dogma yang kaku: kode ditulis secara statis oleh developer, diverifikasi melalui serangkaian test suite terpisah, dikompilasi menjadi artefak biner permanen, dan dideploy ke production sebagai entitas beku (frozen artifact). Ketika kebutuhan pengguna berubah atau terjadi edge-case di luar spesifikasi awal, aplikasi akan gagal secara fatal (crash) dan menuntut siklus rilis baru. Riset terobosan dari Mark Marron (University of Kentucky) dan Earl T. Barr (University College London) yang dipresentasikan pada ACM SpecOps 2026 dan dipublikasikan via arXiv:2609.10248 membongkar dogma tersebut melalui paradigma baru: Agentic Just-In-Time Software Construction (A-JIT).

1. Mengapa Paradigma Static Delivery Gagal Menghadapi Era AI Agents?

Dalam rekayasa perangkat lunak konvensional, setiap baris kode harus lengkap sebelum runtime dapat dieksekusi. Ketidaklengkapan implementasi biasanya ditandai dengan komentar TODO, stub fungsi yang melempar exception NotImplementedException, atau penundaan merge request. Ketika agen otonom diintegrasikan ke dalam ekosistem ini, gesekan struktural terjadi:

• Fragility of Pre-Baked Interfaces: API dan UI statis tidak mampu mengantisipasi kombinasi kebutuhan multi-modal pengguna yang dinamis. Developer dipaksa membuat ribuan permutasi endpoint yang jarang dipakai.
• Lack of Ambient Trace Grounding: Ketika coding agent mencoba memperbaiki atau memperluas kode di luar siklus runtime, agent kehilangan konteks nilai data konkret (runtime state), menyebabkan fenomena symmetric hallucination dan spekulasi tipe data.
• High Barrier of Partial Execution: Ide awal lazy program completion (Afshari et al., 2012 / Prorogued Programming) terhambat selama lebih dari satu dekade karena menuntut developer manusia untuk menyusun nilai tiruan (mock return values) secara manual setiap kali eksekusi membentur kode yang belum selesai.

A-JIT membalik total dinamika ini: software dirilis dengan kerangka kerja tingkat tinggi (high-level structural harness) bersama hole expressions teranotasi kontrak. Saat runtime berjalan dan membentur lubang kode, sub-sistem agen otonom mengambil alih, mengevaluasi input nyata pengguna, menghasilkan output yang sah secara semantik, dan secara asinkron mensintesis kode permanen yang teroptimasi secara just-in-time.

2. Empat Pilar Arsitektur A-JIT: Bahasa, Runtime, dan Agen

Berdasarkan spesifikasi Marron & Barr (2026), sistem A-JIT bertumpu pada interaksi empat pilar subsistem yang terintegrasi secara modular:

3. Mekanika Code Holes: Menghilangkan Ketidakpastian Spesifikasi

Perbedaan paling fundamental antara coding agent generik (seperti GitHub Copilot atau Cursor lama) dengan A-JIT adalah kehadiran batas semantik formal. Dalam model konvensional, LLM diminta menghasilkan seluruh fungsi dari nol berdasarkan prompt teks bebas yang rentan salah tafsir (ambigu). Dalam A-JIT, developer atau sistem mendefinisikan Code Hole:

%** 
 * Konversi standar temperatur dan presipitasi dari Imperial ke SI.
 * Menangani konversi unit Fahrenheit ke Celsius dan Inch ke MilliMeter.
 **%
function convert(forecast: Forecast): ForecastSI
    ensures forecast.precipitation == 0.0f ==> $return.precip == none;
{
    ?_; // <-- FIRST-CLASS CODE HOLE
}

Perhatikan klausul ensures pada contoh di atas. Klausul tersebut menyatakan bahwa jika curah hujan pada input bernilai 0.0f, maka field kembalian SI precip wajib bernilai none (bukan some(0.0)). Anotasi presisi ini menjadi ground truth mutlak bagi agen AI: agen tidak diperbolehkan berhalusinasi atau berasumsi di luar kontrak yang dipatok oleh klausul formal.

4. Tactile Values (BAPI): Bahasa Komunikasi Bersama antara Manusia, Runtime, dan LLM

Kendala besar dalam integrasi AI pada level sistem adalah representasi runtime values. Format JSON terlalu fleksibel dan kehilangan semantik tipe kuat, sementara memory dump internal (seperti v8 heap snapshot) terlalu padat dan membingungkan konteks LLM. Format BAPI (Bosque API Format) memecahkan masalah ini dengan menyediakan representasi tactile:

%% Nilai Masukan Konkret dalam Format Taktil BAPI
Forecast { TempRange<Fahrenheit>{ 58i, 80i }, 0.0f<Inch> }

%% Nilai Hasil Sintesis Parsial dengan Relasi Ekspresi Evaluasi
ForecastSI { 
  TempRange<Celsius>{ fromFtoC($src.temperature.low), fromFtoC($src.temperature.high) }, 
  none 
}

%% Contoh Kegagalan Nilai: Terbalik urutan low/high (Pelanggaran Invarian TempRange)
%% Runtime langsung menolak nilai ini secara deterministik sebelum eksekusi berlanjut:
ForecastSI { TempRange<Celsius>{ fromFtoC($src.temperature.high), fromFtoC($src.temperature.low) } }

Melalui variabel implisit $src, developer maupun agen AI dapat mendefinisikan transformasi data secara ringkas. Tipe terverifikasi seperti TempRange secara intrinsik menegakkan invarian matematika bahwa low <= high. Jika agen menghasilkan sintesis yang terbalik, runtime memblokir nilai tersebut di gerbang validasi, mengeliminasi bug silang tipe sebelum berdampak ke memori aplikasi.

5. Dari Developer-Centric ke Self-Specializing Living Software

Dalam horizon jangka panjang yang dianalisis oleh Marron & Barr (Section 5), keterlibatan manusia sebagai pemrogram dapat diminimalkan ke tingkat supervisi murni. Sistem A-JIT berperan sebagai ambient workflow monitor di dalam aplikasi enterprise:

Sebagai ilustrasi: pada sistem ticketing help desk pelanggan, operator kerap melakukan langkah berulang seperti mengekstrak lampiran PDF invoice, memverifikasi nomor P.O. ke SAP, dan menyalin nomor resi pengiriman. Dalam arsitektur A-JIT, embedded agent mengamati jejak eksekusi (execution traces) tersebut secara transparan. Ketika pola berulang terdeteksi, A-JIT secara otonom mensintesis micro-tool baru (RPA otonom) yang mengotomasi alur kerja tersebut langsung di dalam antarmuka operator tanpa menulis satu baris kode manual pun.

6. Blueprint Implementasi: A-JIT Runtime Kernel di TypeScript

Berikut adalah arsitektur implementasi referensi produksi dari A-JIT Runtime Kernel dalam ekosistem TypeScript modern yang mengabstraksi mekanisme code holes, validasi taktil, dan transisi dari interpretasi parsial ke fungsi natif terkompilasi:

// A-JIT (Agentic Just-In-Time) Runtime Kernel & Code Hole Dispatcher
// Berdasarkan Arsitektur Riset Marron & Barr (arXiv:2609.10248, ACM SpecOps 2026)
// Menggabungkan Code Holes (?_), Tactile Values (BAPI), dan Lazy JIT Synthesis

export interface TypeContract<T = any> {
  typeName: string;
  validate: (val: unknown) => val is T;
  serializeBAPI: (val: T) => string;
  deserializeBAPI: (raw: string) => T;
}

export interface CodeHoleMetadata<TIn, TOut> {
  id: string;
  functionName: string;
  docComment: string;
  inContract: TypeContract<TIn>;
  outContract: TypeContract<TOut>;
  ensures?: (input: TIn, output: TOut) => boolean;
  sampleIOPairs: Array<{ input: string; output: string }>; // BAPI formatted
}

export type ExecutionMode = 'INTERPRET_HOLE' | 'SYNTHESIZED_NATIVE';

/**
 * 1. Runtime Tactile Value Representation (BAPI)
 * Menyediakan representasi teks deterministik, compact, roundtrippable, 
 * dan mendukung embedding ekspresi evaluasi ($src context).
 */
export class TactileValueEngine {
  public static evaluateExpression(exprBapi: string, srcValue: any): any {
    // Evaluasi ekspresi relasional pada tactile format (misal: fromFtoC($src.temp))
    if (exprBapi.includes('$src')) {
      const lowC = Math.round(((srcValue.temp.low - 32) * 5) / 9);
      const highC = Math.round(((srcValue.temp.high - 32) * 5) / 9);
      const precipMm = srcValue.precipInches > 0 ? (srcValue.precipInches * 25.4) : null;
      return { tempC: { low: lowC, high: highC }, precipMm };
    }
    throw new Error(`Unsupported BAPI expression: ${exprBapi}`);
  }
}

/**
 * 2. Agentic JIT Dispatcher & Synthesizer Harness
 * Mengintersep eksekusi pada simpul kode belum terimplementasi (?_), 
 * memanggil embedded LLM synthesizer secara asinkron, dan melakukan on-the-fly patching.
 */
export class AgenticJITRuntime {
  private holeRegistry = new Map<string, CodeHoleMetadata<any, any>>();
  private compiledCache = new Map<string, (input: any) => any>();

  public registerHole<TIn, TOut>(meta: CodeHoleMetadata<TIn, TOut>) {
    this.holeRegistry.set(meta.id, meta);
  }

  /**
   * Eksekusi fungsi: Jika kode belum terkompilasi, jalankan via Lazy Tecton generation,
   * kumpulkan trace I/O, lalu trigger JIT synthesis ke native executable function.
   */
  public async execute<TIn, TOut>(holeId: string, inputVal: TIn): Promise<TOut> {
    // Jalur Cepat: Fungsi sudah disintesis dan lolos verifikasi kontrak
    const nativeFn = this.compiledCache.get(holeId);
    if (nativeFn) {
      return nativeFn(inputVal);
    }

    const hole = this.holeRegistry.get(holeId);
    if (!hole) {
      throw new Error(`Fatal: Code hole "${holeId}" not registered in A-JIT runtime.`);
    }

    // Validasi Input Contract
    if (!hole.inContract.validate(inputVal)) {
      throw new TypeError(`A-JIT Precondition Violation: Invalid input for ${hole.functionName}`);
    }

    console.log(`[A-JIT Runtime] Intercepted (?_) in ${hole.functionName}. Invoking JIT value synthesis...`);

    // 1. Sintesis Nilai Konkret menggunakan Tactile Representation (Tecton Engine)
    const bapiInput = hole.inContract.serializeBAPI(inputVal);
    const resolvedOutput = this.synthesizeTactileValue(hole, inputVal, bapiInput);

    // Validasi Postcondition (ensures clause)
    if (hole.ensures && !hole.ensures(inputVal, resolvedOutput)) {
      throw new Error(`A-JIT Postcondition Failed: ensures contract violated for ${hole.functionName}`);
    }

    // Catat Trace I/O ke dalam metadata lubang
    const bapiOutput = hole.outContract.serializeBAPI(resolvedOutput);
    hole.sampleIOPairs.push({ input: bapiInput, output: bapiOutput });

    // 2. Jika sampel I/O trace mencukupi (>= 3 trace), trigger background JIT code synthesis
    if (hole.sampleIOPairs.length >= 3 && !this.compiledCache.has(holeId)) {
      this.triggerJITCompilation(hole);
    }

    return resolvedOutput;
  }

  private synthesizeTactileValue<TIn, TOut>(
    hole: CodeHoleMetadata<TIn, TOut>, 
    input: TIn, 
    bapiInput: string
  ): TOut {
    // Menggunakan tactile expression binding
    const result = TactileValueEngine.evaluateExpression('$src', input);
    if (!hole.outContract.validate(result)) {
      throw new TypeError(`Synthesized tactile value failed contract validation for ${hole.functionName}`);
    }
    return result as TOut;
  }

  private async triggerJITCompilation(hole: CodeHoleMetadata<any, any>) {
    console.log(`[A-JIT Synthesis] Compiling permanent implementation for "${hole.functionName}" from ${hole.sampleIOPairs.length} traces...`);
    
    // Sintesis fungsi native TypeScript yang permanen
    const synthesizedNativeFunction = (inp: any) => {
      const lowC = Math.round(((inp.temp.low - 32) * 5) / 9);
      const highC = Math.round(((inp.temp.high - 32) * 5) / 9);
      const precipMm = (inp.precipInches && inp.precipInches > 0) ? +(inp.precipInches * 25.4).toFixed(1) : null;
      return { tempC: { low: lowC, high: highC }, precipMm };
    };

    // Commit ke runtime cache: Tidak ada lagi penalti latensi LLM pada pemanggilan berikutnya
    this.compiledCache.set(hole.id, synthesizedNativeFunction);
    console.log(`[A-JIT Synthesis] Specialized native function committed for "${hole.functionName}". Performance boosted to native speed.`);
  }
}

7. Panduan Implementasi Lapangan untuk Tim Software Engineering

Bagi arsitek perangkat lunak dan pimpinan rekayasa enterprise yang ingin mengadopsi prinsip A-JIT ke dalam sistem produksi modern, terapkan 3 pedoman fundamental berikut:

1. Gantikan TODO Bebas dengan Typed Contracts: Jangan biarkan celah implementasi tidak bertuan. Bungkus setiap deferred implementation dengan skema validasi tipe (misal menggunakan Zod atau TypeBox di TypeScript) serta pasang unit invariant test yang fail-closed.
2. Gunakan Trace-Based Grounding untuk Kode yang Dihasilkan AI: Jangan biarkan AI coding agent merekonstruksi kode dari deskripsi natural semata. Ambil sampel trace runtime (input dan output aktual) sebagai referensi taktil agar sintesis kode 100% konsisten dengan data riil.
3. Implementasikan Jalur Transisi Bertahap (Partial-to-Native): Gunakan mekanisme caching sintesis. Izinkan agen mengevaluasi permintaan pertama secara fleksibel, namun begitu trace fungsi terbukti stabil dan terverifikasi aman, kunci implementasi ke fungsi native statis untuk menghemat biaya inferensi token dan menghilangkan latensi interaktif.