GPT-6 Astra vs Agent Harness: Perbezaan Sebenar

GPT-6 Astra vs Agent Harness: Perbezaan Sebenar

Sejak GPT-6 Astra diumumkan pada 3 September 2026, banyak perbincangan terus menggunakan perkataan agent seolah-olah model itu sendiri sudah menjadi sebuah agent.

Bagi aku, itu cara yang agak mengelirukan untuk melihat benda ini.

Astra ialah model. Agent ialah sistem.

Perbezaan ini nampak kecil, tetapi sebenarnya penting. Bila kita membina coding agent, automation system atau AI yang boleh mengendalikan komputer, model hanyalah satu komponen dalam keseluruhan sistem.

Komponen yang menghubungkan model kepada tools, memory, orchestration, permissions, state dan error recovery — itulah agent harness.

Kalau kau pernah menggunakan OpenCode, OpenClaw, Hermes, Claude Code atau mana-mana coding agent moden, kau sebenarnya sudah menggunakan konsep ini.

Artikel ini cuba pecahkan benda tersebut tanpa terlalu banyak hype: apa sebenarnya model, apa itu harness, dan apa yang berlaku apabila model yang lebih berkuasa dimasukkan ke dalam harness yang baik.

GPT-6 Astra Sebenarnya Apa?

Pada asasnya, GPT-6 Astra ialah language model.

Model menerima input, memprosesnya dan menghasilkan output. Output itu boleh berupa teks, kod, keputusan, arahan atau — bergantung kepada interface dan capability yang diberikan kepadanya — tindakan untuk digunakan oleh sistem lain.

Ini penting kerana model itu sendiri tidak secara automatik mempunyai akses kepada komputer kau.

Kalau kau beritahu model:

"Betulkan CSS pada index.html."

Model boleh menganalisis masalah dan mencadangkan perubahan.

Tetapi untuk benar-benar membuka index.html, mengubah fail, menjalankan test dan memastikan perubahan itu berjaya, model memerlukan sistem di sekelilingnya yang menyediakan capability tersebut.

Di sinilah agent harness masuk.

Benchmark bukan keseluruhan cerita

Astra mungkin menunjukkan peningkatan besar dalam beberapa benchmark yang berkaitan dengan reasoning, computer use dan coding.

Antara angka yang dilaporkan dalam benchmark (jadual pelancaran OpenAI, vendor-stated) termasuk:

• ARC-AGI-3: 99.9% (harness Provider Adapter; 62.7% pada harness Standard ARC Prize)
• OSWorld 2.0: 72.6%
• Terminal-Bench 4.0: 57.9%
• ExploitBench: 100%
• FrontierMath Tier 4: 97.6%

Angka seperti ini memang menarik.

Tetapi benchmark model dan prestasi agent bukan benda yang sama.

Benchmark biasanya mengukur sama ada model boleh menghasilkan jawapan atau menyelesaikan tugasan dalam environment tertentu. Ia tak semestinya memberitahu kita bagaimana model akan bertindak bila kena deal dengan filesystem sebenar, network yang tak stabil, permission boundaries, context yang panjang, tool failures dan state yang berubah-ubah. Benchmark juga boleh ditipu — penilaian live-search wujud tepat kerana ujian statik ditipu.

Itulah sebabnya model yang sangat bagus masih boleh menghasilkan agent yang mengecewakan.

Jadi, Apa Itu Agent Harness?

Cara paling mudah untuk fikir tentang harness ialah:

Harness ialah infrastructure yang menghubungkan model kepada tools, environment dan workflow.

Ia bukan model itu sendiri.

Ia mengurus perkara yang diperlukan supaya output model boleh menjadi tindakan sebenar.

Contohnya:

• Tools — terminal, filesystem, browser, API, database
• Memory — context, notes, session state dan compaction
• Orchestration — menjalankan agent loop dan menghantar hasil tool kembali kepada model
• Permissions — menentukan apa yang model boleh lakukan
• State management — menjejaki progress sesuatu tugas
• Error recovery — menentukan apa berlaku apabila sesuatu langkah gagal
• Human approval — meminta manusia campur tangan apabila sesuatu tindakan berisiko

