ระบบเอเจนต์ย่อย

ภาพรวม

เอเจนต์ย่อย (Subagent) คือกลไกการแยกย่อยและมอบหมายงานของพื้นที่ทำงาน Agent หลักสามารถแยกงานคู่ขนานที่ซับซ้อนออกเป็นงานย่อย สร้างเอเจนต์ย่อยเฉพาะทางเพื่อดำเนินการอย่างอิสระ และเมื่อเอเจนต์ย่อยทำงานเสร็จก็จะส่งผลลัพธ์กลับให้ Agent หลักดำเนินการต่อ

ระบบรองรับเอเจนต์ย่อย 3 ประเภท โดยมีความลึกในการซ้อนสูงสุด 3 ระดับ

เอเจนต์ย่อยทั้ง 3 ประเภท

เอเจนต์ย่อยที่สร้างอัตโนมัติ (create_local_sub_agent)

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

"กรุณาสร้างเอเจนต์ย่อยหนึ่งตัวเพื่อรับผิดชอบการค้นหาข้อมูลที่เกี่ยวข้อง แล้วสร้างเอเจนต์ย่อยอีกตัวเพื่อเขียนเอกสาร"

พารามิเตอร์การสร้าง:

ขั้นตอนการดำเนินการ:

1. Agent หลักตัดสินใจสร้างเอเจนต์ย่อยและกำหนดงาน
2. ระบบเริ่ม Agent Loop อิสระ (ค่าเริ่มต้นสูงสุด 50 รอบ)
3. เอเจนต์ย่อยมีลูปเครื่องมืออิสระ กระบวนการดำเนินการมองเห็นได้ในหน้าต่างบทสนทนาของ Agent หลัก
4. เมื่อเอเจนต์ย่อยทำงานเสร็จ จะส่งผลลัพธ์สุดท้ายกลับให้ Agent หลัก
5. Agent หลักดำเนินงานต่อโดยอิงจากผลลัพธ์

เอเจนต์ย่อยแบบส่งงานลงทะเบียนล่วงหน้า (dispatch_sub_agent)

ผู้ใช้สามารถลงทะเบียนล่วงหน้าในการตั้งค่า APP เพื่อสร้างเอเจนต์ย่อยที่มีการกำหนดค่าเฉพาะ และ Agent จะเรียกใช้ผ่านเครื่องมือ dispatch_sub_agent เมื่อจำเป็น

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

รายการการกำหนดค่า:

ดูรายละเอียดหน้าจอการจัดการได้ที่ การลงทะเบียนและการจัดการเอเจนต์ย่อย

การส่งงานข้ามโหนด (dispatch_multi_node_agent)

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

ขั้นตอนการทำงาน:

1. Agent หลักดูรายการโหนดออนไลน์ (แทรกเข้าสู่ระบบพรอมต์)
2. เลือกโหนดเป้าหมายตามการประกาศความสามารถของโหนด
3. ส่ง node.invoke.request ผ่าน Gateway WebSocket
4. โหนดระยะไกลเริ่ม Agent Loop อิสระเพื่อดำเนินงาน
5. เมื่อเสร็จ จะส่งผลลัพธ์กลับผ่าน node.invoke.result

ตัวอย่างสถานการณ์:

• เว็บฝั่งบนคอมพิวเตอร์ A เริ่มบทสนทนา
• งานต้องเข้าถึงไฟล์ในเครื่องบนคอมพิวเตอร์ B
• Agent ส่งงานย่อยการดำเนินการกับไฟล์ไปยังโหนด APP ของคอมพิวเตอร์ B ผ่าน Gateway
• โหนด B ดำเนินการแล้วส่งผลลัพธ์กลับ และแสดงบทสนทนาต่อบนคอมพิวเตอร์ A

การควบคุมความลึกในการซ้อน

เอเจนต์ย่อยรองรับการสร้างแบบซ้อน โดยมีความลึกสูงสุด 3 ระดับ:

                      
                      ความลึก 0: Agent หลัก (บทสนทนากับผู้ใช้)
  └── ความลึก 1: เอเจนต์ย่อย A
        └── ความลึก 2: เอเจนต์ย่อยของย่อย A-1
              └── ความลึก 3: เอเจนต์ระดับลึกที่สุด (ไม่สามารถมอบหมายต่อได้)

                    

ยิ่งความลึกมาก ความเป็นอิสระยิ่งสูง แต่การใช้ Token และเวลาดำเนินการก็เพิ่มขึ้นตามไปด้วย

กลไกการสืบทอดเครื่องมือ

การแสดงผล UI

เอเจนต์ย่อยจะมีเครื่องหมายพิเศษแสดงในหน้าต่างบทสนทนา Work:

ผู้ใช้สามารถเห็นได้อย่างชัดเจนว่าการดำเนินการใดทำโดย Agent หลัก และการดำเนินการใดทำโดยเอเจนต์ย่อย

วิธีสร้างเอเจนต์ย่อยผ่านบทสนทนา

คุณสามารถสั่งให้ Agent สร้างเอเจนต์ย่อยด้วยภาษาธรรมชาติในบทสนทนา ต่อไปนี้คือตัวอย่างพรอมต์บางส่วน:

การอ่านหน้าจอระหว่างการทำงานของเอเจนต์ย่อย

ผลกระทบต่อค่าใช้จ่าย

การใช้ token ของเอเจนต์ย่อยจะถูกคำนวณแยกต่างหาก:

คำแนะนำ: เอเจนต์ย่อยเหมาะกับงานซับซ้อนที่จำเป็นต้องแยกย่อยจริง ๆ สำหรับงานง่าย ๆ ให้ Agent หลักจัดการโดยตรงได้เลย ไม่จำเป็นต้องสร้างเอเจนต์ย่อย

เมื่อใดควรใช้ / ไม่ควรใช้เอเจนต์ย่อย

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

เอกสารที่เกี่ยวข้อง

• การลงทะเบียนและการจัดการเอเจนต์ย่อย — การกำหนดค่าเอเจนต์ย่อยที่ลงทะเบียนล่วงหน้า
• สถาปัตยกรรมหลายโหนด — กลไกพื้นฐานของการส่งงานข้ามโหนด
• เอนจิน Agent Loop — Agent Loop ที่เอเจนต์ย่อยใช้งาน