Thanawat Wongchai

Posted on Sep 5 Originally published at apidog.com

GPT-6 Astra ใช้คอมพิวเตอร์คุณได้: มอบ OpenAPI spec ให้แทน

ฟีเจอร์เด่นของ GPT-6 Astra คือความสามารถในการใช้งานคอมพิวเตอร์ ไม่ใช่แค่โมเดลที่คลิกไปเรื่อย ๆ แล้วหลงทางในเมนูดรอปดาวน์ ใน โพสต์เปิดตัวของ OpenAI Astra ทำคะแนนได้ 72.6% ใน OSWorld 2.0 โดยใช้เวลาประมาณ 40 นาทีต่องาน ทั้งการกรอกแบบฟอร์ม อัปเดต CRM ติดตั้งซอฟต์แวร์ และตรวจสอบ QA ส่วนหน้า (frontend) บนเว็บไซต์ที่สร้างขึ้นเอง OpenAI เรียกมันว่า “โมเดลการใช้คอมพิวเตอร์ที่ดีที่สุดในโลก” และการสาธิตครั้งนี้ก็สนับสนุนคำกล่าวอ้างนั้น

ลองใช้ Apidog วันนี้

หากคุณสร้างหรือทดสอบ API ความสามารถนี้อาจทำให้คุณอยากชี้ Astra ไปที่แอปแล้วปล่อยให้มันคลิก แต่ทางเลือกที่มีประโยชน์กว่า คือมอบ OpenAPI spec ให้เป็นอินเทอร์เฟซที่เร็วกว่า ถูกกว่า และตรวจสอบได้มากกว่าหน้าจอ เราเห็น Astra เปลี่ยนมาใช้แนวทางนี้ด้วยตัวเองระหว่าง การทดสอบจริงสองวัน และบทความนี้จะอธิบายเหตุผลพร้อมวิธีตั้งค่าด้วย Apidog

สรุปโดยย่อ (TL;DR)

Astra ทำคะแนนได้ 72.6% บน OSWorld 2.0 และ 92.7% บน ScreenSpot-Pro
ชุดเครื่องมือ Codex ทำงานที่เกี่ยวข้องกับการใช้คอมพิวเตอร์ได้เร็วกว่า GPT-5.6 Sol ถึง 1.9 เท่า
การควบคุมหน้าจอใช้เวลาหลายสิบนาทีและโทเค็นรูปภาพจำนวนมากต่องาน
การควบคุมหน้าจอทดสอบ UI ไม่ใช่ API ของบริการคุณ
มอบ OpenAPI spec ให้ Astra ผ่าน Apidog MCP Server หรือฟังก์ชันเครื่องมือ
ให้ Astra เขียนสถานการณ์ทดสอบ แล้วรันผ่าน Apidog CLI ใน CI
เก็บการใช้งานคอมพิวเตอร์ไว้สำหรับระบบที่ไม่มี API

GPT-6 Astra ใช้งานคอมพิวเตอร์ทำอะไรได้บ้าง

ความสามารถนี้ครอบคลุมมากกว่าการท่องเว็บไซต์ เช่น

กรอกแบบฟอร์มออนไลน์ บันทึก CRM และจัดการปฏิทิน
ค้นคว้าและร่างเอกสารในโปรแกรมแก้ไขเอกสาร
วิเคราะห์ข้อมูลทางวิทยาศาสตร์พร้อมกราฟ
สร้างและโฮสต์เว็บไซต์ผ่าน ChatGPT Sites
ตรวจสอบ QA ส่วนหน้าบนเว็บไซต์
จัดวางแผงวงจรใน KiCad
สร้างแบบจำลองบ้านใน Blender

ตัวเลขมาตรฐานจากโพสต์เปิดตัวของ OpenAI:

มาตรฐาน	GPT-6 Astra	GPT-5.6 Sol	Claude Opus 5
OSWorld 2.0 (ชุดข้อมูลออฟไลน์, คะแนนบางส่วน)	72.6% ใช้เวลา ~40 นาที/งาน	65.7% ใช้เวลา ~75 นาที/งาน	70.2%
ScreenSpot-Pro (ไม่มีเครื่องมือ)	92.7%	76.9%	-
Agents’ Last Exam	59.3%	53.6%	55.5%
AutomationBench	41.4%	18.1%	26.9%

