การเข้ารหัสแบบเอเจนต์ — การปฏิบัติในการใช้ AI อัตโนมัติ ตัวแทน เพื่อวางแผน เขียน ทดสอบ และทำซ้ำซอฟต์แวร์ — เปลี่ยนจากการสาธิตการวิจัยไปสู่เวิร์กโฟลว์เชิงปฏิบัติของนักพัฒนาในปี 2024–2025 ด้วยการมาถึงของเดือนตุลาคม 2025 คล็อด ไฮกุ 4.5Anthropic ส่งมอบโมเดลที่ได้รับการปรับให้เหมาะสมอย่างชัดเจนสำหรับ ตัวแทน ปริมาณงาน: รวดเร็ว คุ้มค่า และปรับแต่งสำหรับการประสานงานตัวแทนย่อยและงาน "การใช้งานคอมพิวเตอร์" (เช่น การขับเคลื่อนเครื่องมือ ตัวแก้ไข และ CLI) คู่มือนี้รวบรวมข่าวสารล่าสุด บันทึกความสามารถ สูตรสำเร็จ และแนวปฏิบัติที่ดีที่สุดในการกำกับดูแล เพื่อให้นักพัฒนาและผู้นำด้านวิศวกรรมสามารถนำการเขียนโค้ดแบบเอเจนต์ไปใช้ได้อย่างมีความรับผิดชอบและมีประสิทธิภาพในปี 2025
“การเข้ารหัสแบบตัวแทน” (Orchestration, Subagents) คืออะไร?
การเข้ารหัสแบบเอเจนต์ หมายถึงรูปแบบการใช้งาน LLM ที่โมเดลไม่เพียงแต่เขียนโค้ด แต่ยังประสานงานการดำเนินการ เรียกใช้เครื่องมือ จัดการผลลัพธ์ระดับกลาง และจัดการงานย่อยต่างๆ โดยอัตโนมัติ ซึ่งเป็นส่วนหนึ่งของเวิร์กโฟลว์ขนาดใหญ่ ในทางปฏิบัติ นั่นหมายความว่าโมเดลสามารถทำหน้าที่เสมือน “ตัวแทนโปรแกรมเมอร์” ที่วางแผนลำดับขั้นตอน มอบหมายงานให้กับตัวแทน/เครื่องมือย่อย และใช้ผลลัพธ์เพื่อสร้างอาร์ทิแฟกต์ขั้นสุดท้าย Anthropic และบริษัทอื่นๆ กำลังสร้างโมเดลและเฟรมเวิร์กเครื่องมือโดยเฉพาะเพื่อรองรับรูปแบบนี้
การประสานงานกับตัวแทนย่อย
- Orchestrator:ตัวควบคุม (อาจเป็นมนุษย์ โมเดลเอเจนต์เฉพาะอย่างเช่น Sonnet 4.5 หรือโปรแกรมขนาดเล็ก) ที่แยกย่อยงานที่ซับซ้อนออกเป็นงานย่อยที่แยกจากกัน มอบหมายงานเหล่านั้นให้กับเอเจนต์ย่อย และเชื่อมโยงผลลัพธ์เข้าด้วยกัน ออร์เคสเตรเตอร์ทำหน้าที่รักษาสถานะส่วนกลางและบังคับใช้นโยบายต่างๆ (เช่น ความปลอดภัย งบประมาณ)
- ตัวแทนย่อย:พนักงานกลุ่มเล็กที่มีสมาธิสูง (มักเป็นรุ่นที่เบากว่า เช่น Haiku 4.5 หรือแม้แต่โมดูลโค้ดแบบกำหนดตายตัว) ที่จัดการงานย่อยแต่ละงาน เช่น การสรุป การดึงเอนทิตี การเข้ารหัส การเรียก API หรือการตรวจสอบเอาต์พุต
การใช้ Claude Haiku 4.5 เป็นตัวแทนย่อย (ตัวเข้ารหัส) และโมเดลการใช้เหตุผลที่แข็งแกร่งกว่าเป็นตัวประสานงาน ถือเป็นการออกแบบที่พบเห็นได้ทั่วไปและคุ้มต้นทุน โดยตัวประสานงานจะวางแผน ในขณะที่ Haiku จะนำการดำเนินการแบบขนานเล็กๆ น้อยๆ หลายๆ อย่างไปใช้งานอย่างรวดเร็วและมีต้นทุนต่ำ
ทำไมมันถึงสำคัญตอนนี้
ปัจจัยหลายประการมาบรรจบกันเพื่อทำให้การเข้ารหัสแบบเอเจนต์เป็นไปได้ในทางปฏิบัติในปี 2025:
- รุ่นที่ปรับแต่งสำหรับ การใช้คอมพิวเตอร์ด้วยความน่าเชื่อถือที่ดีกว่าสำหรับการเรียกใช้เครื่องมือ การทดสอบ และการประสานงาน
- การปรับปรุงในด้านเวลาแฝงและต้นทุนทำให้สามารถรันอินสแตนซ์ตัวแทนหลายตัวได้แบบขนานกัน
- ระบบนิเวศเครื่องมือ (API, แซนด์บ็อกซ์, การรวม CI/CD) ที่ให้ตัวแทนทำงานในลักษณะที่ควบคุมได้และสังเกตได้
Claude Haiku 4.5 ได้รับการวางตำแหน่งอย่างชัดเจนเพื่อใช้ประโยชน์จากแนวโน้มเหล่านี้โดยนำเสนอความสมดุลระหว่างความเร็ว ต้นทุน และความสามารถในการเขียนโค้ดที่เหมาะสมสำหรับการประสานงานของตัวแทนย่อย
รูปแบบทางจิต (รูปแบบทั่วไป): ผู้วางแผน → ผู้ปฏิบัติงาน → ผู้ประเมิน ผู้วางแผนจะแบ่งวัตถุประสงค์ออกเป็นงานต่างๆ ตัวแทนย่อยของผู้ปฏิบัติงานจะรันงานต่างๆ (มักจะทำงานคู่ขนานกัน) ผู้ประเมินจะตรวจสอบและยอมรับหรือขอให้ปรับปรุงแก้ไข
Claude Haiku 4.5 — มีอะไรใหม่สำหรับนักพัฒนา
Anthropic เปิดตัว Claude Haiku 4.5 ในเดือนตุลาคม 2025 ในฐานะโมเดลประสิทธิภาพสูงและคุ้มค่าที่ปรับแต่งมาเพื่อการเขียนโค้ด การใช้คอมพิวเตอร์ และงานแบบเอเจนต์ การเปิดตัวนี้มุ่งเน้นไปที่การปรับปรุงความเร็วและต้นทุนต่อโทเค็น ควบคู่ไปกับการรักษาประสิทธิภาพการเขียนโค้ดที่แข็งแกร่งและการใช้เหตุผลแบบหลายขั้นตอน ซึ่งเป็นคุณสมบัติที่จำเป็นสำหรับเวิร์กโฟลว์แบบเอเจนต์ในทางปฏิบัติ ซึ่งการเรียกใช้เครื่องมือและลูปสั้นๆ จำนวนมากเป็นเรื่องปกติ Haiku 4.5 ถือเป็นตัวเลือกที่ประหยัดที่สุดใน Haiku ของ Anthropic ในขณะเดียวกันก็มีประสิทธิภาพระดับงานที่สำคัญสำหรับงานโค้ดและงานเอเจนต์ โมเดลนี้พร้อมใช้งานผ่าน API ซึ่งช่วยให้นักพัฒนาสามารถผสานรวมเข้ากับระบบ CI เครื่องมือ in-IDE และออร์เคสเตรเตอร์ฝั่งเซิร์ฟเวอร์ได้
เกณฑ์มาตรฐานและประสิทธิภาพการใช้งานจริง
ในบรรดาตัวชี้วัดหลัก: Claude Haiku 4.5 ได้รับคะแนนสูงในเกณฑ์มาตรฐานการเขียนโค้ด เช่น SWE-bench Verified (รายงานอยู่ที่ ~73.3% ในเอกสาร Anthropic) และแสดงให้เห็นถึงการพัฒนาที่เห็นได้ชัดในด้าน "การใช้งานคอมพิวเตอร์" (งานที่ใช้เครื่องมือ) เมื่อเทียบกับ Haiku รุ่นก่อนๆ Claude Haiku 4.5 เทียบเท่ากับ Sonnet 4 ในงานพัฒนาหลายงาน ในขณะเดียวกันก็มีการแลกเปลี่ยนระหว่างต้นทุนและประสิทธิภาพที่ทำให้น่าสนใจสำหรับระบบเอเจนต์แบบปรับขนาดได้
ฟีเจอร์หลักของ Claude Haiku 4.5 ที่ช่วยให้สามารถเขียนโค้ดแบบเอเจนต์ได้
โปรไฟล์ความเร็วและต้นทุนที่ปรับแต่งสำหรับลูปและการเรียกใช้เครื่องมือ:โดยทั่วไปแล้ว ลูปแบบเอเจนต์จะเกี่ยวข้องกับการเรียกใช้โมเดลสั้นๆ จำนวนมาก (การวางแผน → การเรียกใช้เครื่องมือ → การประเมิน → การวางแผนใหม่) Haiku 4.5 เน้นที่ปริมาณงานและต้นทุนโทเค็นที่ต่ำลง ช่วยให้คุณรันการวนซ้ำได้มากขึ้นในราคาที่ประหยัด สิ่งนี้จำเป็นเมื่อออร์เคสเตรเตอร์ของคุณสร้างเอเจนต์ย่อยสำหรับการทดสอบ การลินต์ หรือการสร้างสาขาทดลอง
การเข้ารหัสแบบสั้นที่แข็งแกร่งยิ่งขึ้นและ "การใช้คอมพิวเตอร์": Haiku 4.5 ได้รับการปรับแต่งให้ทำงานได้ดีกับเกณฑ์มาตรฐานการเขียนโค้ดและงานที่จำลองการใช้งานคอมพิวเตอร์ (การรันคำสั่งเชลล์ การแก้ไขไฟล์ และการตีความบันทึก) ซึ่งทำให้มีความน่าเชื่อถือมากขึ้นสำหรับสคริปต์อัตโนมัติที่ LLM อ่านผลลัพธ์ ตัดสินใจขั้นตอนต่อไป และออกคำสั่งติดตามผล ใช้ความสามารถนี้เพื่อจัดการวงจรการคัดแยก การจัดโครงสร้าง และการทดสอบ-แก้ไขแบบอัตโนมัติ
ความพร้อมใช้งานของ API และระบบนิเวศ: สามารถเข้าถึง Haiku 4.5 ได้ผ่าน API (เช่น โคเมทเอพีไอ ) และผ่านพันธมิตรคลาวด์ (เช่น Vertex AI และ Bedrock) ซึ่งช่วยลดความยุ่งยากในการผสานรวมกับไปป์ไลน์ CI/CD ที่มีอยู่ ออร์เคสเตรเตอร์แบบคอนเทนเนอร์ และบริการคลาวด์ การมีอินเทอร์เฟซแบบโปรแกรมที่เสถียรช่วยลดโค้ดกาวที่เปราะบาง และช่วยให้สามารถจำกัดอัตรา การลองซ้ำ และการตรวจสอบได้อย่างสม่ำเสมอ
รูปแบบการประสานงานหลายเอเจนต์ที่ทำงานได้ดีกับ Haiku 4.5
เมื่อ Haiku 4.5 เป็นเครื่องมือทำงานที่รวดเร็วและราคาไม่แพง รูปแบบการประสานเสียงที่ได้รับการพิสูจน์แล้วหลายรูปแบบก็โดดเด่นขึ้นมา
1) การประสานงานแบบลำดับชั้น (Master/Workers)
วิธีการทำงาน: นักวางแผนระดับสูง (Sonnet) → ผู้ควบคุมระดับกลาง (Haiku orchestrator) → กลุ่มผู้ปฏิบัติงาน (Haikus + รหัสกำหนด) ผู้ควบคุมที่มีความสามารถสูง (เช่น Sonnet 4.5) จะสร้างแผนและกำหนดขั้นตอนให้กับผู้ปฏิบัติงาน Haiku 4.5 จำนวนมาก มาสเตอร์จะรวบรวมผลลัพธ์และดำเนินการตรวจสอบเหตุผลขั้นสุดท้ายหรือการยอมรับ
ควรใช้เมื่อใด: งานที่ซับซ้อนซึ่งจำเป็นต้องมีการคิดวิเคราะห์เชิงขอบเขตเป็นครั้งคราว (การออกแบบ การตัดสินใจด้านนโยบาย) แต่จำเป็นต้องดำเนินการตามขั้นตอนเป็นประจำ Anthropic แนะนำอย่างชัดเจนว่านี่เป็นรูปแบบที่มีประสิทธิภาพ
2) กลุ่มงานฟาร์ม/กลุ่มคนงาน
วิธีการทำงาน: กลุ่มคนงาน Haiku ที่เหมือนกันจะดึงงานจากคิวและรันงานเหล่านั้นอย่างอิสระ ออร์เคสเตรเตอร์จะตรวจสอบความคืบหน้าและมอบหมายงานที่ล้มเหลวใหม่
ควรใช้เมื่อใด: เวิร์กโหลดที่มีปริมาณงานสูง เช่น การสรุปเอกสารแบบกลุ่ม การติดฉลากชุดข้อมูล หรือการรันการทดสอบยูนิตบนเส้นทางโค้ดจำนวนมาก รูปแบบนี้ใช้ประโยชน์จากความเร็วและต้นทุนที่ต่ำของ Haiku
3) ท่อส่ง (การแปลงแบบขั้นบันได)
วิธีการทำงาน: ข้อมูลไหลผ่านขั้นตอนต่างๆ ที่มีการเรียงลำดับ เช่น การนำเข้า → การทำให้เป็นมาตรฐาน (ไฮกุ) → การเสริมแต่ง (เครื่องมือภายนอก) → การสังเคราะห์ (โซเน็ต) แต่ละขั้นตอนมีขนาดเล็กและมีความเฉพาะทาง
ควรใช้เมื่อใด: ETL หลายขั้นตอนหรือการสร้างเนื้อหา โดยที่โมเดล/เครื่องมือต่างๆ เหมาะอย่างยิ่งสำหรับขั้นตอนต่างๆ
4) MapReduce / MapMerge
วิธีการทำงาน: แผนที่: พนักงานไฮกุจำนวนมากประมวลผลข้อมูลอินพุตที่แตกต่างกัน ลด: ผู้ประสานงาน (หรือโมเดลที่แข็งแกร่งกว่า) ผสานและแก้ไขข้อขัดแย้ง
ควรใช้เมื่อใด: การวิเคราะห์คอร์ปัสข้อความขนาดใหญ่ การตรวจสอบคุณภาพ (QA) ขนาดใหญ่ หรือการสังเคราะห์เอกสารหลายฉบับ มีประโยชน์เมื่อคุณต้องการเก็บรักษาการเข้ารหัสเฉพาะที่ไว้เพื่อการตรวจสอบย้อนกลับ แต่ต้องการสรุปหรือการจัดอันดับโดยรวมที่คำนวณเป็นครั้งคราวโดยใช้แบบจำลองที่มีราคาแพงกว่า
5) วงจรผู้ประเมิน (QA + การแก้ไข)
วิธีการทำงาน: ไฮกุจะสร้างผลลัพธ์ขึ้นมา เวิร์กเกอร์ไฮกุหรือผู้ประเมินผลซอนเน็ตอีกคนหนึ่งจะตรวจสอบผลลัพธ์นั้นกับรายการตรวจสอบ หากผลลัพธ์ล้มเหลว ระบบจะวนกลับ
ควรใช้เมื่อใด: งานที่มีความละเอียดอ่อนต่อคุณภาพซึ่งการปรับปรุงแบบวนซ้ำมีราคาถูกกว่าการใช้เฉพาะโมเดลชายแดนเท่านั้น
สถาปัตยกรรมระบบ: เชิงปฏิบัติ การเข้ารหัสพร็อกซี การตั้งค่าด้วย Haiku
สถาปัตยกรรมอ้างอิงแบบกะทัดรัด (ส่วนประกอบ):
- API เกตเวย์ / เอจ: รับคำขอของผู้ใช้ ทำการจำกัดการรับรอง/อัตรา
- พรีโปรเซสเซอร์ (ไฮกุ): ทำความสะอาด ปรับมาตรฐาน สกัดฟิลด์ที่มีโครงสร้าง และส่งคืนวัตถุงานที่เข้ารหัส (JSON) — การเข้ารหัสพร็อกซี.
- Orchestrator (Sonnet / โมเดลที่สูงกว่าหรือเอนจิ้นกฎน้ำหนักเบา): ใช้การเข้ารหัสงานและตัดสินใจว่าจะสร้างงานย่อยใดหรือจะจัดการคำขอเองหรือไม่
- พูลคนงาน (อินสแตนซ์ Haiku): ตัวแทน Haiku แบบคู่ขนานจะดำเนินการงานย่อยที่ได้รับมอบหมาย (การค้นหา การสรุป การสร้างโค้ด การเรียกใช้เครื่องมือง่ายๆ)
- ผู้ประเมิน / ประตูคุณภาพ (โซเน็ตหรือไฮกุ): ตรวจสอบผลลัพธ์และร้องขอการปรับปรุงหากจำเป็น
- ชั้นเครื่องมือ: ตัวเชื่อมต่อกับฐานข้อมูล การค้นหา แซนด์บ็อกซ์การดำเนินการโค้ด หรือ API ภายนอก
พฤติกรรม "การประสานตัวแทนย่อย" ที่ได้รับการปรับปรุงของ Haiku 4.5 ทำให้เหมาะอย่างยิ่งสำหรับองค์ประกอบนี้ เนื่องจากความเร็วในการตอบสนองและโปรไฟล์ต้นทุนช่วยให้สามารถรันเวิร์กเกอร์หลายตัวพร้อมกันเพื่อสำรวจการใช้งานที่หลากหลายได้พร้อมกัน การตั้งค่านี้ถือว่า Haiku เป็น ตัวเข้ารหัสพร็อกซีที่รวดเร็วและตัวดำเนินการลดเวลาแฝงและต้นทุนในขณะที่ยังคงใช้ Sonnet สำหรับการวางแผน/ประเมินผลที่สำคัญ
ข้อควรพิจารณาเกี่ยวกับเครื่องมือและการคำนวณ
- การใช้คอมพิวเตอร์แบบแซนด์บ็อกซ์: มอบเชลล์ที่ควบคุมโดยเอเจนต์หรือสภาพแวดล้อมแบบคอนเทนเนอร์สำหรับการทดสอบและสร้างอาร์ทิแฟกต์ จำกัดการเข้าถึงเครือข่ายและติดตั้งเฉพาะรีโพอที่จำเป็นเท่านั้น
- ราก:การดำเนินการของตัวแทนทุกครั้งควรสร้างบันทึกและความแตกต่างที่มีการลงนามเพื่อรักษาความสามารถในการอธิบายและอนุญาตให้ย้อนกลับได้
- ความเท่าเทียม:การเปิดตัวเวิร์กเกอร์หลายตัวจะช่วยเพิ่มความครอบคลุม (การใช้งานที่แตกต่างกัน) แต่ต้องใช้การประสานงานเพื่อปรับแพตช์ที่ขัดแย้งกัน
- งบประมาณทรัพยากร:ใช้ Haiku 4.5 สำหรับ "ลูปด้านใน" (การวนซ้ำอย่างรวดเร็ว) และสำรองโมเดลที่หนักกว่าไว้สำหรับการตรวจสอบโค้ดขั้นสุดท้ายหรือการวิเคราะห์สถาปัตยกรรมหากจำเป็น
ตัวห่อเครื่องมือและอะแดปเตอร์ความสามารถ
อย่าเปิดเผย API ของระบบดิบให้กับพรอมต์ของโมเดลโดยตรง ห่อเครื่องมือไว้ในอะแดปเตอร์ที่แคบและชัดเจน ซึ่งตรวจสอบอินพุตและทำความสะอาดเอาต์พุต ตัวอย่างความรับผิดชอบของอะแดปเตอร์:
- ตรวจสอบคำสั่งสำหรับการดำเนินการที่ได้รับอนุญาต
- บังคับใช้ข้อจำกัดด้านทรัพยากร/เวลา
- แปลข้อผิดพลาดระดับต่ำเป็น JSON ที่มีโครงสร้างสำหรับผู้ประเมิน
ตัวอย่างการทำงานขั้นต่ำ — Python (แบบอะซิงค์)
ด้านล่างนี้เป็นขั้นต่ำ ในทางปฏิบัติ ตัวอย่าง Python แสดงให้เห็นถึง รูปแบบลำดับชั้น:Sonnet เป็นผู้วางแผน คนงาน Haiku เป็นผู้ดำเนินการ ใช้ Anthropic Python SDK อย่างเป็นทางการสำหรับการส่งข้อความ (ดูเอกสาร SDK) แทนที่ ANTHROPIC_API_KEY ด้วยตัวแปรสภาพแวดล้อมของคุณ คุณยังสามารถใช้ API ของ CometAPI ได้ด้วย: คล็อด ไฮกุ 4.5 API และ คล็อด ซอนเน็ต 4.5 APIราคาการเรียก API ด้วย CometAPI ลด 20% จากราคาอย่างเป็นทางการ ราคาการเรียก API ด้วย CometAPI ลด 20% จากราคาอย่างเป็นทางการ คุณเพียงแค่ต้องเปลี่ยน Key ด้วย CometAPI KEY ที่คุณได้รับ โทร.
หมายเหตุ: ตัวอย่างนี้ตั้งใจให้มีขนาดเล็กและผสมผสานการทำงานแบบซิงโครนัส/อะซิงโครนัสเพื่อความชัดเจน ในการใช้งานจริง คุณจะได้เพิ่มการจัดการข้อผิดพลาดที่มีประสิทธิภาพ การลองใหม่ การจัดการความลับ และคิวงาน (เช่น Redis/RQ, Celery หรือ AWS SQS)
# minimal_haiku_orchestrator.py
# Requires: pip install anthropic aiohttp asyncio
import os
import asyncio
from anthropic import AsyncAnthropic
ANTHROPIC_KEY = os.environ.get("ANTHROPIC_API_KEY")
if not ANTHROPIC_KEY:
raise RuntimeError("Set ANTHROPIC_API_KEY in env")
# Model names (adjust if Anthropic changes exact IDs)
PLANNER_MODEL = "claude-sonnet-4-5-20250929" # high-capability planner
WORKER_MODEL = "claude-haiku-4-5" # fast, cheap worker
client = AsyncAnthropic(api_key=ANTHROPIC_KEY)
async def plan(user_request: str) -> list:
prompt = f"""You are a planner. Break the user's request into an ordered list of small executable steps.
User request: \"\"\"{user_request}\"\"\"
Return JSON array of step objects with "id" and "instruction"."""
resp = await client.messages.create(
model=PLANNER_MODEL,
messages=,
max_tokens=800,
)
text = resp.content.strip()
# naive parse: planner is expected to return JSON
import json
try:
steps = json.loads(text)
except Exception:
# fallback: ask Haiku to reformat if planner returned text
steps = [{"id": i+1, "instruction": line.strip()}
for i, line in enumerate(text.splitlines()) if line.strip()]
return steps
async def worker_execute(step):
# Haiku-heavy fast worker; returns a dict with result and metadata
system = f"You are a fast worker. Execute this single instruction and return JSON with fields: id, output, status."
prompt = f"Instruction: {step}\nReturn JSON with fields: id, output, status"
resp = await client.messages.create(
model=WORKER_MODEL,
messages=[
{"role": "system", "content": system},
{"role": "user", "content": prompt},
],
max_tokens=512,
)
# parse one-line JSON or fallback to raw
import json
txt = resp.content.strip()
try:
data = json.loads(txt)
except Exception:
data = {"id": step, "output": txt, "status": "ok"}
return data
async def evaluate_and_merge(results):
# Use Sonnet again to do final synthesis/QA
combined = "\n\n".join(} -> {r.get('output','')}" for r in results])
prompt = f"Given the partial results below, produce a concise final answer and mark pass/fail if any step failed.\n\n{combined}"
resp = await client.messages.create(
model=PLANNER_MODEL,
messages=,
max_tokens=600,
)
return resp.content.strip()
async def orchestrate(user_request: str):
steps = await plan(user_request)
# run workers in parallel (bounded parallelism recommended)
sem = asyncio.Semaphore(8) # at most 8 concurrent Haiku workers
async def guarded(step):
async with sem:
return await worker_execute(step)
results = await asyncio.gather(*)
final = await evaluate_and_merge(results)
return final
if __name__ == "__main__":
import sys
req = " ".join(sys.argv) or "Summarize the latest design doc and list 5 follow-ups."
out = asyncio.run(orchestrate(req))
print("FINAL OUTPUT:\n", out)
สิ่งนี้ทำอะไรโดยย่อ:
Sonnet วางแผนงาน (ขั้นตอน JSON) Haiku รันแต่ละขั้นตอนพร้อมกัน จากนั้น Sonnet จะสังเคราะห์/ตรวจสอบผลลัพธ์ นี่คือมาตรฐาน นักวางแผน→คนงาน→ผู้ประเมิน ลูป โค้ดนี้ใช้ Anthropic Python SDK (anthropic) ซึ่งตัวอย่างและไคลเอนต์แบบอะซิงค์แสดงเหมือนกัน messages.create อินเตอร์เฟซ.
วิธีการเข้าถึง Claude Haiku 4.5 API
CometAPI เป็นแพลตฟอร์ม API แบบรวมที่รวบรวมโมเดล AI มากกว่า 500 โมเดลจากผู้ให้บริการชั้นนำ เช่น ซีรีส์ GPT ของ OpenAI, Gemini ของ Google, Claude ของ Anthropic, Midjourney, Suno และอื่นๆ ไว้ในอินเทอร์เฟซเดียวที่เป็นมิตรกับนักพัฒนา ด้วยการนำเสนอการตรวจสอบสิทธิ์ การจัดรูปแบบคำขอ และการจัดการการตอบสนองที่สอดคล้องกัน CometAPI จึงทำให้การรวมความสามารถของ AI เข้ากับแอปพลิเคชันของคุณง่ายขึ้นอย่างมาก ไม่ว่าคุณจะกำลังสร้างแชทบ็อต เครื่องกำเนิดภาพ นักแต่งเพลง หรือไพพ์ไลน์การวิเคราะห์ที่ขับเคลื่อนด้วยข้อมูล CometAPI ช่วยให้คุณทำซ้ำได้เร็วขึ้น ควบคุมต้นทุน และไม่ขึ้นอยู่กับผู้จำหน่าย ทั้งหมดนี้ในขณะที่ใช้ประโยชน์จากความก้าวหน้าล่าสุดในระบบนิเวศ AI
นักพัฒนาสามารถเข้าถึงได้ คล็อด ไฮกุ 4.5 API ผ่านทาง CometAPI รุ่นใหม่ล่าสุด ได้รับการอัปเดตอยู่เสมอจากเว็บไซต์อย่างเป็นทางการ เริ่มต้นด้วยการสำรวจความสามารถของโมเดลใน สนามเด็กเล่น และปรึกษา คู่มือ API สำหรับคำแนะนำโดยละเอียด ก่อนเข้าใช้งาน โปรดตรวจสอบให้แน่ใจว่าคุณได้เข้าสู่ระบบ CometAPI และได้รับรหัส API แล้ว โคเมทเอพีไอ เสนอราคาที่ต่ำกว่าราคาอย่างเป็นทางการมากเพื่อช่วยคุณบูรณาการ
พร้อมไปหรือยัง?→ ลงทะเบียน CometAPI วันนี้ !
หากคุณต้องการทราบเคล็ดลับ คำแนะนำ และข่าวสารเกี่ยวกับ AI เพิ่มเติม โปรดติดตามเราที่ VK, X และ ไม่ลงรอยกัน!
สรุป
การใช้ คล็อด ไฮกุ 4.5 เนื่องจากตัวเข้ารหัส/เวิร์กเกอร์พร็อกซีที่รวดเร็วช่วยปลดล็อกระบบมัลติเอเจนต์ที่มีความหน่วงต่ำและคุ้มค่า รูปแบบการใช้งานจริงคือการให้โมเดลที่มีความสามารถสูงกว่าควบคุมและประเมินผล ในขณะที่เวิร์กเกอร์ Haiku หลายพันคนทำงานหนักๆ ตามปกติไปพร้อมๆ กัน ตัวอย่าง Python ขั้นต่ำข้างต้นจะช่วยให้คุณเริ่มต้นได้ – ปรับให้เข้ากับคิวการผลิต การตรวจสอบ และชุดเครื่องมือของคุณ เพื่อสร้างไปป์ไลน์เอเจนต์ที่แข็งแกร่ง ปลอดภัย และปรับขนาดได้