บทเรียนสอนใช้ GPT-6 Astra API: การสร้างเอเจนต์ AI สำหรับงานโปรดักชัน

TL;DR

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

รูปแบบการออกแบบเชิงปฏิบัติคือลูปการดำเนินการที่มีเครื่องมือแบบชัดเจน สิทธิ์ฝั่งแอป การตรวจสอบงบประมาณ และการอนุมัติจากมนุษย์สำหรับการกระทำที่มีผลกระทบ เริ่มต้นด้วย Responses API วัดต้นทุนต่อภารกิจที่ยอมรับ และส่งงานย่อยที่เป็นกิจวัตรไปยังโมเดลที่มีราคาถูกกว่า

Key Takeaways

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

What Is the Astra API, and Which Agent Workloads Fit It?

OpenAI อธิบาย Astra ว่าเป็นโมเดลที่มีความสามารถสูงสุดสำหรับการให้เหตุผลที่ซับซ้อน การเขียนโค้ด การใช้คอมพิวเตอร์ การวิจัย และการสร้างเอกสาร สเปกทางการระบุ หน้าต่างบริบท 1,050,000 โทเค็นและขีดจำกัดผลลัพธ์ 128,000 โทเค็น รับอินพุตเป็นข้อความและภาพ โดยข้อความเป็นโมดาลิตี้ผลลัพธ์โดยกำเนิด

ภาพเปิดตัว OpenAI GPT-6 Astra

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

GPT-6 Astra Agent Benchmarks

การประเมินที่มีประโยชน์ที่สุดคือแบบที่ต้องใช้งานซอฟต์แวร์ งานเทอร์มินัล ปฏิสัมพันธ์เชิงภาพ หรือการทำเวิร์กโฟลว์มืออาชีพให้เสร็จ ผลลัพธ์ที่รายงานโดย OpenAI แสดงให้เห็นถึงความก้าวหน้าที่ใหญ่กว่าในงานเชิงปฏิบัติการมากกว่าดัชนีความฉลาดโดยรวม

GPT-6 Astra นำหน้า GPT-5.6 Sol และ Claude Fable 5.1 ในทุกแถวของเกณฑ์มาตรฐานที่ทั้งสามโมเดลมีคะแนนที่รายงาน ช่องว่างที่แคบที่สุดเหนือ Claude Fable 5.1 คือ 2.1 คะแนนบน Terminal-Bench 4.0 ในขณะที่ความได้เปรียบที่ใหญ่กว่าปรากฏใน AutomationBench, FrontierMath Tier 4 v2, GPQA Diamond และงานย้ายฐานข้อมูล OpenAI ยังรายงาน เวลาในการจำลองภารกิจลดลง 47% ในการเปรียบเทียบ OSWorld ซึ่งมีความสำคัญเมื่อความหน่วงของเอเจนต์กระทบต่อปริมาณงานธุรกิจ

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

Which Astra Features Change Agent Architecture?

GPT-6 Astra Async Tool Calling

การเรียกใช้เครื่องมือแบบอะซิงก์ ช่วยให้โมเดลดำเนินการให้เหตุผลที่เป็นประโยชน์ต่อไป เรียกเครื่องมือที่เป็นอิสระ หรือตอบอีกส่วนหนึ่งของคำขอในขณะที่แอปพลิเคชันกำลังรันปฏิบัติการที่ช้า แอปพลิเคชันยังคงต้องดำเนินการเครื่องมือและคืนผลลัพธ์โดยใช้ call ID เดิม

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

GPT-6 Astra Mid-Turn Steering

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

GPT-6 Astra Structured Tool Design

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

How Should You Architect an Astra Agent?

คำขอโมเดลภาษาทั่วไปมีเส้นทางสั้น: พรอมต์ → โมเดล → คำตอบ เอเจนต์ต้องมีลูปที่สังเกตได้:

เป้าหมาย → การเลือกบริบท → แผน → การเลือกเครื่องมือ → การกระทำที่ได้รับอนุญาต → การสังเกต → การตรวจสอบ → เสร็จสิ้นหรือยกระดับ

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

How Do You Call the Astra API Through CometAPI?

GPT-6 Astra API in CometAPI ใช้รหัสโมเดล gpt-6-astra ผ่านเวิร์กโฟลว์ Responses ที่เข้ากันได้กับ OpenAI ทำขั้นตอนตั้งค่าต่อไปนี้ก่อนส่งคำขอแรก:

1. สร้างบัญชี CometAPI เปิดการเข้าถึง GPT-6 Astra และสร้างคีย์ API
2. ติดตั้งหรืออัปเกรด OpenAI Python SDK ด้วย pip install --upgrade openai
3. เก็บคีย์และ OpenAI-compatible base URL ไว้ใน COMETAPI_KEY และ COMETAPI_BASE_URL; ห้ามฮาร์ดโค้ดความลับสำหรับโปรดักชัน
4. ยืนยันว่าเอ็นด์พอยต์ Responses และรหัสโมเดล gpt-6-astra เปิดใช้งานสำหรับเวิร์กสเปซ แล้วรันตัวอย่างด้านล่าง

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["COMETAPI_KEY"],
    base_url=os.environ["COMETAPI_BASE_URL"],
)

response = client.responses.create(
    model="gpt-6-astra",
    reasoning={"effort": "medium"},
    input=(
        "Analyze this operational incident. Identify the probable root cause, "
        "propose a remediation plan, and separate confirmed facts from assumptions."
    ),
)

print(response.output_text)

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

How Do You Build a Tool-Calling Astra Agent?

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

tools = [
    {
        "type": "function",
        "name": "get_order",
        "description": "Read an order. This tool has no side effects.",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
            "additionalProperties": False,
        },
    },
    {
        "type": "function",
        "name": "check_refund_eligibility",
        "description": "Check eligibility without issuing a refund.",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
            "additionalProperties": False,
        },
    },
    {
        "type": "function",
        "name": "create_refund_request",
        "description": "Create a request after authorization and eligibility checks.",
        "parameters": {
            "type": "object",
            "properties": {
                "order_id": {"type": "string"},
                "reason": {"type": "string"},
            },
            "required": ["order_id", "reason"],
            "additionalProperties": False,
        },
    },
]

response = client.responses.create(
    model="gpt-6-astra",
    reasoning={"effort": "medium"},
    tools=tools,
    input=(
        "Order A18422 arrived damaged. Determine whether a refund is allowed. "
        "Do not create a request until eligibility has been verified."
    ),
)
``````python
import json

def execute_tool(name, arguments):
    if name == "get_order":
        return get_order(**arguments)
    if name == "check_refund_eligibility":
        return check_refund_eligibility(**arguments)
    if name == "create_refund_request":
        assert_user_is_authorized()
        assert_refund_is_eligible(arguments["order_id"])
        return create_refund_request(**arguments)
    raise ValueError(f"Unknown tool: {name}")

while True:
    calls = [item for item in response.output if item.type == "function_call"]
    if not calls:
        break

    outputs = []
    for call in calls:
        result = execute_tool(call.name, json.loads(call.arguments))
        outputs.append({
            "type": "function_call_output",
            "call_id": call.call_id,
            "output": json.dumps(result),
        })

    response = client.responses.create(
        model="gpt-6-astra",
        previous_response_id=response.id,
        tools=tools,
        input=outputs,
    )

print(response.output_text)

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

How Do You Automate Long-Running Workflows with Astra?

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

{
  "objective": "Create a competitor launch brief",
  "companies": ["Competitor A", "Competitor B", "Competitor C"],
  "required_fields": [
    "latest product",
    "launch date",
    "price",
    "key differentiators",
    "primary sources"
  ],
  "output": "executive brief"
}

