GPT-6 Astra: คู่มือปฏิบัติเพื่อเพิ่มประสิทธิภาพการใช้งาน Codex, Agents และการจัดการต้นทุน

วัตถุประสงค์:

เรียนรู้การจัดสรร Luna, Terra, Sol และ Astra อย่างชาญฉลาดเพื่อเพิ่มประสิทธิภาพสูงสุด ลดต้นทุน และทำให้เวิร์กโฟลว์ของเอเจนต์ทำงานได้เป็นเวลานาน

GPT-6 Astra ของ OpenAI ซึ่งประกาศเมื่อวันที่ 3 กันยายน 2026 ถือเป็นก้าวกระโดดครั้งสำคัญในความสามารถของเอเจนต์ในการทำงานด้านคอมพิวเตอร์ที่ซับซ้อน ซึ่งก่อนหน้านี้ต้องอาศัยการแทรกแซงของมนุษย์อย่างมาก

แต่ความท้าทายที่แท้จริงไม่ใช่แค่การถามว่า "Astra สามารถทำงานนี้ได้หรือไม่" อีกต่อไป

คำถามสำคัญในตอนนี้คือ:

Astra สร้างมูลค่าเพิ่มได้จริงที่ไหน เราควรจัดสรรทรัพยากรของเราอย่างไร เราจะทำให้เอเจนต์ทำงานได้นานขึ้นได้อย่างไร และเราจะบรรลุทั้งหมดนี้ด้วยต้นทุนที่ต่ำที่สุดได้อย่างไร?

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

กลุ่มเป้าหมาย

คู่มือนี้ถูกออกแบบมาสำหรับผู้ที่:

• ใช้เอเจนต์ผ่าน Codex หรือ OpenAI API ในสภาพแวดล้อมที่ใกล้เคียงกับการใช้งานจริง
• ต้องการสลับไปมาระหว่าง Luna, Terra, Sol และ Astra เพื่อลดต้นทุน API หรือโครงสร้างพื้นฐานรายเดือน
• ต้องการสร้างเวิร์กโฟลว์ที่ทำงานเป็นเวลานานสำหรับ: การดีบักอย่างละเอียด, การปรับโครงสร้างครั้งใหญ่, การใช้เครื่องมือทางคอมพิวเตอร์, การตรวจสอบทางคณิตศาสตร์, การทดสอบอัตโนมัติ และงานที่ต้องรักษาบริบทเป็นเวลานาน

0. ข้อกำหนดเบื้องต้น

การปรับใช้, องค์กร, Daybreak และความพร้อมใช้งาน

ก่อนที่จะพยายามปรับแต่ง Astra ให้เหมาะสม คุณต้องตรวจสอบก่อนว่าโมเดลนั้นพร้อมใช้งานสำหรับบัญชีและสภาพแวดล้อมของคุณจริงๆ

วันที่ประกาศ

3 กันยายน 2026 — ประกาศอย่างเป็นทางการ

OpenAI — GPT-6 Astra

การปรับใช้

ตามประกาศอย่างเป็นทางการ Trusted Access/Daybreak จะเป็นหนึ่งในช่องทางการปรับใช้แรกๆ

แผน Plus, Pro, Business และ Enterprise รวมถึง API และ AWS จะถูกปรับใช้ในภายหลัง

ในสภาพแวดล้อมขององค์กร ผู้ดูแลระบบอาจต้องเปิดใช้งานการเข้าถึงอย่างชัดเจน

ประเด็นสำคัญ

• Enterprise: ผู้ดูแลระบบต้องเปิดใช้งานเมื่อจำเป็น
• ฟรี: Astra ไม่ได้ถูกวางแผนให้เป็นโมเดลฟรี
• เครดิต: ผู้ใช้แผนแบบชำระเงินอาจมีตัวเลือกเครดิตเพิ่มเติมขึ้นอยู่กับผลิตภัณฑ์
• ความปลอดภัยทางไซเบอร์: ความสามารถขั้นสูงบางอย่างอาจมีเงื่อนไขขึ้นอยู่กับเส้นทางการเข้าถึงเฉพาะ เช่น Daybreak
• รหัสโมเดล API: gpt-6-astra

ราคา API มาตรฐาน

ตามอัตราที่ระบุในเอกสารนี้:

• อินพุต: $10 / ล้านโทเค็น
• เอาต์พุต: $50 / ล้านโทเค็น

มีอัตราและเงื่อนไขที่แตกต่างกันสำหรับโหมดบางโหมด, บริบทแบบยาว, การแคช และการประมวลผลแบบลำดับความสำคัญ

กฎพื้นฐาน:

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

ในขณะที่ตรวจสอบการเข้าถึง สามารถสร้างกลยุทธ์โดยใช้ Sol เป็นโมเดลพื้นฐาน ได้

1. Astra โดดเด่นตรงไหน และเมื่อไหร่ที่ Sol ก็เพียงพอแล้ว?

Astra ถูกออกแบบให้เป็นโมเดลระดับสูงสำหรับงานระดับมืออาชีพ โดยเฉพาะอย่างยิ่งงานที่เกี่ยวข้องกับ:

• การใช้คอมพิวเตอร์
• การท่องเว็บ
• วิศวกรรมซอฟต์แวร์
• เอเจนต์
• วิทยาศาสตร์
• คณิตศาสตร์
• งานแบบ end-to-end ที่ซับซ้อน

เอกสารอย่างเป็นทางการวางตำแหน่งโมเดลระดับสูงไว้สำหรับงาน end-to-end ที่ยากที่สุด

อย่างไรก็ตาม กลยุทธ์ที่ถูกต้อง ไม่ใช่การใช้ Astra สำหรับทุกสิ่งทุกอย่าง

กลยุทธ์ที่ถูกต้องคือ:

ใช้ Astra เฉพาะเมื่อความสามารถที่สูงกว่าของมันมีผลกระทบจริงต่อผลลัพธ์