Tanpa layer-layer ini, model mungkin boleh memberitahu kita apa yang perlu dilakukan.

Dengan layer-layer ini, sistem boleh cuba melakukan kerja tersebut.

Model + Harness + Tools + Environment

Sebab itu aku lebih suka melihat architecture agent seperti ini:

                    AGENT SYSTEM
                         │
             ┌───────────┴───────────┐
             │                       │
          MODEL                   HARNESS
             │                       │
       reasoning               orchestration
       planning                memory
       generation              permissions
                               state
                               retries
                               context
                                   │
                         ┌─────────┴─────────┐
                         │                   │
                       TOOLS             ENVIRONMENT
                         │                   │
                      terminal               OS
                      filesystem             apps
                      browser               network
                      APIs                  services
                       database

Model memberikan capability untuk reasoning dan generation.

Harness menentukan bagaimana capability itu digunakan.

Tools memberikan access.

Environment pula ialah tempat kerja sebenar berlaku.

Keempat-empat bahagian ini saling berkait.

Contoh Paling Mudah

Bayangkan kau bagi arahan:

Fix the CSS bug on line 42 of index.html.

Dengan model sahaja, sistem mungkin menghasilkan:

Change line 42 from:

display: none;

to:

display: flex;

Itu jawapan.

Tetapi sebuah agent system boleh melakukan sesuatu seperti:

1. Read index.html
2. Inspect the relevant CSS
3. Ask the model to analyse the problem
4. Modify the file
5. Run the application or test
6. Inspect the result
7. Detect whether the fix worked
8. Make another change if necessary
9. Ask for approval before committing

Perbezaannya bukan semata-mata pada intelligence model.

Perbezaannya ialah apa yang sistem benarkan model lakukan.

Itulah fungsi harness.

Model Yang Sama, Agent Yang Berbeza

Ini bahagian yang paling menarik.

Katakan kita mempunyai model yang sama.

Kemudian kita letakkan model tersebut dalam dua harness yang berbeza.

                 SAME MODEL
                     │
          ┌──────────┴──────────┐
          │                     │
      Harness A             Harness B
          │                     │
    basic tools             rich tools
    short context           persistent memory
    no retry                retry/recovery
    broad permissions       controlled permissions
          │                     │
       Result A              Result B

Modelnya sama.

Tetapi hasilnya boleh sangat berbeza.

Kajian seperti Harness-Bench (arXiv:2605.27922) menunjukkan perkara ini dengan lebih jelas: jurang harness terbaik-vs-terburuk ialah 23.8 mata merentasi 106 tugasan (76.2 vs 52.4, purata merentas 8 model backend).

Maksudnya mudah:

Memilih model sahaja tidak cukup untuk menentukan prestasi sebuah agent.

Cara model itu dibungkus dan digunakan juga penting.

Jadi, Apa Yang Astra Bawa?

Di sinilah model seperti Astra menjadi menarik.

Salah satu capability yang semakin penting ialah computer use.

Model bukan lagi hanya bekerja dengan teks. Dengan interface yang sesuai, model boleh menerima representasi visual seperti screenshot dan menghasilkan tindakan yang boleh diterjemahkan oleh host kepada operasi GUI.

Contohnya:

1. Melihat keadaan aplikasi
2. Mengenal pasti elemen UI
3. Membaca teks pada skrin
4. Memahami layout
5. Menentukan tindakan seterusnya
6. Menggunakan click, type, scroll atau navigation melalui interface yang disediakan

Perhatikan perkataan penting di sini:

interface yang disediakan.

Model masih memerlukan sistem yang menterjemahkan output itu kepada tindakan sebenar.

Model tidak tiba-tiba mempunyai akses terus kepada keyboard, filesystem atau desktop hanya kerana ia boleh memahami screenshot.

Harness masih diperlukan.

Computer Use Mengubah Harness

Ini sebenarnya lebih menarik daripada sekadar mengatakan:

"Astra boleh guna komputer."

Agen computer-use Astra ialah kajian kes konkritnya — termasuk critical gate ia dihantar bersamanya.

