GPT-5.6: โมเดลเขียนโค้ดเรียกใช้เครื่องมือและจัดลำดับการทำงานได้เอง

การเรียกใช้ฟังก์ชันแบบคลาสสิกมีรูปแบบที่นักพัฒนาเอเจนต์ทุกคนคุ้นเคยเป็นอย่างดี โมเดลจะร้องขอการเรียกใช้เครื่องมือหนึ่งครั้ง แอปพลิเคชันของคุณจะดำเนินการ จากนั้นคุณจะเพิ่มผลลัพธ์ และโมเดลจะร้องขอครั้งต่อไป สี่เครื่องมือ สี่รอบ สี่สิบเครื่องมือ สี่สิบครั้ง แต่ละครั้งจะเพิ่มความหน่วงของเครือข่ายและบริบทที่ถูกเรียกเก็บเงินใหม่ เมื่อ OpenAI เปิดตัว GPT-5.6 สู่สาธารณะเมื่อวันที่ 9 กรกฎาคม 2026 ได้นำเสนอวิธีการหลีกเลี่ยงกระบวนการซ้ำซากนั้น: การเรียกใช้เครื่องมือแบบโปรแกรมใน Responses API

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

button

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

button

สรุป

GPT-5.6 เปิดตัวสู่สาธารณะเมื่อวันที่ 9 กรกฎาคม 2026 ในการเปิดตัว Responses API ได้รับความสามารถในการเรียกใช้เครื่องมือแบบโปรแกรม ซึ่งได้รับการยืนยันในเอกสารสำหรับนักพัฒนาของ OpenAI
แทนที่จะเรียกใช้เครื่องมือหนึ่งครั้งต่อรอบ โมเดลจะเขียน JavaScript ที่สร้างลูป เงื่อนไข และการรวมข้อมูลจากเครื่องมือของคุณ
โค้ดที่สร้างขึ้นจะทำงานในแซนด์บ็อกซ์ V8 ที่แยกต่างหากโดยไม่มีการเข้าถึงเครือข่าย คำจำกัดความของเครื่องมือของคุณยังคงเป็นเส้นทางเดียวไปยังระบบภายนอก ดังนั้นขอบเขตความปลอดภัยจึงไม่เปลี่ยนแปลง
ความหน่วงและค่าใช้จ่ายโทเค็นจะไม่เพิ่มขึ้นตามจำนวนการเรียกใช้เครื่องมือ ซึ่งเป็นจุดที่ลูปเอเจนต์แบบคลาสสิกเสียค่าใช้จ่ายมาก
คุณสมบัตินี้เพิ่งเปิดตัวได้ไม่กี่วัน พารามิเตอร์คำขอและข้อจำกัดที่แน่นอนอยู่ในเอกสารอ้างอิง API ของ OpenAI ดังนั้นโปรดอ่านก่อนที่คุณจะเริ่มพัฒนา
ทดสอบและจำลองปลายทางของเครื่องมือแต่ละอันก่อนที่โมเดลจะจัดการมัน ความคลุมเครือของ Schema จะกลายเป็นข้อผิดพลาดที่ซ้ำไปมาในลูป

สิ่งที่เปิดตัวเมื่อวันที่ 9 กรกฎาคม

GPT-5.6 เปิดตัวมาในรูปแบบสามระดับ: gpt-5.6-sol สำหรับการให้เหตุผลที่ลึกซึ้งที่สุด, gpt-5.6-terra สำหรับงานที่สมดุล, และ gpt-5.6-luna สำหรับปริมาณงานที่รวดเร็วและประหยัดค่าใช้จ่าย นามแฝงแบบง่าย gpt-5.6 จะนำไปสู่ Sol ทั้งสามระดับสามารถใช้งานได้ด้วยตัวเองผ่าน API โดยไม่มีข้อจำกัดของแผนบริการ หลังจากช่วงพรีวิวแบบจำกัดสองสัปดาห์ที่สิ้นสุดลงเมื่อมีการยกเลิกข้อจำกัดการเข้าถึงเมื่อวันที่ 8 กรกฎาคม