1.1. ความแตกต่างปรากฏขึ้นจริงที่ไหน?

ความแตกต่างที่สำคัญที่สุดมักจะปรากฏในงานที่มีปัจจัยหลายอย่างรวมกัน:

• หลายไฟล์หรือหลายโมดูล
• หลายขั้นตอนติดต่อกัน
• การใช้เครื่องมืออย่างเข้มข้น
• การโต้ตอบกับอินเทอร์เฟซแบบกราฟิก
• ปัญหาที่ยากต่อการจำลอง
• การใช้เหตุผลทางคณิตศาสตร์
• การดีบักเป็นเวลานาน
• ต้นทุนสูงหากทำผิดพลาด
• การสูญเสียบริบท
• ความจำเป็นในการรักษากลยุทธ์ไว้เป็นเวลานาน

ในงานประจำวันและงานง่ายๆ ความแตกต่างอาจน้อยกว่ามาก

ดังนั้น กฎที่ดีคือ:

อย่าถามว่าโมเดลไหน "ดีกว่า" ให้ถามว่าโมเดลไหนถูกกว่าในการทำงานนี้ให้สำเร็จอย่างถูกต้อง

1.2. OSWorld, Mind2Web และคำถามเรื่องความเร็ว

เกณฑ์มาตรฐาน เช่น OSWorld และ Mind2Web มีประโยชน์ในการทำความเข้าใจความแตกต่างระหว่างโมเดล แต่ต้องตีความให้ถูกต้อง

ในการจำลองเวลาแฝงของ OSWorld 2.0 ที่กล่าวถึงในเอกสารอย่างเป็นทางการ Astra มีการใช้โปรเซสเซอร์สูงกว่า Sol และแสดง เวลาต่องานน้อยลงประมาณ 47% ในการเปรียบเทียบที่ระบุ

ตัวอย่างเช่น:

• Astra: ประมาณ 40 นาที
• Sol: ประมาณ 75 นาที

คะแนนที่ระบุคือประมาณ:

• Astra: 72.6%
• Sol: 65.7%

ในทำนองเดียวกัน เอกสารระบุว่า Astra + สายรัด Codex ใหม่ สามารถเร็วกว่าประสบการณ์ Sol ปัจจุบันได้ประมาณ 1.9 เท่า ในการทดสอบ Mind2Web บางอย่าง

แต่จำสองสิ่งนี้ไว้

1. มันคือเกณฑ์มาตรฐาน

ผลลัพธ์ 1.9 เท่าบน Mind2Web ไม่ได้หมายความว่างานภายในทุกงานในบริษัทจะเร็วขึ้น 1.9 เท่า

2. มันให้สัญญาณที่มีประโยชน์

ยิ่งงานขึ้นอยู่กับ:

• หน้าจอ
• เครื่องมือ
• การนำทาง
• หลายการกระทำ
• การตัดสินใจระหว่างทาง

มากเท่าไหร่ การประเมิน การรวมกันของโมเดล + ระบบเอเจนต์ ก็ยิ่งสมเหตุสมผลมากกว่าแค่การเปรียบเทียบโทเค็นต่อวินาที

1.3. เมื่อไหร่ที่ Sol ก็เพียงพอแล้ว?

ใช้ Sol, Terra หรือ Luna ก่อนเมื่อ:

• คำตอบสามารถเสร็จสิ้นได้ในการแลกเปลี่ยนครั้งเดียว
• คุณต้องการแก้ไขเพียงหนึ่งหรือสองไฟล์
• การทดสอบสั้น
• งานส่วนใหญ่เป็นการอ่าน
• ไม่จำเป็นต้องใช้ GUI
• ไม่จำเป็นต้องใช้เครื่องมือที่ซับซ้อน
• ต้นทุนในการทำงานซ้ำต่ำ
• ความล้มเหลวไม่ก่อให้เกิดผลกระทบใหญ่หลวง

Astra เริ่มมีความสมเหตุสมผลเมื่อเกิดสิ่งที่ตรงกันข้าม

ตัวอย่างเช่น:

• หลายไฟล์
• หลายโมดูล
• ห่วงโซ่เครื่องมือที่ยาว
• การใช้คอมพิวเตอร์
• การดีบักที่ซับซ้อน
• การตรวจสอบทางคณิตศาสตร์
• งานที่ความล้มเหลวหมายถึงการทำงานซ้ำจำนวนมาก
• การสูญเสียบริบทระหว่างเซสชันที่ยาวนาน

2. การกำหนดค่า ChatGPT, API และ Codex

2.1. ChatGPT: เลือก Astra

เมื่อ Astra พร้อมใช้งาน:

1. เปิด ChatGPT บนเว็บหรือเดสก์ท็อป
2. ตรวจสอบตัวเลือกโมเดล
3. เลือก Astra / GPT-6 Astra
4. หากคุณใช้ Codex ให้ตรวจสอบว่าโมเดลเดียวกันพร้อมใช้งานที่นั่นด้วย
5. หาก Astra ไม่ปรากฏ: ตรวจสอบแผน; ตรวจสอบสิทธิ์ขององค์กร; ตรวจสอบการปรับใช้; ใช้ Sol เป็นการกำหนดค่าชั่วคราว

แผน Pro, Business และ Enterprise อาจมี Astra รุ่นเฉพาะ คุณไม่ควรสรุปจากชื่อที่แสดงในอินเทอร์เฟซเพียงอย่างเดียว: ให้ตรวจสอบคำอธิบายที่สอดคล้องกับแผนเสมอ

2.2. API: model = "gpt-6-astra"

การกำหนดค่าพื้นฐานประกอบด้วยการระบุโมเดลใน Responses API

ข้อควรพิจารณาที่สำคัญ

