Tutorial API GPT-6 Astra: Bangun Agen Pemeriksa Rilis dengan Alat Async dan Steering

Apa Itu API GPT-6 Astra?

API GPT-6 Astra adalah cara Anda mengakses model andalan baru OpenAI, dirilis pada 3 September 2026, melalui Responses API. Untuk tutorial ini, yang penting adalah antarmukanya: gpt-6-astra menerima input teks dan gambar melalui Responses API OpenAI. Rentang upaya penalarannya dari low hingga max, tanpa opsi none. 

Contoh dalam tutorial ini menggunakan client.responses.create alih-alih client.chat.completions.create, tetapi migrasi juga memerlukan perubahan pada format permintaan, keluaran, dan hasil alat. Hapus juga pengaturan temperature, top_p, dan log-probability kustom, karena Astra tidak mendukungnya. Sebelum melakukan panggilan pertama, mari lihat harga.

Berapa biaya GPT-6 Astra?

Untuk permintaan dengan paling banyak 272.000 token input, harga standar adalah $10 per satu juta token input biasa dan $50 per satu juta token output. Input yang di-cache berharga $1 per satu juta, dan penulisan cache berharga $12,50 per satu juta. 

Setelah sebuah permintaan melewati ambang tersebut, OpenAI menerapkan pengali 2x pada tarif input dan cache serta pengali 1,5x pada tarif output. Tarif yang lebih tinggi berlaku untuk seluruh permintaan, bukan hanya token di atas ambang. Tidak ada run dalam tutorial ini yang mendekati ambang tersebut.

Apa yang Akan Kita Bangun dengan API GPT-6 Astra?

Aplikasi staging adalah papan tugas kecil berbasis Flask: halaman beranda, formulir untuk menambahkan tugas, tombol untuk menandai selesai, dan endpoint /health . Kode lengkap, termasuk aplikasi staging, ada di repositori GitHub ini.

Tiga tugas awal muncul sebelum pengujian. Gambar oleh Penulis.

Aplikasi memiliki satu cacat yang disengaja. Agen memiliki tiga pemeriksaan, tetapi hanya rangkaian pengujian yang dirancang untuk menangkapnya.

Mengapa aplikasi menerima judul tugas kosong?

Endpoint pembuatan tugas tidak menolak judul kosong. Saya membiarkan perilaku itu agar agen memiliki kegagalan yang diketahui untuk ditemukan tanpa mengungkapkannya di prompt.

Pemeriksaan rilis mana yang dapat dijalankan agen?

Agen dapat memanggil tiga alat:

• run_test_suite menjalankan pytest, termasuk pengujian impor massal dengan sekitar 250 permintaan HTTP. 

• check_ui_flow menggunakan Playwright untuk menambahkan tugas dan memastikan tugas tersebut muncul. 

• check_staging_health mengirim permintaan GET ke /health. 

Ketiganya berjalan pada staging, tanpa mock. Pemeriksaan browser menggunakan kode tetap; demo penggunaan komputer yang ditulis model menyusul.

Cara Menyiapkan API GPT-6 Astra di Python

Anda memerlukan kunci API OpenAI dengan akses ke gpt-6-astra. Buat kunci di platform.openai.com/api-keys, dan pastikan proyek Anda memiliki gpt-6-astra aktif. Workspace Enterprise menonaktifkan Astra secara default saat peluncuran.

Perintah di bawah menggunakan Windows PowerShell dan memasang semua paket yang diperlukan untuk tutorial ini, termasuk realtime dari OpenAI untuk demo steering.

python -m venv .venv
.venv\Scripts\Activate.ps1
Copy-Item .env.example .env
pip install "openai[realtime]" flask pytest playwright pydantic matplotlib python-dotenv streamlit
playwright install chromium

Di macOS atau Linux, ganti perintah aktivasi dengan source .venv/bin/activate dan perintah salin dengan cp .env.example .env. 