1. กำหนดวัตถุประสงค์ ระบุฟิลด์ที่ต้องมี รูปแบบผลลัพธ์ กำหนดเส้นตาย และเกณฑ์การยอมรับ
2. เรียกค้นหลักฐาน ใช้การค้นเว็บ การค้นไฟล์ ฐานข้อมูล หรือระบบที่เชื่อมต่อ MCP สำหรับข้อมูลปัจจุบัน
3. ตรวจสอบความถูกต้องของหลักฐาน ติดป้ายแหล่งข้อมูลปฐมภูมิ ทุติยภูมิ อนุมาน ความขัดแย้ง และข้อมูลที่ขาด
4. ยกระดับความไม่แน่นอน ขอหลักฐานเพิ่มเติมหรือคำตัดสินจากมนุษย์เมื่อความมั่นใจต่ำกว่าเกณฑ์ที่ต้องการ
5. สร้างและตรวจสอบอาร์ติแฟกต์ ตรวจเช็คทุกฟิลด์ที่ต้องมีก่อนประกาศเสร็จสิ้น

การออกแบบนี้ทำให้การจัดการหลักฐานตรวจสอบได้ และแยกการให้เหตุผลของโมเดลออกจากกฎการยอมรับของระบบ

When Should an Astra Agent Use Computer Automation?

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

การทำงานอัตโนมัติบนคอมพิวเตอร์เหมาะเมื่อไม่มี API ที่ใช้งานได้ ต้องปฏิบัติงานกับแอปพลิเคชันเดิม เวิร์กโฟลว์ขึ้นกับการตรวจสอบเชิงภาพ หรือเอเจนต์ต้องทดสอบอินเทอร์เฟซผู้ใช้จริง ผลลัพธ์ 92.7% ของ ScreenSpot-Pro และ 72.6% ของ OSWorld 2.0 ของ Astra สนับสนุนการใช้งานเชิงภาพ แต่เวิร์กโฟลว์เหล่านี้ยังต้องสภาพแวดล้อมที่ควบคุมได้และนโยบายแบบชัดเจน

How Do You Make Astra Agents Safe for Production?

ความปลอดภัยของเอเจนต์เป็นปัญหาสถาปัตยกรรมแอปพลิเคชันเป็นหลัก OpenAI วาง Astra ไว้ที่ Critical cybersecurity capability threshold ซึ่งเพิ่มความสำคัญของขอบเขตการเข้าถึงและความสามารถในการตรวจสอบ

Separate Read and Write Tools

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

Require Approval for Consequential Actions

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

Make Every Write Idempotent

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

Enforce Budgets Outside the Prompt

ติดตามงบประมาณโทเค็น การเรียกเครื่องมือ การเงิน เวลานาฬิกาผนัง และจำนวนขั้นเวิร์กโฟลว์ในโค้ด ยุติอย่างกำหนดแน่นอนเมื่อถึงขีดจำกัด

Log the Execution Trajectory

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

Astra API Pricing

อัตรา Standard ทางการคือ $10/M อินพุต และ $50/M เอาต์พุต สำหรับพรอมต์ภายในระดับบริบทมาตรฐาน คำขอที่เกิน 272K โทเค็นอินพุตจะถูกคิดในอัตราบริบทยาวสำหรับทั้งคำขอ

ราคาต่อโทเค็นเพียงอย่างเดียวไม่อธิบายเศรษฐศาสตร์ของเอเจนต์ ใช้มาตรการปฏิบัติการต่อไปนี้:

ต้นทุนต่อภารกิจที่ยอมรับ

= โทเค็นโมเดล + ค่าธรรมเนียมเครื่องมือ + รีทรี + โครงสร้างพื้นฐาน + การแก้ไขโดยมนุษย์ หารด้วยจำนวนภารกิจที่ทำถูกต้อง

How Does Astra Compare with Other Agent Models?

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