• สำหรับการเรียกใช้เครื่องมือ ควรใช้ Responses API
• Astra ไม่รองรับ reasoning.effort = "none"
• หากคุณใช้การใช้เหตุผลระดับต่ำ ให้เริ่มต้นด้วยการกำหนดค่าเล็กน้อยและเพิ่มเมื่อจำเป็นเท่านั้น
• พารามิเตอร์ดั้งเดิมบางอย่าง เช่น temperature หรือ top_p อาจไม่พร้อมใช้งาน
• การจัดเก็บข้อมูลใน EU อาจกำหนดข้อจำกัดเกี่ยวกับ Fast/Priority
• การกำหนดค่าแคชสามารถย้ายไปยัง prompt_cache_options.ttl

2.3. Codex: การจัดการบริบทเชิงทดลอง

สำหรับเซสชันที่ยาวนาน Codex สามารถใช้กลไกการจัดการบริบทที่ซับซ้อนกว่าการบีบอัดประวัติแบบง่ายๆ

แนวคิดคือการเก็บรักษาข้อมูลสำคัญ เช่น:

• สมมติฐานที่ตรวจสอบแล้ว
• สมมติฐานที่ถูกยกเลิก
• ไฟล์ที่ตรวจสอบแล้ว
• การทดสอบที่ดำเนินการแล้ว
• ผลลัพธ์ที่ได้รับ
• การตัดสินใจที่ทำไป

การกำหนดค่าเชิงแนวคิดสามารถเป็นได้ดังนี้:

การกำหนดค่าการจัดการบริบทเชิงทดลองควรได้รับการปฏิบัติเช่นนั้น และตรวจสอบกับ Codex เวอร์ชันปัจจุบันก่อนที่จะนำมาใช้เป็นมาตรฐานของทีม

ทำไมมันถึงสำคัญ?

ในเซสชันการดีบักที่กินเวลาหลายชั่วโมง การสูญเสียบริบทอาจบังคับให้เอเจนต์ต้องตรวจสอบใหม่:

• สมมติฐานใดที่ถูกยกเลิกไปแล้ว
• ไฟล์ใดที่ได้รับการตรวจสอบแล้ว
• คำสั่งใดที่ใช้ได้ผลแล้ว
• การทดสอบใดที่ดำเนินการไปแล้ว

การจดบันทึกช่วยลดการทำซ้ำนั้น

สำคัญ:

อย่าเก็บข้อมูลที่เป็นความลับ ความลับ คีย์ API หรือข้อมูลที่ละเอียดอ่อนไว้ในบันทึกถาวรของเอเจนต์

2.4. การอนุมัติและแซนด์บ็อกซ์

เป้าหมายของระบบอัตโนมัติไม่ควรเป็น:

"ให้เอเจนต์ทำทุกอย่างได้"

เป้าหมายควรเป็น:

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

การกำหนดค่าแบบโต้ตอบที่แนะนำเป็นจุดเริ่มต้น:

เอเจนต์สามารถดูแล:

• การอ่านไฟล์
• การรันทดสอบ
• การวิเคราะห์ล็อก
• การเปลี่ยนแปลงในเครื่อง
• การสร้างคอมมิต
• การเตรียม Pull Request
• การตรวจสอบงานของตัวเอง
• การแก้ไขข้อผิดพลาด

มนุษย์ต้องคงการควบคุมเหนือ:

• การผลิต
• การปรับใช้
• การรวมโค้ดครั้งสุดท้าย
• การเผยแพร่
• การส่งข้อมูลภายนอก
• การแก้ไขสิทธิ์
• การดำเนินการที่ไม่สามารถย้อนกลับได้
• ข้อมูลที่เป็นความลับ

การอนุมัติควรกลายเป็น จุดตรวจสอบสุดท้าย ไม่ใช่การขัดจังหวะอย่างต่อเนื่องตลอดทั้งกระบวนการ

2.5. AGENTS.md และ Skills

ก่อนเริ่มงานสำคัญกับ Codex เอเจนต์ต้องรู้กฎของโปรเจกต์

สถาปัตยกรรมที่มีประโยชน์คือ:

AGENTS.md

ประกอบด้วย:

• กฎถาวร
• ขอบเขตที่อนุญาต
• ข้อจำกัด
• เงื่อนไขความสำเร็จ
• การทดสอบที่จำเป็น
• จุดที่ต้องให้มนุษย์อนุมัติ

Skills

ประกอบด้วย:

• ขั้นตอนที่ทำซ้ำๆ
• เวิร์กโฟลว์
• รายการตรวจสอบการปฏิบัติงาน
• กระบวนการเฉพาะทาง

MCP

ใช้สำหรับ:

• การเชื่อมต่อภายนอก
• บริการ
• เครื่องมือ
• แหล่งข้อมูล

การแบ่งอย่างง่ายคือ:

AGENTS.md = กฎ

Skills = ขั้นตอน

MCP = การเชื่อมต่อ

ตัวอย่างขั้นต่ำของ AGENTS.md

3. วิธีเขียนคำแนะนำที่ใช้ประโยชน์จาก Astra

คุณภาพของคำแนะนำมีผลกระทบอย่างมากต่อเอเจนต์ที่ทำงานเป็นเวลานาน

Astra อาจไวต่อ:

• ความคลุมเครือ
• ความขัดแย้ง
• คำแนะนำที่ล้าสมัย
• Skills ที่ไม่สอดคล้องกัน
• กฎที่ซ้ำซ้อน

ดังนั้น การกำหนดค่าที่ดีสามารถปรับปรุงประสิทธิภาพได้มากเท่ากับการเปลี่ยนโมเดล

3.1. เพิ่มความเป็นอิสระ

แทนที่จะสร้างคำแนะนำที่ทำให้เอเจนต์ต้องขอการยืนยันอยู่ตลอดเวลา ให้กำหนดพื้นที่ที่เอเจนต์สามารถดำเนินการได้ด้วยตนเองอย่างชัดเจน

