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

Skill คืออะไร? และจำเป็นไหมที่ต้องแบ่ง Agent หลายตัวคุยกันเอง?

Skill คืออะไร? และจำเป็นไหมที่ต้องแบ่ง Agent หลายตัวคุยกันเอง?

เมื่อเราเข้าใจแล้วว่า 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 ชิ้นต่าง ๆ มาใช้ให้บรรลุเป้าหมายเฉพาะด้าน
แผนภาพประกอบ chapter 14 diagram 01
แผนภาพประกอบเรื่อง

ในระบบ 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 (เอเจนต์เฉพาะกิจ) ทำงานแบบมีขอบเขตจำกัด:

แผนภาพประกอบ chapter 14 diagram 02
แผนภาพประกอบเรื่อง
  • กติกาเหล็ก: Subagent จะได้รับเฉพาะข้อมูลที่จำเป็นสำหรับงานนั้น ๆ ทำงานแบบ "ไปทำเรื่องนี้ให้เสร็จ แล้วส่งผลสรุปกลับมา ห้ามชวนคุยเล่น" เมื่อส่งผลเสร็จ Subagent ตัวนั้นจะถูกปิดทิ้งทันที ไม่มีการเปิดห้องสนทนาค้างไว้เพื่อถกเถียงกันต่อ

4. ประสบการณ์จริง: เจ็บจริงจากการลอง Spawn เอเจนต์คุยกันเอง

ในการพัฒนาเว็บและระบบสถาปัตยกรรมของโปรเจกต์ sabayjai.net นี้ ในช่วงเริ่มต้นผมไม่ได้นึกคิดทฤษฎีขึ้นมาลอย ๆ ครับ แต่เกิดจาก "การทดลองจริงแล้วเจ็บจริง" มาก่อน

ในตอนแรก ผมเคยลองเปิด (Spawn) Agent ขึ้นมาสองตัว แล้วตั้งกติกาให้พวกมันคุยกัน ปรึกษางานกันอย่างอิสระ (Free-form) แล้วเอาผลลัพธ์ที่ได้ไปทำงานต่อ... ผลปรากฏว่า: มั่วเละเทะและออกทะเลไปไกลมากครับ! 5555

สิ่งที่เกิดขึ้นคือพวกมันคุยต่อความยาวสาวความยืด ตีความโจทย์บิดเบือนไปเรื่อย ๆ จนผลลัพธ์สุดท้ายแทบใช้การไม่ได้ แถมยังกินเวลาและสิ้นเปลืองค่า Token ไปเปล่า ๆ (นี่คือบทเรียนจากกรณี Free-form Multi-Agent ที่ผมเจอมากับตัว ซึ่งไม่ได้แปลว่า Multi-Agent ในรูปแบบอื่นที่มีการออกแบบกติกาอย่างเข้มงวดจะไม่มีประโยชน์นะครับ เพียงแต่สำหรับโจทย์ของผม มันไม่ตอบโจทย์ความคุ้มค่าเลย)

หลังจากเห็นผลลัพธ์คาตา ผมจึงตัดสินใจเปลี่ยนแนวทางใหม่ทั้งหมด โดยหันมาใช้รูปแบบ Deterministic Pipeline ที่มีวินัยและรัดกุม:

  1. มี Right-Hand Architect คอยคุมท่อ: มี Agent มือขวาทำหน้าที่เป็นตัวนำ คอยวางแผนและคัดกรองงานให้กระชับ
  2. เรียก Subagent ทีละตัวและตรวจรับทีละขั้น: ถ้าจำเป็นต้องทำงานเฉพาะทาง จะแตกงานย่อยส่งให้ Subagent ทีละตัวทำตามกรอบที่ชัดเจน แล้วตรวจรับผลงานทีละก้าว ไม่เปิดโอกาสให้เอเจนต์ไปคุยกันเองข้ามห้อง
  3. ผมทำ Final Check ด้วยตนเองเสมอ: สุดท้ายผมในฐานะมนุษย์ จะเป็นคนตรวจรับงานขั้นสุดท้าย (Final Check) ด้วยตัวเองเสมอ ก่อนจะตัดสินใจว่าจะดำเนินการก้าวต่อไปอย่างไร

ผลลัพธ์ของการปรับกระบวนท่านี้ ทำให้การทำงานกลับมานิ่ง ตรวจสอบได้ทุกจุด และที่สำคัญคือตอบโจทย์ใหญ่ของผมอย่างมาก นั่นคือ "การควบคุมต้นทุน (Cost) ให้ต่ำและไม่บานปลาย" ครับ

5. มุมมองสถาปัตยกรรม (Architect’s Lens): ไม่มีวิธีที่ดีที่สุด มีแต่วิธีที่ตอบโจทย์เราที่สุด

ผมอยากเน้นย้ำไว้ตรงนี้ชัด ๆ เลยครับว่า ผมไม่ได้กำลังบอกว่าแนวทางที่ผมใช้เป็นแนวทางที่ดีที่สุดในโลก หรือเป็นสูตรสำเร็จสำหรับทุกคน

ในโลกอนาคต หรือในองค์กรยักษ์ใหญ่ที่มีงบประมาณมหาศาล ระบบ Multi-Agent ที่ซับซ้อนอาจจะถูกพัฒนาจนฉลาดและคุ้มค่าที่จะใช้งานในงานวิจัยขั้นสูงก็เป็นได้

แต่สำหรับคนทำงานจริง สำหรับโปรเจกต์ที่เราต้องบริหารจัดการเอง และสำหรับคนที่ ต้องการควบคุมต้นทุน (Cost Optimization) ให้อยู่หมัด:

มิติการเปรียบเทียบMulti-Agent คุยกันเอง (Free-form MAS)Single Agent + SkillsPipeline / 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) ระบบได้อย่างมั่นใจ