Lalu tambahkan kunci API ke file .env baru: Buka file .env yang baru saja Anda salin dan tambahkan OPENAI_API_KEY=sk-..., yang akan dimuat oleh python-dotenv dan diambil otomatis oleh SDK, sehingga Anda tidak pernah mengoper kunci di kode.

Jika dependensi spesifik proyek atau file .env masih baru bagi Anda, panduan kami tentang virtual environment dan variabel lingkungan menjelaskannya. Pastikan kunci bekerja sebelum melanjutkan.

Jika kunci API Anda sudah berfungsi dengan Responses API, lewati subbagian berikut dan mulai dengan loop alat sinkron. Permintaan pertama hanya untuk memverifikasi penyiapan.

Buat panggilan API GPT-6 Astra pertama Anda

Setelah kunci tersedia, kunci perlu dimuat menggunakan dotenv. Setelah itu, Anda bisa membuat klien OpenAI dan mengirim permintaan pertama menggunakan fungsi client.responses.create(). Permintaan sekecil mungkin terlihat seperti ini:

from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()

client = OpenAI()
response = client.responses.create(
    model="gpt-6-astra",
    reasoning={"effort": "low"},
    input="In one sentence, what is a staging environment used for?",
)
print(response.output_text)

Kolom usage dari respons mencantumkan jumlah token yang dibutuhkan untuk perhitungan biaya nanti.

Bangun Loop Alat GPT-6 Astra Sinkron

Potongan di bawah adalah cuplikan; versi yang dapat dijalankan ada di repositori GitHub pendamping.

Sebelum menyentuh hal yang bersifat async, saya membangun versi biasa: 

1. Panggil model

2. Periksa item function_call

3. Jalankan alat yang cocok

4. Kirim kembali hasilnya dengan previous_response_id

5. Ulangi sampai model berhenti meminta alat. 

Loop pemblokiran ini menjadi baseline untuk perbandingan async.

for turn in range(max_turns):
    response = client.responses.create(
        model="gpt-6-astra",
        reasoning={"effort": "low"},
        tools=TOOLS,
        input=next_input,
        previous_response_id=previous_response_id,
    )
    calls = [item for item in response.output if item.type == "function_call"]
    if not calls:
        final_text = response.output_text
        break
    outputs = [
        {"type": "function_call_output", "call_id": call.call_id, "output": run_tool(call)}
        for call in calls
    ]
    next_input, previous_response_id = outputs, response.id

Apa yang ditemukan run baseline

Dalam run baseline, model memanggil setiap alat secara bergiliran. Ia menemukan kegagalan validasi yang diketahui dan mengembalikan keputusan no-go. Di tiga run, total waktu wall-clock rata-ratanya 23,40 detik. Rata-rata tersebut mencakup keseluruhan run, bukan waktu alat per bagian.

Bagaimana Cara Kerja Pemanggilan Alat Async di GPT-6 Astra?

Tandai alat dengan "async": true dalam skemanya, dan aplikasi Anda dapat menunda hasil itu sementara model terus bekerja atau menunggu. Aplikasi Anda tetap menjalankan alat dan mengelola pekerjaan latar belakang.

Cara menjalankan pemeriksaan independen secara konkuren

Saya menandai run_test_suite dan check_ui_flow sebagai async, dan menambahkan alat wait_for_tasks yang ditentukan aplikasi tanpa argumen, karena demo ini hanya pernah memiliki satu batch pekerjaan tertunda pada satu waktu. Penantian tanpa argumen itu menjaga contoh tetap ringkas. 

Dalam runner produksi, identifikasi pekerjaan dengan handle tugas, ikat setiap handle ke call_id asalnya, dan tunggulah hanya ketika langkah berikutnya bergantung pada hasil yang tertunda.

Kembalikan setiap hasil yang selesai pada call_id aslinya, lalu kembalikan status penantian pada call_id milik alat penantian.

