Perspektif Arsitek: Your AI Model Isn't Dumb, Your Harness Is — Apa Maknanya Bagi Masa Depan Engineering?

Your AI Model Isn't Dumb, Your Harness Is Broken: How Harness Engineering Bridges the Enterprise Information Gap — How Does It Work in Production?

Ringkasan: Masalah utama dari AI coding agent yang sering gagal di production bukanlah karena LLM-nya kurang pintar, melainkan karena ketiadaan struktur environment yang memandu, membatasi, dan memverifikasi tindakannya. Dengan beralih dari sekadar Prompt Engineering menuju Harness Engineering—di mana Agent = Model + Harness—perusahaan dapat menjembatani information gap, mengubah chatbot yang tidak terprediksi menjadi sistem otonom yang deterministik dan mampu mengoreksi dirinya sendiri.

Tahun 2026 membawa kita pada era di mana model AI memiliki kemampuan penalaran yang luar biasa. Kita memiliki model frontier seperti Gemini 4 Argon dan Gemini 3.1 Pro Preview yang mampu memproses jutaan token konteks dalam hitungan detik. Namun, di banyak enterprise, keluhan yang terdengar di lorong-lorong tim engineering masih sama: "Kami sudah upgrade ke model paling mahal, tapi agent-nya masih sering merusak build, berhalusinasi memanggil library yang tidak ada, atau terjebak dalam infinite loop saat melakukan debugging."

Reaksi instan dari sebagian besar engineering leader adalah menyalahkan modelnya. Mereka berasumsi bahwa LLM tersebut masih "kurang pintar" untuk memahami kompleksitas arsitektur microservices mereka yang sudah berusia puluhan tahun. Mereka terus menunggu model generasi berikutnya, berharap bahwa kecerdasan mentah (raw intelligence) akan secara ajaib menyelesaikan masalah integrasi sistem.

Namun, akar masalahnya sama sekali bukan pada kecerdasan model. Masalahnya terletak pada information gap—kesenjangan antara apa yang diketahui oleh model secara umum dari data pelatihannya, dan konteks spesifik, implisit, serta aturan main yang berlaku di dalam codebase enterprise Anda. Model AI Anda tidak bodoh; harness Anda yang rusak.

Dalam catatan studi dan hands-on tutorial yang saya (Doddi) susun mengenai History of Harness Engineering & Bridging the Information Gap, saya menemukan sebuah pola yang konsisten: tim yang berhasil mengadopsi AI secara masif tidak menghabiskan waktu mereka untuk melakukan prompt tweaking tanpa henti. Sebaliknya, mereka membangun sistem scaffolding di sekeliling model tersebut. Mereka berhenti memperlakukan AI sebagai chatbot ajaib dan mulai memperlakukannya sebagai komponen komputasi yang membutuhkan environment yang sangat terstruktur.

Evolusi Interaksi: Dari Chatbot Menuju Otonomi Terstruktur

Untuk memahami bagaimana kita sampai pada konsep Harness Engineering, kita harus melihat kembali bagaimana cara engineer berinteraksi dengan AI. Perjalanan ini sangat tergambar jelas dalam esai Mitchell Hashimoto tentang AI Adoption Journey-nya. Hashimoto menguraikan bahwa adopsi tool yang bermakna selalu melewati fase inefisiensi, fase kecukupan (adequacy), hingga akhirnya mencapai penemuan yang mengubah alur kerja secara drastis.

Langkah pertama yang paling krusial, menurut Hashimoto, adalah Drop the Chatbot. Berhenti mencoba melakukan pekerjaan engineering yang bermakna melalui antarmuka chat web standar. Chatbot sangat tidak efisien untuk proyek brownfield (sistem warisan yang sudah berjalan) karena Anda hanya bisa berharap model tersebut memberikan hasil yang benar berdasarkan pelatihan masa lalunya. Mengoreksi chatbot membutuhkan manusia untuk terus-menerus melakukan copy-paste kode dan output terminal, memberi tahu model bahwa ia salah berulang kali. Ini adalah inefisiensi murni. Nilai sebenarnya hanya bisa ditemukan ketika kita menggunakan agent—sebuah LLM yang dapat berinteraksi dan memanggil eksekusi eksternal (membaca file, menjalankan program, melakukan HTTP request) dalam sebuah loop.