ระบบเชิงปฏิบัติสามารถจัดเส้นทางงานตามความซับซ้อนแทนการเลือกโมเดลเดียวสำหรับทุกคำขอ

Choosing GPT-6 Astra: Cost Optimization and When to Use It

• จัดเส้นทางตามความซับซ้อนที่วัดได้ ใช้ตัวจัดเส้นทางที่รองรับการประเมินเพื่อสงวน GPT-6 Astra สำหรับงานที่ความลึกของการให้เหตุผล การใช้เครื่องมือ หรือค่าความล้มเหลวสมควรต่อการยกระดับ
• แคชคำนำที่คงที่ ใช้นโยบาย สคีมา และเอกสารที่ไม่เปลี่ยนแปลงระหว่างคำขอซ้ำ
• เรียกค้นบริบทที่เกี่ยวข้องเท่านั้น อย่าเติมหน้าต่างล้านโทเค็นเพียงเพราะมีให้
• จำกัดจำนวนขั้นของเอเจนต์ กำหนดเงื่อนไขการเสร็จและการหยุดก่อนเริ่มดำเนินการ
• ปรับระดับความพยายามในการให้เหตุผล ใช้ต่ำหรือกลางสำหรับงานย่อยแบบกำหนดแน่นอน และเพิ่มเฉพาะเมื่อความคลุมเครือหรือความล้มเหลวในการตรวจสอบชดเชยต้นทุน
• รันเครื่องมืออิสระแบบขนาน ลดเวลานาฬิกาผนังโดยไม่เพิ่มรอบโมเดลที่ไม่จำเป็น
• ใช้กฎการตัดสินขั้นสุดท้าย ใช้ GPT-6 Astra สำหรับการให้เหตุผลที่ยากผสานกับการดำเนินการระยะยาว วิศวกรรมซอฟต์แวร์ การใช้งานคอมพิวเตอร์ เครื่องมือภายนอกหลายตัว การสร้างอาร์ติแฟกต์มืออาชีพ หรือค่าความล้มเหลวสูง ใช้โมเดลที่มีราคาต่ำกว่าสำหรับการจัดประเภท การดึงข้อมูล การติดแท็ก สรุปแบบกิจวัตร และคำขอมูลค่าต่ำที่ไวต่อเวลา เว้นแต่การประเมินจะชี้ว่าการใช้ Astra ลดต้นทุนต่อภารกิจที่ยอมรับได้อย่างมีนัยสำคัญ

Which Production Metrics Matter for Astra Agents?

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

FAQ

What is the Astra API model ID?

รหัสโมเดลคือ gpt-6-astra.

Does Astra support function calling?

รองรับ รองรับการเรียกฟังก์ชันและการส่งออกแบบมีโครงสร้าง การเรียกเครื่องมือควรใช้ Responses API

Does Astra support MCP?

รองรับ MCP รวมอยู่ในเครื่องมือของ Responses API

Can Astra control a computer?

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

What is async tool calling?

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

What is mid-turn steering?

ช่วยให้แอปพลิเคชันส่งคำสั่งที่อัปเดตระหว่างงานที่กำลังดำเนินอยู่

How large is Astra's context window?

รองรับบริบท 1,050,000 โทเค็น และผลลัพธ์สูงสุด 128,000 โทเค็น

How much does Astra cost?

ราคา OpenAI Standard เริ่มที่ $10/M อินพุต และ $50/M เอาต์พุตสำหรับระดับบริบทมาตรฐาน ราคาผ่านเกตเวย์อาจต่างกันตามผู้ให้บริการและระดับบริบท

Should every agent use Astra?

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

Can I build Astra agents through CometAPI?

ได้ CometAPI เปิดเผยเวิร์กโฟลว์ Responses ที่เข้ากันได้กับ OpenAI ตรวจสอบทุกเครื่องมือและพารามิเตอร์ที่แอปพลิเคชันของคุณต้องการก่อนส่งทราฟฟิกโปรดักชัน