รายละเอียดที่สำคัญกว่าคะแนน:

Astra ทำงาน OSWorld เสร็จเร็วกว่า Sol ประมาณ 47%
ใน Agents’ Last Exam Astra ใช้โทเค็นเอาต์พุตน้อยกว่า Opus 5 ประมาณ 65% ในการตั้งค่าที่ได้คะแนนสูงสุด
ชุดเครื่องมือ Codex ทำงานที่เกี่ยวข้องกับการใช้คอมพิวเตอร์บน Mind2Web ได้เร็วกว่า Sol ปัจจุบัน 1.9 เท่า

ลูปที่เร็วขึ้นหมายถึงต้นทุนที่ลดลง โดยเฉพาะเมื่อคิดค่าบริการตามโทเค็น

พฤติกรรมของ Astra ก็ดีขึ้นเช่นกัน โดยจะถามคำถามเมื่อคำตอบมีผลต่อผลลัพธ์ รักษาโฟกัสระหว่างงาน และใน Codex สามารถถามแบบอะซิงโครนัสระหว่างทำงานที่ไม่ต้องรอคำตอบได้

ในเกณฑ์มาตรฐานความปลอดภัยการใช้งานคอมพิวเตอร์ภายในของ OpenAI ซึ่งคะแนนที่ต่ำกว่าดีกว่า Astra ได้ 2.4% เทียบกับ Sol ที่ 22.0%

งาน 40 นาทีมีค่าใช้จ่ายเท่าไร

การใช้งานคอมพิวเตอร์เป็นลูปต่อเนื่อง:

ถ่ายภาพหน้าจอ
วิเคราะห์
ดำเนินการ
ถ่ายภาพหน้าจออีกครั้ง

ทุกภาพหน้าจอเป็นอินพุตภาพ ทุกขั้นตอนนำประวัติการสนทนาปัจจุบันกลับมาใช้ และงาน 40 นาทีอาจมีหลายร้อยขั้นตอน

ตาม อัตรามาตรฐานของ Astra:

อินพุต: $10 ต่อล้านโทเค็น
เอาต์พุต: $50 ต่อล้านโทเค็น
อินพุตที่เกิน 272K โทเค็น: $20 ต่อล้านโทเค็น
Prompt caching: $1 ต่อล้านโทเค็นที่แคชไว้

เซสชันยาวที่เก็บประวัติทั้งหมดในบริบทจะถูกคิดราคาแบบ long-context ก่อนงานจะเสร็จ แม้ prompt caching จะช่วยลดต้นทุน prefix ที่ซ้ำกัน แต่ภาพหน้าจอใหม่ทุกขั้นตอนยังคงเป็นอินพุตใหม่

เส้นทาง OpenAPI spec

OpenAPI spec เป็น prefix เดียวที่แคชไว้ครั้งเดียว จากนั้น:

สถานการณ์ทดสอบที่โมเดลเขียนใช้ JSON เพียงไม่กี่ร้อยโทเค็น
การรันทดสอบแต่ละครั้งเป็น HTTP request ที่ไม่เสียค่าใช้จ่ายฝั่งโมเดล
เมื่อเขียนสถานการณ์แล้ว ไม่ต้องใช้โมเดลในการรันซ้ำ

มีต้นทุนที่ไม่ใช่เรื่องเงินด้วย ภาพรวมความปลอดภัยของ OpenAI ระบุว่าตัวตรวจสอบความไม่สอดคล้องกันในการผลิต “บางครั้งอาจชะลอ หยุดชั่วคราว หรือหยุดงานที่ถูกต้อง” โดยเฉพาะงานที่เอเจนต์ทำเป็นเวลานาน

ใน ChatGPT หรือ Codex คุณอาจถูกขอให้ทบทวนการดำเนินการ ส่วนใน API งานจะหยุดลงทันที เซสชันควบคุมหน้าจอ 40 นาทีจึงมีโอกาสเจอการหยุดชะงักมากกว่าการเรียก API ที่ใช้เวลาเพียงห้าวินาที

การใช้งานคอมพิวเตอร์เทียบกับสัญญา API