ชุดโมเดลได้รับความสนใจส่วนใหญ่ในวันเปิดตัว แต่ส่วนต่อประสาน API ใหม่เป็นเรื่องที่สำคัญกว่าสำหรับนักพัฒนาเอเจนต์ ตาม รายงานข่าวการเปิดตัวของ MarkTechPost และเอกสารของ OpenAI เอง Responses API ได้รับสี่สิ่งเมื่อเปิดตัวสู่สาธารณะ: การเรียกใช้เครื่องมือแบบโปรแกรม, รุ่นเบต้าหลายเอเจนต์, การให้เหตุผลที่คงอยู่ตลอดหลายรอบ, และการตั้งค่ารายละเอียดภาพที่คงขนาดภาพต้นฉบับไว้

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

ลูปที่การเรียกใช้เครื่องมือแบบโปรแกรมเข้ามาแทนที่

นี่คือการเรียกใช้ฟังก์ชันแบบคลาสสิกกับ Responses API ซึ่งเป็นรูปแบบที่เอเจนต์ในการผลิตเกือบทุกตัวใช้ในปัจจุบัน:

import OpenAI from "openai";
const client = new OpenAI();

const tools = [
  {
    type: "function",
    name: "get_flight_status",
    description: "Return live status for a flight by IATA flight number.",
    parameters: {
      type: "object",
      properties: {
        flight_number: {
          type: "string",
          description: "IATA flight number, for example SQ317"
        }
      },
      required: ["flight_number"]
    }
  }
];

let response = await client.responses.create({
  model: "gpt-5.6",
  input: "Which of these 12 flights are delayed: SQ317, BA15, UA857...",
  tools
});

โมเดลไม่สามารถตอบได้หากไม่มีข้อมูล ดังนั้นจึงส่งการเรียกใช้ฟังก์ชัน โค้ดของคุณจะดำเนินการค้นหา เพิ่มรายการ function_call_output และเรียก API อีกครั้ง:

// One round trip per tool call. This loop is the tax.
while (hasFunctionCalls(response)) {
  const outputs = await executeToolCalls(response); // your code, your infra
  response = await client.responses.create({
    model: "gpt-5.6",
    previous_response_id: response.id,
    input: outputs,
    tools
  });
}

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

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

โหมดโปรแกรมเปลี่ยนรูปแบบอย่างไร

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

สามคุณสมบัติที่ทำให้สิ่งนี้ใช้งานได้จริงแทนที่จะน่ากังวล:

สภาพแวดล้อมรันไทม์ถูกแยกออก OpenAI รัน JavaScript ที่สร้างขึ้นในแซนด์บ็อกซ์ V8 โดยไม่มีการเข้าถึงเครือข่าย โค้ดไม่สามารถเรียก URL, เปิดซ็อกเก็ต หรือส่งข้อมูลออกไปได้ด้วยตัวเอง
เครื่องมือเป็นทางออกเดียว ผลกระทบภายนอกทั้งหมดจะส่งผ่านส่วนหน้าของเครื่องมือที่คุณกำหนดไว้ หากคุณไม่ได้เปิดเผยเครื่องมือ delete_record โค้ดที่สร้างขึ้นก็ไม่สามารถลบเรคอร์ดได้
การควบคุมการทำงานกลายเป็นสิ่งที่แสดงออกได้มากขึ้น ลูป เงื่อนไข การออกก่อนกำหนด การรวมผลลัพธ์: รูปแบบที่เคยต้องใช้การเดินทางไปกลับ N ครั้ง ตอนนี้เกิดขึ้นภายในรอบการตอบกลับเพียงครั้งเดียว

	การเรียกใช้ฟังก์ชันแบบคลาสสิก	การเรียกใช้เครื่องมือแบบโปรแกรม
ใครเป็นผู้เขียน Control Flow	แอปพลิเคชันของคุณ	โมเดล ในรูปแบบ JavaScript
การเดินทางไปกลับสำหรับการเรียกใช้เครื่องมือ N ครั้ง	N ครั้ง แบบอนุกรม	รอบการตอบกลับเดียว
การจัดการรันบนใด	โครงสร้างพื้นฐานของคุณ	แซนด์บ็อกซ์ V8 ที่แยกต่างหาก ไม่มีเครือข่าย
เครื่องมือทำงานอย่างไร	โค้ดของคุณเรียกใช้	ยังคงผ่านส่วนหน้าของเครื่องมือที่คุณประกาศไว้
ขอบเขตความปลอดภัย	คำจำกัดความเครื่องมือ	คำจำกัดความเครื่องมือ ไม่เปลี่ยนแปลง

สิ่งที่ยังคงเหมือนเดิม

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

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

ข้อจำกัดและคำถามที่ยังเปิดอยู่

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

