วิธีสร้าง AI Agents ที่พัฒนาตัวเองได้ด้วย Loop Engineering

เอเจนต์ AI ส่วนใหญ่ไม่ได้ล้มเหลวเพราะโมเดลอ่อนแอ

พวกมันล้มเหลวเพราะระบบรอบๆ โมเดลอ่อนแอ

พรอมพ์ที่คลุมเครือ

การเรียกใช้เครื่องมือที่พัง

เอเจนต์ลองผิดลองถูกในสิ่งที่ผิด

มันลืมสิ่งที่เรียนรู้ไปเมื่อสองขั้นตอนก่อน

มันทำซ้ำการกระทำที่ไม่ดีเดิมๆ

มันประกาศความสำเร็จเร็วเกินไป

และไม่มีใครสร้างวงจรป้อนกลับที่จะช่วยจับข้อผิดพลาดนั้นได้

นั่นคือปัญหาที่แท้จริง

หากคุณต้องการสร้างเอเจนต์ AI ที่พัฒนาขึ้นจริงๆ เมื่อเวลาผ่านไป คุณต้องการมากกว่าพรอมพ์ที่ดีกว่า เครื่องมือมากขึ้น หรืออิสระมากขึ้น

คุณต้องการ วิศวกรรมลูป

วิศวกรรมลูปคือศาสตร์แห่งการออกแบบว่าเอเจนต์:

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

การเปลี่ยนแปลงนั้นสำคัญ

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

พวกมันจะถูกกำหนดโดยความสามารถในการ:

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

นั่นคือสิ่งที่บทความนี้เกี่ยวกับ

ต้องการระบบ AI ที่ใช้งานได้จริงแบบนี้เพิ่มเติมไหม? ByteBuilders แชร์บทสรุปสั้นๆ ที่มีประโยชน์เกี่ยวกับ Claude, เวิร์กโฟลว์ AI, พรอมพ์, ระบบอัตโนมัติ และระบบวิศวกรรมในโลกแห่งความเป็นจริง

สมัครสมาชิกได้ที่นี่:

https://bytebuilders.beehiiv.com/subscribe

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

คุณจะเริ่มสร้างระบบที่พัฒนาขึ้นเพราะพวกมันถูกออกแบบมาให้เรียนรู้

ก่อนอื่น “การพัฒนาตนเอง” จริงๆ แล้วหมายถึงอะไร

หลายคนได้ยินคำว่า “เอเจนต์ที่พัฒนาตนเอง” และนึกถึงระบบที่ฝึกฝนตัวเองได้อย่างน่าอัศจรรย์หรือวิวัฒนาการไปเป็นสิ่งที่อิสระและลึกลับ

นั่นไม่ใช่คำจำกัดความที่มีประโยชน์

เอเจนต์ที่พัฒนาตนเองมักจะง่ายกว่านั้นมาก

มันคือเอเจนต์ที่สามารถใช้สัญญาณจากความพยายามครั้งก่อนเพื่อตัดสินใจได้ดีขึ้นในความพยายามครั้งต่อไป

สิ่งนั้นสามารถเกิดขึ้นได้ผ่าน:

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

กล่าวอีกนัยหนึ่ง:

การพัฒนาตนเองมักจะไม่ใช่การวิวัฒนาการของโมเดล มันคือการวิวัฒนาการของลูป

โมเดลพื้นฐานอาจจะยังคงเหมือนเดิม

สิ่งที่พัฒนาขึ้นคือพฤติกรรมของระบบรอบๆ โมเดล

นั่นเป็นกรอบที่ใช้งานได้จริงและเป็นมิตรกับวิศวกรรมมากกว่า

เหตุผลที่เอเจนต์ส่วนใหญ่ไม่พัฒนาด้วยตัวเอง

เอเจนต์จำนวนมากที่น่าประหลาดใจนั้นไม่ได้ถูกออกแบบมาให้พัฒนาจริงๆ

พวกมันถูกออกแบบมาให้ ดำเนินต่อไป

นั่นไม่ใช่สิ่งเดียวกัน

ระบบเอเจนต์ในปัจจุบันหลายระบบโดยพื้นฐานแล้วคือ:

1. อ่านงาน
2. คิด
3. เรียกใช้เครื่องมือ
4. ดำเนินต่อไปจนกว่าจะหยุด

ปัญหาคือโครงสร้างนี้มักจะขาด:

• เกณฑ์ความสำเร็จที่ชัดเจน
• การจำแนกประเภทความล้มเหลว
• การลองใหม่ที่รับรู้สถานะ
• ความทรงจำเกี่ยวกับสิ่งที่ล้มเหลวไปแล้ว
• การเปรียบเทียบระหว่างความพยายาม
• การประเมินผลลัพธ์
• กฎการยกระดับ

ดังนั้นเอเจนต์จึงไม่พัฒนา

มันแค่วนซ้ำ

นั่นคือความแตกต่างระหว่างการวนซ้ำแบบดิบและการวนซ้ำอย่างชาญฉลาด

วิศวกรรมลูปคือสิ่งที่สร้างความแตกต่างนั้น

วิศวกรรมลูปคือเลเยอร์สถาปัตยกรรมที่แท้จริง

วิธีที่ง่ายที่สุดในการทำความเข้าใจวิศวกรรมลูปคือ:

การเขียนพรอมพ์บอกโมเดลว่าต้องทำอะไร

วิศวกรรมลูปบอกระบบว่าควรทำตัวอย่างไรหลังจากที่มันลองทำแล้ว

ซึ่งรวมถึงคำถามเช่น:

• เอเจนต์ควรทำอย่างไรหลังจากการเรียกใช้เครื่องมือล้มเหลว?
• เมื่อใดที่ควรลองใหม่เทียบกับเปลี่ยนกลยุทธ์?
• อนุญาตให้ลองได้กี่ครั้ง?
• ควรจัดเก็บอะไรไว้ในความทรงจำ?
• ควรประเมินอะไรโดยอัตโนมัติ?
• เมื่อใดที่มนุษย์ควรเข้ามารับช่วงต่อ?
• อะไรนับว่าเป็นการปรับปรุง?

นี่คือเหตุผลที่วิศวกรรมลูปเป็นส่วนหนึ่งของการสนทนาเกี่ยวกับสถาปัตยกรรม ไม่ใช่แค่การสนทนาเกี่ยวกับพรอมพ์

ลูปหลักเบื้องหลังเอเจนต์ที่พัฒนาตนเอง

เอเจนต์ที่พัฒนาตนเองที่มีประโยชน์ส่วนใหญ่เป็นไปตามโครงสร้างซ้ำๆ ที่มีลักษณะประมาณนี้

1เป้าหมาย
2  ↓
3วางแผน
4  ↓
5ลงมือทำ
6  ↓
7สังเกตผลลัพธ์
8  ↓
9ประเมินคุณภาพ
10  ↓
11จัดเก็บสัญญาณ
12  ↓
13ลองใหม่ / แก้ไข / ยกระดับ / สรุปผล

นั่นคือรากฐาน

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

ไม่ใช่ทุกเอเจนต์ที่ต้องการเวอร์ชันที่ซับซ้อน

แต่เอเจนต์ที่เชื่อถือได้ทุกตัวต้องการเวอร์ชันนี้ในรูปแบบใดรูปแบบหนึ่ง

ความแตกต่างระหว่างเอเจนต์แบบไร้เดียงสาและเอเจนต์ที่ผ่านวิศวกรรมลูป

มิติ

เอเจนต์แบบไร้เดียงสา

เอเจนต์ที่ผ่านวิศวกรรมลูป

การจัดการงาน

พยายามทำงานครั้งเดียวหรือดำเนินต่อไปอย่างสุ่มสี่สุ่มห้า

ทำงานผ่านรอบที่มีขอบเขต

การตอบสนองต่อข้อผิดพลาด

ลองใหม่แบบสุ่มหรือล้มเหลวอย่างหนัก

ลองใหม่ตามการจำแนกประเภทความล้มเหลว

ความทรงจำ

มีสถานะที่มีประโยชน์น้อยหรือไม่มีเลย

จัดเก็บบริบทที่นำไปปฏิบัติได้

การประเมิน