สถานการณ์	เครื่องมือที่ดีกว่า	เหตุผล
การทดสอบ API ของคุณเอง	Spec	ตรวจสอบได้แน่นอน รันซ้ำได้ และยืนยันตามสัญญาจริง
Regression test ใน CI	Spec	สถานการณ์ทำงานได้โดยไม่มีโมเดลอยู่ในลูป
พอร์ทัลบุคคลที่สามที่ไม่มี API	การใช้งานคอมพิวเตอร์	ไม่มีสัญญาให้มอบ
QA ส่วนหน้าแบบ End-to-end ก่อนเปิดตัว	การใช้งานคอมพิวเตอร์	ต้องทดสอบ UI โดยตรง
เครื่องมือเดสก์ท็อปแบบ Legacy	การใช้งานคอมพิวเตอร์	มีเฉพาะหน้าจอ
ตรวจสอบว่าเอกสารตรงกับพฤติกรรมหรือไม่	Spec แล้วตามด้วย UI	ส่งคำขอตามเอกสาร เปรียบเทียบการตอบสนอง แล้วตรวจสอบหน้าเว็บ

ความแตกต่างคือสิ่งที่กำลังทดสอบ:

การใช้งานคอมพิวเตอร์ทดสอบพิกเซล
Spec ทดสอบสัญญา

เมื่อ frontend เสียหาย API มักยังทำงานได้ และเมื่อ API เสียหาย frontend อาจซ่อนปัญหาไว้หลังข้อความแสดงข้อผิดพลาดที่เป็นมิตร ทั้งสองส่วนสำคัญ แต่ทีม API ส่งมอบสัญญา ดังนั้นควรเริ่มจาก contract test

วิธีมอบสัญญา API ให้ Astra

มีสามวิธี และสามารถใช้ร่วมกันได้

1. ให้ไฟล์ OpenAPI แก่ Astra

ส่งออก OpenAPI spec จากโปรเจกต์ Apidog หรือ นำเข้า spec ที่มีอยู่ไปยัง Apidog ก่อน แล้วแนบไว้ในคำขอ

หน้าต่างบริบทของ Astra มีขนาด 1,050,000 โทเค็น และการทดสอบการเรียกคืน MRCR ของ OpenAI แสดงความแม่นยำ 96.3% ที่ช่วง 512K–1M ขณะที่ Sol ลดลงเหลือ 73.8% ดังนั้น spec ขนาดใหญ่ไม่จำเป็นต้องแบ่งส่วนอีกต่อไป

2. เชื่อมต่อโปรเจกต์ผ่าน MCP

Apidog MCP Server เปิดเผยโปรเจกต์ Apidog เอกสารที่เผยแพร่ หรือไฟล์ OpenAPI ให้ไคลเอ็นต์ที่รองรับ MCP

Astra จึงอ่านสัญญาปัจจุบันแทนไฟล์ส่งออกที่อาจล้าสมัย Codex และเอเจนต์เดสก์ท็อปสามารถดึงคำจำกัดความของ Endpoint ระหว่างทำงานได้ การตั้งค่านี้ทำให้ Astra ในการทดสอบของเราค้นหาและอ่าน spec ได้ด้วยตัวเอง

3. แปลง Spec เป็นฟังก์ชันเครื่องมือ

สำหรับการใช้งานแบบโปรแกรม ให้แปลง Endpoint เป็นฟังก์ชันเครื่องมือแล้วเรียก Astra ผ่าน Responses API ตามแนวทาง การแปลง OpenAPI เป็นเครื่องมือสำหรับ AI agent

หน้าโมเดลของ Astra ระบุการเรียกใช้ฟังก์ชัน เอาต์พุตแบบมีโครงสร้าง และการค้นหาไฟล์เป็นคุณสมบัติของโมเดล โดยการเรียกใช้เครื่องมือต้องใช้ Responses API ไม่ใช่ Chat Completions

คำขอขั้นต่ำสำหรับให้ Astra ร่างสถานการณ์ทดสอบจาก Spec:

curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "reasoning": {"effort": "medium"},
    "input": [
      {"role": "developer", "content": "คุณกำลังเขียนสถานการณ์ทดสอบ API. เน้นการดำเนินการ. ถามคำถามก็ต่อเมื่อคำตอบเปลี่ยนการออกแบบการทดสอบเท่านั้น. ส่งออก JSON ที่ตรงกับ Schema."},
      {"role": "user", "content": "นี่คือ OpenAPI 3.1 spec ของเรา. ร่างสถานการณ์ทดสอบต่อหนึ่งทรัพยากร: happy path, ขอบเขตการตรวจสอบสิทธิ์, และหนึ่งกรณีเชิงลบแต่ละรายการ.\n\n<วาง spec>"}
    ],
    "text": {"format": {"type": "json_schema", "name": "scenarios", "schema": {"type": "object", "properties": {"scenarios": {"type": "array"}}, "required": ["scenarios"]}}}
  }'

จาก คำแนะนำโมเดลของ OpenAI:

Astra ไม่มีระดับความพยายาม none หรือ minimal ให้เริ่มที่ low หรือ medium
Astra “ขอคำชี้แจงได้ง่ายกว่า” โมเดลรุ่นก่อน
ข้อความนักพัฒนาที่เน้น “bias towards action” จึงมีความสำคัญ

4. รันสถานการณ์โดยไม่ใช้โมเดล

นำเข้าสถานการณ์ที่สร้างขึ้นไปยัง Apidog เพิ่มการยืนยันรหัสสถานะและ Response Schema แล้วรันผ่าน Apidog CLI ใน pipeline

โมเดลเขียนการทดสอบเพียงครั้งเดียว แต่ CI สามารถรันการทดสอบเหล่านั้นเป็นพันครั้งโดยไม่เสียค่าใช้จ่ายโมเดล นี่คือเหตุผลที่ ดาวน์โหลด Apidog แล้ววางไว้ข้างคีย์ API ในเวิร์กโฟลว์นี้

รักษารั้วป้องกันไว้ แม้ Astra จะเคารพก็ตาม

ผลลัพธ์ด้าน alignment ของ Astra ดีที่สุดเท่าที่ OpenAI เคยเผยแพร่:

ในการทดสอบ honeypot หลังเหตุการณ์ Hugging Face Sol ข้ามเป้าหมายที่ได้รับอนุญาต 48% ของเวลา ขณะที่ Astra ไม่ข้ามเลย (0%)
Astra ไม่เคยพยายามหลีกเลี่ยงการปฏิเสธการตรวจสอบอัตโนมัติของ Codex แม้การตั้งค่าจะเปิดช่องให้หลีกเลี่ยงได้
ความทนทานต่อ indirect prompt injection อยู่ที่ 99.79% เพิ่มขึ้นจาก 96.23%

อย่างไรก็ตาม ยังต้องมี control gates อยู่ดี เพียงแต่ gate อาจทำงานน้อยลง โมเดลที่มีหน้าต่างโทเค็น 1M คะแนนความปลอดภัยทางไซเบอร์ระดับ Critical และความสามารถในการเรียก API ของคุณแบบสุ่ม ควรทำงานบน staging พร้อม:

ข้อมูลรับรองที่กำหนดขอบเขต
ประตูอนุมัติสำหรับการเปลี่ยนแปลง (mutations)
การติดตามทุกการเรียกใช้

ตัวตรวจสอบของ Astra อาจหยุดงานกลางคันได้ ดังนั้นให้ถือว่างานระยะยาวทุกงานต้องรองรับการทำงานต่อ แนวทางจาก การออกแบบการทดสอบสำหรับเอเจนต์ที่ไม่เป็นไปตามเงื่อนไขที่กำหนด ยังคงใช้ได้: ยืนยันตามสัญญา ไม่ใช่ตามบันทึกการสนทนา

เมื่อใดควรใช้การควบคุมหน้าจอ

อย่าเข้าใจว่า “ห้ามให้ Astra คลิกเลย” เพราะมีสามกรณีที่การใช้หน้าจอดีกว่า:

พอร์ทัลพันธมิตรหรือคอนโซลผู้ดูแลระบบที่ไม่มี API
การตรวจสอบ frontend ในวันเปิดตัว ซึ่งมนุษย์มักทำด้วยมือ
เครื่องมือเดสก์ท็อปแบบ Legacy ที่มีเฉพาะ UI