Namun, sekadar menggunakan agent tidak langsung menyelesaikan masalah. Hashimoto menceritakan fase di mana ia memaksa dirinya untuk Reproduce Your Own Work. Ia melakukan pekerjaan secara manual, lalu memaksa agent untuk menghasilkan hasil yang identik tanpa melihat solusi manualnya. Proses ini sangat menyiksa pada awalnya, tetapi dari sinilah keahlian terbentuk. Ia belajar bahwa sesi agent harus dipecah menjadi tugas-tugas yang jelas dan dapat ditindaklanjuti. Jangan meminta agent untuk "menggambar burung hantu" dalam satu sesi mega. Pisahkan sesi perencanaan (planning) dari sesi eksekusi. Dan yang paling penting: jika Anda memberi agent cara untuk memverifikasi pekerjaannya sendiri, ia akan lebih sering memperbaiki kesalahannya sendiri dan mencegah regresi.

Setelah memahami batasan ini, Hashimoto mulai menerapkan End-of-Day Agents. Ia memblokir 30 menit terakhir setiap hari kerja untuk menjalankan agent secara paralel guna melakukan riset mendalam, mengeksplorasi ide-ide ambigu, atau melakukan triase issue dan Pull Request menggunakan GitHub CLI. Agent ini tidak diizinkan untuk merespons langsung ke publik; mereka hanya menghasilkan laporan untuk dibaca keesokan paginya, memberikan warm start yang luar biasa. Puncaknya adalah fase Outsource the Slam Dunks, di mana tugas-tugas yang sudah pasti bisa diselesaikan dengan baik oleh agent sepenuhnya didelegasikan, sementara engineer manusia fokus pada arsitektur tingkat tinggi.

Perjalanan Hashimoto ini adalah representasi sempurna dari pergeseran industri: dari Prompt Engineering (merekayasa kata-kata), menuju Context Engineering (memberikan dokumen via RAG), dan kini bermuara pada Harness Engineering.

Seperti yang didefinisikan dengan sangat presisi oleh Birgitta Böckeler dari Thoughtworks dalam artikelnya mengenai Harness Engineering, persamaan modern untuk sistem AI adalah: Agent = Model + Harness. Harness adalah segala sesuatu di dalam agent kecuali model itu sendiri. Ini mencakup system prompt, mekanisme retrieval kode, sistem orkestrasi, hingga outer harness yang kita bangun khusus untuk use case dan sistem kita. Tujuan dari harness yang dibangun dengan baik ada dua: meningkatkan probabilitas agent melakukan hal yang benar pada percobaan pertama, dan menyediakan feedback loop yang mengoreksi masalah secara mandiri sebelum kode tersebut mencapai mata manusia.

Jebakan Context Window dan Sindrom "Amnesiac Engineer"

Meskipun kita sudah menggunakan agent, tantangan baru muncul ketika kita meminta agent untuk mengerjakan tugas yang memakan waktu berjam-jam atau berhari-hari. Mengapa agent yang berjalan lama (long-running agents) sering gagal?

Penelitian mendalam dari Anthropic mengenai effective harnesses for long-running agents mengungkap inti masalahnya. Tantangan utama dari long-running agents adalah mereka harus bekerja dalam sesi-sesi yang terpisah (discrete sessions), dan setiap sesi baru dimulai tanpa ingatan tentang apa yang terjadi sebelumnya. Bayangkan sebuah proyek perangkat lunak yang dikerjakan oleh engineer yang bekerja dalam sistem shift, di mana setiap engineer baru tiba di meja kerja tanpa ingatan sama sekali tentang apa yang terjadi pada shift sebelumnya. Ini adalah sindrom "amnesiac engineer".