ถือว่าการเสร็จสิ้นหมายถึงความสำเร็จ

ตรวจสอบผลลัพธ์เทียบกับเกณฑ์

การปรับปรุง

โดยบังเอิญ

โดยการออกแบบ

บทบาทของมนุษย์

เป็นเพียงทางเลือกสุดท้ายในกรณีฉุกเฉิน

จุดยกระดับโดยเจตนา

ความน่าเชื่อถือ

ไม่สอดคล้องกัน

แข็งแกร่งขึ้นเรื่อยๆ เมื่อเวลาผ่านไป

นี่คือการเปลี่ยนแปลง

เอเจนต์ที่ผ่านวิศวกรรมลูปไม่จำเป็นต้อง “ฉลาดกว่า” ในระดับโมเดล

มันแค่ทำงานภายในระบบที่ดีกว่า

องค์ประกอบพื้นฐานห้าประการของเอเจนต์ที่พัฒนาตนเอง

หากคุณต้องการให้เอเจนต์พัฒนาขึ้น คุณต้องมีลูปที่มีโครงสร้าง

องค์ประกอบพื้นฐานทั้งห้านี้สำคัญที่สุด

1. เกณฑ์ความสำเร็จที่ชัดเจน

หากระบบไม่รู้ว่า “ดี” เป็นอย่างไร มันก็ไม่สามารถพัฒนาไปสู่สิ่งนั้นได้

เกณฑ์ความสำเร็จอาจเป็น:

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

หากไม่มีสิ่งนี้ เอเจนต์ก็ไม่มีอะไรที่มั่นคงให้ปรับให้เหมาะสม

1. เลเยอร์การประเมิน

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

สิ่งนี้อาจเป็น:

• การตรวจสอบตามกฎ
• การตรวจสอบความถูกต้องของ Schema
• การทดสอบหน่วย
• การให้คะแนน LLM-as-judge
• การตรวจสอบหลักฐานยืนยันการดึงข้อมูล
• การตรวจสอบความถูกต้องของตรรกะทางธุรกิจ
• การตรวจสอบโดยมนุษย์

นี่คือความแตกต่างระหว่าง “มันสร้างคำตอบ” และ “มันสร้างคำตอบที่มีประโยชน์”

1. ความทรงจำป้อนกลับ

การพัฒนาตนเองต้องการความทรงจำ แต่ไม่ใช่แค่ประวัติศาสตร์ดิบๆ

เอเจนต์ต้องการ ความทรงจำที่ใช้งานได้

ความทรงจำป้อนกลับที่ดีประกอบด้วยสิ่งต่างๆ เช่น:

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

ไม่ใช่ทุกบริบทที่ควรคงอยู่

เฉพาะบริบทที่ช่วยในการตัดสินใจครั้งต่อไปเท่านั้น

1. การแก้ไขกลยุทธ์

หลังจากการประเมิน เอเจนต์ต้องตัดสินใจว่าจะเปลี่ยนแปลงอะไร

ซึ่งอาจรวมถึง:

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

นี่คือจุดที่ระบบปรับตัวได้จริงๆ

1. ขอบเขตและเงื่อนไขการหยุด

เอเจนต์ที่พัฒนาตนเองยังคงต้องการการควบคุม

ไม่อย่างนั้นคุณจะไม่ได้การปรับปรุง

คุณจะได้ความโกลาหล

กำหนดขีดจำกัดสำหรับ:

• การลองใหม่
• ต้นทุน
• ความหน่วง
• การกระทำที่ก่อให้เกิดความเสียหาย
• เกณฑ์การอนุมัติจากมนุษย์
• กฎการละทิ้งงาน

ลูปที่มีขอบเขตมีค่ามากกว่าลูปที่ไม่มีข้อจำกัด

วิศวกรรมลูปในทางปฏิบัติมีลักษณะอย่างไร

นี่คือรูปแบบง่ายๆ ที่ใช้ได้ดีกับเอเจนต์หลายตัว

ลูป 1: พยายาม

เอเจนต์พยายามทำงานด้วยบริบทปัจจุบัน

ลูป 2: ประเมิน

การตรวจสอบทำงาน