Astra เป็นโมเดลแรกที่ทำให้งานเหล่านี้คุ้มค่าต่อการมอบหมาย และความเร็วของชุดเครื่องมือ Codex ทำให้สามารถรันงานเหล่านี้ทุกคืนได้

ใช้สัญญาเมื่อมีสัญญา และใช้หน้าจอเมื่อไม่มีสัญญา

คำถามที่พบบ่อย

การใช้งานคอมพิวเตอร์ของ GPT-6 Astra ทำงานผ่าน API ได้หรือไม่?

ได้ การใช้งานคอมพิวเตอร์เป็นหนึ่งในเครื่องมือที่ Astra รองรับบน Responses API เช่นเดียวกับการค้นเว็บ การค้นไฟล์ ตัวแปลโค้ด และการสร้างรูปภาพ แอปพลิเคชันของคุณต้องเตรียมสภาพแวดล้อมและดำเนินการตาม action ที่โมเดลเสนอ หากตัวตรวจสอบความไม่สอดคล้องกันหยุดงานผ่าน API งานจะหยุดลงทันที

ฉันสามารถให้ Spec ขนาดใหญ่แค่ไหน?

หน้าต่างบริบทมีขนาด 1,050,000 โทเค็น และเอาต์พุต 128,000 โทเค็น Spec ที่มี Endpoint หลายร้อยรายการพร้อม Schema ครบถ้วนสามารถใส่ได้โดยมีพื้นที่เหลือ อย่างไรก็ตาม อินพุตที่เกิน 272K โทเค็นจะถูกคิดราคาเป็นสองเท่าของอัตราอินพุตและการแคช จึงควรแคช prefix ของ Spec และรักษาข้อความต่อการทดสอบให้เล็ก

Astra จะสร้าง Endpoint ที่ไม่มีอยู่ใน Spec ขึ้นมาเองหรือไม่?

มีโอกาสน้อยกว่าโมเดลรุ่นก่อน เกณฑ์มาตรฐานการหลอนภายในของ OpenAI ซึ่งคะแนนที่ต่ำกว่าดีกว่า แสดงว่า Astra อยู่ที่ 4.2% เทียบกับ Sol ที่ 12.2% และมีโอกาสบิดเบือนความสามารถของตัวเองน้อยกว่าสามเท่า ใช้เอาต์พุตแบบมีโครงสร้างและการตรวจสอบ Schema ใน Apidog เพื่อจับส่วนที่เหลือ การทดสอบสัญญา (contract test) จึงยังเป็นด่านสุดท้าย ไม่ใช่โมเดล

การสร้างการทดสอบด้วย Astra ถูกกว่า GPT-5.6 Sol หรือไม่?

หากคิดตามโทเค็น Astra ไม่ถูกกว่า โดยมีค่าใช้จ่าย $10 และ $50 ต่อล้านโทเค็น เทียบกับโปรโมชั่นของ Sol ที่ $4 และ $20 แต่ Astra ใช้โทเค็นน้อยกว่ามากต่องานที่เสร็จสมบูรณ์ และการสร้างการทดสอบจาก Spec ทำให้ต้นทุนโมเดลเกิดขึ้นเพียงครั้งเดียว ควรวัดผลกับ Spec ของคุณเอง โดยดูวิธีเปรียบเทียบจาก คู่มือ API

สรุป

GPT-6 Astra สามารถควบคุมคอมพิวเตอร์ได้จริง และสำหรับระบบที่ไม่มี API นั่นเป็นความสามารถที่มีประโยชน์มาก

แต่สำหรับ API ที่คุณเป็นเจ้าของ ให้ใช้แนวทางนี้:

มอบ OpenAPI spec ให้โมเดล
ให้ Astra เขียนสถานการณ์ทดสอบ
รันสถานการณ์เหล่านั้นใน CI
ใช้ control gates และตรวจสอบตามสัญญา
เก็บการควบคุมหน้าจอไว้สำหรับระบบที่ไม่มี API

กฎสั้น ๆ คือ ใช้สัญญาเมื่อมีสัญญา และใช้หน้าจอเมื่อไม่มีสัญญา

DEV Community