Meskipun model modern memiliki fitur context compaction (pemadatan konteks) untuk mencegah kehabisan context window, kompresi ini tidak selalu meneruskan instruksi yang sangat jelas ke instansiasi agent berikutnya. Anthropic menemukan dua pola kegagalan utama ketika agent dibiarkan berjalan tanpa harness yang tepat:

1. Mencoba melakukan "One-Shot" pada seluruh aplikasi: Agent cenderung mencoba melakukan terlalu banyak hal sekaligus. Hal ini sering menyebabkan model kehabisan konteks di tengah-tengah implementasi, meninggalkan sesi berikutnya dengan fitur yang baru setengah jadi dan tidak terdokumentasi. Agent berikutnya harus menebak-nebak apa yang terjadi dan membuang banyak token (dan biaya) hanya untuk membuat aplikasi dasar kembali berjalan.
2. Penyelesaian Prematur (Premature Completion): Setelah beberapa fitur dibangun, instansiasi agent berikutnya akan melihat sekeliling, melihat bahwa ada kemajuan yang telah dicapai, dan secara prematur mendeklarasikan bahwa seluruh proyek telah selesai, padahal masih banyak edge cases yang belum ditangani.

Selain itu, ada masalah pengujian. Tanpa prompting yang eksplisit, agent cenderung membuat perubahan kode, mungkin menjalankan unit test atau perintah curl, tetapi gagal menyadari bahwa fitur tersebut tidak berfungsi secara end-to-end dari perspektif pengguna.

Inilah information gap yang sebenarnya. Model memiliki pengetahuan sintaksis yang sempurna, tetapi ia kehilangan orientasi state (state orientation) di tengah eksekusi yang panjang.

Membangun Harness 6-Lapis yang Self-Verifying

Untuk menjembatani kesenjangan ini, kita tidak bisa hanya mengandalkan model yang lebih besar. Kita harus merekayasa harness yang memaksa model untuk bekerja secara inkremental, deterministik, dan dapat diverifikasi. Solusinya adalah arsitektur harness berlapis yang menggabungkan temuan dari Anthropic dan Thoughtworks.

1. Pemisahan Peran: Initializer Agent dan Coding Agent

Anthropic mengusulkan solusi dua bagian yang sangat elegan. Daripada menggunakan satu prompt raksasa untuk seluruh siklus hidup, kita membaginya:

• Initializer Agent: Sesi agent pertama menggunakan prompt khusus yang menugaskan model untuk menyiapkan environment awal. Ia membuat skrip init.sh, file claude-progress.txt (atau agent-progress.txt) yang menyimpan log tindakan, dan melakukan git commit awal. Yang paling penting, Initializer Agent diminta untuk menulis daftar kebutuhan fitur yang komprehensif dalam format JSON. Mengapa JSON? Karena LLM jauh lebih kecil kemungkinannya untuk secara tidak sengaja mengubah atau menimpa struktur file JSON dibandingkan dengan file Markdown. Semua fitur diinisialisasi dengan status "passes": false.
• Coding Agent: Setiap sesi berikutnya adalah Coding Agent yang ditugaskan hanya untuk membuat kemajuan inkremental pada satu fitur pada satu waktu. Ia dilarang keras menghapus tes, dan hanya diizinkan mengubah status "passes" menjadi true setelah fitur benar-benar selesai. Ia harus meninggalkan environment dalam keadaan bersih (clean state) di akhir sesi dengan pesan commit Git yang deskriptif, memungkinkan agent berikutnya untuk menggunakan Git guna membatalkan perubahan kode yang buruk jika diperlukan.

2. Feedforward (Guides) dan Feedback (Sensors)

Di dalam loop Coding Agent tersebut, kita menerapkan konsep Steering Loop dari Thoughtworks. Birgitta Böckeler membaginya menjadi dua mekanisme kontrol:

• Guides (Feedforward): Mengantisipasi perilaku agent dan mengarahkannya sebelum ia bertindak. Ini meningkatkan probabilitas hasil yang baik pada percobaan pertama.
  • Computational Guides: Deterministik dan sangat cepat (dijalankan oleh CPU). Contoh: tool modifikasi kode dengan resep OpenRewrite, atau linter yang memaksa konvensi coding perusahaan.
  • Inferential Guides: Berbasis semantik (dijalankan oleh GPU/NPU). Contoh: File AGENTS.md yang berisi instruksi spesifik tentang arsitektur sistem yang dibaca oleh LLM sebelum ia mulai menulis kode.
• Sensors (Feedback): Mengamati setelah agent bertindak dan membantunya mengoreksi diri. Ini sangat kuat ketika sensor menghasilkan sinyal yang dioptimalkan untuk konsumsi LLM (seperti pesan error linter kustom yang menyertakan instruksi perbaikan—sebuah bentuk prompt injection yang positif).
  • Computational Sensors: Murah dan cepat. Contoh: Pre-commit hook yang menjalankan tes ArchUnit untuk memeriksa pelanggaran batas modul. Dijalankan dalam hitungan milidetik.
  • Inferential Sensors: Menggunakan "LLM as a judge". Contoh: Menggunakan model yang lebih kecil dan cepat untuk mereview kode yang baru saja ditulis oleh Coding Agent utama, memastikan kode tersebut memenuhi standar semantik sebelum di-commit.

Prinsip utamanya adalah "Keep quality left". Sama seperti dalam Continuous Delivery di mana kita ingin menemukan bug sedini mungkin, dalam Harness Engineering, kita mendistribusikan sensor umpan balik di seluruh siklus hidup. Sensor komputasional yang cepat dijalankan bahkan sebelum commit dibuat.

Use Case Nyata di Lapangan: Ide Implementasi Praktis

Bagaimana arsitektur harness ini mengubah cara enterprise beroperasi di dunia nyata? Google telah membuktikan hal ini melalui ekosistem Antigravity mereka. Dengan merilis Gemini 4 Argon di Google Antigravity (model frontier untuk penalaran kompleks) dan Gemini 3.8 Flash di Google Antigravity (model workhorse harian yang sangat cepat dan murah), Google menciptakan agent-first experience yang sesungguhnya.

Di internal Alphabet, lebih dari 100.000 pengguna mengandalkan Argon di dalam Antigravity setiap bulannya. Hasilnya? Peningkatan 35% dalam kode yang dihasilkan oleh agent, dan yang lebih penting, penurunan 30% dalam post-submit rollbacks. Ini membuktikan bahwa harness yang baik tidak hanya meningkatkan kecepatan, tetapi juga kualitas.

Berikut adalah 4 use case nyata di lapangan yang menunjukkan bagaimana Harness Engineering memindahkan jarum produktivitas:

1. Migrasi Codebase & Sistem Legacy (Fortran ke Rust)

• The Everyday Problem: Perusahaan memiliki sistem inti (seperti riset ilmiah atau sistem perbankan core) yang terkunci di dalam codebase legacy yang rapuh seperti Fortran atau COBOL. Engineer modern takut menyentuhnya, dan rewrite manual memakan waktu bertahun-tahun dengan risiko kegagalan yang masif.
• How It Works in Practice: Menggunakan custom skill di dalam Antigravity, tim mengerahkan Initializer Agent (Gemini 4 Argon) untuk memetakan seluruh arsitektur Fortran dan membuat daftar fitur JSON yang komprehensif. Kemudian, Coding Agent berjalan secara inkremental, menerjemahkan modul demi modul ke dalam Rust modern. Computational sensors (kompiler Rust) memberikan feedback loop instan mengenai memory safety, sementara inferential sensors memastikan logika bisnis tetap ekuivalen.
• The Tangible Impact: Agent secara otonom mengirimkan codebase yang telah dimodernisasi, mencapai peningkatan performa 1.8x lipat dan jaminan memory safety, memberikan fondasi yang kuat untuk inovasi masa depan tanpa downtime yang berarti.

