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

หนึ่งสมอง หลายผู้กำกับ — รู้จัก AI Harness และโลกของค่าบริการ

หนึ่งสมอง หลายผู้กำกับ — รู้จัก AI Harness และโลกของค่าบริการ

เมื่อเราอ่านมาถึงตรงนี้ เราได้เห็นภาพจิ๊กซอว์สำคัญหลายชิ้นแล้วครับ

เริ่มจาก ตอนที่ 9 ที่เราได้รู้จักว่า Harness คือ "คนดูแลเวที" ที่คอยป้อนบท ควบคุมความจำ และเชื่อมต่อโลกภายนอกให้กับ AI Model ต่อด้วย ตอนที่ 10 ที่เราพาเครื่องมือ (Tools) เข้ามาติดปีกให้โมเดลคำนวณและหยิบข้อมูลจริงได้ และใน ตอนที่ 11 ที่เราเห็นมาตรฐานกลางอย่าง MCP (Model Context Protocol) ที่เปิดทางให้แอปพลิเคชันต่าง ๆ สลับสับเปลี่ยนเครื่องมือภายนอกได้อย่างอิสระโดยไม่ต้องเขียนโค้ดเชื่อมต่อใหม่ทุกครั้ง

แต่ในโลกความเป็นจริงของการพัฒนาซอฟต์แวร์และการทำงานร่วมกับ AI ทุกวัน มีอีกคำถามหนึ่งที่หลายคนมักสงสัยและถามผมอยู่เสมอ:

"ทำไมโมเดลตัวเดียวกันเป๊ะ เช่น Claude 3.5 Sonnet พอไปใช้ในแอปหนึ่ง ตอบฉลาดและเขียนโค้ดคล่องมาก แต่พอเอาไปใช้ในอีกแอปหนึ่ง กลับดูงุ่มง่ามและทำผิดบ่อยจัง?"
และที่สำคัญไม่แพ้กัน... "ทำไมโปรแกรมนี้คิดเงินเดือนละ 20 เหรียญ แต่พอเขียนโค้ดผ่านอีกโปรแกรมหนึ่ง ค่า API กลับพุ่งไปหลักร้อยเหรียญ ทั้งที่คุยกับ AI เรื่องเดียวกัน?"

ในตอนนี้ ผมจะชวนทุกท่านถอยออกมามองภาพใหญ่ในฐานะ Software Architect ครับ เราจะมาเจาะลึกว่าเบื้องหลังหน้าจอพิมพ์แชตนั้น ใครเป็นผู้กำกับ ใครเป็นคนคิดเงิน และทำไม "หนึ่งสมอง" เมื่อถูกวางลงบน "หลายเวที" จึงให้ผลลัพธ์และค่าใช้จ่ายที่ต่างกันลิบลิ่ว

1. จาก MCP สู่ Model Provider: เมื่อสมองและผู้กำกับแยกทางกัน

ในตอนที่ 11 เราเห็นว่า MCP ทำหน้าที่เป็นเต้ารับสากลเชื่อมระหว่าง Host (ผู้กำกับ) กับ External Tools (เครื่องมือภายนอก)

แต่ในฝั่งของ สมอง (Model) เองล่ะ? โมเดลชั้นนำของโลกมาจากหลากหลายค่าย ไม่ว่าจะเป็น OpenAI, Anthropic, Google, Meta หรือโมเดลโอเพนซอร์สอย่าง DeepSeek แต่ละค่ายต่างมีรูปแบบการเชื่อมต่อ (API Format, Parameter, Context Window Limit) เป็นของตัวเองอย่างสิ้นเชิง

เพื่อไม่ให้แอปพลิเคชันต้องเขียนโค้ดรองรับโมเดลใหม่ทุกครั้ง ระบบ AI ยุคนี้จึงมีเลเยอร์ที่เรียกว่า Model Adapter หรือ Provider Layer ทำหน้าที่เป็นสะพานแปลงคำสั่งสากลให้เข้ากับ API ของโมเดลแต่ละเจ้า

