องค์ที่ 3 · ตอนที่ 13

หัวใจของ Agent — ลูป คิด-ทำ-ตรวจ (The Agent Loop)

หัวใจของ Agent — ลูป คิด-ทำ-ตรวจ (The Agent Loop)

ถ้ามีคนมาบอกคุณว่า:

“ระบบนี้ไม่ได้เป็นแค่ Chatbot ธรรมดาแล้วนะ แต่มันคือ AI Agent เต็มตัว!”

คำถามสำคัญที่คนทำงานซอฟต์แวร์หรือคนทั่วไปควรตั้งข้อสงสัยในใจทันทีคือ: อะไรคือเส้นแบ่งที่แท้จริงระหว่าง “แชตบอตธรรมดา” กับ “Agent”?

คำว่า Agent กลายเป็นคำยอดฮิตประจำวงการเทคโนโลยี ทุกค่ายต่างเคลมว่าผลิตภัณฑ์ของตนคือ Agent อัจฉริยะที่ทำงานแทนมนุษย์ได้ แต่ถ้าเราถอดคำโฆษณาและการตลาดออกให้หมด แล้วงัดฝากระโปรงดูการทำงานเบื้องลึก เราจะพบความจริงที่เรียบง่ายและเป็นวิทยาศาสตร์มากครับ

ในตอนนี้ ผมจะพาทุกคนไปดู "หัวใจที่เต้นอยู่" ของระบบ Agent นั่นคือกลไกที่เรียกว่า Agent Loop (วงจร คิด-ทำ-ตรวจ) เพื่อให้เรามองเห็นทะลุว่าทำไมโมเดลที่เดิมทีตอบได้แค่ทีละประโยค ถึงกลายร่างเป็นผู้ช่วยที่ทำงานหลายขั้นตอนแทนเราได้โดยอัตโนมัติ

1. เส้นแบ่งระหว่าง Chatbot กับ Agent: Single Turn vs Multi-step

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

สถานการณ์ที่ 1: Chatbot ปกติ (Single Turn / คำสั่งเดียวจบ)

  • เราสั่ง: "ช่วยเขียนโค้ดอ่านไฟล์รายงานยอดขายปี 2025 ให้หน่อย"
  • โมเดลทำ: รับคำสั่ง → ประมวลผลคำตอบ (Completion) → ส่งโค้ดกลับมาแสดงบนหน้าจอ
  • จบงาน: มนุษย์ต้องเป็นคนก็อปปี้โค้ดนั้นไปวางในไฟล์ กดรันเอง ถ้าเกิดเออเร่อก็ต้องก็อปปี้เออเร่อกลับมาแปะถามโมเดลใหม่

นี่คือโลกของ Chatbot ครับ มันเก่งเรื่องให้คำแนะนำและผลิตข้อความ แต่มัน "ไม่ลงมือทำ" และ "ไม่ตรวจงานตัวเอง"

สถานการณ์ที่ 2: AI Agent (Autonomous Loop / ทำงานเป็นวงจร)

  • เราสั่ง: "ช่วยค้นหาไฟล์ยอดขายปี 2025 ในเครื่อง แล้วสรุปยอดรวมของไตรมาสที่ 3 ให้หน่อย"
  • สิ่งที่เกิดขึ้นเบื้องหลัง โดยที่เราไม่ได้พิมพ์สั่งซ้ำเลยแม้แต่คำเดียว:
  1. ก้าวที่ 1 (คิด): โมเดลคิดในใจว่า "ฉันต้องหาไฟล์ก่อนว่าอยู่ที่ไหน" → สั่งเรียก Tool ค้นหาไฟล์
  2. ก้าวที่ 2 (ทำ): Harness รันค้นหาไฟล์ พบไฟล์ชื่อ sales_2025_q3.csv อยู่ในโฟลเดอร์ reports/ แล้วส่งผลกลับเข้าโมเดล
  3. ก้าวที่ 3 (ตรวจ & คิดต่อ): โมเดลเห็นชื่อไฟล์แล้วคิดว่า "เจอไฟล์แล้ว ต่อไปฉันต้องส่งไฟล์นี้ให้ Tool คำนวณสรุปยอดตัวเลขออกมาให้แน่นอน" → สั่งเรียก Tool คำนวณยอดขาย
  4. ก้าวที่ 4 (ทำ): Tool ฝั่งโปรแกรมคำนวณตัวเลข 50 แถวอย่างแม่นยำ แล้วส่งผลลัพธ์กลับมาเป็นตัวเลข 1,450,000 บาท
  5. ก้าวที่ 5 (ตรวจ & สรุปผล): โมเดลได้รับตัวเลขที่ถูกต้องแล้ว → สรุปว่าเป้าหมายครบถ้วน จึงพิมพ์รายงานส่งกลับมาให้เรา