3.2. การอนุมัติหลังจากผลลัพธ์ที่ตรวจสอบได้

กฎที่ดีที่สุดข้อหนึ่งสำหรับเอเจนต์อัตโนมัติคือ:

สร้างผลลัพธ์ที่ตรวจสอบได้ก่อน จากนั้นจึงขออนุมัติสำหรับขั้นตอนที่ไม่สามารถย้อนกลับได้

วิธีนี้หลีกเลี่ยงรูปแบบ:

เอเจนต์ → คำถาม → มนุษย์ → เอเจนต์ → คำถาม → มนุษย์

และแทนที่ด้วย:

เอเจนต์ → ตรวจสอบ → ดำเนินการ → ทดสอบ → เตรียมผลลัพธ์ → มนุษย์อนุมัติ → ดำเนินการขั้นสุดท้าย

3.3. คำถามที่ไม่ขัดขวางงานหลัก

ในเซสชันที่ยาวนาน การอนุญาตให้ถามคำถามอิสระโดยไม่หยุดโฟลว์หลักอาจมีประโยชน์

กฎที่ดีคือ:

งานหลักมีเงื่อนไขความสำเร็จคงที่หนึ่งประโยค หากมีคำถามอิสระเกิดขึ้นระหว่างการดำเนินการ ให้ตอบสั้นๆ โดยไม่ขัดจังหวะงานหลัก หยุดเวิร์กโฟลว์หลักเฉพาะเมื่อคำถามเปลี่ยนทิศทางของงาน ขอบเขต สิทธิ์ หรือผลลัพธ์ที่ต้องการ

API ยังสามารถใช้กลไกในการส่งคำแนะนำเพิ่มเติมระหว่างการดำเนินการและเครื่องมือแบบอะซิงโครนัสสำหรับงานที่ยืดเยื้อ

3.4. การมอบหมายให้กับเอเจนต์ย่อย

เมื่องานสามารถทำแบบขนานได้ ให้ทำอย่างชัดเจน

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

ตัวอย่างการทำแบบขนาน:

• เอเจนต์ A → ตรวจสอบโมดูลการตรวจสอบสิทธิ์
• เอเจนต์ B → วิเคราะห์การทดสอบ
• เอเจนต์ C → ตรวจสอบประเภท
• เอเจนต์ D → ตรวจสอบเอกสาร

จากนั้น เอเจนต์หลักจะรวมผลลัพธ์

3.5. ควบคุมปริมาณการทดสอบ

การทดสอบมากขึ้นไม่ได้หมายถึงผลลัพธ์ที่ดีกว่าเสมอไป

สำหรับการเปลี่ยนแปลงเล็กน้อย:

เป้าหมายคือเพื่อป้องกันไม่ให้การปรับเปลี่ยนเล็กน้อยทำให้เกิดการทดสอบที่ไม่จำเป็นจำนวนมาก

3.6. เทมเพลตสำหรับการดีบักเป็นเวลานาน

3.7. เทมเพลตสำหรับงานคอมพิวเตอร์และเบราว์เซอร์

4. เพิ่มมูลค่าสูงสุด ไม่ใช่จำนวนโทเค็น

คำถามที่ถูกต้องไม่ใช่:

"ฉันจะใช้โทเค็นทั้งหมดของ Astra ได้อย่างไร?"

คำถามที่ถูกต้องคือ:

"ฉันจะทำงานให้เสร็จมากขึ้นต่อทุกๆ ดอลลาร์ที่ใช้ไปได้อย่างไร?"

ตามอัตราที่ระบุ:

Astra มีราคาต่อโทเค็นแพงกว่าอย่างเห็นได้ชัด

แต่ราคาต่อโทเค็นไม่ได้แสดงถึงต้นทุนจริงในการทำงานให้เสร็จเสมอไป

หาก Astra ทำได้:

• ข้อผิดพลาดน้อยลง
• การวนซ้ำน้อยลง
• การทำงานซ้ำน้อยลง
• การเรียกใช้เครื่องมือน้อยลง
• เวลารวมน้อยลง
• อัตราความสำเร็จสูงขึ้น

ต้นทุนต่องานที่ เสร็จสมบูรณ์ ก็สามารถแข่งขันได้หรือต่ำกว่าด้วยซ้ำ

4.1. ตารางการจัดเส้นทางเชิงปฏิบัติ

กฎทั่วไป:

Luna/Terra สำหรับปริมาณมาก → Sol สำหรับงานมาตรฐาน → Astra สำหรับงานที่คุ้มค่ากับต้นทุนจริงๆ

4.2. นิสัยที่ช่วยลดต้นทุน

1. เขียนเงื่อนไขความสำเร็จก่อน

วิธีนี้ช่วยลดการสำรวจที่ไม่จำเป็น

1. หลีกเลี่ยงบทพูดคนเดียวระหว่างทาง

ให้ความสำคัญกับ:

สถานะ → การดำเนินการถัดไป → ผลลัพธ์

แทนที่จะอธิบายไม่รู้จบ

1. ส่งการตรวจสอบง่ายๆ ไปยังโมเดลที่ประหยัด

อย่าเสีย Astra ไปกับ:

• การตรวจสอบรูปแบบ
• การสรุปบันทึกขนาดเล็ก
• การจำแนกไฟล์
• การทำงานซ้ำๆ

1. ทำให้คำนำหน้าคำสั่งมีเสถียรภาพ

การรักษาคำแนะนำของระบบ/นักพัฒนาให้สอดคล้องกันอาจช่วยให้การใช้แคชมีประสิทธิภาพ

1. ใช้โหมดเร็วเฉพาะเมื่อเพิ่มมูลค่า

หากโหมดมีราคาแพงกว่า จะต้องมีเหตุผลจากการลดเวลาในการดำเนินการจริง