เมื่อมีทั้ง Model Adapter และ MCP เข้ามารองรับ บทบาทของ AI Harness จึงเด่นชัดและทรงพลังขึ้นมาอย่างแท้จริง:

  • Model (สมอง): ทำหน้าที่คาดเดาและประมวลผลข้อความ (Next-token prediction และ Reasoning) ตามที่เราคุยกันในบทแรก ๆ
  • Harness (ผู้กำกับเวที): ทำหน้าที่วางโครงสร้างการทำงานทั้งหมด จัดการ Context ประวัติการสนทนา คัดกรอง System Prompt ตัดสินใจว่าจะหยิบ Tool ตัวไหนมาใส่ไว้ในพรอมต์ ควบคุมสิทธิ์ความปลอดภัย และประเมินว่าผลลัพธ์ที่โมเดลส่งกลับมานั้นสมบูรณ์หรือยัง

นี่คือคำตอบของปริศนาข้อแรกครับ: ทำไมโมเดลตัวเดียวกัน ถึงเก่งไม่เท่ากันในต่างแอป?

เปรียบเหมือน "นักแสดงนำยอดฝีมือคนเดิม" แต่ไปเล่นละครสองเรื่อง เรื่องแรกมี ผู้กำกับชั้นครู (Harness คุณภาพสูง) ที่คัดสรรบทอย่างประณีต จัดฉากและอุปกรณ์ประกอบฉาก (Context & Tools) ไว้อย่างเป็นระเบียบ ให้ข้อมูลที่กระชับตรงประเด็น นักแสดงจึงเปล่งประกาย เล่นได้ลื่นไหล ไร้ข้อผิดพลาด

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

ความฉลาดของ AI ที่เราสัมผัสได้ จึงไม่ใช่ผลลัพธ์จากตัว Model โดด ๆ เพียงอย่างเดียว แต่เป็นผลลัพธ์ร่วมระหว่าง ศักยภาพของสมอง (Model Capability) และ ศิลปะในการกำกับของ Harness (Harness Engineering) เสมอครับ

2. สำรวจโลกของ Harness และเครื่องมือสาย Coding

เพื่อให้เห็นภาพการทำงานจริง ผมอยากพาทุกท่านไปสำรวจเครื่องมือสาย Coding Agent ในท้องตลาด ซึ่งมีแนวคิดและจุดยืนแตกต่างกันอย่างน่าสนใจ:

1) เครื่องมือจาก Frontier Labs (ค่ายพัฒนาโมเดลยักษ์ใหญ่)

ค่ายที่สร้างโมเดลเรือธง มักสร้าง Harness ประจำค่ายที่ถูกปรับจูน (fine-tuned) ให้เข้ากับสมองของตนเองอย่างแนบแน่น:

  • OpenAI Codex: ปัจจุบันได้เติบโตจากจุดเริ่มต้นของการเติมโค้ด กลายมาเป็น Coding Agent เต็มรูปแบบที่ทำงานครอบคลุมหลากหลายช่องทาง ทั้งบน CLI, ส่วนต่อขยายใน IDE, บริการบน Cloud และแอปพลิเคชัน Desktop ช่วยให้นักพัฒนาสั่งการให้ตรวจสอบไฟล์ แก้ไขโค้ด และสั่งรันงานได้อย่างต่อเนื่อง
  • Google Antigravity: สภาพแวดล้อมและ Harness สำหรับ Agentic AI ยุคใหม่ที่ประสานงานร่วมกับโมเดลตระกูล Gemini อย่างลึกซึ้ง ออกแบบมาให้รองรับการคิดเชิงกลยุทธ์ การวางแผนขั้นตอน (Planning Artifacts) และการตรวจสอบโค้ดอย่างรัดกุม
  • Claude Code: เครื่องมือ Agentic CLI ตัวใหม่จากค่าย Anthropic ที่ทำงานบนเทอร์มินัล ออกแบบมาเพื่อเป็นคู่หูโปรแกรมเมอร์ในการค้นหาโค้ดเบส แก้ไขไฟล์ และรันคำสั่งโดยตรง (ตัวนี้ลูกชายนำมาแนะนำให้รู้จักในเชิงสถาปัตยกรรม แต่ในงานประจำวันผมเองยังไม่ได้ลองนำมาใช้งานครับ)