2. Technical Debt & Backlog Burndown

• The Everyday Problem: Tim engineering tenggelam dalam ratusan laporan bug yang menua (stale bugs). Tidak ada yang tahu mana bug yang masih relevan, mana yang sudah diperbaiki secara tidak sengaja oleh commit lain, dan mana yang merupakan duplikat.
• How It Works in Practice: Agent Antigravity yang ditenagai Argon mengambil antrean 134 laporan bug terbuka. Agent ini menggunakan harness yang memungkinkannya melakukan referensi silang (cross-referencing) terhadap riwayat commit, memeriksa apakah kandidat perbaikan benar-benar mencapai production, dan menginspeksi telemetri langsung (log) untuk melihat apakah error tersebut masih terjadi.
• The Tangible Impact: Dalam waktu kurang dari 3 jam, agent menutup 97 bug yang sudah basi atau duplikat dengan bukti commit yang terdokumentasi (pengurangan antrean sebesar 72,4%). Sisa 37 tiket disortir berdasarkan pemilik, menghilangkan tiket yang tidak memiliki assignee.

3. Automated Security Audits (Runtime Tracing)

• The Everyday Problem: Reviewer manusia dan tool analisis statis tradisional sering kali melewatkan celah keamanan logika bisnis karena mereka hanya membaca code diff (perbedaan kode) secara terisolasi, tanpa memahami bagaimana data mengalir saat aplikasi berjalan.
• How It Works in Practice: Argon di dalam Antigravity digunakan untuk mengaudit sekumpulan perubahan kontrol akses (access-control). Alih-alih hanya membaca diff, harness memungkinkan Argon untuk melacak bagaimana izin (permissions) benar-benar mengalir pada saat runtime. Agent menyimulasikan eksekusi payload dan mengevaluasi state akhir.
• The Tangible Impact: Argon menemukan empat bug keamanan kritis yang tersembunyi. Sebagai perbandingan, dua model frontier generasi sebelumnya yang mengaudit kode identik (tanpa harness runtime tracing ini) menyimpulkan bahwa tidak ada celah keamanan sama sekali.

4. Optimasi Infrastruktur & FinOps (YouTube Comment Optimization)

• The Everyday Problem: Layanan frontend mengonsumsi terlalu banyak CPU, menyebabkan latensi tinggi bagi pengguna dan tagihan cloud yang membengkak, tetapi menemukan bottleneck di jutaan baris kode ibarat mencari jarum di tumpukan jerami.
• How It Works in Practice: Argon menelusuri data profil production dari frontend komentar YouTube. Dengan harness yang mampu membaca metrik performa, Argon mengidentifikasi bahwa rendering emoji yang redundan menyumbang hampir 45% dari beban server. Agent kemudian mengusulkan dan mengimplementasikan 12 optimasi yang ditargetkan secara inkremental.
• The Tangible Impact: Jejak CPU (CPU footprint) berkurang hingga setengahnya. Pembaruan ini mengurangi latensi pemuatan komentar di server sebesar 30 ms dan menurunkan latensi end-to-end di sisi klien sebesar 20 ms.

Arsitektur & Implementasi Produksi

Untuk memvisualisasikan bagaimana Harness Engineering beroperasi, mari kita lihat topologi arsitekturnya. Alih-alih loop sederhana antara User dan LLM, kita memiliki sistem terdistribusi yang mengelola state dan verifikasi.

flowchart LR
    subgraph HarnessEngineeringPipeline["Harness Engineering Pipeline"]
        A[User Prompt] --> B(Initializer Agent<br/>Gemini 4 Argon)
        B --> C[(State Management<br/>JSON Feature List & init.sh)]
        C --> D{Coding Agent<br/>Gemini 4 Argon}
        
        D -->|Writes Code| E[Computational Sensors<br/>Linters, ArchUnit, Tests]
        E -->|Fails| D
        E -->|Passes| F[Inferential Sensors<br/>Gemini 3.8 Flash as Judge]
        
        F -->|Semantic Flaw| D
        F -->|Approved| G[Browser Automation<br/>Puppeteer MCP]
        
        G -->|End-to-End Fails| D
        G -->|Success| H[Git Commit & Update JSON]
        H -->|Next Feature| D
    end
    
    style B fill:#e8f0fe,stroke:#1a73e8
    style D fill:#e8f0fe,stroke:#1a73e8
    style F fill:#fce8e6,stroke:#d93025
    style C fill:#e6f4ea,stroke:#1e8e3e