ความแตกต่างสำคัญอยู่ตรงนี้ครับ: Chatbot ทำงานแบบ Single Turn (ยิงครั้งเดียวจบ) แต่ Agent มี "วงจรทำงานซ้ำอัตโนมัติ" จนกว่าเป้าหมายจะสำเร็จ

2. ผ่าโครงสร้าง ReAct Loop: วงจร คิด - ทำ - ตรวจ

ในวงการวิจัย AI มีรูปแบบการออกแบบ (Design Pattern) ที่มีชื่อเสียงมากชื่อว่า ReAct (Reason + Act) ซึ่งอธิบายกลไกการหมุนของ Agent Loop ไว้อย่างเป็นระบบ โดยแบ่งเป็น 3 จังหวะที่วนรอบตัวเอง:

แผนภาพประกอบ chapter 13 diagram 01
แผนภาพประกอบเรื่อง

มาเจาะลึก 3 จังหวะนี้กันครับ:

1) คิด (Reason / Thought):

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

  • เราอยู่ที่จุดไหนแล้ว?
  • ขั้นตอนถัดไปที่ควรทำคืออะไร?
  • ต้องเรียกใช้เครื่องมือ (Tool) ตัวไหน หรือสามารถตอบผู้ใช้ได้เลย?

2) ทำ (Act / Tool Call):

เมื่อโมเดลตัดสินใจได้ มันจะส่งสัญญาณ Function Calling (ตามที่เราคุยกันในตอนที่ 10) ออกมาบอกชื่อ Tool และพารามิเตอร์ จากนั้น Harness จะรับช่วงต่อ ทำหน้าที่เป็นมือเท้าไปกดอ่านไฟล์ รันเทสต์ หรือค้นหาฐานข้อมูลในโลกความเป็นจริง

3) ตรวจ (Observe / Feedback):

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

วงจร คิด → ทำ → ตรวจ จะหมุนวนไปเรื่อย ๆ รอบแล้วรอบเล่า จนกระทั่งโมเดลประเมินว่าบรรลุเป้าหมายครบถ้วนแล้ว มันจึงจะหยุดเรียก Tool และสรุปคำตอบสุดท้ายกลับมาหาเรา

3. เมื่อลูปหมุนไม่หยุด: ปัญหา Infinite Loop และเงื่อนไขการหยุด (Stop Conditions)

ฟังดูเหมือน Agent จะทำงานได้ฉลาดและเป็นอิสระมากใช่ไหมครับ? แต่ในโลกความเป็นจริงของการทำระบบ สิ่งที่โปรแกรมเมอร์กลัวที่สุดไม่ใช่ AI ไม่ยอมทำงาน แต่คือ "AI ทำงานไม่ยอมหยุด!"

ลองจินตนาการสถานการณ์นี้ครับ:

  • โมเดลพยายามแก้บั๊กในโค้ด โดยการแก้ไฟล์ → สั่งรันเทสต์ → ผลเทสต์ยังพัง
  • โมเดลคิดใหม่ → แก้ไฟล์อีกแบบ → รันเทสต์ → ผลเทสต์ยังพังแบบเดิม
  • โมเดลวนกลับไปแก้แบบแรก → รันเทสต์ → พังซ้ำ...

ถ้าปล่อยทิ้งไว้โดยไม่มีใครคุม วงจรนี้จะกลายเป็น Infinite Loop (วงจรวนไม่รู้จบ) ซึ่งในยุค AI ค่าเสียหายของ Infinite Loop ไม่ใช่แค่เครื่องค้าง แต่คือ "ค่า Token ที่พุ่งทะยานเผาเงินในกระเป๋าเราอย่างรวดเร็ว!" (จำเรื่องปรากฏการณ์โทเคนสะสม Context Accumulation ในตอนที่ 12 ได้ใช่ไหมครับ)

