Solutions Choose your path
For individuals Build, learn, and create with simple usage-based access. For business Scale teams, billing, governance, and model workflows. More English 繁體中文 日本語 한국어 Français Deutsch Español Italiano Português Русский العربية ไทย Tiếng Việt Bahasa Indonesia Bahasa Melayu Türkçe Polski Nederlands Danish Norsk Қазақ اردو
เริ่มต้นฟรี เริ่มต้นฟรี
500+ AI Model API, All In One API.
Just In CometAPI © 2026 CometAPI · All rights reserved
Home Blog OpenAI Agents API: คุณสมบัติ ราคา และการใช้งาน guide / งานวิจัย CometAPI
OpenAI Agents API: คุณสมบัติ ราคา และการใช้งาน เรียนรู้ว่า OpenAI Agents API คืออะไร ทำงานอย่างไร คุณสมบัติ ราคา ตัวอย่างโค้ด การใช้งานจริง และทางเลือกอื่น ๆ
Deon Goodwin ทีมวิจัยโมเดล AI และ API เรียนรู้ว่า OpenAI Agents API คืออะไร ทำงานอย่างไร คุณสมบัติ ราคา ตัวอย่างโค้ด การใช้งานจริง และทางเลือกอื่น ๆ
ใช้สรุปนี้เพื่อดูคำตอบอย่างรวดเร็ว แล้วอ่านคู่มือเพื่อดูบริบท ตัวอย่าง และรายละเอียดการใช้งาน
from openai import OpenAI
client = OpenAI(
api_key="YOUR_COMETAPI_KEY",
base_url="https://api.cometapi.com/v1",
)
response = client.chat.completions.create(
model="gpt-5-mini",
messages=[{"role": "user", "content": "Build this workflow."}],
)
print(response.choices[0].message.content)TL;DR
OpenAI Agents API เป็นแพลตฟอร์มแบบจัดการสำหรับสร้างเอเจนต์ AI ที่สามารถให้เหตุผล ใช้เครื่องมือ รันโค้ด และทำงานหลายขั้นตอนให้เสร็จสิ้น เหมาะสำหรับแอปที่ต้องทำงานต่อเนื่องข้ามเทิร์น เรียกใช้เครื่องมือ และกู้คืนจากการขัดจังหวะ โดยไม่ต้องสร้างลูปเอเจนต์ทั้งหมดเอง คู่มือนี้ช่วยให้นักพัฒนาประเมินความสามารถ ตัวเลือกการเชื่อมต่อ และต้นทุน
แตกต่างจาก LLM API แบบทั่วไป OpenAI Agents API รองรับเซสชันแบบถาวร สภาพแวดล้อมการรันแบบจัดการ การประสานงานหลายเอเจนต์ การสตรีมเหตุการณ์ และอาร์ติแฟกต์ นักพัฒนาสามารถใช้เอ็นด์พอยต์แบบเนทีฟของ OpenAI Agents API เพื่อการรันแบบจัดการ หรือบูรณาการโมเดลที่รองรับของ OpenAI ผ่าน CometAPI เพื่อสร้างเวิร์กโฟลว์เอเจนต์แบบกำหนดเอง ซึ่งเป็นเส้นทางการเชื่อมต่อที่แตกต่างกัน
Key Takeaways
OpenAI Agents API จัดการเซสชันแบบถาวรและการรันหลายขั้น ลดงานออร์เคสเตรชันที่นักพัฒนาต้องดูแลเอง
ความสามารถหลักรวมถึงการรันโค้ดใน sandbox การเชื่อมต่อเครื่องมือและ MCP ซับเอเจนต์ และอาร์ติแฟกต์ที่บันทึกไว้
เรียนรู้ต่อ
เชื่อมโยงบทความนี้กับการตัดสินใจถัดไป ดูทุกหัวข้อ ตรวจสอบความชัดเจน การอ้างอิงแหล่งที่มา และคำศัพท์ API ปัจจุบันแล้ว
ต้นทุนของ OpenAI Agents API รวมโทเคนของโมเดล เครื่องมือที่คิดค่าบริการ และคอมพิวต์แบบโฮสต์ที่เลือกใช้ ควรประเมินต้นทุนต่อภารกิจที่เสร็จสมบูรณ์
ผลลัพธ์ที่ลูกค้ารายงานให้หลักฐานเฉพาะงาน มากกว่ามาตรฐานเดียวสำหรับทุกแอปพลิเคชัน
การรันแบบเนทีฟที่จัดการโดยระบบ และเอเจนต์แบบกำหนดเองที่ใช้ CometAPI เป็นตัวเลือกการเชื่อมต่อที่ต่างกัน พร้อมภาระโครงสร้างพื้นฐานต่างกัน
What Is the OpenAI Agents API? OpenAI Agents API เป็นบริการรันแบบจัดการสำหรับแอปพลิเคชันที่ทำงานหลายขั้นตอนโดยใช้โมเดล reasoning และเครื่องมือภายนอก โดยเปิดเผยฮาร์เนสเอเจนต์ของ Codex เป็นบริการ แทนที่จะต้องจัดการการเรียกโมเดล การเรียกเครื่องมือ สถานะเซสชัน และการกู้คืนงานด้วยตนเอง นักพัฒนาสามารถมอบหมายการประสานงานส่วนใหญ่ให้กับรันไทม์ได้
แชตบอททั่วไปสร้างคำตอบครั้งเดียว; เอเจนต์สามารถวางแผนขั้นตอน รันโค้ดในสภาพแวดล้อมที่ได้รับอนุญาต ตรวจสอบข้อผิดพลาด ลองใหม่ และส่งมอบไฟล์ที่สร้างขึ้น ทำให้ API เหมาะกับเวิร์กโฟลว์เชิงปฏิบัติการมากกว่าแชตอย่างเดียว
OpenAI Agents API Workflow เวิร์กโฟลว์ของเอเจนต์ประกอบด้วยสี่ส่วน: เอเจนต์กำหนดโมเดล คำสั่ง และเครื่องมือที่พร้อมใช้; สภาพแวดล้อมให้คอมพิวต์และการเข้าถึงไฟล์; เซสชันคงบริบทการสนทนาและงานที่บันทึก; และเหตุการณ์กับรายการเผยความคืบหน้าและผลลัพธ์ ส่วนประกอบเหล่านี้ช่วยให้อแอปของคุณส่งภารกิจ ติดตามการรัน และทำงานต่อในเทิร์นถัดไป ดูแนวคิดพื้นฐานได้ที่ Agents API overview
เวิร์กโฟลว์ปกติ: สร้างเซสชัน; ส่งเป้าหมาย; ปล่อยให้โมเดลให้เหตุผลและเลือกเครื่องมือที่อนุญาต; รันเครื่องมือเหล่านั้น; ตรวจสอบผลลัพธ์ระหว่างทาง; และสตรีมความคืบหน้าและอาร์ติแฟกต์สุดท้าย เซสชันสามารถทำต่อได้ตามต้องการ
What Are the Main OpenAI Agents API Features? ความสามารถของ managed harness ครอบคลุมการรันโค้ด การจัดการบริบท การเชื่อมต่อเครื่องมือ การกำกับ และการมอบหมาย ทั้งนี้ขึ้นกับสภาพแวดล้อมและเครื่องมือที่กำหนดด้วย
รันไทม์แบบจัดการ ฮาร์เนสที่ใช้ Codex ลดโค้ดออร์เคสเตรชัน การคงอยู่ของเซสชัน สถานะหลายเทิร์น รองรับงานติดตามผล การจัดการบริบท การย่อบริบทยแบบจัดการ เวิร์กโฟลว์ที่ยืดยาว การรันแบบโฮสต์ Linux sandbox; Python และ Node.js รันโค้ดจริง สภาพแวดล้อม self-hosted คอมพิวต์ที่นักพัฒนาดูแล ควบคุมโครงสร้างพื้นฐาน การรันหลายเอเจนต์ ซับเอเจนต์ที่ตั้งค่าได้ งานย่อยแบบขนาน การเชื่อมต่อเครื่องมือ Functions และ MCP เชื่อมบริการต่างๆ การใช้คอมพิวเตอร์ การโต้ตอบ UI แบบควบคุม ทำงานอัตโนมัติผ่านอินเทอร์เฟซ สตรีมมิงและเว็บฮุค เหตุการณ์ความคืบหน้า แอปรวดเร็วตอบสนอง Artifacts ไฟล์ที่บันทึกไว้ รายงานที่ส่งมอบได้
Persistent Sessions and Context Management เซสชันจะคงค่าคอนฟิก บริบทการสนทนา และงานที่บันทึกไว้ข้ามเทิร์น นักพัฒนาสามารถส่งคำสั่งใหม่ไปยังเซสชันเดิม; การจัดการบริบทช่วยคงงานที่ยืดยาว ลดความจำเป็นต้องเขียนตรรกะบีบอัดทรานสคริปต์เอง
Sandboxed Code Execution none ไม่มีการรันในเครื่อง เวิร์กโฟลว์ที่ใช้เครื่องมือระยะไกล openai_hosted sandbox ที่ OpenAI จัดการ โค้ด การวิเคราะห์ และประมวลผลไฟล์ self_hosted คอมพิวต์ที่นักพัฒนาควบคุม โครงสร้างพื้นฐานแบบกำหนดเอง
สภาพแวดล้อมแบบโฮสต์สามารถรันโปรแกรม Python, Node.js และคำสั่งบรรทัดคำสั่งในพื้นที่ทำงานที่แยกออกมา สภาพแวดล้อมแบบ self-hosted ช่วยให้เอเจนต์ที่จัดการโดยระบบใช้คอมพิวต์ที่นักพัฒนาควบคุม นักพัฒนาดูแลและปกป้องสภาพแวดล้อมนั้น ในขณะที่ Agents API ยังคงจัดการฮาร์เนสเอเจนต์และสถานะเซสชัน
Multi-Agent Collaboration เอเจนต์ผู้ประสานงานสามารถมอบหมายงานอิสระให้กับซับเอเจนต์เฉพาะทางได้ เอเจนต์วิจัยอาจตรวจสอบแหล่งข้อมูลต่างกัน ในขณะที่เอเจนต์หลักสรุปหลักฐาน ความขนานช่วยเพิ่มอัตราการทำงาน แต่การเรียกโมเดลเพิ่มเติมและการประสานงานอาจเพิ่มค่าใช้จ่าย API รองรับการตั้งค่าความขนานและซับเอเจนต์ที่ยืดหยุ่น
OpenAI Agents API vs Agents SDK vs Responses API vs AgentKit วัตถุประสงค์ การรันแบบจัดการ ออร์เคสเตรชันเน้นโค้ด อินเฟอเรนซ์และเครื่องมือ องค์ประกอบสำหรับเอเจนต์ ลูปของเอเจนต์ ระบบจัดการ แอป/SDK นักพัฒนาจัดการเอง ขึ้นกับองค์ประกอบ โครงสร้างพื้นฐาน แบบโฮสต์หรือภายนอก นักพัฒนาควบคุม แอปบวกเครื่องมือโฮสต์ แตกต่างกันตามส่วน หลายเอเจนต์ การประสานงานในตัว ส่งต่อการทำงาน กำหนดเอง ตามองค์ประกอบ เหมาะสำหรับ งานอัตโนมัติที่ทนทาน เอเจนต์แบบปรับแต่ง ควบคุมละเอียด เครื่องมือฝังสำหรับเอเจนต์
Agents API ให้การรันแบบจัดการ; Agents SDK เหมาะกับแอปที่เป็นเจ้าของสแตกออร์เคสเตรชัน; Responses API เหมาะสำหรับอินเฟอเรนซ์และเวิร์กโฟลว์เครื่องมือที่เบากว่า; AgentKit เป็นองค์ประกอบการพัฒนาเสริม ไม่ใช่รันไทม์เอเจนต์แบบโฮสต์ที่เทียบเท่าอีกตัว
How to Get Started With the OpenAI Agents API
ใช้คีย์โปรเจ็กต์ OpenAI Platform ที่มีสิทธิ์สำหรับเอเจนต์และอินเฟอเรนซ์ตาม quickstart prerequisites ตัวอย่าง curl ใช้เชลล์ที่รองรับ Bash และติดตั้ง curl แล้ว; ตัวอย่าง PowerShell ตั้งค่าเฉพาะตัวแปรสภาพแวดล้อม เก็บคีย์ไว้นอกซอร์สคอนโทรล
ตัวอย่างโค้ด Bash: รันคำสั่งต่อไปนี้ในเทอร์มินัลที่รองรับ Bash
export OPENAI_API_KEY="your-openai-api-key"
ตัวอย่างโค้ด PowerShell: ตั้งค่า API key ในกระบวนการ PowerShell ปัจจุบัน
$env:OPENAI_API_KEY="your-openai-api-key"
Step 2: Create Your First Agent ตัวอย่างโค้ด Bash: รันคำสั่งต่อไปนี้ในเทอร์มินัลที่รองรับ Bash
curl --no-buffer --fail-with-body \
https://api.openai.com/v1/agents/sessions \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-H "OpenAI-Beta: agents=v1" \
-H "Content-Type: application/json" \
-d '{
"agent": {
"model": "gpt-6-astra",
"instructions": "Write reliable Python code, execute it, and report observed results."
},
"environment": {"type": "openai_hosted", "container_size": "small"},
"input": "Calculate the mean and standard deviation of [12,15,19,20,24] in Python.",
"stream": true
}'
เซสชันจะเริ่มเทิร์นแรกและสตรีมเหตุการณ์สถานะขณะเอเจนต์เรียกใช้เครื่องมือและเตรียมคำตอบ
Step 3: Enable Multi-Agent Execution ตัวอย่างโค้ด Bash: รันคำสั่งต่อไปนี้ในเทอร์มินัลที่รองรับ Bash
curl --no-buffer --fail-with-body \
https://api.openai.com/v1/agents/sessions \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-H "OpenAI-Beta: agents=v1" \
-H "Content-Type: application/json" \
-d '{
"agent": {
"model": "gpt-6-astra",
"instructions": "Delegate independent analyses and reconcile the results.",
"multi_agent": {"enabled": true, "max_concurrent_subagents": 2}
},
"environment": {"type": "none"},
"input": "Compare two release changes: date filtering in search and export URL behavior.",
"stream": true
}'
Step 4: Continue an Existing Session ตัวอย่างโค้ด Bash: รันคำสั่งต่อไปนี้ในเทอร์มินัลที่รองรับ Bash
curl --fail-with-body \
"https://api.openai.com/v1/agents/sessions/$SESSION_ID/events" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-H "OpenAI-Beta: agents=v1" \
-H "Content-Type: application/json" \
-d '{"events":[{"type":"agent.session.input.message","input":[{"role":"user","content":[{"type":"input_text","text":"Summarize the findings in an executive report."}]}]}]}'
จัดเก็บตัวระบุเซสชัน ใช้มาตรการ retry และแยกแยะคำสั่งใหม่ออกจากข้อความที่ใช้กำกับงานที่กำลังทำอยู่
Step 5: Inspect Results and Clean Up ตัวอย่างโค้ด Bash: รันคำสั่งต่อไปนี้ในเทอร์มินัลที่รองรับ Bash
curl --fail-with-body \
"https://api.openai.com/v1/agents/sessions/$SESSION_ID/items?order=asc&limit=100" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-H "OpenAI-Beta: agents=v1"
curl --fail-with-body -X DELETE \
"https://api.openai.com/v1/agents/sessions/$SESSION_ID" \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-H "OpenAI-Beta: agents=v1"
ดึงอาร์ติแฟกต์มาก่อนลบทรัพยากรที่จัดการไว้ การตัดการเชื่อมต่อสตรีมไม่ได้หมายความว่ายกเลิกงานที่กำลังดำเนินอยู่เสมอไป
Session Configuration Parameters ความพยายามด้าน reasoning มีผลต่อ latency การใช้โทเคน และความลึกของการวางแผน เลือกระดับความพยายามที่โมเดลและอินเทอร์เฟซที่เลือกสนับสนุนตาม official GPT-6 guidance ; การตั้งค่าระดับโมเดลไม่ควรถูกสันนิษฐานว่าจะใช้ได้เหมือนกันกับทุกเอ็นด์พอยต์
CometAPI สามารถให้บริการอินเฟอเรนซ์ของโมเดลสำหรับแอปเอเจนต์แบบกำหนดเอง แอปของคุณยังคงรับผิดชอบลูปเอเจนต์ การเรียกใช้เครื่องมือ สถานะเซสชัน การกู้คืน และการจัดเส้นทางระหว่างโมเดลที่รองรับ ซึ่งให้การควบคุมออร์เคสเตรชัน พร้อมกับทำให้โครงสร้างพื้นฐานนั้นเป็นของคุณในการดูแล
เลือกการเชื่อมต่อแบบเนทีฟของ Agents API เมื่อคุณต้องการให้ OpenAI จัดการการรันของเอเจนต์และสถานะเซสชัน เลือกแอปที่ใช้ CometAPI เมื่อคุณต้องการสร้างและดูแลออร์เคสเตรชันของคุณเองรอบ API ของโมเดลที่รองรับ การเข้าถึงโมเดลผ่าน CometAPI ไม่ได้ทำให้รองรับเอ็นด์พอยต์เซสชันของ Agents API แบบเนทีฟโดยอัตโนมัติ; ตรวจสอบอินเทอร์เฟซที่คุณตั้งใจใช้ ต้นทุนก็แยกกัน: การใช้งานแบบเนทีฟคิดโดย OpenAI ส่วนแอปแบบกำหนดเองรวมค่าบริการของ CometAPI กับต้นทุนโครงสร้างพื้นฐานของคุณ
ตัวอย่างโค้ด Bash: รันคำสั่งต่อไปนี้ในเทอร์มินัลที่รองรับ Bash
pip install --upgrade openai
export COMETAPI_KEY="your-cometapi-key"
ตัวอย่างโค้ด Python: ส่งคำขออินเฟอเรนซ์ของโมเดลและพิมพ์คำตอบ
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["COMETAPI_KEY"],
base_url="https://api.cometapi.com/v1",
)
response = client.responses.create(
model="gpt-6-astra",
input=(
"Analyze an API latency spike after a database migration. "
"Identify possible causes and prioritize diagnostic steps."
),
)
print(response.output_text)
นักพัฒนาสามารถเข้าถึง GPT-6 Astra API in CometAPI ตัวอย่างด้านบนทำอินเฟอเรนซ์โมเดล; การสร้างลูปเครื่องมือตามที่อธิบายด้านล่างเป็นความรับผิดชอบของแอปแยกต่างหาก
คอนโทรลเลอร์แบบกำหนดเองสามารถพรมพ์โมเดล ตรวจสอบคำขอเรียกเครื่องมือ อนุญาตและรันการกระทำ ส่งคืนผลลัพธ์ และวนซ้ำจนเสร็จหรือถึงขีดจำกัดที่กำหนด ตั้งขีดจำกัดจำนวนเทิร์น การเรียกเครื่องมือ เวลาและการใช้จ่าย; ต้องมีการยืนยันอิสระสำหรับการกระทำที่ทำลายข้อมูล
What Are the Best OpenAI Agents API Applications?
ซอฟต์แวร์เอนจิเนียริง: วิเคราะห์ปัญหา สร้างการเปลี่ยนแปลงโค้ด รันเทสต์ และเตรียมรีวิว พร้อมการอนุมัติก่อน merge หรือ deploy
การวิเคราะห์ข้อมูลและรายงาน: ประมวลผลชุดข้อมูลที่อัปโหลด รันการคำนวณใน Python สร้างแผนภูมิ และแปลงผลลัพธ์เป็นรายงานเพื่อสนับสนุนการตัดสินใจ
การตอบสนองเหตุการณ์ IT: ตรวจสอบการแจ้งเตือน เชื่อมโยงล็อก อ้างอิง runbook และแนะนำการแก้ไข พร้อมการอนุมัติจากมนุษย์สำหรับการกระทำที่เสี่ยง
ระบบอัตโนมัติฝ่ายสนับสนุนลูกค้า: ดึงข้อมูลที่เกี่ยวข้อง สรุปทิคเก็ต ร่างคำตอบ และส่งต่อเคสที่ยังไม่แก้ผ่านการเข้าถึง CRM ที่อนุญาต
วิจัยและประมวลเอกสาร: เปรียบเทียบเอกสาร ตรวจสอบข้อกล่าวอ้าง ดึงข้อเท็จจริง และเตรียมข้อค้นพบพร้อมการอ้างอิง
Evaluate Your Workflow เริ่มจากภารกิจตัวแทนของงานจริงของคุณ และกำหนดเกณฑ์ความสำเร็จ เปรียบเทียบเอเจนต์กับกระบวนการปัจจุบันโดยใช้อินพุตและเกณฑ์ยอมรับเดียวกัน รวมคำขอติดตามผลและความล้มเหลวของเครื่องมือเพื่อทดสอบการกู้คืน ไม่ใช่เฉพาะเส้นทางที่สมบูรณ์แบบ
การทำภารกิจสำเร็จ เป้าหมายที่สำเร็จ ความมีประโยชน์ปลายทาง ความสำเร็จของเครื่องมือ การเชื่อมต่อที่ถูกต้อง การตรวจจับความล้มเหลว อัตราการกู้คืน ความสำเร็จหลังความล้มเหลว ความทนทาน เวลาเสร็จสิ้น เวลาที่ใช้ไป ความหน่วง ต้นทุนต่อภารกิจที่สำเร็จ ค่าใช้จ่าย / ภารกิจสำเร็จ ประสิทธิภาพ การแทรกแซงจากมนุษย์ การกระทำด้วยมือ ระดับความอัตโนมัติ การปฏิบัติตามข้อกำหนดด้านความปลอดภัย การยึดนโยบาย การควบคุมความเสี่ยง
อ่านเมตริกเหล่านี้ร่วมกัน เวิร์กโฟลว์ที่ทำภารกิจได้มากกว่าอาจยังไม่เหมาะ หากต้องแก้ไขด้วยมือบ่อยหรือเกินขีดจำกัดเวลาและต้นทุน ใช้ผลลัพธ์เพื่อกำหนดจุดที่ควรทำอัตโนมัติ จุดที่ควรคงการรีวิวมนุษย์ และความล้มเหลวที่ควรแก้ไขก่อนขยายการใช้งาน
How Much Does the OpenAI Agents API Cost? ไม่มีค่าธรรมเนียมแพลตฟอร์มฮาร์เนสแบบจัดการแยกต่างหาก โทเคนของโมเดล การเรียกเครื่องมือที่คิดค่าบริการ และคอมพิวต์แบบโฮสต์ที่เลือกใช้เป็นตัวกำหนดต้นทุนรวม อัตราโมเดลด้านล่างเป็น USD ต่อหนึ่งล้านโทเคนสำหรับการประมวลผลแบบ Standard พร้อมพรอมป์ต์บริบทสั้น (สูงสุด 272K โทเคนอินพุต) ตรวจเมื่อ 21 ตุลาคม 2026 พรอมป์ต์ที่ยาวกว่า ระดับการประมวลผลอื่น การเขียนแคช และการประมวลผลตามภูมิภาคอาจเปลี่ยนแปลงอัตราที่ใช้
GPT-6 Astra $10.00 $1.00 $50.00 GPT-6.1 Sol $2.00 $0.10 $10.00 GPT-6 Luna $0.10 $0.01 $0.50
สำหรับการเข้าถึงโมเดลผ่าน CometAPI นักพัฒนาสามารถใช้ GPT-6.1 Sol และ GPT-6 Luna ตารางข้างบนเป็นอัตราของ OpenAI; การคิดค่าบริการของ CometAPI ใช้อัตราที่เกี่ยวข้องของตนเอง
Hosted container — Small หน่วยความจำ 1 GB; ช่วงเวลา 20 นาที $0.03 ต่อช่วงเวลา Hosted container — Medium หน่วยความจำ 4 GB; ช่วงเวลา 20 นาที $0.12 ต่อช่วงเวลา Hosted container — Large หน่วยความจำ 16 GB; ช่วงเวลา 20 นาที $0.48 ต่อช่วงเวลา Web search ต่อ 1,000 ครั้ง; โทเคนเนื้อหาคิดแยก $10 ต่อ 1,000 ครั้ง บวกโทเคนเนื้อหา File search storage ต่อ GB ต่อวัน หลังโควตาฟรี $0.10 ต่อ GB/วัน
Example: Estimating a Task Cost โทเคนอินพุต 50,000 × $10 / 1M $0.50 โทเคนเอาต์พุต 10,000 × $50 / 1M $0.50 Web searches 2 × $0.01 $0.02 Small container ช่วงเวลา 20 นาทีหนึ่งครั้ง $0.03 รวม ไม่รวมค่าใช้จ่ายจิปาถะอื่นๆ $1.05
ผลรวม $1.05 นี้เป็นตัวอย่างโดยสมมุติปริมาณโทเคนตามที่ระบุ การค้นหา 2 ครั้ง ช่วงเวลา small container 20 นาที 1 ครั้ง และไม่มีโทเคนเนื้อหาการค้นหาที่คิดเพิ่มหรือการเขียนแคชจริง ต้นทุนจริงยังขึ้นกับการลองใหม่ การใช้ซับเอเจนต์ พฤติกรรมแคช และกฎการคิดค่าบริการ sandbox ที่ใช้กับเซสชัน ติดตามต้นทุนต่อภารกิจที่สำเร็จในเวิร์กโหลดตัวแทนของคุณ
What Are the Limitations of the OpenAI Agents API? ข้อจำกัดด้านข้อมูล. Agents API รองรับการเก็บข้อมูลเฉพาะในสหรัฐอเมริกา และไม่รองรับ Zero Data Retention (ZDR) สภาพแวดล้อม sandbox แบบ self-hosted ไม่เปลี่ยนคุณสมบัติ ZDR ตรวจสอบเงื่อนไขการเก็บรักษาและที่ตั้งข้อมูลของบริการก่อนส่งข้อมูลอ่อนไหว
ความเข้ากันได้ของ API และโมเดล. อินเทอร์เฟซ public-beta อาจเปลี่ยนแปลง และคุณสมบัติที่รองรับอาจต่างกันตามโมเดล ทดสอบโมเดล เอ็นด์พอยต์ การตั้งค่า reasoning และเครื่องมือที่แอปคุณใช้จริง ทำซ้ำการตรวจบูรณาการเมื่อเปลี่ยนโมเดลหรือรับการอัปเดต API
การควบคุมการรัน. งานหลายขั้นสามารถใช้โทเคนสะสม ใช้เวลาผันผวน และเจอความล้มเหลวของเครื่องมือ ตั้งงบและขีดจำกัดจำนวนเทิร์นและเวลารัน ให้เฉพาะสิทธิ์ที่งานต้องการ และมอนิเตอร์งานที่รันนานแบบอะซิงค์ วางแผนการกู้คืนจากการเรียกเครื่องมือที่ถูกขัดจังหวะ และต้องมีการอนุมัติจากมนุษย์สำหรับการกระทำที่มีผลกระทบสูง
FAQ
ลูกค้า OpenAI Agents API ควร retry ข้อความติดตามผลอย่างไร? ใช้ submission key เดิมเมื่อ retry ข้อความเชิงตรรกะเดียวกัน ตาม session input and retry pattern เก็บ session ID และ submission key ไว้ร่วมกันในสถานะแอป คำสั่งของผู้ใช้ที่แยกกันควรใช้คีย์ของตัวเอง; การสูญเสียการตอบกลับ HTTP ไม่ควรถูกมองว่าเป็นคำสั่งใหม่โดยอัตโนมัติ
เซสชันของ OpenAI Agents API สามารถเปลี่ยนโมเดลได้หรือไม่? session settings endpoint รองรับการอัปเดตโมเดล ความพยายาม reasoning และระดับบริการ การอัปเดตมีผลกับเทิร์นถัดไป; เทิร์นที่กำลังทำงานจะคงการตั้งค่าเดิม ตรวจสอบว่าคอนฟิกที่ได้รองรับโดยโมเดลที่เลือก และสร้างเซสชันใหม่เมื่อจำเป็นต้องเปลี่ยนการตั้งค่าที่เอ็นด์พอยต์นี้ไม่ยอมรับ
OpenAI Agents API จำกัดการเข้าถึงเครือข่ายของ sandbox อย่างไร? สภาพแวดล้อมแบบโฮสต์ของ OpenAI รองรับการเข้าถึงออกแบบ enabled, disabled หรือ restricted โหมด restricted ใช้รายการอนุญาตโฮสต์แบบชัดเจน และการ redirect หรือซับโดเมนบางรายการอาจต้องเพิ่มเอง กำหนด sandbox network policy สำหรับบริการที่งานต้องใช้; การเข้าถึงเครือข่ายและข้อมูลรับรองของแอปเป็นการควบคุมคนละส่วน
Conclusion ประเมิน Agents API ด้วยภารกิจตัวแทนที่ต้องใช้เครื่องมือหลายครั้งและอย่างน้อยหนึ่งเทิร์นติดตามผล วัดอัตราการทำสำเร็จ พฤติกรรมการกู้คืน ความหน่วง และต้นทุนต่อภารกิจที่สำเร็จ ผลลัพธ์เหล่านี้จะชี้ว่าการรันแบบจัดการตรงตามความต้องการของแอปคุณหรือไม่