2) เครื่องมือทางเลือกและ Open-Source Multi-Model

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

  • Cline (เดิมชื่อ Claude Dev): ส่วนขยายบน VS Code ยอดนิยมที่รองรับการเชื่อมต่อ MCP อย่างเต็มรูปแบบ มีจุดเด่นด้านการควบคุมสิทธิ์อย่างละเอียด ผู้ใช้สามารถเลือกได้ว่าจะกด Approve ยืนยันทีละขั้นตอน หรือจะเปิดระบบ Auto-Approve เฉพาะคำสั่งหรือขอบเขตไฟล์ที่ไว้ใจ เพื่อความคล่องตัวในการทำงาน และเปิดให้สลับใช้โมเดลค่ายไหนก็ได้ผ่าน API
  • OpenCode: เครื่องมือ Coding Agent แบบโอเพนซอร์สบนเทอร์มินัล ออกแบบมาเพื่อความคล่องตัว ใช้งานร่วมกับโมเดลได้หลากหลาย และมีบริการเสริมจากผู้พัฒนา เช่น แพ็กเกจรายเดือน OpenCode Go หรือบริการเติมเครดิตตามการใช้งาน OpenCode Zen ที่ช่วยอำนวยความสะดวกในการเชื่อมต่อโมเดลโดยไม่ต้องวิ่งไปสมัคร API ทีละเจ้า
  • Freebuff: ชุดเครื่องมือ AI Coding สไตล์ Multi-surface (ครอบคลุมทั้ง CLI, Desktop, Cloud) ที่มีทั้งสิทธิ์ใช้งานฟรีแบบสนับสนุนด้วยโฆษณา (Ad-supported) และแพ็กเกจเหมาจ่ายรายชั่วโมง/รายเดือนสำหรับผู้ใช้ที่ต้องการโควตาแน่นอนโดยไม่ต้องดูโฆษณา โดยผู้ใช้ต้องศึกษาเงื่อนไขและนโยบายความเป็นส่วนตัวของผู้ให้บริการแต่ละระดับอย่างรอบคอบ
  • Code Commander: แดชบอร์ดแนว Desktop Command Center ที่ทำหน้าที่ควบคุม Multi-agent และมอนิเตอร์การทำงานพร้อมกันหลาย ๆ Repository มีหน้าต่าง Live Diff ตรวจสอบการแก้โค้ด และจัดการเครื่องมือผ่านเทอร์มินัลหลายหน้าต่างพร้อมกัน (เป็นอีกหนึ่งเครื่องมือที่ลูกชายนำมาเล่าให้ฟังถึงแนวคิดการจัดการหลายโปรเจกต์พร้อมกัน)

3) OpenRouter: ประตูทางผ่าน ไม่ใช่ผู้กำกับเวที

มีหลายคนที่เพิ่งเริ่มศึกษา มักสับสนระหว่าง Cline / OpenCode กับ OpenRouter

ผมอยากเน้นย้ำตรงนี้ครับว่า OpenRouter ไม่ใช่ Coding Harness

ถ้า Harness เปรียบเสมือนรถยนต์ที่พาเราวิ่งไปยังจุดหมาย OpenRouter คือ "ปั๊มน้ำมันรวมมิตร" หรือ Model Gateway ที่รวบรวมน้ำมัน (โมเดล) จากทุกโรงกลั่น (OpenAI, Anthropic, Google, Meta, DeepSeek) มารวมไว้ที่หัวจ่ายเดียว เราเพียงแค่เปิดบัญชีกับ OpenRouter เติมเงินครั้งเดียว แล้วเอา Key เดียวไปเสียบใส่รถยนต์ (Harness เช่น Cline หรือ OpenCode) เราก็สามารถสลับเติมน้ำมันรุ่นไหน ยี่ห้อไหนก็ได้ โดยไม่ต้องไปเปิดบัญชีรายเดือนกับผู้ผลิตโมเดลทีละเจ้าให้วุ่นวายครับ