4.3. การตรวจสอบต้นทุนรายสัปดาห์

ทุกสัปดาห์ให้ตรวจสอบ:

• งานที่ดำเนินการกับ Astra
• เหตุผลที่ใช้มัน
• ผลลัพธ์
• ต้นทุนโดยประมาณ
• หาก Sol เพียงพอหรือไม่
• หาก Terra เพียงพอหรือไม่
• จำนวนการวนซ้ำ
• ความล้มเหลว
• การทำงานซ้ำ

กฎง่ายๆ

หากคุณไม่สามารถอธิบายเป็นลายลักษณ์อักษรได้ว่า:

"Astra จำเป็นเพราะ..."

ให้พิจารณาย้ายหมวดหมู่งานนั้นไปยังโมเดลที่ต่ำกว่า

5. เวิร์กโฟลว์ที่แนะนำ

5.1. การดีบักเป็นเวลานาน

ขั้นตอนที่ 1 — การจำแนกประเภท

หากมีหลายไฟล์ การจำลองที่ซับซ้อน หรือเครื่องมือมากมาย:

Astra

หากเป็นเรื่องง่าย:

Sol/Terra

ขั้นตอนที่ 2 — ข้อจำกัด

กำหนดใน AGENTS.md:

• ไฟล์ที่อนุญาต
• ไฟล์ที่ห้าม
• คำสั่งที่อนุญาต
• การทดสอบที่จำเป็น
• จุดอนุมัติ

ขั้นตอนที่ 3 — การกำหนดค่า

model = "gpt-6-astra" approval_policy = "on-request" sandbox_mode = "workspace-write" [features.context_management] experimental_mode = true

ขั้นตอนที่ 4 — เริ่มต้น

เริ่มต้นด้วยเงื่อนไขความสำเร็จที่ชัดเจนเสมอ

ขั้นตอนที่ 5 — บันทึก

เก็บรักษา:

• สมมติฐาน
• การทดสอบ
• ผลลัพธ์
• ไฟล์ที่ตรวจสอบ
• การตัดสินใจ

ขั้นตอนที่ 6 — การขัดจังหวะ

คำถามอิสระต้องไม่ทำลายบริบทของงานหลัก

ขั้นตอนที่ 7 — ผลงานที่ส่งมอบ

เอเจนต์สามารถไปได้ไกลถึง:

Pull Request พร้อมสำหรับการตรวจสอบ

การรวมโค้ดครั้งสุดท้ายยังคงอยู่ภายใต้การควบคุมของมนุษย์

ขั้นตอนที่ 8 — การเรียนรู้

หากปัญหาเดิมปรากฏขึ้นซ้ำๆ:

เปลี่ยนเป็น

Skill

.

5.2. การปรับโครงสร้างขนาดใหญ่

กลยุทธ์สองขั้นตอนใช้ได้ผลดี:

ขั้นตอนที่ 1 — การตรวจสอบราคาถูก

ใช้:

Luna → Terra → Sol

เพื่อสร้าง:

• แผนผังการพึ่งพา
• ผลกระทบ
• โมดูลที่ได้รับผลกระทบ
• ความเสี่ยง
• แผนการดำเนินการ

ขั้นตอนที่ 2 — การดำเนินการ

ใช้:

Astra

สำหรับโมดูลที่ต้องการความสามารถที่สูงกว่าจริงๆ

ขั้นตอนที่ 3 — การทำแบบขนาน

เอเจนต์ย่อยสำหรับ:

• การทดสอบ
• การตรวจสอบประเภท
• การตรวจสอบ
• โมดูลอิสระ

ขั้นตอนที่ 4 — การตรวจสอบโดยมนุษย์

มนุษย์มุ่งเน้นไปที่:

• สถาปัตยกรรม
• API สาธารณะ
• ความเข้ากันได้
• การตัดสินใจที่ไม่สามารถย้อนกลับได้

5.3. การใช้คอมพิวเตอร์

สำหรับงานเบราว์เซอร์หรือ GUI:

1. กำหนดหน้าจอเป้าหมายอย่างชัดเจน
2. กำหนดการดำเนินการที่ห้าม
3. ใช้ Astra เมื่องานยาวหรือซับซ้อนทางสายตา
4. ใช้สายรัด Codex ล่าสุดเมื่อเหมาะสม
5. บันทึกสถานะและขั้นตอน
6. เปลี่ยนผลลัพธ์เป็นผลงานที่ตรวจสอบได้

ตัวเลข 1.9 เท่าใน Mind2Web ควรตีความเป็นเพียงเกณฑ์มาตรฐาน ไม่ใช่การรับประกันประสิทธิภาพภายใน

5.4. เอเจนต์ที่ใช้ API

การกำหนดค่าเชิงแนวคิด:

Model: gpt-6-astra API: Responses Reasoning: ต่ำ → สูงเมื่อจำเป็น Tools: เปิดใช้งาน Long-running tools: อะซิงโครนัสเมื่อเหมาะสม Human gate: การดำเนินการสุดท้ายที่ไม่สามารถย้อนกลับได้

สำหรับเครื่องมือที่ทำงานเป็นเวลานาน:

ใช้การดำเนินการเครื่องมือแบบอะซิงโครนัสเมื่อเวลาทำงานของเครื่องมือนานพอที่การบล็อกการดำเนินการแบบซิงโครนัสจะลดปริมาณงาน

หากระดับความยากเปลี่ยนแปลงระหว่างการดำเนินการ:

เพิ่มความพยายามในการใช้เหตุผลเฉพาะเมื่องานยากขึ้นจริงๆ กลับไปยังระดับการใช้เหตุผลที่ต่ำกว่าสำหรับการดำเนินการตามปกติเมื่อเหมาะสม

แนวคิดคือการสงวนทรัพยากรที่แพงที่สุดไว้สำหรับช่วงเวลาที่ต้องการจริงๆ

