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

แนวคิดนี้กำลังเปลี่ยนวิธีทำงานกับ AI ของคนบางกลุ่มไปแล้ว มีวิศวกรที่คลุกคลีกับ coding agent ระดับแนวหน้าอย่าง Boris Cherny และ Peter Steinberg ประกาศต่อสาธารณะว่าเลิกพิมพ์ prompt สั่ง agent เองทีละครั้ง แล้วหันมาออกแบบ loop ให้ agent ทำงานแทน เพราะพอ AI เก่งขึ้น คอขวดของงานไม่ได้อยู่ที่ว่าใครพิมพ์ prompt เก่งกว่า แต่อยู่ที่ว่าใครออกแบบวงจรให้มันทำงานเองได้ดีกว่า ตัวอย่างจริงหลายตัวอย่างที่ Nate Herk รวบรวมไว้ในคลิปอธิบายเรื่อง agent loop ช่วยให้เห็นภาพชัดว่าวงจรแบบนี้หน้าตาเป็นยังไง และทำไมมันถึงได้ผล

ถอด loop ออกมาดู มีแค่สามชิ้น

ถ้าแกะ agent loop ออกมา จะเหลือองค์ประกอบแค่สามอย่าง อย่างแรกคือ trigger หรือสิ่งที่จุดให้ loop เริ่มทำงาน อย่างที่สองคือ action หรือสิ่งที่ agent ลงมือทำในแต่ละรอบ ส่วนอย่างที่สามคือ stop condition หรือเงื่อนไขที่บอกว่าเมื่อไหร่ควรหยุด สามชิ้นนี้ประกอบกันเป็นวงจรที่หมุนเองได้

ภายในแต่ละรอบ agent จะเดินตามจังหวะเดิมเสมอ เริ่มจาก reason คือวางแผนว่ารอบนี้จะทำอะไร ต่อด้วย act คือลงมือทำจริง แล้วปิดท้ายด้วย observe คือดูว่าผลที่ได้ออกมาเป็นยังไง จากนั้นเอาผลไปเทียบกับเงื่อนไขที่ตั้งไว้ ถ้ายังไม่ผ่านก็กลับไปวางแผนรอบใหม่แล้วทำซ้ำ ถ้าผ่านแล้วก็จบ วนแบบนี้ไปเรื่อยๆ จนกว่าจะถึงเส้นชัยที่กำหนด นี่คือเหตุผลที่คนตั้งวงจรไว้ครั้งเดียว แล้วปล่อยให้มันทำงานต่อได้โดยไม่ต้องคอยป้อนคำสั่งทุกขั้นตอน

เป้าหมายต้องวัดได้ และ AI ต้องตรวจเองเป็น

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

เงื่อนไขข้อที่สองคือวิธีที่ agent ใช้ตรวจงานของตัวเอง loop ที่ดีที่สุดมักเขียนได้ประมาณว่า "ทำซ้ำไปจนกว่าค่า X จะเท่ากับผล Y" เพราะมันชัดจน agent ตัดสินเองได้ว่าผ่านหรือยัง ปัญหาจะเริ่มก็ตอนที่เงื่อนไขกลายเป็นเรื่องความรู้สึก เช่นบอกว่า "ทำไปจนกว่าจะพอใจ" เพราะคำว่าพอใจตัดสินยาก agent เลยอาจวิ่งวนนานเกินจำเป็นโดยไม่รู้ว่าตรงไหนคือพอ

loop ที่ดีที่สุดบอกได้ชัดว่า "ทำซ้ำไปจนกว่าค่า X จะเท่ากับผล Y"

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

ดูจากของจริงสามงาน