Apabila model mempunyai visual understanding dan computer-use capability yang lebih baik, jenis tools yang boleh dibina di sekelilingnya turut berubah.

Sebelum ini, banyak automation bergantung kepada struktur yang mudah dibaca mesin:

Model
  ↓
API
  ↓
Structured data

Dengan computer use, kita boleh mempunyai:

Model
  ↓
Screenshot / visual state
  ↓
Decision
  ↓
Computer-use action
  ↓
Application
  ↓
New screenshot
  ↓
Model

Loop ini membuka lebih banyak kemungkinan.

Contohnya, sebuah agent boleh digunakan untuk menguji aplikasi desktop, mengendalikan software yang tiada API yang baik, memeriksa hasil visual sesuatu UI atau menyelesaikan workflow yang sebelum ini memerlukan manusia menggunakan mouse dan keyboard.

Tetapi sekali lagi, capability model bukan sama dengan reliability system.

Kenapa Harness Masih Sangat Penting?

Bayangkan Astra diberikan akses kepada terminal.

Model boleh menghasilkan command yang betul.

Tetapi bagaimana sistem menangani situasi seperti ini?

$ npm test

Error: ECONNREFUSED

Model perlu tahu bahawa command gagal.

Kemudian ia perlu menerima output itu.

Kemudian memutuskan sama ada perlu retry, mencari punca masalah atau meminta manusia campur tangan.

Harness yang menentukan bagaimana loop itu berlaku.

Contoh:

User
 │
 ▼
Model
 │
 ▼
Tool call
 │
 ▼
Terminal
 │
 ├── Success ────────► Model
 │
 └── Error
       │
       ▼
   Error handler
       │
       ├── Retry
       ├── Diagnose
       ├── Rollback
       └── Ask human

Model penting.

Tetapi loop di sekeliling model juga penting.

Kalau Dah Ada OpenCode, OpenClaw atau Hermes?

Kalau kau menggunakan coding agent seperti OpenCode, OpenClaw, Hermes atau sistem yang sama konsepnya, sebahagian besar architecture itu sebenarnya sudah wujud — dan landskap framework agen open-source lebih maju daripada yang disangka kebanyakan pasukan.

Contohnya:

                    AGENT
                      │
              ┌───────┴───────┐
              │               │
           HARNESS           MODEL
              │               │
       ┌──────┼──────┐        │
       │      │      │        │
     Tools  Memory  State    LLM
       │      │      │
   terminal  context workflow
   files     notes   retries
   browser   history permissions
   APIs

Dalam architecture seperti ini, model bukan komponen yang perlu kau bina dari kosong.

Ia lebih kepada backend intelligence yang boleh ditukar.

Hari ini mungkin model A.

Esok model B.

Lusa local model.

Architecture utama masih boleh dikekalkan.

Contohnya secara konsep:

model = "gpt-6-astra"

kemudian:

model = "next-generation-model"

Kalau architecture harness kau direka dengan baik, perubahan model tidak sepatutnya memerlukan kau membina semula keseluruhan sistem.

Itulah nilai model-agnostic architecture.

Model-Agnostic Bukan Bermaksud Model Tak Penting

Ada satu perkara yang perlu diperjelaskan.

Model-agnostic tidak bermaksud:

"Semua model sama."

Memang tidak.

Model yang berbeza mempunyai capability, latency, cost, context window dan reliability yang berbeza.

Contohnya:

                    TASK
                      │
          ┌───────────┼───────────┐
          │           │           │
       Simple       Coding     Complex
       task         task       reasoning
          │           │           │
      Local LLM     Mid-tier   Frontier model

Kalau tugas hanya memformat fail atau menghasilkan boilerplate, model yang murah mungkin sudah mencukupi.

Untuk debugging kompleks, reasoning panjang atau computer-use workflow yang sukar, model frontier mungkin lebih berbaloi.

Jadi architecture yang baik bukan:

"Gunakan model paling kuat untuk semuanya."

Sebaliknya:

Gunakan model yang sesuai untuk tugas, dan bina harness yang boleh menggunakan lebih daripada satu model.