3. ใครเป็นคนเก็บเงินเรา? ถอดรหัสโครงสร้างค่าบริการ AI

เมื่อมีทั้ง Harness, Gateway และ Model Providers คำถามสำคัญถัดมาคือ: เงินในกระเป๋าเราไหลไปหาใครบ้าง?

ความเข้าใจผิดยอดฮิตอันดับหนึ่งของผู้เริ่มต้นคือ: "ผมจ่ายค่าบริการรายเดือน ChatGPT Plus หรือ Claude Pro เดือนละ 20 เหรียญแล้ว ทำไมพอเอามาต่อกับโปรแกรมเขียนโค้ดถึงยังใช้ไม่ได้ หรือทำไมต้องจ่ายเพิ่ม?"

ความจริงคือ Subscription รายเดือน ไม่เท่ากับ สิทธิ์การใช้ API ครับ โลกของค่าบริการ AI แบ่งออกเป็นหลายรูปแบบดังนี้:

รูปแบบค่าบริการใครเป็นคนเก็บเงิน?ลักษณะการคิดเงินเหมาะกับใคร?
1. Web Subscription (เช่น ChatGPT Plus, Claude Pro)ค่ายโมเดลโดยตรงจ่ายคงที่รายเดือน (เช่น $20/เดือน) ให้สิทธิ์คุยผ่าน Web Chat หรือแอปทางการตามรอบ Rate Limitผู้ใช้งานทั่วไปที่เน้นพิมพ์คุย ถามตอบ และทำงานหน้าเว็บ
2. API Pay-as-you-goค่ายโมเดล หรือ Gateway (เช่น OpenRouter)คิดเงินตามปริมาณการใช้งานจริง นับเป็น Input Tokens และ Output Tokens (ล้านละกี่ดอลลาร์)นักพัฒนา, องค์กร, และผู้ที่ต้องการเชื่อมต่อผ่าน Harness อิสระ
3. BYOK (Bring Your Own Key)ผู้ให้บริการคิดค่าซอฟต์แวร์/Harness (หรือแจกฟรี) แล้วให้เราจ่ายค่า Model แยกต่างหากผู้ใช้นำ API Key ส่วนตัวมาใส่ ทำให้จ่ายค่า Token ตรงให้ค่ายโมเดลตามจริง (แต่ต้องดูเงื่อนไขว่าตัว Harness มีคิดค่าบริการโปรแกรมแยก หรือมีค่าบริการเสริมอื่นเพิ่มเติมหรือไม่)ผู้ใช้ที่ต้องการความยืดหยุ่น และต้องการสลับใช้คีย์หรือโมเดลตามโควตาของตนเอง
4. Credit-based & Markupผู้ให้บริการ Harness สำเร็จรูปผู้ให้บริการซื้อ Token มา แล้วขายเป็น Credit ให้เรา โดยบวกกำไรส่วนต่าง (Markup) และค่าบำรุงรักษาระบบผู้ใช้ที่ต้องการความสะดวก ไม่อยากจัดการ API Key หลายใบ
5. Freemium & Ad-supported (เช่น Freebuff โมเดลฟรี)สปอนเซอร์ หรือผู้ลงโฆษณาใช้งานได้โดยไม่ต้องจ่ายเงินสด แลกกับการดูโฆษณาหรือยินยอมให้ประมวลผลข้อมูลการใช้งานตามนโยบายความเป็นส่วนตัว (ขณะที่บางเจ้าก็มีแพ็กเกจเหมาจ่ายรายชั่วโมง/รายเดือนให้เลือกอัปเกรด)ผู้เริ่มต้นทดลองใช้งาน ที่ยอมรับเงื่อนไขและนโยบายความเป็นส่วนตัวได้
6. Local Models (เช่น Ollama + Llama 3)ไม่มีใครเก็บค่าลิขสิทธิ์โมเดลเสียค่าเครื่องคอมพิวเตอร์สเปกสูง (GPU) และค่ากระแสไฟฟ้าที่บ้านผู้ที่ทำงานกับข้อมูลความลับระดับสูงสุด หรือต้องการออฟไลน์ 100%

