ผมจะแสดงให้คุณเห็นทีละขั้นตอนว่าจะได้ผลลัพธ์ที่ดีที่สุดจาก Claude Code, Codex, OpenCode หรือ harness ใดก็ตามที่คุณใช้อยู่...
เพราะ harness ก็แค่แอปที่คุณใช้พิมพ์คำสั่งให้ agent หรือก็คือห้องนักบินที่คุณนั่งควบคุม
สัญชาตญาณคือการไล่ตามโมเดลที่ดีกว่าเอามาใส่ในนั้น (ใช้ Fable 5 ยังไงล่ะ)
แต่ความได้เปรียบจริงๆ อยู่ที่อื่น อยู่ที่ว่าคุณหยุดแค่โมเดลเดียว
และช่วงเวลานี้ทำให้ความผิดพลาดนั้นแพงกว่าเดิม... เพราะโมเดลที่ดีที่สุดกลายเป็นเป้าที่เคลื่อนที่ตลอด คุณไม่สามารถพึ่งพามันได้:
- Fable 5 กำลังจะกลับมาประมาณสัปดาห์นึงแล้วก็จะแพงเกินเอื้อม
- Mythos 5 ถูกจำกัดให้แค่บริษัทที่ผ่านการตรวจสอบโดยรัฐบาล
- GPT-5.6 Sol ถูกส่งออกไปแค่ประมาณ 20 บริษัทที่ได้รับอนุมัติเท่านั้น
ดังนั้นการเดิมพันทั้งองค์กรของคุณกับโมเดลที่ "ดีที่สุด" ในเดือนนี้จะพังทันทีที่มันถูกจำกัดการเข้าถึง
ดังนั้นทางออกคือการรวม frontier LLMs หลายตัวเข้าด้วยกัน ให้โมเดลหลายตัวทำงานร่วมกันแทนที่จะให้ตัวเดียวรับภาระทั้งหมด
นี่คือสิ่งที่แยกผลลัพธ์ธรรมดาออกจากผลลัพธ์ที่ดีที่สุด และนี่คือสิ่งแรกที่ผมตั้งค่าในทุกโปรเจกต์ตอนนี้
ถ้าคุณอยากเรียนรู้วิธีใช้เครื่องมือเหล่านี้ให้คุ้มค่าที่สุดและทำเงินจริงๆ นั่นคือสิ่งที่ชุมชน real time AI ops ถูกสร้างขึ้นมา: weeklyaiops.com
การส่งงานไปมาแสนช้าและน่าเบื่อ
ดูสิว่าโปรเจกต์ทั่วไปเป็นยังไง คอขวดอยู่ตรงกลางเลย:
คุณเปิด harness หนึ่งตัวแล้วส่งงานให้มัน
จากนั้นคุณเอาแผนของมันไปวางให้โมเดลที่สอง แล้วถามว่า "ถูกต้องไหม"
โมเดลที่สองก็หาจุดบกพร่อง แล้วคุณก็เอาข้อสังเกตเหล่านั้นกลับไปให้โมเดลแรก
คุณใช้เวลาทั้งบ่ายเป็น messenger ส่งบริบทกลับไปมาระหว่างสองโมเดลที่คุยกันไม่รู้เรื่อง
พูดตรงๆ เลย การส่งงานไปมาแบบนี้มันน่าเบื่อที่สุด...
ผมรู้จักวงจรนี้ดีเกินไป ให้ Claude เช็คแผนของ Codex แล้วเอาจุดบกพร่องกลับไปอีกทางหนึ่ง และวันทั้งวันก็หายไปกับการส่งข้อความระหว่างสองโมเดล
ทำไมการรวม AI หลายตัวถึงชนะโมเดลโปรดของคุณ
มีเหตุผลที่โมเดลที่สองคอยจับสิ่งที่โมเดลแรกพลาดไป...
โมเดลที่ตรวจสอบงานมีจุดบอดร่วมกับโมเดลที่สร้างงาน เพราะพวกมันล้มเหลวในที่เดียวกัน
ดังนั้นการขอให้โมเดลเดียวตรวจสอบตัวเองจะได้คำตอบมั่นใจว่า "ดูดีนะ" ในบั๊กที่มันเองก็เป็นคนเขียน
คณะกรรมการ (council) แก้ปัญหานั้นในเชิงโครงสร้าง ไม่ใช่แค่พร้อมต์ที่ดีกว่า - เพราะโมเดลที่ต่างกันจะปกปิดจุดอ่อนของกันและกัน
และข้อพิสูจน์นี้มีงานวิจัยรองรับ:
ทีมวิจัยที่ Sakana สร้างผู้ประสานงาน (coordinator) ที่เล็กพอที่จะรันบนแล็ปท็อป เป็นโมเดลที่ไม่เคยตอบคำถามคุณเลย
มันอ่านคำถาม
ตัดสินใจว่าโมเดลใหญ่ตัวไหนควรจัดการแต่ละส่วน
แล้วส่งงานออกไป
พวกเขาชี้มันไปที่ GPT-5, Gemini และ Claude และมันชนะทั้งสามตัวด้วยตัวมันเอง...
จากนั้นพวกเขาลองสลับเอาโมเดลระดับท็อปมาทำหน้าที่ประสานงานแทน และผลออกมาแย่กว่า ฮ่าๆ
ดังนั้นวาทยากรไม่จำเป็นต้องเป็นโมเดลที่แข็งแกร่งที่สุดที่คุณมี แต่มันต้องอ่านปัญหาแล้วส่งต่อไปให้คนที่เก่งที่สุดในส่วนนั้น
สามบทบาท และบทบาทที่ถูกข้ามไป
ผู้ประสานงานให้แต่ละโมเดลทำงานทีละอย่าง:
thinker: แบ่งงานย่อย สร้างแผน หาจุดบกพร่อง
worker: ลงมือทำงาน ร่าง โค้ด ตัวเลข หรืออะไรก็ตามที่เป็นผลลัพธ์
verifier: ตัดสินผลลัพธ์แล้วบอกว่า "ส่งได้" หรือ "แก้ตรงนี้"
verifier มักถูกข้ามไป แต่เป็นบทบาทที่สำคัญที่สุด
งานยังไม่เสร็จเมื่อโมเดลสร้างอะไรบางอย่าง... มันจะเสร็จเมื่อ verifier รับรอง
กฎข้อเดียว เงื่อนไข "เสร็จ" ที่ชัดเจน คือความแตกต่างระหว่างวงจรที่จบกับวงจรที่หมุนวนไม่รู้จบ
ส่งงานไปมาให้คณะกรรมการจัดการ
การเพิ่ม coordinator อาจฟังดูเหมือนอีกชั้นที่ต้องจัดการ
แต่มันกลับตรงกันข้าม เลเยอร์ที่คุณเอาออกคือตัวคุณเอง
ดังนั้นวิธีง่ายๆ คือคุณมอบหมายการประสานงานนั่นเอง: คุณหยุดเป็น messenger แล้วให้ coordinator จัดการ loop thinker, worker และ verifier ให้คุณ
ตอนนี้ผมใช้ Fugu (sakana.ai/fugu) และขอบอกให้ชัดเจน นี่ไม่ใช่สปอนเซอร์ ผมแค่ชอบมัน
มันคือเวอร์ชันที่ถูกทำให้เป็นผลิตภัณฑ์จากงานวิจัยนั้น คุณแค่ชี้ harness ไปที่มันเหมือนกับที่คุณชี้ไปยังโมเดลอื่นๆ แล้วมันจะรัน council ภายใต้คำขอเดียว
ผมจะพูดตรงๆ ว่ามันคืออะไร เพราะนี่สำคัญ
มันเพิ่งเกิดมาได้ไม่กี่วัน มันใช้เวลาเพราะมันรัน council จริงๆ ไม่ใช่แค่จำลอง และมันแข็งแกร่งที่สุดในบทบาท verifier ตัวที่ตรวจสอบงานก่อนส่ง
20 ดอลลาร์ก็เข้าได้ พร้อมเดือนที่สองฟรีถ้าเริ่มก่อนสิ้นเดือนกรกฎาคม
ผมไม่เชื่อมั่นมันแบบมืดบอด ผมเชื่อมั่นใน council pattern และนี่เป็นวิธีที่ง่ายที่สุดที่ผมเจอในการรัน pattern นั้นโดยไม่ต้องคอยดูแล
ทีนี้มาดูขั้นตอนการทำงานทีละขั้นเพื่อให้ได้ผลลัพธ์ที่ดีที่สุดกับ harness ตัวไหนก็ได้:
รัน council ตอนเริ่มและตอนส่งงาน
ผมใช้ council ในสองช่วงของทุกโปรเจกต์ คือตอนเริ่มและตอนส่งมอบ
นึกถึงงานจริงๆ เช่น เปิดตัว newsletter, สร้าง lead list, ส่ง landing page
1. สัมภาษณ์ก่อน - ก่อนเริ่มงานใดๆ ให้ agent สัมภาษณ์คุณอย่างละเอียด (grill-me จาก matt คือ skill ที่ทำให้ agent ซักถามคุณทุกอย่าง) ความลึกของการสัมภาษณ์นั้นกำหนดเพดานของทุกอย่างที่ตามมา
2. เรียกประชุม council - เพื่อสร้างแผน coordinator จัดการส่วนที่ต้องใช้หลายโมเดล คุณไม่ต้องคอยวางข้อมูลระหว่างเครื่องมืออีกต่อไป
3. กำหนดลูป - ตั้งเป้าหมายและเงื่อนไขการหยุดตั้งแต่แรก มันจะได้รันได้โดยไม่ต้องให้คุณคอยดูทุกขั้นตอน
4. มอบหมายตามบทบาท - ส่งงานที่ถูกต้องไปยังที่ที่ถูกต้อง และพึ่งพา subagent (subagent ก็แค่ agent ผู้ช่วยที่ตัวหลักส่งงานให้)
5. ตรวจสอบตอนส่ง - เมื่องานดูเหมือนเสร็จ ส่งกลับไปให้ council ตรวจสอบอย่างละเอียดก่อนปล่อยออกไป
ลูปเดียวกัน สองปลาย วางแผนตอนเริ่ม ตรวจสอบตอนจบ - นั่นคือเครื่องยนต์ทั้งหมด และมันเปลี่ยนความเร็วที่ผมสามารถส่งสิ่งที่ผมมั่นใจได้อย่างมาก
council คือเครื่องยนต์ การตั้งค่าทำให้มันคมกริบ
เครื่องยนต์จะดีได้ก็ต่อเมื่อเครื่องจักรรอบๆ ดีด้วย...
ดังนั้นนี่คือหกท่าที่ทำให้ agent แต่ละตัวใน council สร้างผลงานที่ดีที่สุด ไม่มีอะไรซับซ้อน
1. สร้าง skill ของตัวเอง อย่าโหลด library มาใช้
skill คือชุดคำสั่งที่บันทึกไว้ที่ agent ของคุณสามารถใช้ซ้ำได้ เหมือนสูตรอาหารที่มันทำตาม (ไม่มีอะไรมากไปกว่าไฟล์ markdown พร้อมตัวอย่าง...)
สิ่งล่อใจคือการคว้า library skill ขนาดใหญ่ที่คนอื่นเผยแพร่แล้วรันเลย
ผมขอข้ามนะ ประมาณหนึ่งในสามของ skill สาธารณะมีช่องโหว่ด้านความปลอดภัย... หรือแย่กว่านั้น ฮ่า
และแม้แต่ skill ที่สะอาดก็เป็นบริบทของคนอื่น ไม่ใช่ของคุณ skill จะช่วยได้ก็ต่อเมื่อคุณเจอปัญหาที่มันแก้ด้วยตัวเอง
ก่อนหน้านั้น มันแค่เสียงรบกวนที่ทำให้ memory ของ agent เต็ม
ดังนั้นข้อเสนอของผมคือ: สร้าง skill สองสามอันที่คุณต้องการจริงๆ จากประสบการณ์ที่ล้มเหลวของคุณเอง นั่นคือที่มาของความได้เปรียบที่แท้จริง
2. ใช้ CLI เล็กๆ เป็นค่าเริ่มต้น ไม่ใช่ MCP servers
อธิบายสั้นๆ ก่อน MCP คือวิธีเพิ่มเครื่องมือพิเศษให้ agent ส่วน CLI คือคำสั่งเล็กๆ ที่คุณรันในหน้าต่างข้อความ
ปฏิกิริยาตามธรรมชาติคือการต่อ MCP กับทุกอย่าง และแต่ละตัวจะโหลดคำแนะนำทั้งหมดเข้าไปใน memory ของ agent ก่อนที่คุณจะถามคำถามแรกด้วยซ้ำ
คำอธิบายเครื่องมือเหล่านั้นกิน memory มากกว่า 100,000 คำตั้งแต่เริ่ม เบียดพื้นที่ทำงานจริง
ดังนั้นสำหรับงานประจำวัน ให้ใช้ CLI เล็กๆ แทน มันเบากว่า agent รู้วิธีรันคำสั่งอยู่แล้ว และผลลัพธ์จะไปอยู่ในไฟล์แทนที่จะอุดตัน memory
เครื่องมือชื่อ printing-press (printingpress.dev) จะเขียน CLI แบบนี้ให้คุณสำหรับบริการใดๆ จากพร้อมต์เดียว... ใช้มันให้คุ้ม
เก็บ MCP ไว้สำหรับงานที่ต้องการจริงๆ เช่น การล็อกอินร่วมกัน ผู้ใช้จำนวนมาก การเชื่อมต่อที่ต้องเปิดตลอดเวลา
กฎคือ CLI-first ไม่ใช่ CLI-only
3. ให้ไฟล์คำสั่งมีน้ำหนักเบา
agent ของคุณอ่านไฟล์คำสั่งก่อนทุกงาน โดยปกติคือ AGENTS.md หรือ CLAUDE.md
แรงกระตุ้นคือการยัดทุกอย่างที่คุณนึกได้ลงไป แล้ว agent ก็จะทำตามน้อยลง ไม่ใช่มากขึ้น
โมเดลทำตามคำสั่งได้อย่างน่าเชื่อถือประมาณ 150 ถึง 200 คำสั่ง จากนั้นมันจะเริ่มทำหล่นหาย
เก็บให้ต่ำกว่า 100 บรรทัด - มันทำงานได้ดีกว่าแบบนั้น
4. ล้าง context เก็บ memory ไว้ในไฟล์
context window คือความจำระยะสั้นของ agent และเมื่อมันเต็ม มันก็จะโง่ลงเรื่อยๆ
Claude Opus 4.8 เป็นตัวอย่างที่ดี... มันเป็นโมเดลที่ยอดเยี่ยม แต่ทันทีที่คุณถึง 300-400k tokens คุณควรล้าง context 100% - อย่าใช้การย่อ (compacting)
ดังนั้นล้างมันบ่อยๆ และเก็บความจำที่สำคัญไว้ในไฟล์แทน
ไฟล์ learnings.md ที่ agent อ่านตอนเริ่มเซสชันและอัปเดตตอนจบ ทุกครั้ง แม้เมื่อมันคิดว่าไม่มีอะไรเปลี่ยนแปลง
ให้มันอัปเดตบันทึกเหล่านั้นหลังจากแต่ละ commit ซึ่ง commit คือจุด checkpoint ที่บันทึกงาน
กฎที่คงทนอยู่ในไฟล์คำสั่ง สิ่งที่มันเรียนรู้ระหว่างทางอยู่ใน learnings และถ้าคุณแก้ไขไฟล์กฎหลังรันทุกครั้ง แสดงว่าคุณใส่สิ่งที่ผิดลงไป
ผมสร้าง skill สำหรับตัวเองชื่อ /before-clear มันแค่สร้าง checkpoint ในโปรเจกต์ ไฟล์ชั่วคราวที่ agent อ่านก่อน... มันมี todo ง่ายๆ สรุปสั้นๆ ว่าเกิดอะไรขึ้นในเซสชันที่แล้วและงานสำคัญที่สุดถัดไปคืออะไร
ผมแทบไม่เคยเสีย context สำคัญระหว่างเซสชันเลย
5. เขียนกฎน้อยข้อ แต่ละข้อชัดเจน
กฎสั้นๆ ชัดเจน ดีกว่ากฎเจ๋งๆ เต็มกองมาก
เมื่อไฟล์กฎยาว กฎจะเริ่มแข่งขันกัน และ agent ต้องเดาว่าข้อไหนชนะ
เขียนแต่ละกฎเหมือนที่คุณบอกพนักงานใหม่ หนึ่งบรรทัด หนึ่งความหมาย ไม่มีช่องให้ตีความ
เมื่อกฎชัดเจน agent ทำตาม เมื่อมันคลุมเครือ agent ด้นสด และการด้นสดคือที่ที่ผลลัพธ์ของคุณเริ่มเบี่ยงเบน
6. มอบหมายงานหนักให้ subagent
โยนงานที่ยุ่งเหยิงและแพงลงไปให้ subagent โดยเฉพาะอะไรก็ตามที่แตะ browser
การขับ browser จาก agent หลักสามารถเผา context จำนวนมากไปกับ screenshot
ส่งงานเดียวกันให้ subagent แล้วมันจะกลับมาพร้อม "เสร็จแล้ว นี่คือสรุป" ในหนึ่งหรือสองบรรทัด
agent หลักยังคงเป็นวาทยากร ผู้ช่วยเป็นคนเอื้อมถึง และ memory หลักของคุณยังสะอาด
มันคือแนวคิด council อีกครั้ง ลดลงมาหนึ่งระดับ คุณประสานงานแทนที่จะลงมือทำเองทั้งหมด
ระบบปฏิบัติการทั้งหมด ในบล็อกเดียว
โมเดลที่ดีที่สุดถูกจำกัดการเข้าถึงเรื่อยๆ ดังนั้นโมเดลเดียวไม่สามารถเป็นรากฐานของคุณได้
ส่งมอบการประสานงานให้ council: thinker วางแผน worker สร้าง verifier รับรอง
verifier คือเงื่อนไขการหยุด งานเสร็จเมื่อมันบอก ไม่ใช่ก่อนหน้านั้น
รัน council สองครั้ง ตอนเริ่มเพื่อวางแผน และตอนส่งมอบเพื่อตรวจสอบ
ผมใช้ Fugu ในการรัน 20 ดอลลาร์ให้ลอง ไม่ได้สปอนเซอร์ บอกตามตรงว่ายังอยู่ในช่วงต้น
จากนั้นรักษาให้ agent แต่ละตัวคมกริบ:
สร้าง skill ของตัวเอง อย่าโหลด library
CLI-first, MCP สำหรับเมื่อคุณต้องการจริงๆ
ไฟล์คำสั่งต่ำกว่า 100 บรรทัด
ล้าง context บ่อยๆ เก็บ memory ในไฟล์
กฎน้อยข้อ แต่ละข้อชัดเจน
มอบหมายงานหนักให้ subagent
อย่างอื่นที่เพิ่มเติมไปจากนี้เป็นการปรับแต่งล้วนๆ ที่คุณอาจไม่สังเกตด้วยซ้ำถ้าคุณไม่ใช่วิศวกรซอฟต์แวร์
นี่คือวิธีที่คุณสร้างระบบปฏิบัติการที่ทำงานได้ดี ไม่ว่าจะมีหรือไม่มี Fable 5...
ยังไงก็ตาม ผมกำลังสร้างชุมชน AI ที่ดีที่สุดในโลก คุณมาอยู่ด้วยกันไหม?
