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

klaatcode แก้ปัญหานี้โดยให้โมเดลตัวหนึ่งอ่านคำสั่งของเราก่อน แล้วเลือกรุ่นที่คุ้มกับงานนั้น งานเบาใช้รุ่นเล็กราคาถูก งานหนักค่อยใช้รุ่นท็อป แล้วคุ้มจริงไหม คำตอบอยู่ในผลทดสอบที่ให้ klaatcode แข่งกับ Claude Code (coding agent ตัวดังจาก Anthropic) บนโจทย์เขียนโค้ดชุดเดียวกัน 30 ข้อ ทั้งคู่ทำได้เท่ากัน คือผ่าน 30 จาก 30 ข้อ แต่ค่าใช้จ่ายต่อโจทย์ต่างกันมาก ฝั่ง klaatcode อยู่ที่ราว 0.026 ดอลลาร์ ส่วน Claude Code อยู่ที่ 0.146 ดอลลาร์ หรือ klaatcode ถูกกว่าราว 5.5 เท่า

30 จาก 30 ข้อ ที่ตรวจซ้ำเองได้

ตัวเลขนี้น่าเชื่อเพราะวิธีวัดเปิดเผยหมด การทดสอบให้ agent แต่ละตัวแก้โจทย์เขียนโค้ดจริงชุดเดียวกัน 30 ข้อ ด้วยคำสั่งและวิธีตรวจคำตอบแบบเดียวกัน klaatcode กับ Claude Code จึงทำงานภายใต้เงื่อนไขเดียวกัน (ในชุดทดสอบยังมี opencode กับ Grok Build ให้เทียบด้วย) ผลสรุปอยู่ในตารางสั้นๆ

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

ก่อนไปต่อ ต้องบอกตามตรงว่านี่เป็นตัวเลขจากการทดสอบของโปรเจกต์เอง ยังไม่มีการทดสอบจากแหล่งอื่นมายืนยันซ้ำ สิ่งที่ต่างจากคำโฆษณาคือชุดทดสอบเปิดให้ดาวน์โหลดไปรันตรวจเองได้ ใครสงสัยว่าตัวเลขจริงไหมก็ตรวจเองได้เลย

ให้โมเดลเลือกโมเดล แบ่งงานเป็นห้าระดับ

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

• nano สำหรับงานจิ๊บจ๊อย เช่น เติมคำให้อัตโนมัติ
• fast สำหรับคำถามสั้นๆ และงานแก้ไขเล็กน้อย
• code เป็นค่าเริ่มต้นของงานเขียนโค้ดทั่วไป
• reason สำหรับงานที่ต้องคิด เช่น ไล่หาบั๊ก วางสถาปัตยกรรม ตรรกะที่ซับซ้อน
• heavy สำหรับงานหนักสุด เช่น รื้อโครงสร้างครั้งใหญ่ แก้ปัญหาที่ยากที่สุด

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

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

ทำแผนที่โค้ด แทนที่จะอ่านทั้งไฟล์

กลไกที่สองคือวิธีที่มันทำความรู้จักโปรเจกต์ของเรา แทนที่จะเปิดอ่านและป้อนเนื้อหาทั้งไฟล์เข้าโมเดลทุกครั้ง klaatcode ทำดัชนีโปรเจกต์เป็น code knowledge graph ซึ่งเป็นแผนที่ที่บอกว่าฟังก์ชันไหนเรียกใช้ฟังก์ชันไหน และแต่ละจุดเชื่อมโยงกันอย่างไร

พอมีแผนที่แล้ว เวลาต้องแก้จุดใดจุดหนึ่ง มันไม่ต้องอ่านทั้งไฟล์เพื่อไล่หาส่วนที่เกี่ยวข้อง แต่ค้นจากแผนที่ได้ตรงๆ ว่าส่วนไหนเรียกใช้โค้ดจุดนี้บ้างและการแก้จะกระทบส่วนไหนต่อ จากนั้นจึงดึงมาเฉพาะส่วนที่เกี่ยวข้อง

วิธีนี้ประหยัดเพราะโมเดลคิดเงินตามจำนวนโทเคน ซึ่งเป็นหน่วยวัดปริมาณข้อความที่โมเดลอ่านและเขียน ยิ่งป้อนข้อความยาวก็ยิ่งเปลืองโทเคน การค้นจากแผนที่แล้วดึงมาเฉพาะส่วนที่เกี่ยวข้องจึงกินโทเคนน้อยกว่าการอ่านทั้งไฟล์ราว 5 ถึง 15 เท่า และในการทดสอบ klaatcode ใช้โทเคนเหลือราว 28% ของที่ Claude Code ใช้