ปรากฏการณ์โทเคนสะสม (Context Accumulation): ทำไมค่า API ถึงพุ่งเร็ว?

เมื่อเราพิมพ์คุยใน Web Chat ทั่วไป การถามตอบ 1 ครั้งอาจกินพลังงานเพียงไม่กี่ร้อย Tokens

แต่เมื่อเราใช้ Coding Agent (Harness + Tools) ในการสั่งว่า "ช่วยตรวจสอบบั๊กในโปรเจกต์นี้และแก้ให้หน่อย":

  1. Harness ต้องส่งโค้ดทั้งไฟล์และรายการเครื่องมือทั้งหมดเข้าไปใน Prompt (กินไปแล้ว 5,000 Tokens)
  2. โมเดลตอบกลับมาขอเรียกใช้ Tool ค้นหาไฟล์ (Output 100 Tokens)
  3. Harness อ่านไฟล์ขึ้นมา แล้วส่งประวัติทั้งหมดกลับเข้าไปให้โมเดลดูอีกรอบเป็นรอบที่สอง (คราวนี้ประวัติยาวขึ้น กลายเป็น 8,000 Tokens)
  4. โมเดลขอเรียก Tool เพื่อรันเทสต์ แล้วส่งผลกลับเข้าไปเป็นรอบที่สาม (กลายเป็น 12,000 Tokens)

ปรากฏการณ์การพอกพูนสะสมของโทเคนเช่นนี้ ทำให้ยิ่ง Agent วนลูปทำงานหลายรอบ ปริมาณ Input Tokens จะพอกพูนสะสมตามความยาวของประวัติการสนทนาอย่างรวดเร็ว หากเราใช้โมเดลตัวท็อปที่มีราคา Input สูง การปล่อยให้ Agent วนลูปแก้ปัญหาเพียง 10 นาที อาจกินค่า API ไปหลายดอลลาร์ได้อย่างไม่น่าเชื่อครับ

นี่คือเหตุผลที่ Harness หลายตัวต้องมีระบบ Usage Quota, Rate Limit, และหน้าต่างเตือนค่าใช้จ่าย เพื่อไม่ให้งบประมาณของเราบานปลายโดยไม่รู้ตัวครับ

