GPT-5.6 Pemanggilan Alat Programatik: Model Menulis Kode Orkestrasi

Pemanggilan fungsi klasik mengikuti pola yang familier bagi pembuat agen: model meminta satu alat, aplikasi Anda mengeksekusinya, hasil dikirim kembali, lalu model meminta alat berikutnya. Empat alat berarti empat perjalanan bolak-balik; empat puluh alat berarti empat puluh. Setiap putaran menambah latensi jaringan dan konteks yang diproses ulang. Saat OpenAI meluncurkan GPT-5.6 untuk ketersediaan umum pada 9 Juli 2026, mereka memperkenalkan cara untuk mengurangi loop ini: pemanggilan alat secara terprogram di Responses API.

Coba Apidog hari ini

Konsepnya sederhana: alih-alih mengembalikan satu panggilan alat agar kode aplikasi Anda menjalankan loop, model menulis JavaScript untuk mengorkestrasi beberapa panggilan alat. JavaScript tersebut berjalan dalam runtime V8 terisolasi tanpa akses jaringan. Alat yang Anda deklarasikan tetap menjadi satu-satunya jalur ke sistem eksternal, sehingga batas keamanan yang sudah Anda terapkan dengan pemanggilan fungsi OpenAI tidak berubah. Yang berpindah hanyalah orkestrasi: loop, percabangan, dan agregasi yang sebelumnya hidup di aplikasi Anda.

Perubahan ini berdampak langsung pada desain API. Setiap alat kini dapat dipanggil berkali-kali oleh kode yang dihasilkan model dalam satu siklus respons. Karena itu, presisi skema, bentuk error, idempotensi, rate limit, dan latensi endpoint menjadi semakin penting. Artikel ini membahas cara kerja fitur tersebut, masalah pada loop klasik, dan cara menyiapkan endpoint alat dengan Apidog sebelum mengeksposnya ke model.

TL;DR

• GPT-5.6 menjadi GA pada 9 Juli 2026, dan Responses API mendapatkan pemanggilan alat secara terprogram.
• Model menulis JavaScript untuk menjalankan loop, kondisional, dan agregasi melalui alat yang Anda deklarasikan.
• Kode berjalan di sandbox V8 tanpa akses jaringan; definisi alat tetap menjadi batas keamanan utama.
• Loop agen klasik menambah latensi dan token seiring jumlah panggilan alat. Mode terprogram mengurangi perjalanan bolak-balik tersebut.
• Parameter, batas eksekusi, dan timeout harus selalu diverifikasi di referensi API OpenAI sebelum implementasi.
• Uji, mock, dan validasi setiap endpoint alat. Ambiguitas skema dapat berubah menjadi bug yang diulang dalam loop.

Apa yang diluncurkan pada 9 Juli

GPT-5.6 hadir dalam tiga tingkat:

• gpt-5.6-sol untuk penalaran terdalam.
• gpt-5.6-terra untuk beban kerja seimbang.
• gpt-5.6-luna untuk volume cepat dan hemat biaya.

Alias gpt-5.6 mengarah ke Sol. Ketiga model dapat diakses melalui API tanpa pembatasan paket setelah pratinjau terbatas dua minggu yang berakhir saat pembatasan akses dicabut pada 8 Juli.

Selain keluarga model, Responses API mendapatkan beberapa kemampuan baru. Berdasarkan liputan peluncuran MarkTechPost dan dokumentasi OpenAI, fitur GA mencakup:

1. Pemanggilan alat secara terprogram.
2. Multi-agen dalam beta.
3. Penalaran yang bertahan di seluruh giliran.
4. Pengaturan detail visi yang mempertahankan dimensi gambar asli.

Yang paling relevan bagi pembuat agen adalah pemanggilan alat secara terprogram: model menulis JavaScript untuk mengorkestrasi panggilan alat, lalu runtime V8 terisolasi menjalankannya tanpa akses jaringan.

Loop yang digantikan oleh pemanggilan alat secara terprogram

Berikut contoh pemanggilan fungsi klasik dengan Responses API:

import OpenAI from "openai";

const client = new OpenAI();

const tools = [
  {
    type: "function",
    name: "get_flight_status",
    description: "Return live status for a flight by IATA flight number.",
    parameters: {
      type: "object",
      properties: {
        flight_number: {
          type: "string",
          description: "IATA flight number, for example SQ317"
        }
      },
      required: ["flight_number"]
    }
  }
];

