เมื่อเราเข้าใจแล้วว่า Agent Loop (วงจร คิด-ทำ-ตรวจ) คือกลไกขับเคลื่อนที่ทำให้ AI สามารถหยิบเครื่องมือมาแก้ปัญหาต่อเนื่องได้เอง คำถามข้อใหญ่ถัดมาที่มักเกิดขึ้นในที่ประชุมทีมพัฒนาระบบ หรืองานสัมมนา AI ยุคนี้ก็คือ:
“ถ้าเรามีงานชิ้นใหญ่ เช่น พัฒนาเว็บแอปพลิเคชันขึ้นมาหนึ่งระบบ...
เราควรสร้าง Agent สถาปนิก, Agent โปรแกรมเมอร์, Agent ผู้ตรวจความปลอดภัย, และ Agent ตรวจสอบโค้ด (QA) แล้วปล่อยให้พวกมันมานั่งประชุม ถกเถียง และทำงานร่วมกันในระบบ (Multi-Agent System) เลยดีไหม?”
ภาพฝันนี้ดูน่าตื่นตาตื่นใจมากครับ! เหมือนเรากำลังเป็นผู้บริหารที่มีกองทัพพนักงาน AI หลายสิบตัวนั่งคุยและส่งงานให้กันในโลกดิจิทัล
แต่ในฐานะคนทำระบบซอฟต์แวร์ตัวจริง ผมอยากชวนทุกคนถอยออกมาหนึ่งก้าวเพื่อดูว่า เบื้องหลังภาพฝันของ Multi-Agent นั้นมีความจริงอะไรซ่อนอยู่ และคำว่า Skill แท้จริงแล้วคืออะไร ต่างจาก Tool อย่างไร และทำไมในหลาย ๆ สถานการณ์ สถาปัตยกรรมแบบ "คนเดียวที่มีทักษะครบ" ถึงทำงานเสร็จไวกว่า และคุมงบประมาณได้ดีกว่าการตั้งคณะกรรมการ AI ขึ้นมาคุยกันเองครับ
1. ถอดรหัสคำว่า "Skill": ต่างจาก "Tool" อย่างไร?
หลายคนมักสับสนระหว่างคำสองคำนี้: Tool กับ Skill
เพื่อความเข้าใจง่ายที่สุด ผมขอเปรียบเทียบกับโลกงานช่างครับ:
- Tool (เครื่องมือ): คือ "อุปกรณ์" เช่น ค้อน, ตะปู, เลื่อย, เครื่องวัดระดับน้ำ หรือในโลกคอมพิวเตอร์คือ ฟังก์ชันอ่านไฟล์ (
read_file), ฟังก์ชันค้นหาฐานข้อมูล (search_db), หรือการรันคำสั่งเทอร์มินัล (run_command) - ตัว Tool มีหน้าที่แค่ทำตามสั่งตรง ๆ สั่งให้ตอกก็ตอก สั่งให้อ่านก็อ่าน แต่มัน "ไม่มีวิธีคิดและไม่มีลำดับขั้นตอน" ในตัวมันเอง
- Skill (ทักษะ / ระเบียบวิธี): คือ "วิชาชีพช่างไม้และคู่มือขั้นตอนการทำงาน" เช่น วิธีการสร้างโต๊ะกินข้าวหนึ่งตัว ต้องเริ่มต้นจากวัดขนาดไม้ → ใช้เลื่อยตัดให้ได้มุม → ขัดเสี้ยน → ประกอบด้วยตะปูและกาว → ตรวจสอบความแข็งแรง
- Skill คือชุดขององค์ความรู้, ลำดับขั้นตอน (Procedure), กฎเกณฑ์ที่ต้องระวัง, และวิธีตัดสินใจในการหยิบ Tool ชิ้นต่าง ๆ มาใช้ให้บรรลุเป้าหมายเฉพาะด้าน
ในระบบ AI สมัยใหม่ Skill ไม่ใช่โปรแกรมลึกลับอะไรเลยครับ โดยเนื้อแท้แล้ว Skill มักจะถูกบันทึกอยู่ในรูปของ เอกสารแนะนำและคู่มือขั้นตอน (Instruction / Guideline File เช่น Markdown) ที่ถูก Harness โหลดเข้ามาเติมใน Context ของโมเดลเมื่อต้องทำงานนั้น ๆ เพื่อบอกโมเดลว่า:
"เมื่อต้องทำงานประเภทนี้ ให้ทำตามกติกา 1-2-3-4 นี้ และให้หยิบ Tool ตามลำดับนี้นะ ห้ามทำข้ามขั้นตอน"
ดังนั้น แทนที่เราจะต้องสร้าง Agent ตัวใหม่ทุกครั้งที่มีงานใหม่ เราเพียงแค่ "สอนทักษะ (Skill)" เพิ่มเข้าไปในคลังความรู้ของ Agent ตัวเดิม มันก็สามารถหยิบวิชาชีพนั้นมาทำงานได้อย่างเชี่ยวชาญแล้วครับ
2. มนต์สะกดของ Multi-Agent: ภาพฝัน vs ความจริงในอ่าง
ในช่วงปีที่ผ่านมา เฟรมเวิร์กประเภท Multi-Agent Systems (MAS) เช่น CrewAI, AutoGen หรือ ChatDev ได้รับความนิยมและเป็นที่พูดถึงอย่างกว้างขวาง
แนวคิดพื้นฐานคือการจำลององค์กร: ให้ Agent แต่ละตัวมี System Prompt คนละแบบ (ตัวหนึ่งเป็น Product Manager อีกตัวเป็น Coder อีกตัวเป็น Reviewer) แล้วเปิดห้องแชตให้พวกมันพิมพ์คุยกันเองเพื่อส่งมอบงาน
แต่เมื่อนำมาใช้งานจริงในระดับวิศวกรรม เรากลับพบปัญหาใหญ่ 3 ประการ:
1) การคุยวนในอ่าง (Echo Chamber & Endless Debates):
เมื่อเราปล่อยให้ Agent สองตัวถกเถียงกัน สิ่งที่มักเกิดขึ้นคือ:
- Agent Coder เขียนโค้ดส่งไป
- Agent Reviewer ตรวจแล้วบอกว่า "ดีมาก แต่ขอให้ปรับตัวแปรนี้นิดหน่อย และเพิ่มเอกสารกำกับด้วย"
- Agent Coder ตอบกลับว่า "แก้ตัวแปรแล้ว แต่คิดว่าเอกสารแบบเดิมกระชับกว่า คุณคิดว่าอย่างไร?"
- Agent Reviewer ตอบว่า "เห็นด้วยเรื่องความกระชับ แต่ขอย้ำว่าควรมีหัวข้อย่อย..."
พวกมันสามารถผลัดกันชม ผลัดกันขอแก้ และคุยสุภาพใส่กันไปมาได้เรื่อย ๆ โดยที่งานไม่คืบหน้าไปไหนเลย!
2) การเผาผลาญโทเคนแบบทวีคูณ (Token Explosion):
จำเรื่อง Context Accumulation ในตอนที่ 12 ได้ใช่ไหมครับ? ในระบบ Multi-Agent แบบเปิดให้คุยกันอิสระ (Free-form) ข้อความทุกบรรทัดที่ Agent A พิมพ์คุยกับ Agent B จะถูกส่งกลับเข้าไปใน Context ของทั้งคู่ ยิ่งพวกมันคุยกันยาว ปริมาณ Token ที่ต้องจ่ายจะเพิ่มขึ้นเป็นทวีคูณ การปล่อยให้ Agent คุยประชุมกันเองเพียงไม่กี่รอบ อาจเผาผลาญงบประมาณค่า API ไปอย่างรวดเร็วโดยที่เนื้องานไม่ได้คืบหน้าตามสัดส่วนเลยครับ
3) ความรับผิดชอบที่สูญหาย (Diffusion of Responsibility):
เมื่อเกิดบั๊กหรือระบบพัง เรามักจะตามหาต้นตอไม่ได้ว่าเกิดจากความผิดพลาดของใคร เพราะ Agent ตัวหนึ่งบอกว่าทำตามที่อีกตัวสั่ง ส่วนอีกตัวก็บอกว่านึกว่าตัวแรกตรวจแล้ว การดีบักระบบ Multi-Agent จึงเป็นฝันร้ายที่สุดเรื่องหนึ่งของ Software Architect ครับ
3. ทางเลือกที่รัดกุม: Single Agent with Skills vs Pipeline (แบ่งงานเป็นทอด)
เมื่อภาพฝันของ Multi-Agent ที่นั่งคุยกันอย่างอิสระมักนำไปสู่ความสูญเปล่า ในทางสถาปัตยกรรมระดับมืออาชีพ เรามีทางเลือกที่ดีกว่าและเสถียรกว่ามาก 2 รูปแบบครับ:
รูปแบบที่ 1: Single Agent with Dynamic Skills (คนเดียวรอบรู้หลายวิชา)
แทนที่จะสร้าง Agent 3 ตัว เราใช้ Agent เพียงตัวเดียว แต่มี Harness ที่คอยสลับ Skill ให้ตามจังหวะงาน:
- เมื่อเริ่มงาน: Harness ป้อน Skill การวิเคราะห์ความต้องการ (Planning Skill) ให้ Agent วางแผน
- เมื่อเริ่มลงมือ: สลับมาป้อน Skill การเขียนโค้ด (Coding Skill) ให้ Agent เขียนตามแผน
- เมื่อตรวจงาน: ป้อน Skill การตรวจรับ (Testing/Review Skill) ให้ Agent ตรวจสอบความถูกต้อง
ข้อดี: บริบทไม่กระจัดกระจาย ไม่มีการคุยอวยกันเอง ค่า Token ประหยัดที่สุด และ Agent มีสมาธิจดจ่อกับงานทีละขั้นตอนอย่างมีวินัย
รูปแบบที่ 2: Deterministic Pipeline / Subagent Delegation (ส่งต่องานตามรางรถไฟ)
ถ้างานจำเป็นต้องแยกบริบทจริง ๆ เพื่อไม่ให้ Context บวม เราจะไม่ปล่อยให้ Agent มานั่งคุยกันในห้องเปิด แต่เราจะออกแบบเป็น Pipeline (ท่อส่งงาน) หรือส่งให้ Subagent (เอเจนต์เฉพาะกิจ) ทำงานแบบมีขอบเขตจำกัด:
- กติกาเหล็ก: Subagent จะได้รับเฉพาะข้อมูลที่จำเป็นสำหรับงานนั้น ๆ ทำงานแบบ "ไปทำเรื่องนี้ให้เสร็จ แล้วส่งผลสรุปกลับมา ห้ามชวนคุยเล่น" เมื่อส่งผลเสร็จ Subagent ตัวนั้นจะถูกปิดทิ้งทันที ไม่มีการเปิดห้องสนทนาค้างไว้เพื่อถกเถียงกันต่อ
4. ประสบการณ์จริง: เจ็บจริงจากการลอง Spawn เอเจนต์คุยกันเอง
ในการพัฒนาเว็บและระบบสถาปัตยกรรมของโปรเจกต์ sabayjai.net นี้ ในช่วงเริ่มต้นผมไม่ได้นึกคิดทฤษฎีขึ้นมาลอย ๆ ครับ แต่เกิดจาก "การทดลองจริงแล้วเจ็บจริง" มาก่อน
ในตอนแรก ผมเคยลองเปิด (Spawn) Agent ขึ้นมาสองตัว แล้วตั้งกติกาให้พวกมันคุยกัน ปรึกษางานกันอย่างอิสระ (Free-form) แล้วเอาผลลัพธ์ที่ได้ไปทำงานต่อ... ผลปรากฏว่า: มั่วเละเทะและออกทะเลไปไกลมากครับ! 5555
สิ่งที่เกิดขึ้นคือพวกมันคุยต่อความยาวสาวความยืด ตีความโจทย์บิดเบือนไปเรื่อย ๆ จนผลลัพธ์สุดท้ายแทบใช้การไม่ได้ แถมยังกินเวลาและสิ้นเปลืองค่า Token ไปเปล่า ๆ (นี่คือบทเรียนจากกรณี Free-form Multi-Agent ที่ผมเจอมากับตัว ซึ่งไม่ได้แปลว่า Multi-Agent ในรูปแบบอื่นที่มีการออกแบบกติกาอย่างเข้มงวดจะไม่มีประโยชน์นะครับ เพียงแต่สำหรับโจทย์ของผม มันไม่ตอบโจทย์ความคุ้มค่าเลย)
หลังจากเห็นผลลัพธ์คาตา ผมจึงตัดสินใจเปลี่ยนแนวทางใหม่ทั้งหมด โดยหันมาใช้รูปแบบ Deterministic Pipeline ที่มีวินัยและรัดกุม:
- มี Right-Hand Architect คอยคุมท่อ: มี Agent มือขวาทำหน้าที่เป็นตัวนำ คอยวางแผนและคัดกรองงานให้กระชับ
- เรียก Subagent ทีละตัวและตรวจรับทีละขั้น: ถ้าจำเป็นต้องทำงานเฉพาะทาง จะแตกงานย่อยส่งให้ Subagent ทีละตัวทำตามกรอบที่ชัดเจน แล้วตรวจรับผลงานทีละก้าว ไม่เปิดโอกาสให้เอเจนต์ไปคุยกันเองข้ามห้อง
- ผมทำ Final Check ด้วยตนเองเสมอ: สุดท้ายผมในฐานะมนุษย์ จะเป็นคนตรวจรับงานขั้นสุดท้าย (Final Check) ด้วยตัวเองเสมอ ก่อนจะตัดสินใจว่าจะดำเนินการก้าวต่อไปอย่างไร
ผลลัพธ์ของการปรับกระบวนท่านี้ ทำให้การทำงานกลับมานิ่ง ตรวจสอบได้ทุกจุด และที่สำคัญคือตอบโจทย์ใหญ่ของผมอย่างมาก นั่นคือ "การควบคุมต้นทุน (Cost) ให้ต่ำและไม่บานปลาย" ครับ
5. มุมมองสถาปัตยกรรม (Architect’s Lens): ไม่มีวิธีที่ดีที่สุด มีแต่วิธีที่ตอบโจทย์เราที่สุด
ผมอยากเน้นย้ำไว้ตรงนี้ชัด ๆ เลยครับว่า ผมไม่ได้กำลังบอกว่าแนวทางที่ผมใช้เป็นแนวทางที่ดีที่สุดในโลก หรือเป็นสูตรสำเร็จสำหรับทุกคน
ในโลกอนาคต หรือในองค์กรยักษ์ใหญ่ที่มีงบประมาณมหาศาล ระบบ Multi-Agent ที่ซับซ้อนอาจจะถูกพัฒนาจนฉลาดและคุ้มค่าที่จะใช้งานในงานวิจัยขั้นสูงก็เป็นได้
แต่สำหรับคนทำงานจริง สำหรับโปรเจกต์ที่เราต้องบริหารจัดการเอง และสำหรับคนที่ ต้องการควบคุมต้นทุน (Cost Optimization) ให้อยู่หมัด:
| มิติการเปรียบเทียบ | Multi-Agent คุยกันเอง (Free-form MAS) | Single Agent + Skills | Pipeline / Strict Subagent |
|---|---|---|---|
| ความซับซ้อนของระบบ | สูงมาก (ชิ้นส่วนคุยกันเอง) | ต่ำ (ชิ้นส่วนเดียว เปลี่ยนหมวกได้) | ปานกลาง (ไหลตามรางที่กำหนด) |
| การใช้ Token & ค่าบริการ | สูงมาก เสี่ยง Token ระเบิด | ต่ำ คุมงบได้แม่นยำ | ควบคุมได้ตามขนาดงานย่อย |
| ความสามารถในการควบคุมลำดับงาน | ต่ำ คาดเดายาก คุยวนได้ | ปานกลางถึงสูง ทำตามคู่มือทีละขั้น | สูง ควบคุมการส่งต่อเป็นทอด ๆ |
| ความง่ายในการดีบักหาสาเหตุ | ยากมาก หาคนรับผิดชอบไม่เจอ | ง่ายมาก มีประวัติงานชัดเจน | ง่าย ไล่เช็กทีละข้อต่อของท่อ |
ในฐานะ Software Architect ผมยึดหลักการคลาสสิกที่ชื่อว่า Occam's Razor: "เมื่อมีทางเลือกหลายทาง ให้เริ่มจากทางที่เรียบง่ายที่สุดก่อน แล้วค่อยเพิ่มความซับซ้อนเมื่อมีเหตุผลและความจำเป็นรองรับ" การเลือกใช้ Single Agent ที่เสริม Skill หรือการต่อท่อเป็น Pipeline แล้วคุมด้วยมือเราเอง จึงเป็นแนวทางที่คุ้มค่า สงบ และไม่ทำให้เงินในกระเป๋าเราละลายไปกับการคุยวนในอ่างครับ
บทสรุปและสิ่งที่จะคุยกันต่อ
ในตอนนี้ เราได้เห็นความจริงที่กระจ่างชัดขึ้นอีกระดับ:
- Tool คือค้อน แต่ Skill คือวิชาช่างไม้: Skill คือคู่มือขั้นตอนและกติกาที่ป้อนให้ Agent รู้จักวิธีหยิบใช้ Tools ตามลำดับ
- ระวังกับดัก Multi-Agent: ภาพฝันที่ให้ Agent มานั่งคุยกันเองมักจบลงด้วยการคุยวนในอ่างและเผาผลาญ Token
- เริ่มจากความเรียบง่ายก่อนเสมอ: การเริ่มจาก Single Agent ที่เปลี่ยน Skill ได้ หรือการต่อท่อแบบ Pipeline ที่มีทิศทางชัดเจน ช่วยให้เราคุมต้นทุนได้อยู่หมัด และค่อยขยับขยายความซับซ้อนเมื่อจำเป็นจริง ๆ
แต่เรื่องนี้ก็นำพาเราไปสู่คำถามเชิงลึกข้อถัดไป:
"ถ้าเราไม่ควรปล่อยให้ Agent คุยกันอย่างไร้ระเบียบ... แล้วเส้นแบ่งจริง ๆ ระหว่าง 'Workflow ที่ล็อกขั้นตอนตายตัวเหมือนรางรถไฟ' กับ 'Autonomous Agent ที่ปล่อยให้ตัดสินใจได้อย่างอิสระเหมือนรถออฟโรด' อยู่ตรงไหน? งานแบบไหนควรใช้แบบไหนกันแน่?"
ในตอนต่อไป — ตอนที่ 15: ทางรถไฟ หรือ รถออฟโรด?: Workflow vs Autonomous Agent เราจะมาหาคำตอบกันครับว่า จะจัดสมดุลระหว่าง "ความเป๊ะของระบบ" กับ "ความยืดหยุ่นของ AI" อย่างไรให้ธุรกิจไม่พังครับ!
ศัพท์เทคนิค → คำแปลภาษาคนทำงาน — แตะเพื่อย่อ/ขยาย
- Tool vs Skill: Tool คือเครื่องมือเดี่ยว ๆ ที่ทำตามสั่ง (เช่น อ่านไฟล์, รันคำสั่ง) ส่วน Skill คือคู่มือระเบียบวิธี ลำดับขั้นตอน และศิลปะในการเลือกหยิบ Tools มาแก้ปัญหาเฉพาะด้าน
- Multi-Agent System (MAS): ระบบที่ประกอบด้วย Agent หลายตัวทำงานร่วมกัน มีประโยชน์ในเชิงทฤษฎี แต่หากปล่อยให้คุยกันอย่างอิสระ มักเสี่ยงต่อการคุยวนในอ่าง (Echo Chamber) และเผา Token สูง
- Subagent & Pipeline: การแบ่งงานเป็นทอด ๆ โดยมอบหมายงานย่อยที่มีขอบเขตชัดเจนให้เอเจนต์เฉพาะกิจทำ แล้วส่งผลลัพธ์กลับมาตามท่อทางเดินที่กำหนดไว้ตายตัว
หลักคิดเชิงสถาปัตยกรรม — แตะเพื่อย่อ/ขยาย
- Occam’s Razor for AI: อย่าเพิ่มจำนวน Agent ในระบบโดยไม่จำเป็น ระบบที่ดีที่สุดมักเริ่มต้นจาก Single Agent ที่ฝึก Skill ให้เชี่ยวชาญก่อนเสมอ
- Deterministic Control over Free Talk: ในงานระดับ Production ความแม่นยำและตรวจสอบได้สำคัญกว่าภาพลวงตาของการให้ AI คุยกันเอง การควบคุมลำดับงานผ่าน Pipeline ที่รัดกุมช่วยลดต้นทุนและป้องกันความผิดพลาดได้อย่างมหาศาล
- One Role per Session: วินัยในการกำหนดบทบาทของ Agent ให้ชัดเจนในแต่ละงาน ช่วยให้บริบทไม่สับสน และทำให้มนุษย์สามารถกำกับดูแล (Supervise) ระบบได้อย่างมั่นใจ