TOOLS = [
    {"type": "function", "name": "run_test_suite", "async": True, ...},
    {"type": "function", "name": "check_ui_flow", "async": True, ...},
    {"type": "function", "name": "check_staging_health", ...},
    {"type": "function", "name": "wait_for_tasks", ...},
]

Untuk run ini, aplikasi mengirim setiap panggilan yang ditandai ke sebuah thread pool. Sambil pemeriksaan latar belakang berjalan, aplikasi melakukan pemeriksaan health sinkron yang cepat. Lalu ia memblokir di wait_for_tasks sampai pemeriksaan yang tertunda selesai.

Apakah pemanggilan alat async mengurangi waktu wall-clock?

Di tiga run, async mengurangi rata-rata waktu wall-clock sebesar 19,1%, dari 23,40 detik menjadi 18,94 detik. Rata-rata tampak lurus sampai hasil run individual masuk; grafik di bawah menunjukkan seberapa besar variasinya. Tiga run cukup untuk menunjukkan apa yang terjadi di sini, bukan untuk memprediksi latensi produksi.

Waktu run bervariasi di kedua mode. Gambar oleh Penulis.

Mengapa pemeriksaan konkuren menyebabkan race condition?

Menjalankan pemeriksaan browser dan pengujian impor massal secara bersamaan kadang menyebabkan asersi impor massal gagal karena kedua pemeriksaan memodifikasi daftar tugas dalam memori yang sama. Itu melanggar asumsi akses eksklusif pada pengujian. Mengisolasi data di runner atau di pengujian akan menghindari race.

Penggunaan Komputer GPT-6 Astra yang Dibatasi untuk Pengujian UI

Untuk penggunaan komputer, dokumentasi GPT-6 Astra merekomendasikan eksekusi kode, sementara alat terstruktur computer tetap didukung sebagai alternatif. Dengan eksekusi kode, satu panggilan dapat menggabungkan beberapa tindakan, loop, dan logika kondisional, sementara alat computer mengembalikan satu aksi mouse atau keyboard terstruktur sekali jalan untuk diterjemahkan dan diputar ulang oleh aplikasi Anda.

Cara membatasi runner penggunaan komputer

Saya menamai kelasnya BrowserSandbox, tetapi nama itu melebih-lebihkan perlindungannya. Kelas ini memberi kode yang ditulis model sebuah page Playwright, fungsi log(), dan helper expect_text() . Python tetap bisa menyuntikkan built-in ke exec(), dan halaman dapat menavigasi ke origin lain.

sandbox_globals = {"page": self.page, "log": log, "expect_text": expect_text}
exec(code, sandbox_globals)

Perlakukan ini sebagai runner demo, bukan batas keamanan. Kode yang ditulis model memerlukan proses atau container terisolasi dengan pembatasan filesystem, proses, jaringan, dan origin.

Apa yang terjadi dalam pemeriksaan UI?

Saya membatasi loop pada delapan giliran karena pemeriksaan yang dibatasi perlu batas tegas. Model menginspeksi halaman, menemukan input formulir, membuat judul "UI flow check, cobalt otter 73921," mengirimkan tugas, dan memastikan judul tersebut muncul, yang memakan waktu 13 detik. Tutorial penggunaan komputer GPT-5.4 kami membahas contoh terperinci menggunakan pendahulu Astra.

Bagaimana Cara Kerja Steering di Tengah Giliran pada GPT-6 Astra?

Steering di tengah giliran hanya tersedia untuk gpt-6-astra melalui koneksi WebSocket.

Buka koneksi dan buat respons, lalu kirim event response.steer dengan instruksi baru saat respons sedang dihasilkan. Event response.steer.accepted berarti pembaruan telah diantrekan, bukan diterapkan. Sebelum membuat kelanjutan otomatis, server menyelesaikan item output saat ini dan pekerjaan alat hosted apa pun yang sudah berjalan. 

Jika masih memerlukan hasil alat klien atau persetujuan, response.steer.pending mengidentifikasi input yang hilang.