4. ประสบการณ์จริง: เปิดสมุดบัญชีคนทำงาน และเหตุผลที่ผมเลือกจ่ายแต่ละค่าย

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

  1. ChatGPT Subscription (จ่ายรายเดือนต่อเนื่องมาตั้งแต่เดือนมิถุนายน):
  • เหตุผลที่ยอมจ่าย: เพราะความสามารถที่รอบด้าน มีรอบรีเซ็ตโควตาให้ใช้ได้เรื่อย ๆ ไม่ค่อยติดขัด และจุดเด่นที่สุดสำหรับผมคือ การสร้างรูปภาพ (Image Generation) ต่อเนื่อง ที่ไม่ค่อยติดเพดานหรือหวงโควตาง่าย ๆ เหมือนเจ้าอื่น
  • โมเดลที่ใช้: ในชีวิตประจำวันผมใช้โมเดลกลุ่ม Luna เป็นหลัก ส่วนโมเดลระดับสูงตัวอื่นจะหยิบมาใช้เฉพาะจังหวะที่โควตายังเหลือและมีงานวิเคราะห์ที่จำเป็นจริง ๆ
  1. Gemini (ได้แพ็กเกจโปรโมชัน 3 เดือน เดือนละ 189 บาท):
  • เหตุผลที่ยอมจ่าย: เป็นตัวเสริมชั้นดีสำหรับการเขียนโค้ด แต่จุดเด่นจริง ๆ สำหรับผมคือ การช่วยเกลาและแต่งเนื้อหาหนังสือ สำนวนที่ได้กำลังพอเหมาะ ไม่ออกแนวกวดขันคุมเข้มจนเครียดเกินไป (แม้จะมีนิสัยชอบอวยชมเรามากไปบ้างในบางจังหวะ)
  • โมเดลที่ใช้: ปกติผมใช้ Gemini Flash เป็นหลัก เพราะตอบสนองไว คล่องตัว และประหยัด
  1. Cline + DeepSeek API (ตัวเดียวที่ยอมจ่ายแบบยิง API ตรง):
  • เหตุผลที่ยอมจ่าย: ในช่วงแรก ๆ ผมยอมจ่ายแบบ Pay-as-you-go ไปราว 30 ดอลลาร์ เพื่อนำมาใช้เป็นสมองสำรองและการทดลองเชื่อมต่อภายนอก ซึ่งราคาโทเคนประหยัดมาก คุมงบได้แม่นยำ แต่สำหรับงานเขียนโค้ดทั่วไป ปัจจุบันผม เลิกใช้ Cline แล้ว เนื่องจากปัญหาอาการค้างระหว่างทำงานบ่อยครั้งตามที่เคยเล่าให้ฟัง
  1. OpenCode & OpenCode Go (Open-source Harness ที่ผมชอบ):
  • เหตุผลที่ยอมจ่าย: OpenCode เป็นโอเพนซอร์สบนเทอร์มินัลที่ผมถูกใจในความคล่องตัว ในตอนแรกผมจึงยอมจ่ายแพ็กเกจรายเดือน OpenCode Go 1 เดือนเพื่อทดสอบระบบการเข้าถึงโมเดล
  • เหตุผลที่หยุดจ่าย: พบว่าในเดือนหลัง ๆ โควตาการเข้าถึงโมเดลที่จัดสรรให้ลดลงจากเดือนแรกอย่างเห็นได้ชัด จึงตัดสินใจหยุดต่ออายุ แต่ยังชอบใช้งานตัว Harness ต่อไป โดยหันมาเชื่อมต่อกับโมเดลกลุ่มประหยัด เช่น DeepSeek Flash และ Mimo Flash
  1. Freebuff (ยังใช้งานอยู่มาประมาณ 2 เดือน):
  • เหตุผลที่ใช้: จุดเด่นที่ตอบโจทย์มากคือ ระบบนับเวลาการใช้งานรายชั่วโมง เราจ่ายรอบเดียวแล้วระบบจะให้จำนวนชั่วโมงต่อวันมา ทำให้เรามีอิสระเลือกเช่าได้เลยว่าในชั่วโมงนั้นจะดึงโมเดลตัวไหนมาทำงาน ซึ่งสำหรับการทำงานของผม ผมใช้สิทธิ์จนถึง Limit เหมาจ่ายรายวันก็เพียงพอแล้ว โดยไม่เคยจำเป็นต้องเปิดใช้แพ็กเกจส่วนขยายเพิ่มเติม
  • โมเดลที่ใช้: ก่อนหน้านี้ผมเคยใช้ GLM 5.3 Flash (ซึ่งปัจจุบันระบบถอดออกไปแล้ว), DeepSeek Flash, และ Muse Spark เป็นหลัก ส่วนโมเดลตัวอื่น ๆ ในระบบก็มีให้เลือกหลากหลายแต่ยังไม่ค่อยได้หยิบมาใช้
  1. เครื่องมืออื่น ๆ (เช่น Claude Code, Code Commander):
  • ลูกชายนำมาแนะนำและแลกเปลี่ยนแนวคิดเชิงสถาปัตยกรรมให้ฟัง แต่ในชีวิตการทำงานจริงผมยังไม่ได้เปิดใช้งานเป็นหลักครับ