ตัวอย่าง:

• schema ตรวจสอบความถูกต้องหรือไม่?
• โค้ดผ่านการทดสอบหรือไม่?
• คำตอบอ้างอิงแหล่งที่มาที่ต้องการหรือไม่?
• เครื่องมือส่งคืนฟิลด์ที่ถูกต้องหรือไม่?

ลูป 3: วินิจฉัย

หากล้มเหลว ให้จำแนกสาเหตุ

ตัวอย่าง:

• บริบทขาดหาย
• อาร์กิวเมนต์เครื่องมือไม่ดี
• การดึงข้อมูลล้มเหลว
• สมมติฐานที่หลอน
• ผลลัพธ์ไม่สมบูรณ์
• ความขัดแย้งของนโยบาย

ลูป 4: ปรับตัว

เปลี่ยนความพยายามครั้งต่อไป

ตัวอย่าง:

• ดึงบริบทเพิ่มเติม
• เขียนงานใหม่ให้แคบลง
• ลองใช้เครื่องมืออื่น
• เพิ่มกฎการตรวจสอบความถูกต้อง
• ถามผู้ใช้เพื่อหาข้อมูลที่ขาดหาย

ลูป 5: จัดเก็บสัญญาณที่มีประโยชน์

บันทึกเฉพาะสิ่งที่ช่วยในการทำงานในอนาคต

แล้วทำซ้ำ

นั่นคือวิศวกรรมลูปในแง่การปฏิบัติการ

แผนภาพเชิงปฏิบัติสำหรับเอเจนต์ที่ผ่านวิศวกรรมลูป

1เป้าหมายผู้ใช้
2   ↓
3ตัวแปลงาน
4   ↓
5ผู้วางแผน
6   ↓
7เลเยอร์เครื่องมือ / การกระทำ
8   ↓
9ผลลัพธ์
10   ↓
11ผู้ประเมิน
12   ├── ผ่าน → สรุปผล
13   ├── ล้มเหลว: บริบทขาดหาย → ดึงเพิ่มเติม
14   ├── ล้มเหลว: การใช้เครื่องมือไม่ดี → แก้ไขการกระทำ
15   ├── ล้มเหลว: ความมั่นใจต่ำ → ยกระดับ
16   └── ล้มเหลว: สามารถกู้คืนได้ → ลองใหม่ด้วยความทรงจำ

นี่คือจุดที่คุณภาพของเอเจนต์กลายเป็นระบบแทนที่จะเป็นเรื่องบังเอิญ

สัญญาณการพัฒนาตนเองควรมาจากไหน

นี่เป็นหนึ่งในคำถามการออกแบบที่สำคัญที่สุด

หากคุณป้อนสัญญาณที่ผิดเข้าสู่ลูป เอเจนต์อาจปรับให้เหมาะสมในทิศทางที่ผิด

แหล่งสัญญาณการปรับปรุงที่แข็งแกร่ง ได้แก่:

สัญญาณที่แน่นอน (Deterministic)

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

สัญญาณเวิร์กโฟลว์

• จำนวนครั้งที่ลองใหม่
• ความหน่วงของเครื่องมือ
• ขั้นตอนที่เกิดความล้มเหลว
• เกณฑ์ความมั่นใจที่ถูกข้าม
• ความถี่ในการยกระดับ

สัญญาณจากมนุษย์

• กดถูกใจ / กดไม่ถูกใจ
• ผลลัพธ์ที่ถูกแก้ไข
• ฉบับร่างที่ยอมรับเทียบกับที่ปฏิเสธ
• รูปแบบการแทนที่ด้วยตนเอง
• บันทึกของผู้ตรวจสอบ

สัญญาณเปรียบเทียบ

• คุณภาพผลลัพธ์เวอร์ชัน A เทียบกับเวอร์ชัน B
• การเปรียบเทียบตัวแปรการดึงข้อมูล
• การเปรียบเทียบเส้นทางเครื่องมือ
• การปรับปรุงคะแนนจากการทำงานซ้ำๆ

เอเจนต์ที่พัฒนาตนเองที่ดีที่สุดมักจะรวมอย่างน้อยสองหมวดหมู่เหล่านี้เข้าด้วยกัน