พารามิเตอร์คำขอที่แน่นอน, ข้อจำกัดการดำเนินการ และพฤติกรรมการหมดเวลาเป็นของ เอกสารอ้างอิง API และคู่มือโมเดลของ OpenAI ชื่อพารามิเตอร์อาจเปลี่ยนแปลงได้ในระหว่างการปรับปรุงที่ตามมาหลังจากการเปิดตัวสู่สาธารณะ ดังนั้นโปรดอ่านเอกสารอ้างอิงก่อนที่คุณจะเขียนโค้ดเพื่อใช้งานคุณสมบัตินี้
การดีบักเป็นส่วนใหม่ เมื่อการจัดการเคยอยู่ในที่เก็บของคุณ คุณสามารถตั้งค่าจุดพักได้ แต่ตอนนี้ส่วนหนึ่งของการควบคุมการทำงานถูกสร้างขึ้นใหม่ทุกครั้งที่ร้องขอ การบันทึกลำดับการเรียกใช้เครื่องมือที่แซนด์บ็อกซ์สร้างขึ้นจึงกลายเป็นงานหลักของการสังเกตการณ์
ยังไม่มีประวัติการใช้งานจริงในการผลิต บันทึกวันแรกของ Simon Willison เกี่ยวกับ GPT-5.6 เป็นบันทึกที่ดีของการทดสอบอิสระที่ปรากฏขึ้น คาดการณ์ว่าจะมีปัญหาที่ซับซ้อนปรากฏขึ้นที่นั่นก่อนที่เอกสารทางการจะกล่าวถึง
ลำดับการนำไปใช้งานที่เหมาะสม: เริ่มต้นด้วยเครื่องมือแบบอ่านอย่างเดียว เฝ้าดูการจัดการที่สร้างขึ้น ตรวจสอบการนับโทเค็นกับลูปเก่าของคุณ และหลังจากนั้นจึงค่อยเปิดเผยเครื่องมือที่มีผลข้างเคียง

เครื่องมือของคุณตอนนี้กลายเป็น API ที่โค้ดของผู้อื่นเรียกใช้

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

นั่นยกระดับมาตรฐานในสี่สิ่ง:

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

นี่คือที่ที่ API workbench จริงๆ จะแสดงความสามารถ กำหนดหรือนำเข้าสเปกของปลายทางเครื่องมือแต่ละอัน ส่งคำขอทดสอบไปยังมัน และยืนยันว่า Schema การตอบสนองตรงกับสิ่งที่คำจำกัดความเครื่องมือของคุณรับประกัน จากนั้นไปอีกขั้น: จำลอง API เครื่องมือเพื่อให้คุณสามารถทดสอบการจัดการกับข้อมูลจำลองที่คาดการณ์ได้โดยไม่ต้องแตะต้องระบบการผลิต ดาวน์โหลด Apidog และเซิร์ฟเวอร์จำลองในตัวจะให้บริการการตอบสนองที่มีโครงสร้างตาม Schema สำหรับทุกปลายทางที่คุณกำหนดไว้ ดังนั้นคุณจึงสามารถมอบส่วนหน้าของเครื่องมือทั้งหมดให้โมเดลและดูว่ามันจัดการอย่างไรก่อนที่จะแตะต้องข้อมูลจริงแม้แต่รายการเดียว

button

คุณสมบัติ GA อื่นๆ โดยย่อ

การเรียกใช้เครื่องมือแบบโปรแกรมไม่ได้มาเดี่ยวๆ มีการเพิ่ม Responses API ที่เกี่ยวข้องกันอีกสองอย่างที่สำคัญที่นี่:

Multi-agent, ในเวอร์ชันเบต้า: การดำเนินการ subagent แบบขนานที่จัดการโดย API อยู่ในช่วงเริ่มต้น ควรรอดูมากกว่าที่จะคาดหวังมาก
การให้เหตุผลที่คงอยู่: บริบทการให้เหตุผลที่ถูกนำกลับมาใช้ใหม่ระหว่างรอบผ่าน reasoning.context เพื่อให้เซสชันเอเจนต์ที่ยาวนานหยุดการสรุปผลลัพธ์เดียวกันซ้ำๆ ในแต่ละรอบ

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

การเรียกใช้เครื่องมือแบบโปรแกรมเทียบกับโหมด Ultra

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