จากบิลค่าบริการจริงทั้งหมดนี้ จะเห็นว่าการเป็น Software Architect ไม่ได้แปลว่าเราต้องจ่ายเงินซื้อบริการที่แพงที่สุด แต่เรามองหา ความคุ้มค่าและจุดเด่นเฉพาะทางของแต่ละค่าย (Fit-for-Purpose):

"จงเลือกเครื่องมือให้เหมาะกับงาน ไม่ใช่พยายามดัดแปลงงานให้เข้ากับเครื่องมือที่เราเผลอซื้อมา"

ถ้าต้องการคู่คิดรอบด้านพร้อมปั่นรูปภาพ ChatGPT ยังตอบโจทย์ได้สม่ำเสมอที่สุด ถ้าต้องการผู้ช่วยเกลาสำนวนหนังสือ Gemini Flash ทำหน้าที่ได้อย่างเป็นธรรมชาติ ถ้าต้องการความยืดหยุ่นรายชั่วโมง Freebuff ก็เป็นทางเลือกที่จัดสรรเวลาได้ดี และถ้าต้องการต่อระบบอัตโนมัติ การใช้ API ตรงแบบ Pay-as-you-go กับโมเดลอย่าง DeepSeek ก็ยังคงเป็นคำตอบที่ควบคุมงบประมาณได้ชัดเจนที่สุดครับ

5. มุมมองสถาปัตยกรรม (Architect’s Lens): การแยกส่วนเพื่อความอยู่รอด

ในทางวิศวกรรมซอฟต์แวร์ สิ่งที่เราคุยกันมาทั้งหมดในบทนี้คือหลักการพื้นฐานที่เรียกว่า Separation of Concerns (การแยกหน้าที่ความรับผิดชอบ):

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

เมื่อเรามองระบบ AI เป็น 3 เลเยอร์ที่แยกจากกันอย่างชัดเจน:

  1. User Interface & Workflow (Harness)
  2. Tool Standardization (MCP & Local APIs)
  3. Reasoning Engine (Model Providers via Gateway/Adapter)

ประโยชน์มหาศาลที่เกิดขึ้นกับเราในฐานะผู้สร้างระบบคือ:

  • ไม่ติดกับดักค่ายใดค่ายหนึ่ง (No Vendor Lock-in): วันนี้โมเดลค่าย A อาจจะฉลาดที่สุด แต่วันพรุ่งนี้ค่าย B อาจออกโมเดลใหม่ที่ฉลาดเท่ากันแต่ราคาถูกกว่า 5 เท่า หากระบบของเราแยกเลเยอร์ไว้อย่างดี เราแค่เปลี่ยนพารามิเตอร์ของ Model Adapter เพียงบรรทัดเดียว ระบบทั้งหมดก็ยังทำงานต่อได้ทันที
  • ควบคุมงบประมาณได้เฉียบคม (Cost Optimization): เราสามารถมอบหมายงานง่าย ๆ เช่น ค้นหาเอกสารหรือสรุปข้อความสั้น ให้โมเดลตัวเล็กราคาประหยัดทำ แล้วส่งต่องานคิดตรรกะซับซ้อนให้โมเดลตัวท็อปราคาแพง
  • ความปลอดภัยที่ตรวจสอบได้ (Auditable Governance): Harness ที่ดีจะทำหน้าที่เป็นป้อมปราการ คอยตรวจสอบและบันทึกประวัติการใช้จ่าย การเรียกใช้เครื่องมือ และการเข้าถึงข้อมูลเสมอ

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

ในตอนนี้ เราได้เห็นภาพที่สมบูรณ์ขึ้นมากครับ:

  • เรารู้แล้วว่า สมอง (Model) มีหน้าที่ประมวลผลข้อความ
  • เรารู้แล้วว่า ผู้กำกับ (Harness) คือผู้จัดฉาก คุมความจำ และเชื่อมต่อโลกจริง
  • เรารู้แล้วว่า เครื่องมือ (Tools & MCP) คือสิ่งที่ช่วยให้ระบบลงมือทำได้
  • และเรารู้แล้วว่า กลไกการคิดเงิน เบื้องหลัง ทำงานอย่างไรและคิดตามอะไร