งานแรกคือการออกแบบ thumbnail ด้วย Claude Code ซึ่งเป็น coding agent ที่รับคำสั่งเป็นภาษาคนแล้วลงมือทำงานให้ ผ่านคำสั่ง /goal ตัว agent ใช้เวลาราว 27 นาที สร้างคอนเซ็ปต์ออกมา 10 แบบ แล้วให้คะแนนแต่ละแบบตามเกณฑ์สี่ข้อสไตล์ MrBeast ยูทูเบอร์แถวหน้าของโลกที่ขึ้นชื่อเรื่อง thumbnail คือความชัด · ความชวนสงสัย · แรงดึงอารมณ์ · คอนทราสต์ของภาพ จากนั้นคัดเหลือสามอันดับแรกแล้วปรับต่อจนคะแนนนิ่ง เกณฑ์สี่ข้อนี้แหละที่ทำให้ agent ตัดสินเองได้ว่าแบบไหนดีกว่าแบบไหน

งานที่สองคือการสร้างเครื่องบินสามมิติด้วย Three.js ไลบรารีสำหรับสร้างภาพสามมิติบนเว็บ ผ่าน /goal เหมือนกัน คราวนี้ใช้เวลาราว 37 นาที จุดที่น่าสนใจคือวิธีตรวจงาน agent ไม่ได้เดาเอาเองว่าถูก แต่เปิด browser ขึ้นมาดูจริงๆ ว่าเครื่องบินที่ render ออกมาหน้าตาถูกต้องไหม

งานที่สามคือการจำลองภาพปกอัลบั้ม Abbey Road ของวง The Beatles ด้วย HTML และ CSS งานนี้ตั้งเงื่อนไขหยุดไว้ชัดเจนว่าคะแนนเฉลี่ยต้องถึง 9 ขึ้นไป และตั้งเพดานไว้ไม่เกิน 8 รอบ สุดท้าย agent หยุดเองที่รอบ 7 เพราะผ่านเกณฑ์แล้ว นี่คือภาพของ loop ที่ออกแบบมาดี มีทั้งเป้าที่วัดได้และเพดานกันไม่ให้วิ่งไม่หยุด

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

และ loop ก็ไม่ได้จำกัดอยู่แค่งานเขียนโค้ด มีคนใช้มันตัดต่อวิดีโอทั้งคลิป ตั้งแต่ดึง transcript ออกมา ตัดช่วงพูดผิด จัดจังหวะ ซิงค์เสียง ไปจนถึง render และตรวจผลเองทั้งหมด ขอแค่บอกได้ว่างานที่ดีหน้าตาเป็นยังไง agent ก็วนเข้าหามันได้

เลือกทรงของ loop ให้พอดีงาน

loop ไม่ได้มีหน้าตาเดียว แต่แบ่งคร่าวๆ ได้สามทรงตามจำนวนและบทบาทของ agent

• Solo loop · agent ตัวเดียววน reason → act → observe → ทำซ้ำ เหมาะกับงานส่วนใหญ่ที่คนเดียวทำจบได้ และเป็นแบบที่คนใช้บ่อยที่สุด
• Maker-checker · agent ตัวหนึ่งทำงาน อีกตัวหนึ่งคอยให้คะแนนและ feedback เหมาะเมื่ออยากได้คนตรวจที่แยกออกจากคนทำ ช่วยลดอาการเข้าข้างงานตัวเอง
• Manager + helpers · agent หลักคุมทิศทาง แล้วกระจายงานย่อยให้ sub-agent หลายตัว เหมาะกับงานใหญ่ที่ซอยเป็นชิ้นๆ ได้ แต่ก็ซับซ้อนและคุมยากกว่าแบบอื่น

ถ้าเพิ่งเริ่ม ให้เริ่มจาก solo loop ก่อนเสมอ เพราะมันเข้าใจง่ายและคุมง่ายที่สุด ต่อเมื่อจำเป็นต้องมีคนตรวจที่เป็นกลางจริงๆ ค่อยขยับไป maker-checker และเก็บแบบ manager กับลูกทีมไว้ใช้กับงานใหญ่ที่แยกชิ้นได้ชัดเท่านั้น