เพื่อป้องกันความพินาศทางการเงินและเวลา สถาปัตยกรรม Harness ที่ดีจึงต้องมี กฎเหล็กในการหยุด (Termination & Stop Conditions) เสมอ:

  1. Max Iterations (จำกัดรอบสูงสุด): กำหนดเพดานล็อกไว้เลยว่า ห้ามหมุนเกินกี่รอบ (เช่น ห้ามเกิน 10 หรือ 15 ลูป) ถ้ายังแก้ไม่เสร็จ ให้หยุดแล้วรายงานปัญหาให้มนุษย์ทราบทันที
  2. Token & Cost Budget (เพดานงบประมาณ): ล็อกไว้ว่าสำหรับงานชิ้นนี้ ยอมให้ใช้ Token ได้ไม่เกินเท่าไหร่ (เช่น ไม่เกิน 50,000 Tokens หรือไม่เกิน $0.50)
  3. แยกสัญญาณจบงาน ออกจากเกณฑ์ตรวจรับจริง (Completion Signal vs Acceptance Criteria):
  • Completion Signal: เมื่อโมเดลคิดว่าตนเองทำขั้นตอนครบแล้ว มันจะส่งสัญญาณหยุดเรียก Tool (เช่น ตอบสรุปผล)
  • Acceptance Criteria & Verification: แต่ในโลกวิศวกรรม การที่โมเดลบอกว่า "เสร็จแล้ว" ไม่ได้แปลว่า "งานสำเร็จจริง" เสมอไป Harness หรือระบบภายนอกที่ดีจะต้องมีการรันชุดตรวจวัด (Automated Tests หรือ Verification Step) เพื่อพิสูจน์ผลลัพธ์จริงตามเกณฑ์ตรวจรับ ก่อนจะส่งมอบงานให้มนุษย์
  1. Human-in-the-Loop Interruption (มนุษย์กดเบรก): มีปุ่ม Stop หรือช่องทางให้มนุษย์สามารถเข้าแทรกแซง หยุดลูป หรือส่งคำสั่งทักท้วงได้ตลอดเวลา

4. ประสบการณ์จริง: วันที่นั่งมอง Agent ทำงาน และจังหวะที่มันหลงทางวนลูป

ในการพัฒนาซอฟต์แวร์ด้วย Coding Agent ประจำวันของผม เวลาที่ผมสั่งงาน Agent ให้แก้ปัญหาในโปรเจกต์ จังหวะที่น่าตื่นเต้นที่สุดคือการได้นั่งดูล็อกการทำงานของมันแบบเรียลไทม์ครับ

หน้าจอจะแสดงว่ามันกำลังคิดอะไร (Thinking...) จากนั้นสั่งอ่านไฟล์ วิเคราะห์โค้ด สั่งรันเทสต์ พอติด Error มันก็อ่านผลแล้วสั่งเปิดไฟล์เพื่อแก้โค้ด แล้วสั่งรันเทสต์ซ้ำจนผลผ่านเป็นสีเขียว ในวันที่ทุกอย่างราบรื่น มันทำงานได้รวดเร็วและคล่องตัวมาก

แต่ในวันที่มัน "หลงทางและวนลูปไม่เลิก" ก็เกิดขึ้นกับผมจริง ๆ หลายครั้งครับ เท่าที่นึกออกและจำได้แม่นยำมี 2 เหตุการณ์:

  1. Cline + DeepSeek ร้องโวยวายกลางห้องแชต: มีอยู่ครั้งหนึ่งที่สั่งให้แก้ปัญหา โค้ดหมุนลูปไปเรื่อย ๆ จนกระทั่งตัวมันเอง "เริ่มรู้ตัวว่ากำลังวนลูปอยู่ในอ่าง" แทนที่มันจะหาทางออกเงียบ ๆ มันกลับเริ่มพิมพ์ส่งเสียงโวยวายรัว ๆ ในช่องแชต บอกให้ผมช่วยกด Cancel หรือหยุดการทำงานที เป็นภาพที่ทั้งขำและสะท้อนความจริงว่าตัวโมเดลเองก็เริ่มจับอาการหลงทางของลูปได้
  2. Freebuff วนตรวจบรรทัดเดิมไม่ยอมปล่อย: อีกครั้งหนึ่งคือตอนส่งงานให้ Freebuff ช่วยแก้ปัญหา ปรากฏว่ามันหมุนลูปตรวจงานอยู่นานมากจนผิดสังเกต พอผมเข้าไปเปิดส่องดูแท็บความคิดเชิงลึก (Thinking...) ถึงได้เห็นว่ามันกำลังอ่านตรวจวนซ้ำอยู่ที่บรรทัดเดิมซ้ำไปซ้ำมาไม่ยอมขยับไปไหน สุดท้ายผมต้องเป็นคนกดปุ่มหยุด (Stop) เอง แล้วพิมพ์ถามสรุปว่าเกิดอะไรขึ้น ซึ่งมันก็ยอมรับตรง ๆ ว่ามันกำลังติดลูปวนอยู่จริง ๆ