ลูปที่ดีที่สุดปรับปรุงเวิร์กโฟลว์ ไม่ใช่แค่การตอบสนอง

นี่คือจุดที่การออกแบบมีความเป็นผู้ใหญ่มากขึ้น

การใช้งานที่อ่อนแอใช้ลูปเพื่อสร้างข้อความใหม่เท่านั้น

การใช้งานที่แข็งแกร่งกว่าใช้ลูปเพื่อปรับปรุงเวิร์กโฟลว์ทั้งหมด

นั่นหมายความว่าเอเจนต์สามารถปรับปรุงได้โดยการเปลี่ยนแปลง:

• สิ่งที่มันดึงข้อมูล
• เครื่องมือที่มันใช้
• ลำดับขั้นตอน
• สิ่งที่มันจำ
• สิ่งที่มันไม่สนใจ
• ไม่ว่าจะถามเพื่อขอคำชี้แจงเร็วขึ้น
• ไม่ว่าจะหยุดเร็วขึ้น

สิ่งนี้มีประสิทธิภาพมากกว่า “เขียนคำตอบใหม่อีกครั้ง”

ระบบจะแก้ไขตัวเองในระดับกระบวนการ

รูปแบบพรอมพ์ที่สนับสนุนการพัฒนาตนเอง

การเขียนพรอมพ์ยังคงมีความสำคัญ

เพียงแค่ต้องสนับสนุนลูป

นี่คือรูปแบบพรอมพ์ที่มีประโยชน์

พรอมพ์ 1: พรอมพ์การดำเนินการที่รับรู้การประเมิน

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

พรอมพ์ 2: พรอมพ์การวินิจฉัยความล้มเหลว

1ความพยายามก่อนหน้านี้ล้มเหลว
2จำแนกสาเหตุความล้มเหลวที่น่าจะเป็นไปได้เป็นหนึ่งในหมวดหมู่เหล่านี้:
3- บริบทขาดหาย
4- การใช้เครื่องมือในทางที่ผิด
5- สมมติฐานที่ไม่ดี
6- ผลลัพธ์ไม่สมบูรณ์
7- ความล้มเหลวของรูปแบบหรือ schema
8- ความขัดแย้งของนโยบาย
9จากนั้นเสนอการเปลี่ยนแปลงเล็กน้อยที่สุดครั้งต่อไปที่ช่วยเพิ่มโอกาสในการประสบความสำเร็จ

พรอมพ์ 3: พรอมพ์การแก้ไข

1แก้ไขความพยายามครั้งต่อไปโดยใช้ข้อเสนอแนะจากผู้ประเมินด้านล่าง
2อย่าทำซ้ำเส้นทางการใช้เหตุผลเดียวกันหากมันล้มเหลวไปแล้ว
3เลือกใช้โซลูชันที่แคบกว่าและมีหลักฐานยืนยันมากกว่า
4หากจำเป็น ให้ดึงบริบทเพิ่มเติมก่อนตอบ

พรอมพ์ 4: พรอมพ์สรุปความทรงจำ

1สรุปความพยายามครั้งล่าสุดเป็นบล็อกความทรงจำสั้นๆ สำหรับการทำงานครั้งต่อไป
2รวมเฉพาะ:
3- สิ่งที่ล้มเหลว
4- สิ่งที่ได้ผล
5- สิ่งที่ควรหลีกเลี่ยง
6- สิ่งที่ควรลองต่อไป
7เก็บให้สั้นกว่า 120 คำ

สิ่งเหล่านี้ไม่ใช่พรอมพ์วิเศษ

它们是旨在强化循环行为的提示。

สถาปัตยกรรมลูปสไตล์ Python อย่างง่าย

ด้านล่างนี้เป็นตัวอย่างอย่างง่ายของวิศวกรรมลูปในโค้ด