ลองทำ loop แรกของตัวเอง

ถ้าอยากลองจริง วิธีที่เข้าถึงง่ายที่สุดตอนนี้คือใช้คำสั่งแบบ /goal ใน Claude Code ซึ่งจัดการวงจร loop ทั้งหมดให้ในตัว ก่อนจะสั่ง ลองวางสามอย่างนี้ให้ชัดก่อน

1. นิยามเป้าหมายให้วัดได้ บอกให้ชัดว่างานที่เสร็จต้องได้อะไร ถ้าใส่เป็นตัวเลขหรือเกณฑ์ได้ยิ่งดี
2. บอกวิธีตรวจงาน ให้ agent รู้ได้ว่าผ่านแล้วหรือยัง เขียนเงื่อนไขให้เป็นรูปธรรมที่สุด
3. ตั้งเพดานจำนวนรอบ เพื่อกันไม่ให้ loop วิ่งไม่หยุด เช่นไม่เกิน 8 รอบ

พอครบสามอย่างก็เขียนรวมเป็นคำสั่งเดียว เช่น "สร้าง thumbnail 10 แบบ ให้คะแนนแต่ละแบบตามเกณฑ์ ชัด · ชวนสงสัย · กระตุกอารมณ์ · คอนทราสต์ภาพ เก็บสามอันดับแรกมาปรับต่อ จนคะแนนเฉลี่ยถึง 9 และหยุดเมื่อครบ 8 รอบ" จากนั้นก็ปล่อยให้ agent เดินวงจร reason → act → observe เอง แล้วรอมันรายงานเมื่อถึงเกณฑ์หรือครบเพดานจำนวนรอบ ถ้าไม่อยากเขียนเองตั้งแต่ต้น ก็มีคนทำคลังรวม loop สำเร็จรูปไว้ให้หยิบไปปรับใช้และส่งของตัวเองเข้าไปเพิ่มได้ด้วย อย่างคลัง loop ที่ Matthew Berman ครีเอเตอร์สาย AI รวบรวมเอาไว้

วงจรที่วิ่งนานเกินไป ก็เผาเงินเปล่า

loop ไม่ได้ฟรี ทุกรอบที่ agent คิดและลงมือมีค่าใช้จ่ายเกิดขึ้น ถ้าตั้งเงื่อนไขจบไว้ยากเกินจนผ่านยาก loop ก็จะวิ่งยาวและเปลืองเกินจำเป็น คนที่ใช้จริงบอกว่าส่วนใหญ่ปล่อย loop กันราว 35 นาทีถึงไม่กี่ชั่วโมง บางงานปล่อยข้ามคืน 4 ถึง 8 ชั่วโมงแล้วตื่นมาเก็บผล แต่พอเลยสัก 12 ชั่วโมงขึ้นไปกลับไม่ค่อยคุ้ม เพราะยิ่งวิ่งนานไม่ได้แปลว่ายิ่งดีเสมอไป

อีกกับดักหนึ่งคือคิดว่าต้องมี agent ห้าตัววิ่งตลอด 24 ชั่วโมงถึงจะไม่ตกขบวน จริงๆ แล้วไม่ใช่เลย ถ้ายังไม่เข้าใจว่าตัวเองกำลังทำอะไร การเพิ่มจำนวน agent มีแต่จะขยายปัญหาเดิมให้ใหญ่ขึ้น ไม่ได้ช่วยแก้อะไร และวิธีนี้ก็ไม่ได้เหมาะกับทุกคนหรือทุกงานเท่ากัน คนที่เขียนโค้ดระดับลึกอย่าง Peter Steinberg ก็มี use case ของตัวเอง ซึ่งอาจไม่ตรงกับงานของคนทั่วไป

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

---

ที่มา: คลิป Finally. Agent Loops Clearly Explained. จากช่อง Nate Herk