async with client.responses.connect() as connection:
    await connection.response.create(model="gpt-6-astra", input=TASK)
    async for event in connection:
        if event.type == "response.created" and initial_response_id is None:
            initial_response_id = event.response.id
            await asyncio.sleep(1.0)
            await connection.response.steer(
                previous_response_id=initial_response_id,
                input="Also add a rollback plan, but skip mobile.",
            )

Penundaan satu detik menyamakan kode eksperimen dan memberi waktu respons pertama untuk mulai. Tanpa penundaan itu, ini akan menguji titik berbeda dalam siklus hidup respons.

Apa yang tidak diubah oleh steering di tengah giliran?

Steering tidak menulis ulang respons asli. Jika pembaruan memotongnya, respons itu berakhir dengan status: "incomplete" dan incomplete_details.reason: "steered". Respons penerus kemudian berlanjut dengan instruksi baru. 

Jika respons pertama selesai sebelum pembaruan berlaku, respons itu tetap selesai. Steering tidak membalikkan atau membatalkan tindakan sisi klien yang sudah mulai; aplikasi Anda tetap memiliki kendali atas perilaku itu. Steering yang diantrekan hanya ada di koneksi WebSocket saat ini, jadi catat pembaruan sebelum mencoba menyambung kembali.

Jalur perbandingan membiarkan respons pertama selesai, lalu mengirim permintaan baru dengan instruksi gabungan. Di dua run, steering rata-rata 26,91 detik dibanding 50,02 detik untuk jalur selesai-lalu-mulai ulang. Perbandingan ini tidak mencakup kebijakan batalkan-lalu-mulai ulang atau menilai ketepatan teks akhir.

Rata-rata dua run untuk waktu dan biaya. Gambar oleh Penulis.

Jalur mulai ulang menghasilkan dua respons penuh yang mencakup beberapa permintaan yang sama. Setup itu menjelaskan sebagian kesenjangan waktu, jadi saya tidak akan menganggap dua run ini sebagai tolok ukur umum untuk steering.

Cara Mengubah Upaya Penalaran GPT-6 Astra di Tengah Percakapan

gpt-6-astra mendukung upaya penalaran dari low hingga max. Upaya yang lebih tinggi dapat meningkatkan penggunaan token penalaran, tetapi tidak menjamin jawaban berbeda. configuration_update mengubah respons berikutnya dan selanjutnya sampai pembaruan lain menimpanya, sementara pengaturan tingkat permintaan tetap tidak berubah. 

Dalam pipeline ini, laporan mengakhiri percakapan, jadi pembaruan hanya memengaruhi langkah terakhir itu.

response = client.responses.create(
    model="gpt-6-astra",
    previous_response_id=previous_id,
    reasoning={"effort": "low"},  # default remains low
    input=[
        {"type": "configuration_update", "reasoning": {"effort": "high"}},
        {"role": "user", "content": "Diagnose the root cause and recommend a fix."},
    ],
)

Saya menggunakan jejak kegagalan yang sama pada kedua tingkat upaya dan membandingkan diagnosis serta penggunaan token.

Satu hal yang halus: kolom reasoning.effort pada respons tetap melaporkan pengaturan tingkat permintaan, bukan upaya yang dipilih oleh configuration_update. Jangan gunakan kolom itu untuk memeriksa apakah pembaruan berlaku.

Apakah upaya penalaran tinggi mengubah diagnosis?

Dalam run gabungan penuh, langkah yang ditingkatkan menggunakan 108 token penalaran. Setiap langkah lain pada low menggunakan nol. Dalam pengujian terisolasi sebelumnya dengan jejak kegagalan yang lebih panjang, upaya rendah menggunakan nol token penalaran, dan upaya tinggi menggunakan 318. Keduanya mengidentifikasi bug validasi, jadi perubahan upaya yang lebih tinggi mengubah penggunaan token tetapi tidak diagnosis.