1MAX_ATTEMPTS = 4
2
3memory = []
4
5for attempt in range(MAX_ATTEMPTS):
6    context = build_context(task=task, memory=memory)
7    plan = agent.plan(context)
8    result = agent.act(plan)
9
10    evaluation = evaluator.check(task=task, result=result)
11
12    if evaluation.passed:
13        return {
14            "status": "success",
15            "result": result,
16            "attempt": attempt + 1,
17        }
18
19    failure_summary = agent.summarize_failure(
20        result=result,
21        evaluation=evaluation,
22    )
23
24    memory.append({
25        "attempt": attempt + 1,
26        "failure": failure_summary,
27        "suggested_fix": evaluation.next_step,
28    })
29
30    if evaluation.requires_human:
31        return {
32            "status": "escalated",
33            "reason": evaluation.reason,
34            "attempt": attempt + 1,
35            "memory": memory,
36        }
37
38return {
39    "status": "failed",
40    "reason": "max_attempts_reached",
41    "memory": memory,
42}

นี่ตั้งใจให้เรียบง่าย

ประเด็นสำคัญไม่ใช่โค้ดเอง

มันคือโครงสร้าง:

• พยายาม
• ประเมิน
• จัดเก็บสัญญาณ
• ปรับตัว
• ลองใหม่หรือยกระดับ

นั่นคือรูปแบบที่ต้องซึมซับ

วิศวกรรมลูปมีความสำคัญมากที่สุดที่ไหน

แนวทางนี้มีค่าอย่างยิ่งในเวิร์กโฟลว์ที่ไม่รับประกันความสำเร็จในครั้งแรก

เอเจนต์เขียนโค้ด

เหมาะสำหรับลูปเพราะระบบสามารถ:

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

เอเจนต์สนับสนุน

มีประโยชน์เพราะระบบสามารถ:

• ดึงบริบทนโยบาย
• ร่างการตอบกลับ
• ตรวจสอบหลักฐานยืนยัน
• ขออนุมัติหากมีความเสี่ยงสูง

เอเจนต์วิจัย

มีประโยชน์เพราะระบบสามารถ:

• รวบรวมหลายแหล่ง
• ระบุช่องว่าง
• ค้นหาอีกครั้ง
• สังเคราะห์เมื่อมีหลักฐานเพียงพอเท่านั้น

เอเจนต์แยกข้อมูลเอกสาร

มีประโยชน์เพราะระบบสามารถ:

• แยกวิเคราะห์ไฟล์
• ตรวจสอบความถูกต้องของ Schema
• ลองใหม่ในฟิลด์ที่ไม่ชัดเจน
• ยกระดับกรณีที่มีความมั่นใจต่ำ

เอเจนต์เวิร์กโฟลว์ปฏิบัติการ

มีคุณค่าเพราะระบบสามารถ:

• เรียกใช้ API
• ตรวจสอบผลลัพธ์
• กู้คืนจากความล้มเหลวบางส่วน
• ส่งต่อข้อยกเว้นไปยังมนุษย์

ในทุกกรณีเหล่านี้ คุณภาพของลูปสำคัญกว่าคุณภาพของการสร้างครั้งเดียว

ข้อผิดพลาดทั่วไปในวิศวกรรมลูป

ข้อผิดพลาด 1: ถือว่าการลองใหม่คือการปรับปรุง

ความพยายามที่มากขึ้นไม่ได้หมายถึงการเรียนรู้ที่ดีขึ้นโดยอัตโนมัติ

หากระบบทำพฤติกรรมเดิมซ้ำ มันไม่ได้กำลังพัฒนา

มันแค่กำลังวนซ้ำ

ข้อผิดพลาด 2: จัดเก็บความทรงจำมากเกินไป

ไม่ใช่บริบทในอดีตทั้งหมดที่จะช่วยได้

ความทรงจำที่มากเกินไปอาจทำให้ความพยายามครั้งต่อไปปนเปื้อน

จัดเก็บบทเรียนที่บีบอัดและนำไปปฏิบัติได้—ไม่ใช่กองถอดความดิบ

ข้อผิดพลาด 3: ข้ามการประเมิน

หากไม่มีการตรวจสอบ เอเจนต์ไม่สามารถรู้ได้ว่ามันดีขึ้นหรือไม่

นี่คือความล้มเหลวเชิงโครงสร้างที่พบบ่อยที่สุด