let response = await client.responses.create({
  model: "gpt-5.6",
  input: "Which of these 12 flights are delayed: SQ317, BA15, UA857...",
  tools
});

Model memerlukan data penerbangan, sehingga ia menghasilkan panggilan fungsi. Aplikasi Anda kemudian menjalankan alat, menambahkan function_call_output, dan memanggil API lagi:

// Satu perjalanan bolak-balik per panggilan alat.
while (hasFunctionCalls(response)) {
  const outputs = await executeToolCalls(response);

  response = await client.responses.create({
    model: "gpt-5.6",
    previous_response_id: response.id,
    input: outputs,
    tools
  });
}

Untuk 12 penerbangan, loop ini dapat berjalan 12 kali. Biayanya muncul di dua tempat:

1. Latensi: setiap iterasi memerlukan perjalanan jaringan ke OpenAI dan waktu inferensi model.
2. Token: output alat terakumulasi dalam konteks, sehingga iterasi berikutnya dapat memproses ulang hasil sebelumnya.

Dalam agen bertingkat, efeknya lebih besar. Misalnya, agen lima langkah dengan sepuluh panggilan alat per langkah dapat menghasilkan sekitar lima puluh pemanggilan model.

Loop ini bukan bagian dari penalaran agen. Itu adalah perpipaan aplikasi.

Bagaimana mode terprogram mengubah bentuk

Dengan pemanggilan alat secara terprogram, model dapat menulis program JavaScript yang:

1. Melakukan loop pada daftar nomor penerbangan.
2. Memanggil get_flight_status untuk setiap nomor.
3. Memfilter penerbangan tertunda.
4. Mengurutkan hasil berdasarkan durasi keterlambatan.
5. Mengembalikan agregat akhir.

Alat Anda tetap melakukan pekerjaan nyata. Perbedaannya adalah aliran kontrol kini ditulis oleh model dan dijalankan di sandbox.

Tiga properti utama fitur ini:

• Runtime terisolasi: JavaScript berjalan dalam sandbox V8 tanpa akses jaringan.
• Alat sebagai satu-satunya jalan keluar: semua efek eksternal harus melalui alat yang Anda deklarasikan.
• Aliran kontrol ekspresif: loop, kondisional, keluar dini, dan agregasi hasil dapat terjadi dalam satu siklus respons.

	Pemanggilan fungsi klasik	Pemanggilan alat terprogram
Siapa yang menulis aliran kontrol	Aplikasi Anda	Model dalam JavaScript
Perjalanan bolak-balik untuk N panggilan alat	N, diserialkan	Satu siklus respons
Lokasi orkestrasi	Infrastruktur Anda	Sandbox V8 terisolasi tanpa jaringan
Eksekusi alat	Kode Anda memanggilnya	Tetap melalui alat yang Anda deklarasikan
Batas keamanan	Definisi alat	Definisi alat, tidak berubah

Apa yang tetap sama

Definisi alat tetap menggunakan nama, deskripsi, dan parameter JSON Schema. Model hanya dapat menyusun panggilan ke alat yang Anda deklarasikan.

Artinya, jawaban untuk pertanyaan berikut tidak berubah:

Apa yang dapat dilakukan agen ini terhadap sistem saya?

Jawabannya tetap: hanya tindakan yang diizinkan oleh permukaan alat Anda.

Namun, kualitas skema menjadi lebih penting. Pada loop klasik, parameter ambigu mungkin menghasilkan satu panggilan buruk yang bisa Anda inspeksi sebelum iterasi berikutnya. Dalam mode terprogram, ambiguitas itu dapat tertanam dalam loop dan diulang berkali-kali.

Gunakan praktik yang sama seperti saat membangun output terstruktur:

• Gunakan tipe yang ketat.
• Gunakan enum untuk pilihan tertutup.
• Nyatakan unit, format, dan rentang nilai.
• Tandai field wajib sebagai required.
• Hindari deskripsi parameter yang dapat ditafsirkan lebih dari satu cara.

Contoh skema yang lebih spesifik:

{
  "type": "object",
  "properties": {
    "departure_date": {
      "type": "string",
      "format": "date",
      "description": "Tanggal keberangkatan dalam format ISO 8601: YYYY-MM-DD."
    },
    "cabin_class": {
      "type": "string",
      "enum": ["economy", "premium_economy", "business", "first"],
      "description": "Kelas kabin penerbangan."
    }
  },
  "required": ["departure_date", "cabin_class"],
  "additionalProperties": false
}