บทเรียนจากเหตุการณ์จริงทำให้ผมได้สัจธรรมข้อสำคัญ:

Agent ไม่ใช่ผู้วิเศษ แต่คือระบบอัตโนมัติที่มีโอกาสหลงทางได้เสมอ
หน้าที่ของ Software Architect จึงไม่ใช่การปล่อยมือทิ้งขว้างแบบ 100% แต่คือการตั้งรั้ว Guardrails, กำหนดขอบเขตเป้าหมายให้แคบและชัดเจน และคอยเป็น "พี่เลี้ยงผู้ตรวจการ" (Human Supervisor) ที่คอยดึงสติมันเมื่อมันเริ่มหมุนวนผิดทิศครับ

5. มุมมองสถาปัตยกรรม (Architect’s Lens): บันไดเปรียบเทียบพัฒนาการสู่ Agent

ในฐานะคนทำระบบ เราจะแยกแยะและมองพัฒนาการของระบบ AI รอบตัวเราอย่างไร? ในเชิงสถาปัตยกรรม ผมอยากชวนมองผ่าน "กรอบบันได 4 ระดับ" นี้เพื่อช่วยให้เราเห็นภาพการทำงานและกลไกควบคุม (ไม่ใช่มาตรฐานสากลที่บังคับใช้ทุกแห่ง แต่เป็นแว่นจำแนกพฤติกรรม):

บันไดพัฒนาการพฤติกรรมการทำงานใครเป็นคนคุมลูป?ตัวอย่างพฤติกรรม
ขั้นที่ 0: Raw Modelถามคำ ตอบคำ ประมวลผลข้อความรอบเดียวจบไม่มีลูป (Single Turn)โมเดลเปลือย ๆ ที่เรียกผ่าน API ตรง
ขั้นที่ 1: Conversational Botมีบริบทต่อเนื่อง คุยโต้ตอบ แลกเปลี่ยนข้อมูลได้มนุษย์พิมพ์ป้อนทีละรอบการพิมพ์คุยถามตอบทั่วไปในห้องแชต
ขั้นที่ 2: Tool-Augmented Botเริ่มหยิบเครื่องมือเฉพาะทางมาเสริม (เช่น ค้นเว็บ, อ่านไฟล์, วาดกราฟ)มนุษย์สั่ง หรือระบบเรียกตามเงื่อนไขเฉพาะหน้าWeb Chat ยุคปัจจุบันที่เริ่มมี Code Interpreter หรือ Search ในตัว
ขั้นที่ 3: Autonomous Agentรับเป้าหมาย แล้วหมุนลูป ReAct วางแผน-ลงมือ-ตรวจผล หลายขั้นตอนจนสำเร็จHarness + Model ร่วมกันหมุนลูปอัตโนมัติCoding Agent (Codex, Cline, Antigravity) ที่ลุยแก้ไฟล์จนงานเสร็จ

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

แต่หัวใจที่ทำให้ระบบก้าวขึ้นมาทำหน้าที่เป็น Agent เต็มตัวในขั้นที่ 3 ได้อย่างมีวินัย ไม่ใช่แค่ความฉลาดของสมองกล แต่คือ การออกแบบโครงสร้าง Harness ให้รองรับวงจรวนซ้ำ (Feedback Loop), การจัดการ State ข้ามก้าว, และการมีระบบคุมความปลอดภัยที่ไม่ปล่อยให้ลูปหมุนจนงบประมาณพังทลาย นั่นเองครับ

บทสรุปและสิ่งที่จะคุยกันต่อ