6. สิ่งที่ควรทำและไม่ควรทำ

สิ่งที่ควรทำ

• เก็บ Astra ไว้สำหรับงานที่มันสร้างความแตกต่างจริงๆ
• ตรวจสอบความไม่สอดคล้องกันระหว่าง AGENTS.md และ Skills
• ให้การอนุมัติเป็นจุดตรวจสอบสุดท้าย
• สร้างผลลัพธ์ที่ตรวจสอบได้ก่อนขออนุญาต
• เปิดใช้งานการจัดการบริบทสำหรับงานที่ยาวนานเมื่อเหมาะสม
• บันทึกสมมติฐาน การทดสอบ และผลลัพธ์
• ปฏิบัติต่อเกณฑ์มาตรฐานเป็นแนวทาง ไม่ใช่ KPI ภายใน
• วัดอัตราความสำเร็จและเวลาต่องาน
• ตรวจสอบตั้งแต่ต้นว่างานต้องใช้ Daybreak หรือไม่
• เก็บข้อมูลที่เป็นความลับออกจากบันทึกถาวร

สิ่งที่ไม่ควรทำ

• ใช้ Astra สำหรับทุกคำถามเล็กๆ น้อยๆ
• ตีความวลีส่งเสริมการขายเป็นข้อมูลจำเพาะทางเทคนิค
• ปฏิบัติต่อประสบการณ์ส่วนตัวบน X หรือ Reddit ว่าเป็นเอกสารทางการ
• ประกาศการปรับใช้ในองค์กรก่อนที่ผู้ดูแลระบบจะเปิดใช้งาน
• ให้การเข้าถึงการดำเนินการที่ไม่สามารถย้อนกลับได้โดยอัตโนมัติ
• เก็บความลับหรือข้อมูลที่เป็นความลับในไฟล์บริบท
• รันชุดทดสอบขนาดใหญ่สำหรับการเปลี่ยนแปลงเล็กน้อย
• ใช้เกณฑ์มาตรฐานภายนอกแทนที่เมตริกภายใน

7. แผนการดำเนินการ 60 นาที

0–5 นาที

ตรวจสอบว่า gpt-6-astra พร้อมใช้งานหรือไม่:

• ตัวเลือกโมเดล
• API
• Codex

หากเป็น Enterprise ให้ตรวจสอบสิทธิ์ของผู้ดูแลระบบ

5–15 นาที

ตรวจสอบ:

model = "gpt-6-astra" approval_policy = "on-request" sandbox_mode = "workspace-write"

และสำหรับการทดลองบริบท:

[features.context_management] experimental_mode = true

รีสตาร์ท Codex หากจำเป็น

15–25 นาที

อัปเดต AGENTS.md:

• ขอบเขต
• ข้อจำกัด
• การทดสอบ
• เงื่อนไขความสำเร็จ
• จุดอนุมัติ

25–35 นาที

สร้างตารางการจัดเส้นทาง:

Luna → Terra → Sol → Astra

35–55 นาที

ดำเนินงานดีบักจริงที่มีขอบเขตจำกัดกับ Astra

ใช้เงื่อนไขความสำเร็จที่ชัดเจน

55–60 นาที

บันทึก:

• Astra จำเป็นจริงๆ หรือไม่?
• Sol เพียงพอหรือไม่?
• มันป้องกันการทำงานซ้ำได้มากแค่ไหน?
• การกำหนดค่าใดที่ใช้ได้ผล?
• อะไรควรกลายเป็น Skill?

แค่นี้ก็เพียงพอแล้ว

คุณไม่จำเป็นต้องทดสอบทุกฟีเจอร์ที่มี

การกระจาย + ข้อจำกัด + เซสชันที่ยาวนาน = พื้นฐานสำหรับการใช้ประโยชน์จาก Astra

8. รูปแบบเชิงปฏิบัติที่เกิดขึ้นซ้ำๆ

1. จรวดสองขั้นตอน

โมเดลประหยัด → Astra

ก่อนอื่น:

• การตรวจสอบ
• การกำหนดขอบเขต
• การวิเคราะห์

จากนั้น:

• การดำเนินการที่ซับซ้อน
• การรวมระบบ
• การตรวจสอบ

2. เงื่อนไขความสำเร็จตั้งแต่เริ่มต้น

ในเอเจนต์ที่ทำงานเป็นเวลานาน ให้เขียนในส่วนแรกของคำแนะนำ:

"งานจะเสร็จสิ้นเมื่อ..."

วิธีนี้ป้องกันการสำรวจอย่างไร้จุดหมาย

3. บริบทและการจดบันทึก

สำหรับงานที่ยาวนาน ให้เก็บรักษา:

• สมมติฐาน
• ผลลัพธ์
• การตัดสินใจ
• การทดสอบ
• ไฟล์สำคัญ

อย่าพึ่งพาหน่วยความจำที่ถูกบีบอัดของเอเจนต์แต่เพียงผู้เดียว

4. การอนุมัติต้องเป็นขั้นตอนสุดท้าย

อย่าขัดจังหวะตลอดเวลา

ดีกว่า:

ตรวจสอบ → ดำเนินการ → ทดสอบ → เตรียมผลลัพธ์ → ตรวจสอบ → อนุมัติ → ดำเนินการที่ไม่สามารถย้อนกลับได้

5. เกณฑ์มาตรฐานเป็นแนวทาง

Mind2Web และ OSWorld สามารถช่วยคุณตัดสินใจว่าจะทดสอบอะไร

แต่ KPI ที่แท้จริงต้องเป็นภายใน:

• อัตราความสำเร็จ
• เวลาในการดำเนินการ
• ต้นทุนต่องาน
• จำนวนการวนซ้ำ
• การทำงานซ้ำ
• การแทรกแซงของมนุษย์

9. ข้อผิดพลาดทั่วไป

ก่อนที่จะสรุปว่า:

"Astra อ่อนแอ"

ให้ตรวจสอบก่อนตามลำดับนี้:

1. การมองเห็น

โมเดลพร้อมใช้งานจริงหรือไม่?

1. กรอบงาน

Codex อัปเดตและกำหนดค่าอย่างถูกต้องหรือไม่?

1. พรอมต์

คำแนะนำชัดเจนหรือไม่?

1. AGENTS.md

มีกฎที่ขัดแย้งกันหรือไม่?

1. Skills

มีขั้นตอนที่เก่าหรือไม่สอดคล้องกันหรือไม่?

1. การจัดเส้นทาง

คุณใช้โมเดลที่เหมาะสมกับงานหรือไม่?

บ่อยครั้งที่ปัญหาไม่ใช่ความสามารถของโมเดล

มันคือ สภาพแวดล้อมที่โมเดลกำลังทำงานอยู่

10. รายการตรวจสอบการดำเนินการสำหรับทีม

• กำหนดว่าใครจะใช้ Astra
• เปิดใช้งานสิทธิ์การดูแลระบบที่จำเป็น
• กำหนดเจ้าของและกำหนดเวลา
• สร้างตารางการจัดเส้นทาง Luna/Terra/Sol/Astra
• สร้าง AGENTS.md ขั้นต่ำ
• กำหนด approval_policy
• กำหนด sandbox_mode
• กำหนดจุดแทรกแซงของมนุษย์
• บันทึกการดำเนินการที่เป็นความลับ
• กำหนดการตรวจสอบต้นทุนรายสัปดาห์
• บันทึกว่างานใดที่ต้องใช้ Astra จริงๆ
• แปลงข้อผิดพลาดที่เกิดขึ้นซ้ำๆ เป็น Skills

ลำดับความสำคัญควรเป็นการลดข้อผิดพลาดและการทำงานซ้ำของทีม ไม่ใช่แค่การเพิ่มความเร็วของเอเจนต์แต่ละตัวให้สูงสุด

11. แผนผังการตัดสินใจ: Sol vs. Astra

ใช้ลำดับนี้เมื่อเริ่มงาน:

1. สามารถเสร็จสิ้นได้ในการแลกเปลี่ยนครั้งเดียวหรือไม่?

ใช่ → Luna / Terra / Sol

ไม่ → ดำเนินการต่อ

1. ต้องใช้ GUI เครื่องมือ หรือหลายขั้นตอนหรือไม่?

ใช่ → Astra

ไม่ → ดำเนินการต่อ

1. ต้นทุนของความล้มเหลวสูงหรือไม่?

ใช่ → Astra

ไม่ → Sol/Terra

1. งานสามารถเปลี่ยนระดับความยากระหว่างการดำเนินการได้หรือไม่?

ใช่ → พิจารณา Astra + การปรับระดับการใช้เหตุผลแบบไดนามิก

1. Astra ยังไม่พร้อมใช้งานหรือไม่?

ดำเนินการเวิร์กโฟลว์เดียวกันกับ Sol

เมื่อ Astra ปรากฏขึ้น ให้เปลี่ยนเฉพาะโมเดลและรักษาโครงสร้างไว้

12. การย้าย API ไปยัง Astra

ลำดับที่แนะนำคือ:

1. เปลี่ยนโมเดล

model = "gpt-6-astra"

1. ใช้ Responses API

โดยเฉพาะอย่างยิ่งหากมีการเรียกใช้เครื่องมือ

1. ตรวจสอบการใช้เหตุผล

Astra ไม่ใช้:

reasoning.effort = "none"

เริ่มต้นด้วยระดับต่ำเมื่อเพียงพอ

1. ลบพารามิเตอร์ที่ไม่จำเป็น

ตรวจสอบพารามิเตอร์ เช่น:

temperature top_p

หากโมเดลหรือเอนด์พอยต์ไม่รองรับอีกต่อไป

1. ตรวจสอบแคช

ย้ายไปยัง:

prompt_cache_options.ttl

เมื่อเหมาะสม

1. ตรวจสอบการจัดเก็บข้อมูล

หากคุณใช้ข้อกำหนดด้านโครงสร้างพื้นฐานหรือการจัดเก็บข้อมูลใน EU ให้ตรวจสอบข้อจำกัดที่เกี่ยวข้อง

1. ปรับการใช้เหตุผลแบบไดนามิก

ระหว่างงานที่ยาก:

เพิ่มความพยายามในการใช้เหตุผลเมื่องานยากขึ้นจริงๆ

ระหว่างการดำเนินการตามปกติ:

กลับไปยังระดับการใช้เหตุผลที่ต่ำกว่าเมื่อการใช้เหตุผลเพิ่มเติมไม่มีประโยชน์อีกต่อไป

1. เครื่องมือที่ยาวนาน

พิจารณาการดำเนินการแบบอะซิงโครนัสเมื่อเวลาเครื่องมือสมเหตุสมผล

13. การกำหนดค่า Codex ขั้นต่ำ

การกำหนดค่าเริ่มต้นสามารถเป็นได้ดังนี้:

model = "gpt-6-astra" model_reasoning_effort = "high" approval_policy = "on-request" sandbox_mode = "workspace-write" [features.context_management] experimental_mode = true

และพื้นที่เก็บข้อมูลควรมี AGENTS.md ที่กำหนด:

AGENTS.md

เป้าหมาย

• เปลี่ยนแปลงให้น้อยที่สุด
• การทำงานจะเสร็จสมบูรณ์เมื่อการทดสอบที่จำเป็นทั้งหมดผ่าน

ขอบเขตที่อนุญาต

• src/
• tests/

จุดตรวจสอบที่ต้องขออนุมัติ

• การปรับใช้ในระบบผลิตจริง
• การส่งข้อมูลภายนอก
• การเปลี่ยนแปลงสิทธิ์การเข้าถึง
• การรวมโค้ดครั้งสุดท้าย