Batas dan pertanyaan terbuka

Fitur ini masih baru. Sebelum membangun ulang arsitektur agen Anda, perhatikan beberapa hal berikut:

• Parameter permintaan, batas eksekusi, dan perilaku timeout ada di referensi API serta panduan model OpenAI. Verifikasi referensi sebelum mengunci implementasi.
• Debugging berubah. Jika orkestrasi sebelumnya berada di repositori Anda, Anda dapat memakai breakpoint. Kini sebagian alur kontrol dibuat per permintaan.
• Logging urutan panggilan alat, input, output, error, dan durasi eksekusi menjadi kebutuhan observabilitas inti.
• Belum ada rekam jejak produksi jangka panjang. Catatan hari pertama Simon Willison tentang GPT-5.6 dapat menjadi referensi untuk pengujian independen dan masalah awal.
• Mulailah dari alat baca-saja. Amati orkestrasi, ukur token dan latensi, lalu ekspos alat dengan efek samping secara bertahap.

Alat Anda sekarang adalah API yang dipanggil oleh kode orang lain

Dalam pemanggilan fungsi klasik, alat biasanya dipanggil satu kali per perjalanan bolak-balik. Aplikasi Anda menentukan urutan dan kecepatan panggilan.

Dalam mode terprogram, kode yang dihasilkan model dapat:

• Memanggil endpoint secara berurutan.
• Membuat percabangan berdasarkan respons.
• Mengulang panggilan saat memenuhi kondisi tertentu.
• Mengagregasi output dari banyak panggilan.

Dengan kata lain, alat Anda adalah kontrak API yang digunakan oleh klien yang ditulis mesin dan belum pernah Anda review sebelum dieksekusi.

Fokus pada empat area ini:

1. Presisi skema

Nyatakan unit, format, dan rentang pada setiap parameter.

Jangan gunakan:

{
  "date": "03/04/2026"
}

Gunakan:

{
  "departure_date": "2026-04-03"
}

Sertakan format dalam deskripsi agar model tidak perlu menebaknya.

2. Bentuk error

Kode yang dihasilkan akan membuat keputusan berdasarkan respons alat. Jangan menyembunyikan kegagalan dalam respons 200 OK.

Hindari:

{
  "success": false,
  "message": "Something went wrong"
}

Lebih baik gunakan status HTTP yang sesuai dan respons error terstruktur:

{
  "error": {
    "code": "FLIGHT_NOT_FOUND",
    "message": "No flight was found for flight_number SQ317."
  }
}

3. Idempotensi dan rate limit

Panggilan yang sebelumnya tersebar selama satu menit dapat muncul dalam satu lonjakan. Pastikan endpoint Anda memiliki:

• Rate limit yang jelas.
• Respons 429 yang konsisten.
• Dukungan idempotency untuk operasi tulis.
• Strategi retry yang aman.
• Batas konkurensi jika backend tidak dapat menangani banyak request sekaligus.

4. Latensi

Endpoint delapan detik mungkin masih dapat diterima jika dipanggil satu kali. Namun, dalam loop dua belas iterasi, endpoint tersebut akan mendominasi waktu respons.

Ukur latensi endpoint sebelum mengeksposnya sebagai alat:

curl -o /dev/null -s -w \
"time_total=%{time_total}\nhttp_code=%{http_code}\n" \
"https://api.example.com/flights/SQ317"

Gunakan workbench API untuk mengimpor spesifikasi endpoint, mengirim request pengujian, dan memverifikasi apakah respons sebenarnya sesuai dengan kontrak alat. Anda juga dapat membuat mock API agar orkestrasi dapat diuji menggunakan data palsu yang konsisten tanpa menyentuh produksi.

Unduh Apidog untuk mendefinisikan endpoint, menguji kontrak, dan menjalankan server mock dengan respons berbentuk skema sebelum model mengakses data nyata.

Fitur GA lainnya secara singkat

Pemanggilan alat secara terprogram bukan satu-satunya tambahan pada Responses API.

• Multi-agen, dalam beta: menjalankan subagen paralel yang dikelola API. Fitur ini layak dipantau, tetapi belum ideal untuk beban kerja yang sangat kritis.
• Penalaran yang bertahan: konteks penalaran dapat digunakan kembali lintas giliran melalui reasoning.context, sehingga sesi agen panjang tidak perlu mengulang kesimpulan yang sama.