ข้อผิดพลาด 4: ไม่มีเงื่อนไขการหยุด

เอเจนต์ที่ไม่มีข้อจำกัดไม่ใช่สิ่งที่ล้ำหน้า

มันแพง

ข้อผิดพลาด 5: ไม่สนใจข้อเสนอแนะของมนุษย์

หากมนุษย์แก้ไขสิ่งเดิมซ้ำแล้วซ้ำเล่าและลูปไม่เคยใช้สัญญาณนั้น ระบบก็ไม่ได้พัฒนาจริงๆ

ข้อผิดพลาด 6: ใช้ลูปยักษ์เดียวสำหรับทุกงาน

งานที่แตกต่างกันต้องการลูปที่แตกต่างกัน

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

ลำดับการสร้างเชิงปฏิบัติที่ฉันแนะนำ

หากคุณกำลังสร้างจากศูนย์ ให้ใช้ลำดับนี้

ขั้นตอนที่ 1: กำหนดความสำเร็จอย่างชัดเจน

ผลลัพธ์ที่ดีมีลักษณะอย่างไร?

ขั้นตอนที่ 2: กำหนดหมวดหมู่ความล้มเหลว

ทำไมเอเจนต์นี้ถึงมักจะล้มเหลว?

ขั้นตอนที่ 3: สร้างผู้ประเมินก่อน

ระบบจะรู้ได้อย่างไรว่ามันสำเร็จหรือล้มเหลว?

ขั้นตอนที่ 4: ออกแบบกฎความทรงจำ

อะไรควรคงอยู่ระหว่างความพยายาม?

ขั้นตอนที่ 5: กำหนดกลยุทธ์การลองใหม่

อะไรเปลี่ยนแปลงระหว่างความพยายามครั้งที่หนึ่งและครั้งที่สอง?

ขั้นตอนที่ 6: เพิ่มตรรกะการยกระดับ

เมื่อใดที่มนุษย์ควรเข้ามามีส่วนร่วม?

ขั้นตอนที่ 7: บันทึกทุกสิ่งที่สำคัญ

คุณไม่สามารถปรับปรุงสิ่งที่คุณไม่ได้สังเกต

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

อย่าทำให้ระบบซับซ้อนเกินไปก่อนที่วงจรหลักจะเสถียร

ลำดับนั้นช่วยให้ทีมโฟกัสที่พฤติกรรมแทนที่จะเป็นกระแส

รายการตรวจสอบง่ายๆ ก่อนที่คุณจะเรียกเอเจนต์ว่า “พัฒนาตนเอง”

ใช้สิ่งนี้เป็นการตรวจสอบความเป็นจริง

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

หากส่วนใหญ่หายไป ระบบอาจจะไม่ได้พัฒนาตนเอง

มันแค่เป็นแบบวนซ้ำ

ความคิดสุดท้าย

อนาคตของเอเจนต์ AI ไม่ใช่แค่พรอมพ์ที่ดีกว่า เครื่องมือมากขึ้น หรือห่วงโซ่ที่ยาวขึ้น

มันคือลูปที่ดีกว่า

นั่นคือสิ่งที่วิศวกรรมลูปทำให้เป็นไปได้

มันเปลี่ยนเอเจนต์จากเครื่องสร้างครั้งเดียวเป็นระบบที่สามารถ:

• สังเกต
• ประเมิน
• ปรับตัว
• จดจำ
• ลองใหม่อย่างชาญฉลาด
• พัฒนาภายใต้สภาวะจริง

นั่นคือสิ่งที่การพัฒนาตนเองมีลักษณะจริงๆ ใน AI ระดับการผลิต

ไม่ใช่ความลึกลับ

ไม่ใช่เวทมนตร์

แค่การออกแบบระบบที่ดีกว่า

หากคุณต้องการเอเจนต์ที่แข็งแกร่งขึ้น อย่าแค่ถามว่าจะทำให้พวกมันลงมือทำได้อย่างไร

ถามว่าจะทำให้พวกมัน เรียนรู้จากสิ่งที่เกิดขึ้นต่อไป ได้อย่างไร

นั่นคือจุดที่พลังที่แท้จริงอยู่