Pembaruan konfigurasi hanya berfungsi dalam permintaan standar, agen tunggal. API menolak pembaruan yang bersebelahan, dan pembaruan tidak dapat digabung dengan kompaksi otomatis atau pemangkasan otomatis.

Cara Menggunakan Output Terstruktur GPT-6 Astra

Langkah terakhir pipeline memanggil client.responses.parse untuk mengganti teks bebas dengan Pydantic model yang tervalidasi.

class GoNoGoReport(BaseModel):
    decision: str
    summary: str
    checks_completed: list[str]
    failures: list[str]
    risks: list[str]
    follow_up_actions: list[str]
    confidence: float

response = client.responses.parse(
    model="gpt-6-astra",
    previous_response_id=previous_id,
    text_format=GoNoGoReport,
    input=[...],
)

Pydantic memeriksa tipe field yang dideklarasikan di sini. Ini tidak membuktikan bahwa laporan cocok dengan bukti, dan versi ini tidak membatasi decision pada dua nilai atau confidence pada suatu rentang.

Apa yang ditangkap laporan go/no-go?

Laporan mengembalikan decision: "no_go". Ia mengklasifikasikan kegagalan validasi yang disebutkan sebelumnya di bawah failures dan isu konkurensi di bawah risks. Untuk yang terakhir, ia menulis: "kemungkinan gangguan dari pemeriksaan UI konkuren terhadap data staging bersama." Prompt tidak menyebutkan risiko itu.

Jaga latensi dan biaya di luar skema ini dan hitung dalam kode. Model mengisi field laporan dari bukti alat.

Antarmuka Streamlit mengonsumsi generator yang sama dengan runner baris perintah. Antarmuka merender setiap event alat saat tiba, lalu menampilkan laporan yang diurai di tab Report dan JSON.

Progres agen langsung di samping laporan akhir. Video oleh Penulis.

Dasbor menjalankan pipeline rilis async gabungan dengan pemeriksaan browser tetap, pembaruan penalaran, laporan terstruktur, dan tampilan waktu. Panel biayanya membaca buku besar yang sama seperti runner baris perintah. Dasbor tidak menjalankan demo terpisah untuk penggunaan komputer yang ditulis model atau steering.

Cara Melacak Penggunaan Token dan Biaya API GPT-6 Astra

Untuk porsi token model dalam run ini, kolom usage berisi empat jumlah token yang diperlukan untuk menilai setiap respons. Penulisan cache memiliki tarif sendiri, jadi jangan gabungkan dengan input biasa. Alat di sini berjalan dalam aplikasi Anda; jika Anda menambahkan alat hosted dengan biaya terpisah, sertakan juga biayanya.

details = usage.input_tokens_details
cached_tokens = details.cached_tokens
cache_write_tokens = details.cache_write_tokens
ordinary_tokens = usage.input_tokens - cached_tokens - cache_write_tokens

cost = (
    ordinary_tokens * PRICE_INPUT
    + cached_tokens * PRICE_CACHED_INPUT
    + cache_write_tokens * PRICE_CACHE_WRITE
    + usage.output_tokens * PRICE_OUTPUT
) / 1_000_000

Perhitungan ini mencakup satu respons. Buku besar menerapkannya setelah setiap respons, lalu menjumlahkan total panggilan.

Catat cache_write_tokens bahkan ketika nilainya nol. Jika tidak, penulisan cache di masa depan bisa tersembunyi di dalam jumlah input biasa, dan itu cara yang menjengkelkan untuk menemukan kesalahan penagihan.

Pertimbangan Produksi Agen GPT-6 Astra

Demo ini memerlukan perubahan berikut sebelum bisa menjadi gerbang deployment.

Izin alat dan isolasi

Pertahankan batas staging dan isolasi BrowserSandbox seperti dijelaskan di atas. Jangan berikan kredensial basis data atau akses produksi.

Siklus hidup pekerjaan async

Di demo, setiap pekerjaan tertunda selesai, dan tidak ada yang lain menyentuhnya. Runner yang dideploy harus bertahan dalam kasus ketika keduanya tidak benar. Ia perlu, untuk setiap entri tertunda:

• Batas waktu dan state final, agar tidak ada yang tertahan selamanya
• Flag pengiriman, agar callback dan retry tidak mengirim hasil yang sama dua kali
• Stempel waktu mulai dan selesai, untuk membedakan timeout dari penyelesaian yang terlambat tetapi valid
• Penolakan panggilan duplikat, agar tugas yang sama tidak dapat diluncurkan dua kali
• Penanganan error thread latar belakang, agar pengecualian yang dilempar muncul ke permukaan alih-alih hilang ke dalam pool
• Pembatalan, yang berarti mengabaikan hasil yang terlambat dan menghentikan pekerjaan eksternal yang sudah berlangsung

Steering dan tindakan yang tidak dapat dibalik

Steering dapat mengubah instruksi di masa depan, tetapi tidak dapat membalikkan efek samping yang telah selesai. Jika sebuah alat sudah mengubah sistem eksternal, tindakan alat terpisah harus mengompensasinya.

Pemantauan misalignment

Penghentian otomatis berlaku untuk permintaan Responses API yang menggunakan penalaran persisten, WebSocket, atau kompaksi OpenAI. Permintaan lain dapat memicu peringatan, tetapi tidak dihentikan secara otomatis. 

Sebelum streaming, pemantauan misalignment dapat memblokir run yang tercakup dengan HTTP 403 dan kode misalignment_policy_violation. Klien streaming mungkin malah menerima error setelah output dimulai. API tidak menyediakan jalur lanjut umum untuk percakapan yang dihentikan.

Daftar Periksa Deployment Agen GPT-6 Astra

Sebelum memindahkan agen ini dari demo lokal ke deployment, tambahkan kontrol ini. Kontrol ini berada di kode aplikasi, bukan di instruksi model.

• Tetapkan timeout eksplisit pada panggilan HTTP aplikasi staging dan koneksi WebSocket

• Catat input biasa, input cache, penulisan cache, output, ID respons, dan jumlah giliran

• Berikan peringatan pada run yang tidak lengkap atau run yang mencapai batas giliran. Tetapkan peringatan terpisah untuk pemborosan anggaran

• Sematkan versi SDK openai dan periksa ulang perilaku async, steering, dan configuration_update sebelum peningkatan versi

Kapan Sebaiknya Menggunakan Alat Async atau Steering GPT-6 Astra?

Pilih jalur paling sederhana yang sesuai dengan pekerjaan.

• Mulai dengan permintaan sinkron dan output terstruktur saat alat mengembalikan hasil dengan cepat, dan persyaratan tetap tetap.
• Tambahkan pemanggilan alat async saat model atau alat lain dapat melakukan pekerjaan berguna selama panggilan yang lambat, dan waktu yang dihemat membenarkan overhead manajemen pekerjaan ekstra.
• Gunakan steering di tengah giliran saat persyaratan berubah selama run.

Penutup

Pemeriksaan rilis sinkron menjadi lebih berguna setelah alat yang lambat bisa tumpang tindih, meski hasilnya bukan kemenangan bersih. Di tiga run, async mengurangi waktu rata-rata dari 23,40 detik menjadi 18,94 detik, lalu mengekspos race state bersama yang disembunyikan loop sekuensial. 

Saya akan mengisolasi browser dan data pengujian, menjaga giliran rutin pada low, dan menaikkan upaya penalaran hanya ketika bukti memerlukan tinjauan lebih dekat. Jika alat selesai dengan cepat dan persyaratan tetap, cukup berhenti pada loop sinkron dengan output terstruktur. Gunakan async saat pekerjaan independen bisa tumpang tindih, dan gunakan steering saat instruksi berubah selama respons.

Untuk dasar-dasar API, saya merekomendasikan mengikuti kursus Working with the OpenAI API kami. Untuk sistem agen yang lebih besar, lihat kursus Building Scalable Agentic Systems.