Kedua kemampuan tersebut dapat melengkapi pemanggilan alat secara terprogram: agen mempertahankan konteks penalaran dan mengurangi perjalanan bolak-balik saat mengorkestrasi alat.

Pemanggilan alat terprogram vs mode ultra

Peluncuran ini juga menghadirkan mode ultra. Keduanya sama-sama dapat melakukan lebih banyak pekerjaan per permintaan, tetapi menyelesaikan hambatan yang berbeda.

Mode ultra adalah pengaturan multi-agen yang menjalankan empat agen paralel secara default. Pendekatan ini sengaja menggunakan lebih banyak token untuk mengurangi waktu wall-clock. Menurut OpenAI, mode ini meningkatkan Terminal-Bench 2.1 dari 88.8% menjadi 91.9%.

Pemanggilan alat secara terprogram adalah kemampuan API untuk satu agen yang menulis kode orkestrasi bagi alat-alatnya sendiri.

Ringkasnya:

Jika hambatan utama Anda adalah...	Gunakan
Latensi dari banyak panggilan alat	Pemanggilan alat secara terprogram
Waktu penalaran untuk masalah sulit	Mode ultra
Loop aplikasi yang panjang dan berulang	Pemanggilan alat secara terprogram
Eksplorasi paralel oleh beberapa agen	Mode ultra

Untuk detail lebih lanjut, lihat artikel mode ultra GPT-5.6.

FAQ

Apakah saya perlu menulis ulang definisi alat yang sudah ada?

Tidak. Alat tetap menggunakan bentuk JSON Schema yang sama seperti pemanggilan fungsi klasik.

Namun, Anda perlu memperketat kontraknya:

• Tambahkan enum bila pilihannya terbatas.
• Tentukan format tanggal, ID, mata uang, dan satuan.
• Gunakan field wajib secara konsisten.
• Pastikan deskripsi cukup spesifik untuk menghindari salah tafsir.

Bisakah JavaScript yang dihasilkan mengakses internet?

Tidak. Kode berjalan dalam runtime V8 terisolasi tanpa akses jaringan.

Alat yang Anda deklarasikan adalah satu-satunya cara untuk memengaruhi sistem di luar sandbox. Karena itu, audit permukaan alat dengan standar yang sama seperti saat Anda mengekspos API publik.

Model GPT-5.6 mana yang mendukung pemanggilan alat terprogram?

OpenAI mendokumentasikan kemampuan ini sebagai permukaan Responses API untuk keluarga GPT-5.6. Ketiga tingkatan—gpt-5.6-sol, gpt-5.6-terra, dan gpt-5.6-luna—dapat diakses melalui API.

Tetap periksa referensi API untuk detail kemampuan dan batas tiap tingkat model sebelum memilihnya. Untuk konfigurasi awal, lihat cara menggunakan API GPT-5.6.

Apa bedanya dengan interpreter kode?

Interpreter kode menjalankan kode sebagai hasil akhir, misalnya untuk analisis data, pembuatan grafik, atau transformasi file.

Pemanggilan alat secara terprogram menghasilkan kode dengan tujuan berbeda: mengoordinasikan alat yang Anda deklarasikan. Hasil akhirnya adalah output alat yang sudah diagregasi, bukan kode itu sendiri.

Langkah implementasi berikutnya

Loop bolak-balik adalah bagian paling mekanis dari banyak agen produksi. GPT-5.6 membuat loop tersebut opsional, tetapi konsekuensinya jelas: orkestrasi berpindah ke model, sementara tanggung jawab terhadap API alat yang presisi dan aman semakin besar.

Mulai dengan satu workflow baca-saja:

1. Pilih alur kerja yang membutuhkan banyak lookup atau agregasi data.
2. Tulis ulang definisi alat dengan schema yang ketat.
3. Uji request valid, input buruk, error backend, timeout, dan rate limit.
4. Mock respons alat agar Anda dapat menguji orkestrasi tanpa data produksi.
5. Tambahkan logging untuk setiap panggilan alat dan durasi eksekusinya.
6. Bandingkan token, latensi, dan tingkat error dengan loop klasik.
7. Ekspos alat dengan efek samping hanya setelah perilaku baca-saja stabil.

Saat model mulai menulis kode terhadap alat Anda, pastikan ia bekerja dengan permukaan API yang sudah diuji, dapat diprediksi, dan aman.