Jangan Campurkan Benchmark Model Dengan Benchmark Agent

Ini antara kesimpulan paling penting daripada semua ini.

Kalau satu model mendapat score lebih tinggi daripada model lain dalam benchmark, itu menunjukkan model itu mempunyai capability yang lebih baik dalam benchmark itu.

Ia tak semestinya bermaksud agent yang menggunakan model itu akan jadi lebih baik dalam production.

Production agent mempunyai masalah lain:

• Tool calls boleh gagal
• API boleh timeout
• Context boleh menjadi terlalu panjang
• Files boleh berubah
• Permission boleh menghalang tindakan
• Browser boleh berada dalam state yang tidak dijangka
• Database boleh unavailable
• Model boleh memilih tool yang salah
• Workflow boleh tersangkut
• Manusia mungkin perlu approve sesuatu tindakan

Semua ini berada di luar persoalan:

"Berapa tinggi score model dalam benchmark?"

Sebab itu aku rasa kita patut mula membezakan dua perkara:

MODEL CAPABILITY
       ≠
AGENT RELIABILITY

Model menentukan sebahagian daripada ceiling.

Harness menentukan sebahagian besar daripada bagaimana ceiling itu digunakan dalam dunia sebenar.

Evolusi Model dan Harness

Hubungan antara model dan harness juga tidak kekal statik.

Apa yang hari ini perlu dilakukan oleh harness mungkin suatu hari nanti boleh dilakukan secara lebih native oleh model.

Sebaliknya, apabila model menjadi lebih berkuasa, kita boleh mengurangkan sebahagian orchestration yang sebelum ini diperlukan.

Secara kasar, prosesnya boleh kelihatan seperti:

Capability baru
      │
      ▼
Harness menyediakan workaround
      │
      ▼
Model dilatih dengan workflow itu
      │
      ▼
Capability menjadi lebih native
      │
      ▼
Sebahagian workaround boleh dikurangkan
      │
      ▼
Harness berkembang ke masalah seterusnya

Ini bukan bermaksud harness akan hilang.

Sebaliknya, lapisan tanggungjawab berubah.

Semakin model boleh buat sendiri, semakin harness boleh memberi tumpuan kepada perkara seperti:

• permissions
• identity
• security
• trust
• state
• resource management
• human approval
• observability
• auditability

Dan untuk production system, perkara-perkara ini tidak hilang hanya kerana model menjadi lebih pintar.

Apa Yang Patut Dibina Sekarang?

Kalau kau sedang membina agent system, aku rasa beberapa perkara lebih penting daripada mengejar setiap model baru.

1. Bina harness yang model-agnostic

Jangan letakkan terlalu banyak logic khusus kepada satu model.

Tools, memory, permissions dan orchestration sepatutnya boleh digunakan dengan beberapa model backend.

2. Asingkan model daripada tools

Jangan jadikan model sebagai tempat semua logic berada.

Gunakan interface yang jelas:

Model
  ↓
Tool selection
  ↓
Tool execution
  ↓
Result
  ↓
Model

Ini memudahkan testing dan debugging.

3. Treat permissions sebagai architecture

Jangan beri agent akses penuh hanya kerana model itu pintar. Permissions ialah sempadan keselamatan, bukan budi bahasa — lihat threat model agen AI.

Bezakan antara:

Read
Write
Execute
Network
Delete
Deploy

dan tentukan mana yang memerlukan approval.

Model yang lebih kuat tidak menghapuskan keperluan untuk permission boundary.

4. Uji harness secara berasingan

Kalau prestasi agent berubah selepas upgrade model, jangan terus salahkan model.

Bandingkan:

Same model
Different harness

dan:

Same harness
Different model

Barulah kau boleh tahu komponen mana yang sebenarnya memberi kesan. Persekitaran latihan adaptif membawa idea yang sama lebih jauh: ubah dunianya, bukan sekadar modelnya.

5. Jangan gunakan frontier model untuk semua benda

Kos juga sebahagian daripada architecture.

Kalau local model sudah cukup untuk tugas tertentu, gunakan local model.