Ultra คือการตั้งค่าแบบหลายเอเจนต์ที่รันเอเจนต์สี่ตัวพร้อมกันโดยค่าเริ่มต้น โดยใช้โทเค็นมากขึ้นโดยเจตนาเพื่อลดเวลาจริง; ตามข้อมูลของ OpenAI มันช่วยเพิ่มคะแนน Terminal-Bench 2.1 จาก 88.8% เป็น 91.9% มันมีอยู่ใน ChatGPT Work บนแผน Pro และ Enterprise และใน Codex ตั้งแต่ Plus ขึ้นไป การเรียกใช้เครื่องมือแบบโปรแกรมเป็นความสามารถของ API ที่เอเจนต์หนึ่งตัวจัดการเครื่องมือของมันในโค้ด Ultra ทำให้การคิดเป็นแบบขนาน; การเรียกใช้เครื่องมือแบบโปรแกรมช่วยลดการเดินทางไปกลับในการดำเนินการ รายละเอียดทั้งหมดอยู่ในบทความ โหมด Ultra ของ GPT-5.6 ของเรา แต่สรุปสั้นๆ คือ: หากปัญหาคอขวดของคุณคือความหน่วงของการเรียกใช้เครื่องมือ คุณต้องการการเรียกใช้เครื่องมือแบบโปรแกรม; หากเป็นเวลาในการพิจารณาปัญหาที่ซับซ้อน คุณต้องการ Ultra

button

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

ฉันจำเป็นต้องเขียนคำจำกัดความเครื่องมือที่มีอยู่ใหม่หรือไม่?

ไม่จำเป็น เครื่องมือยังคงใช้รูปแบบ JSON Schema แบบเดียวกับที่แสดงในโค้ดด้านบน และคำจำกัดความที่เขียนขึ้นสำหรับการเรียกใช้ฟังก์ชันแบบคลาสสิกยังคงใช้งานได้ งานที่ควรทำคือการทำให้กระชับขึ้น: เพิ่ม enums, ระบุรูปแบบ, และทำให้คำอธิบายเฉพาะเจาะจงเพียงพอที่โค้ดที่สร้างขึ้นจะไม่สามารถเข้าใจผิดได้

JavaScript ที่สร้างขึ้นสามารถเข้าถึงอินเทอร์เน็ตได้หรือไม่?

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

โมเดล GPT-5.6 ใดบ้างที่รองรับการเรียกใช้เครื่องมือแบบโปรแกรม?

OpenAI ระบุไว้ว่าเป็นส่วนต่อประสาน Responses API สำหรับตระกูล GPT-5.6 และทั้งสามระดับ (gpt-5.6-sol, gpt-5.6-terra, gpt-5.6-luna) สามารถใช้งานได้ด้วยตนเองสำหรับบัญชี API ใดๆ ตรวจสอบเอกสารอ้างอิง API สำหรับรายละเอียดระดับชั้นก่อนที่จะเลือกใช้ สำหรับการตั้งค่าเบื้องต้นและการทดลองเรียกใช้ครั้งแรก ดู วิธีใช้ GPT-5.6 API

สิ่งนี้แตกต่างจาก Code Interpreter อย่างไร?

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

สิ่งนี้ส่งผลต่อคุณอย่างไร

ลูปการเดินทางไปกลับเป็นส่วนที่น่าสนใจน้อยที่สุดของเอเจนต์ทุกตัวที่คุณเคยปล่อยออกไป และ GPT-5.6 ทำให้มันเป็นทางเลือก การจัดการได้ย้ายไปที่โมเดลแล้ว; ความรับผิดชอบต่อ API ของเครื่องมือที่สะอาด แม่นยำ และทำงานได้ดีได้ย้ายมาที่คุณ โดยมีน้ำหนักมากกว่าเดิม

ขั้นตอนต่อไปนั้นเป็นรูปธรรม เลือกเวิร์กโฟลว์ที่เน้นการอ่านข้อมูลหนักๆ หนึ่งอย่าง เขียนหรือปรับปรุง Schema เครื่องมือที่จำเป็นให้รัดกุมยิ่งขึ้น และทดสอบปลายทางแต่ละอันผ่าน API client และ mock server ของ Apidog จนกว่าสัญญาจะทนทานต่อการเรียกใช้แบบกะทันหันและอินพุตที่ไม่ถูกต้อง เมื่อโมเดลเริ่มเขียนโค้ดเพื่อใช้งานเครื่องมือของคุณ คุณต้องการให้โค้ดนั้นอ่านจากพื้นผิวที่คุณได้ทดสอบแล้ว