Implementasi Kode: Antigravity CLI (agy) Harness Pattern

Berikut adalah contoh realistis bagaimana pola ini diimplementasikan menggunakan Python dan Antigravity SDK untuk membangun custom harness yang mengatur Initializer dan Coding Agent.

import json
import subprocess
from antigravity import Agent, Model, Workspace

# 1. Konfigurasi Model
# Argon untuk penalaran kompleks (Initializer & Coding)
argon_model = Model("gemini-4-argon")
# 3.8 Flash untuk sensor inferensial yang cepat dan murah
flash_judge = Model("gemini-3.8-flash")

def run_harness_pipeline(user_prompt: str, workspace_path: str):
    ws = Workspace(workspace_path)
    
    # FASE 1: Initializer Agent (Feedforward Guide)
    initializer = Agent(
        model=argon_model,
        system_prompt="You are an Initializer Agent. Set up the environment. Create a comprehensive 'features.json' with all requirements marked as 'passes': false. Create init.sh and make the first git commit."
    )
    ws.execute(initializer, user_prompt)
    
    # FASE 2: Coding Agent Loop (Incremental Progress)
    while True:
        # Baca state saat ini
        state = json.loads(ws.read_file("features.json"))
        pending_features = [f for f in state['features'] if not f['passes']]
        
        if not pending_features:
            print("🎉 Semua fitur selesai diverifikasi!")
            break
            
        target_feature = pending_features[0]
        print(f"⚙️ Mengerjakan fitur: {target_feature['description']}")
        
        coding_agent = Agent(
            model=argon_model,
            system_prompt=f"Implement ONLY the following feature: {target_feature['description']}. Do not modify other features. Ensure code is clean."
        )
        ws.execute(coding_agent, f"Implement {target_feature['name']}")
        
        # FASE 3: Computational Sensors (Feedback)
        linter_result = subprocess.run(["npm", "run", "lint"], cwd=workspace_path, capture_output=True)
        if linter_result.returncode != 0:
            # Feedforward error back to agent
            ws.execute(coding_agent, f"Linter failed. Fix these errors:\n{linter_result.stderr.decode()}")
            continue
            
        # FASE 4: Inferential Sensors (LLM as Judge)
        diff = ws.get_git_diff()
        judge_prompt = f"Review this diff for semantic flaws or security issues based on our AGENTS.md guidelines:\n{diff}"
        judge_decision = flash_judge.generate(judge_prompt)
        
        if "REJECTED" in judge_decision:
            ws.execute(coding_agent, f"Code review failed. Address this feedback:\n{judge_decision}")
            ws.git_revert() # Kembalikan ke state bersih
            continue
            
        # FASE 5: Commit & Update State
        ws.git_commit(f"feat: {target_feature['name']} implemented and verified")
        target_feature['passes'] = True
        ws.write_file("features.json", json.dumps(state, indent=2))

Kode di atas bukan sekadar script pemanggil API biasa. Ini adalah sebuah Harness. Ia membatasi ruang gerak agent, memaksanya bekerja satu per satu, memverifikasi hasilnya secara komputasional (Linter) dan inferensial (Gemini 3.8 Flash), serta mengelola state menggunakan JSON dan Git.

📊 Production FinOps & TCO Simulation