ลักษณะการทำงาน

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

หลังจากแก้ไขการกำหนดค่า:

1. รีสตาร์ท Codex;
2. ดำเนินงานอ่านขนาดเล็ก
3. ตรวจสอบว่าสภาพแวดล้อมทำงานได้
4. เริ่มงานหลัก

14. นิยาม "การใช้ประโยชน์สูงสุด" ในหนึ่งประโยค

ในเอกสารนี้ การใช้ประโยชน์สูงสุดไม่ได้หมายถึงการกินโทเคนสูงสุด

มันหมายถึง:

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

การตัดสินใจหลายอย่างตามมาจากนิยามนี้:

• การอัปเดตตารางเส้นทางทุกสัปดาห์ดีกว่าการเปลี่ยนโมเดลตามอำเภอใจ
• การทดสอบการดีบักจริงดีกว่าการลองใช้ฟีเจอร์ใหม่ทุกอย่าง
• การวัดความสำเร็จและเวลาต่องานดีกว่าการไล่ตาม benchmark
• เราต้องไม่เปลี่ยนวลีโปรโมชันเป็นข้อกำหนดภายใน
• หาก Astra ไม่พร้อมใช้งาน สามารถใช้ Sol เป็นตัวแทนชั่วคราวได้

15. สามสิ่งที่ต้องส่งมอบพื้นฐาน

ท้ายที่สุดแล้ว ระบบทั้งหมดนี้ควรสร้างสามองค์ประกอบ:

1. ตารางการจัดสรรแบบไดนามิก

กำหนดว่าเมื่อใดควรใช้:

Luna / Terra / Sol / Astra

2. AGENTS.md

กำหนด:

• กฎ;
• ขอบเขต;
• ข้อจำกัด;
• การทดสอบ;
• เงื่อนไขการเสร็จสมบูรณ์;
• จุดตรวจสอบของมนุษย์

3. พรอมต์การปฏิบัติงานแบบยาว

ต้องกำหนด:

• บทบาท;
• วัตถุประสงค์;
• เงื่อนไขการเสร็จสมบูรณ์;
• ขั้นตอน;
• ข้อจำกัด;
• เครื่องมือ;
• การตรวจสอบ;
• รูปแบบผลลัพธ์

สามองค์ประกอบนี้สำคัญกว่าการจดจำแคตตาล็อกฟีเจอร์ทั้งหมด

16. การ์ดจำแนกประเภทเพื่อคัดลอก

ใช้การ์ดนี้เมื่อเริ่มเซสชันสำคัญแต่ละครั้ง:

การ์ดไม่จำเป็นต้องสมบูรณ์แบบ

เป้าหมายของมันคือการสร้าง นิสัยในการจำแนกประเภท

หากคุณแนะนำ Astra แต่งานต้องการเพียงคำตอบสั้น ๆ คุณอาจกำลังใช้โมเดลที่ใหญ่เกินไป

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

17. วิธีคิดเกี่ยวกับราคาอย่างแท้จริง

อัตราต่อล้านโทเคนเป็นเพียงส่วนหนึ่งของสมการเท่านั้น

ตัวอย่างเช่น:

Astra

• Input: $10
• Output: $50

Sol

• Input: $4
• Output: $20

Astra มีราคาแพงกว่า

แต่ลองจินตนาการดู:

Sol

โทเคน $5 + พยายาม 4 ครั้ง + ล้มเหลว 2 ครั้ง + ทำงานซ้ำโดยมนุษย์ = ต้นทุนจริงสูง

Astra

โทเคน $12 + พยายาม 1 ครั้ง + ผลลัพธ์ที่ถูกต้อง = ต้นทุนรวมต่ำกว่าต่องาน

ดังนั้น สำหรับงานสั้น:

ราคาต่อโทเคนมีความสำคัญอย่างมาก

สำหรับงานยาว:

ต้นทุนต่องานที่เสร็จสมบูรณ์มีความสำคัญมากกว่า

เมตริกสุดท้ายควรเป็น:

ต้นทุน × อัตราความสำเร็จ × เวลา × การแทรกแซงของมนุษย์

และไม่ใช่แค่:

$/1M โทเคน

บทสรุป

เป้าหมายของ Astra ไม่ควรเป็นการทำให้มันเป็นโมเดลเริ่มต้นสำหรับทุกอย่าง

เป้าหมายควรเป็นการสร้างระบบที่แต่ละโมเดลทำงานที่มันมีประสิทธิภาพสูงสุด

Luna

งานปริมาณมากและงานง่าย

Terra

สมดุลระหว่างต้นทุนและความสามารถ

Sol

งานมาตรฐานและการเขียนโปรแกรมทั่วไป

Astra

งานที่ซับซ้อน ยาว เป็น agentic, GUI, คณิตศาสตร์, การดีบัก และงานที่ความล้มเหลวมีค่าใช้จ่ายสูง

รูปแบบที่ทรงพลังที่สุดคือ:

ตรวจสอบด้วยต้นทุนต่ำ → วางแผน → ดำเนินการกับ Astra เมื่อจำเป็น → ตรวจสอบ → เตรียมผลลัพธ์ที่ตรวจสอบได้ → การแทรกแซงของมนุษย์เฉพาะที่จุดตรวจสอบสุดท้าย

การปรับให้เหมาะสมอย่างแท้จริงไม่ใช่การใช้ Astra มากขึ้น

มันคือ การรู้อย่างแม่นยำว่าเมื่อใดที่ Astra คุ้มค่า

และยิ่ง agents มีความซับซ้อนมากเท่าไร โครงสร้างพื้นฐานที่อยู่รอบตัวพวกมันก็ยิ่งสำคัญมากขึ้นเท่านั้น: AGENTS.md, Skills, sandbox, การอนุมัติ, การจัดการบริบท**