ในตอนนี้ เราได้เห็นความจริงใต้ฝากระโปรงแล้วครับว่า:

  • Agent ไม่ใช่เวทมนตร์: แต่มันคือวงจรการทำงานแบบวนซ้ำ คิด (Reason) → ทำ (Act) → ตรวจ (Observe)
  • หัวใจคือ Feedback: การเอาผลลัพธ์จากโลกจริงป้อนกลับเข้าไปให้โมเดลดู เพื่อปรับแผนในก้าวถัดไป
  • ต้องมีรั้วกั้น: ต้องมีกฎเหล็ก Max Iterations และเพดานงบประมาณเสมอ เพื่อไม่ให้ลูปหมุนเผาเงินจนหมดตัว

แต่เมื่อระบบเริ่มหมุนลูปทำงานที่ซับซ้อนขึ้นเรื่อย ๆ คำถามถัดมาของคนทำระบบและผู้อ่านหลายคนมักจะเป็น:

"ถ้างานของเรามีหลายขั้นตอน เช่น ต้องมีคนวางแผน คนเขียนโค้ด คนตรวจความปลอดภัย... เราควรเอา Agent หลาย ๆ ตัวมานั่งประชุมคุยกันเอง (Multi-Agent System) ดีไหม? หรือว่าจริง ๆ แล้ว เราแค่สอน 'ทักษะเฉพาะด้าน' (Skill) ให้กับ Agent ตัวเดียวก็เอาอยู่แล้ว?"

ในตอนต่อไป — ตอนที่ 14: Skill คืออะไร? และจำเป็นไหมที่ต้องแบ่ง Agent หลายตัวคุยกันเอง? เราจะมาผ่าความจริงเรื่อง Multi-Agent ขยี้ภาพลวงตาเรื่องการคุยวนในอ่าง และค้นพบว่าทำไมสถาปัตยกรรมที่เรียบง่ายถึงมักชนะระบบที่ซับซ้อนเสมอครับ!

ศัพท์เทคนิค → คำแปลภาษาคนทำงาน — แตะเพื่อย่อ/ขยาย
  • Agent: ระบบ AI ที่รับมอบหมาย "เป้าหมาย (Goal)" แล้วสามารถวางแผนและหมุนวงจรทำงานอัตโนมัติต่อเนื่องหลายขั้นตอนจนสำเร็จ โดยไม่ต้องรอมนุษย์กดสั่งทุกก้าว
  • Agent Loop (วงจรคิด-ทำ-ตรวจ): ลูปการทำงานแบบอัตโนมัติที่โมเดลประเมินสถานการณ์ (Reason) → สั่งเรียกใช้เครื่องมือภายนอก (Act) → รับผลลัพธ์จริงกลับมาตรวจสอบ (Observe) แล้ววนซ้ำจนกว่างานจะเสร็จ
  • ReAct (Reason + Act): รูปแบบการออกแบบสากลที่ผสานการคิดเชิงตรรกะและการลงมือปฏิบัติการเข้าไว้ในวงจรเดียวกัน
  • Infinite Loop & Stop Conditions: ความเสี่ยงของการที่ Agent วนลูปแก้ปัญหาไม่รู้จบ และกฎเหล็กควบคุมการหยุด เช่น การจำกัดจำนวนรอบสูงสุด (Max Iterations) หรือการคุมเพดาน Token
หลักคิดเชิงสถาปัตยกรรม — แตะเพื่อย่อ/ขยาย
  • Single Turn vs Feedback Loop: เส้นแบ่งที่แท้จริงระหว่าง Chatbot กับ Agent ไม่ใช่ความฉลาดของคำตอบ แต่คือความสามารถในการรับ Feedback จากโลกจริงกลับมาประเมินผลและปรับแผนการกระทำในก้าวถัดไปได้เอง
  • Harness is the Engine of the Loop: ตัวที่ขับเคลื่อนลูปและคุมสติของ Agent ไม่ใช่ตัวโมเดลโดด ๆ แต่คือ Harness ที่คอยป้อน Context คุมการเรียก Tool และตั้งรั้วความปลอดภัย (Guardrails) ป้องกันงบประมาณบานปลาย
  • Human Supervision is Essential: ในระบบงานจริง มนุษย์ยังคงต้องเป็นผู้ดูแลระดับสูง (Human-in-the-Loop) เพื่อคอยตรวจสอบและแทรกแซงเมื่อ Agent เริ่มแสดงพฤติกรรมหลงทาง