Banyak pemimpin teknologi ragu mengimplementasikan agent otonom karena takut tagihan token LLM akan meledak. Namun, Harness Engineering justru merupakan strategi FinOps yang brilian. Dengan mencegah agent melakukan one-shotting (yang membuang jutaan token konteks secara berulang karena kegagalan), dan dengan mengalihkan tugas verifikasi ke model yang lebih murah (Gemini 2.5 Flash / 3.8 Flash), kita secara drastis menurunkan Total Cost of Ownership (TCO).

Berikut adalah simulasi deterministik menggunakan data SKU resmi Google Cloud untuk tim beranggotakan 100 engineer yang menjalankan 500 sesi agent per hari.

Architecture Option	Google SKU Unit Price & Monthly Formula	Estimated Monthly Cost
Option A: Traditional Chatbot / Unharnessed Agents	Unoptimized Pro Input (Full Context Pasting): $1.25/1M input tokens × 5,000 = $6,250.00 Unoptimized Pro Output (Rewriting Full Files): $10/1M output tokens × 500 = $5,000.00 Cloud Run Orchestration (vCPU): $2.4e-05/vCPU-second × 2,592,000 = $62.21 Cloud Run Orchestration (Memory): $2.5e-06/GiB-second × 10,368,000 = $25.92	$11,338.13 / mo
Option B: 6-Layer Harness Engineering (Antigravity Pattern)	Tier 1: Flash Input (Sensors & Linters): $0.15/1M input tokens × 8,000 = $1,200.00 Tier 1: Flash Output (Sensors & Linters): $0.6/1M output tokens × 800 = $480.00 Tier 2: Pro Input (Initializer & Complex Logic): $1.25/1M input tokens × 2,000 = $2,500.00 Tier 2: Pro Output (Incremental Commits): $10/1M output tokens × 200 = $2,000.00 GKE Autopilot (Agent Sandboxes - vCPU): $0.0445/vCPU-hour × 14,400 = $640.80 GKE Autopilot (Agent Sandboxes - Memory): $0.00492/GiB-hour × 57,600 = $283.39 AlloyDB (Agent State Management): $0.0662/vCPU-hour × 1,440 = $95.33	$7,199.52 / mo
Net FinOps Impact (Monthly Savings)	Based on the latest Google SKU information	36.5% TCO Reduction ($4,138.61 / mo)

Catatan: Simulasi di atas menggunakan baseline SKU Gemini 2.5 Pro/Flash sebagai standar enterprise Vertex AI untuk merepresentasikan tiering antara model frontier (seperti Argon) dan model workhorse (seperti 3.8 Flash).

Seperti yang terlihat, meskipun Opsi B (Harness Engineering) membutuhkan infrastruktur tambahan seperti GKE Autopilot untuk sandboxing dan AlloyDB untuk state management, penghematan dari pengurangan pemborosan token model frontier (karena agent tidak lagi berhalusinasi dan mengulang dari awal) menghasilkan pengurangan TCO sebesar 36,5%. Anda mendapatkan sistem yang jauh lebih andal dengan biaya yang lebih murah.

Kesimpulan: Masa Depan Adalah Milik Para "Harness Builders"

Kita telah melewati fase di mana kita terpesona oleh kemampuan LLM untuk menulis puisi atau membuat fungsi sorting sederhana. Di ranah enterprise software engineering, tantangannya bukan lagi pada generation, melainkan pada integration, verification, dan state management.

Model AI Anda tidak bodoh. Ia hanya menderita amnesia dan kurangnya batasan yang jelas. Dengan mengadopsi prinsip Harness Engineering—memisahkan Initializer dari Coding Agent, menerapkan computational dan inferential sensors, serta mengelola state secara deterministik melalui JSON dan Git—Anda menjembatani information gap tersebut.

Alat-alat seperti Google Antigravity dengan Gemini 4 Argon dan 3.8 Flash telah membuktikan bahwa ketika model frontier diletakkan di dalam harness yang tepat, mereka dapat memecahkan masalah engineering terberat di dunia, mulai dari optimasi CPU YouTube hingga memodernisasi codebase Fortran yang berusia puluhan tahun.

Berhentilah melakukan prompt engineering tanpa arah. Mulailah membangun harness Anda.