Simpan model yang mahal untuk kerja yang memang memerlukan capability tambahan.

Jadi, Astra Atau Harness?

Jawapannya bukan salah satu.

Kau perlukan kedua-duanya.

Model memberikan intelligence.

Harness memberikan execution layer.

Tools memberikan access.

Environment memberikan tempat kerja — daripada container hingga hardware sebenar yang boleh dikendalikan agen.

Dan permission system menentukan sejauh mana agent boleh bertindak.

Kalau model hebat tetapi harness buruk, agent masih boleh gagal.

Kalau harness hebat tetapi model terlalu lemah, agent juga akan mempunyai ceiling yang rendah.

Architecture yang lebih masuk akal ialah:

             ┌───────────────────────┐
             │      AGENT SYSTEM     │
             │                       │
             │       ┌───────┐       │
             │       │ MODEL │       │
             │       └───┬───┘       │
             │           │           │
             │       HARNESS         │
             │           │           │
             │    ┌──────┼──────┐    │
             │    │      │      │    │
             │  Tools  Memory  State │
             │    │      │      │    │
             │    └──────┼──────┘    │
             │           │           │
             │       Environment     │
             └───────────────────────┘

Dan di sinilah aku rasa hype mengenai model baru selalu terlepas satu benda.

Model bukan keseluruhan agent.

Kesimpulan

GPT-6 Astra boleh jadi model yang jauh lebih berkuasa daripada generasi sebelumnya. Capability seperti reasoning, coding dan computer use memang boleh mengubah apa yang boleh dilakukan oleh sebuah agent.

Tetapi Astra sendiri bukan keseluruhan agent.

Ia hanyalah satu komponen dalam sistem yang lebih besar.

Agent yang benar-benar berguna memerlukan lebih daripada model:

model + harness + tools + environment + permissions + state.

Kalau kau sudah menggunakan OpenCode, OpenClaw, Hermes atau sistem agent yang sama konsepnya, soalan yang lebih menarik bukan:

"Perlukah aku tukar kepada Astra?"

Soalannya ialah:

"Apa yang berlaku kalau aku masukkan model yang lebih kuat ke dalam harness yang sudah aku bina?"

Itu soalan yang lebih tepat.

Sebab pada akhirnya, model menentukan apa yang mungkin.

Harness menentukan bagaimana kemungkinan itu menjadi kerja sebenar.

FAQ

Apa itu agent harness AI?

Infrastructure yang menyambungkan model kepada tools, state, workflow, dan environment tempat kerja berlaku — terminal, file, browser, API, memory, permissions, retries. Model memberi intelligence; harness memberi execution dan control.

Apa beza model AI dengan agent harness?

Model membuat keputusan; harness bertindak. Tukar model dan capability berubah; tukar harness dan apa yang boleh disentuh, diingati, dan dirosakkan agen berubah. Model yang sama dalam dua harness berbeza praktikalnya dua agen berbeza.

Kenapa agen AI perlukan harness?

Kerana model kosong tidak boleh menjalankan arahan, mengingati state merentas langkah, menguatkuasakan permissions, atau pulih daripada kegagalan. Harness membekalkan tools, memory, orchestration, observability, dan gate kelulusan manusia — semua yang menukar completion menjadi hasil.

Apa yang dikawal oleh agent harness?

Pemilihan dan pelaksanaan tools, pengurusan context dan memory, sandboxing, akses network, sempadan permissions, retries, penilaian, dan log audit. Paling penting, ia juga patut mengawal apa yang model tidak dibenarkan buat.

Adakah agent harness sempadan keselamatan?

Sepatutnya, tetapi hanya dengan reka bentuk. Harness yang menguatkuasakan identiti, tools least-privilege, sandboxing, dan log audit di luar model ialah sempadan sebenar. Yang sekadar menggelungkan panggilan model bukan — lihat threat model agen AI.

Sumber

• OpenAI: GPT-6 Astra: A new generation of intelligence
• ARC Prize: OpenAI's GPT-6 Astra on ARC-AGI-3
• arXiv: Harness-Bench: Measuring Harness Effects across Models in Realistic Agent Workflows