แต่ยังมีคำถามสำคัญอีกหนึ่งข้อที่ยังค้างคาอยู่:

"เมื่อโมเดลประมวลผลเสร็จ 1 รอบ แล้วได้คำตอบออกมา... อะไรคือกลไกภายในที่สั่งให้มัน 'คิดซ้ำ' วางแผนขั้นถัดไป แล้วตัดสินใจหยิบเครื่องมือชิ้นที่สองมาชิ้นที่สาม จนกระทั่งงานเสร็จสมบูรณ์โดยที่เราไม่ต้องคอยกดสั่งทุกก้าว?"

ในตอนต่อไป — ตอนที่ 13: หัวใจของ Agent — ลูป คิด-ทำ-ตรวจ (The Agent Loop) เราจะมาเปิดฝากระโปรงดู "หัวใจที่เต้นอยู่" ของระบบ Agentic AI ว่ามันมีวงจรความคิด การตรวจสอบข้อผิดพลาด และการวนซ้ำอย่างไร จนกลายเป็นผู้ช่วยอัจฉริยะที่ทำงานแทนเราได้อย่างแท้จริงครับ!

ศัพท์เทคนิค → คำแปลภาษาคนทำงาน — แตะเพื่อย่อ/ขยาย
  • Model Provider: ผู้ผลิตและให้บริการสมองกล (เช่น OpenAI, Anthropic, Google) ผู้ถือครองและรันโมเดลบนดาต้าเซ็นเตอร์
  • Model Adapter / Provider Layer: เลเยอร์สะพานเชื่อมในตัว Harness ที่แปลงคำสั่งสากลให้เข้ากับ API เฉพาะตัวของแต่ละค่าย
  • Model Gateway (เช่น OpenRouter): ปั๊มน้ำมันรวมมิตร หรือประตูทางผ่านที่รวมโมเดลจากหลายค่ายไว้ในที่เดียว ไม่ใช่ตัวควบคุมการทำงาน (Harness)
  • BYOK (Bring Your Own Key): รูปแบบการใช้ซอฟต์แวร์ที่เรานำกุญแจ API ส่วนตัวมาใส่ ทำให้จ่ายค่าประมวลผลโมเดลตามจริงกับผู้ให้บริการโดยตรง (ทั้งนี้ขึ้นอยู่กับว่าผู้พัฒนา Harness นั้น ๆ มีคิดค่าโปรแกรมแยกต่างหากหรือไม่)
  • ปรากฏการณ์โทเคนสะสม (Context Accumulation): ปรากฏการณ์ที่โทเคนพอกพูนสะสมทวีคูณในการหมุนลูปของ Agent จากการส่งบริบท ประวัติ และข้อมูลไฟล์ซ้ำเข้าไปในระบบทุกรอบการทำงาน
หลักคิดเชิงสถาปัตยกรรม — แตะเพื่อย่อ/ขยาย
  • Separation of Concerns: แยกขาดระหว่าง UI/Workflow (Harness), เตาเสียบเครื่องมือ (MCP) และ สมองกล (Model) เพื่อความยืดหยุ่น ป้องกัน Vendor Lock-in และสลับโมเดลได้ทันทีเมื่อมีรุ่นที่คุ้มค่ากว่า
  • Fit-for-Purpose & Cost Awareness: เลือกเครื่องมือและโมเดลให้ตรงกับลักษณะงาน งานง่ายให้โมเดลประหยัดทำ งานยากส่งให้โมเดลตรรกะสูง และระวังงบประมาณบานปลายจากการวนลูปของ Agent
  • Subscription vs API: ไม่สับสนระหว่างค่าบริการเหมาจ่ายรายเดือนของแอปแชต กับค่าบริการเชื่อมต่อประมวลผลตามจริงของ API