การป้อนข้อมูลเข้าโมเดลให้น้อยลงคือหัวใจของการลดค่าใช้จ่ายในการใช้ agent อีกวิธีที่ใช้หลักเดียวกันคือไม่ส่งข้อมูลเดิมซ้ำ หรือที่เรียกว่า prompt caching ส่วนการทำแผนที่โค้ดของ klaatcode แก้ปัญหาเดียวกันจากอีกด้าน โดยตัดข้อมูลที่ไม่เกี่ยวออกตั้งแต่ต้น ให้โมเดลอ่านเฉพาะส่วนที่จำเป็นจริงๆ

โอเพนซอร์สเฉพาะตัวโปรแกรม ส่วนโมเดลยังเสียเงิน

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

ส่วนที่เป็นโอเพนซอร์สจริงๆ คือฝั่ง client หรือตัวโปรแกรมที่เราติดตั้งในเครื่อง มันเป็นแค่หน้าจอสำหรับพิมพ์คำสั่ง แล้วส่งต่อให้บริการบนคลาวด์ทำงานจริงอีกที ตัวโปรแกรมนี้เปิดโค้ดให้ดูและแก้ได้ แต่โมเดลเบื้องหลังยังเป็นบริการแบบเสียเงิน ก่อนติดตั้งจึงควรรู้ว่าต้องมีบัญชีและเตรียมงบไว้ ไม่ใช่ติดตั้งแล้วใช้ฟรีได้เลย

สำหรับคนที่ไม่อยากผูกกับบริการนี้ klaatcode ก็เปิดทางเลือกไว้ให้ เรานำโมเดลของตัวเองมาเชื่อมต่อแทนได้ ขอแค่โมเดลนั้นเชื่อมต่อด้วยวิธีมาตรฐานที่ใช้กันทั่วไป จากนั้นสั่ง /model add แล้วสลับไปใช้รุ่นที่เลือกเองในแต่ละรอบการทำงาน เท่ากับได้ใช้ client ที่ดีโดยไม่ต้องพึ่งบริการโมเดลแบบเสียเงิน

เลือกรุ่นให้เหมาะกับงาน หลักที่ใช้ได้กับ agent ทุกตัว

ต่อให้ไม่ได้ดาวน์โหลด klaatcode มาใช้ แนวคิดหลักของมันก็หยิบไปใช้ได้ทันที คือเลือกรุ่นโมเดลให้เหมาะกับความหนักเบาของงาน งานเบาใช้รุ่นราคาถูก งานหนักค่อยใช้รุ่นราคาแพง อย่าปล่อยให้รุ่นท็อปทำทุกงานโดยอัตโนมัติ

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

ลองเองในไม่กี่บรรทัด

ถ้าอยากลองของจริงก็ติดตั้งได้ด้วยคำสั่งเดียว เครื่องต้องติดตั้งตัวรันโปรแกรม JavaScript เช่น Node หรือ Bun ไว้ก่อน เมื่อเปิดใช้ครั้งแรก ระบบจะให้ล็อกอินผ่านเบราว์เซอร์โดยไม่ต้องสร้างหรือวาง API key เอง

# ติดตั้ง (ต้องมี Node 18 ขึ้นไป หรือ Bun 1 ขึ้นไป)
npm install -g klaatcode

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

bun install
bun run bench                                # รันชุดทดสอบของ klaatcode
bun bench/compare-agents.ts --agent claude   # เทียบกับ Claude Code (สลับเป็น opencode หรือ grok ได้)

รันจบจะได้ตัวเลขค่าใช้จ่ายกับความแม่นออกมาให้เทียบกับที่โปรเจกต์ประกาศไว้ตรงๆ

klaatcode ยังมีหลายอย่างที่พัฒนาไม่เสร็จ ทั้งเครื่องมือสำหรับเปิดดูนิยามฟังก์ชัน การแยกพื้นที่ทำงานเพื่อสั่งงานหลายอย่างพร้อมกัน และคะแนนจากสนามทดสอบมาตรฐานที่ยังไม่ประกาศ ทั้งหมดอยู่ในแผนแต่ยังไม่เสร็จ จึงควรมองว่ามันยังอยู่ระหว่างพัฒนา ไม่ใช่เครื่องมือที่เสร็จสมบูรณ์แล้ว

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

ที่มา: โปรเจกต์ klaatcode บน GitHub