5 ระดับของ AI Agents: จาก Prompt สู่ Production

ตอนนี้มีอยู่ 5 คำที่คนชอบพูดถึงกันบ่อยมากเวลาคุยเรื่อง agent นั่นคือ Context engineering, loop engineering, Jev engineering, harness engineering และ eval engineering

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

วิธีที่เห็นภาพง่ายที่สุดคือ ลองจินตนาการว่าคุณเพิ่งรับพนักงานใหม่เข้ามาคนหนึ่ง:

• Context - บนโต๊ะทำงานของเขามีอะไรอยู่บ้างตอนที่คุณสั่งงาน
• Loop - เขาทำตามเช็กลิสต์ที่คุณให้ หรือคิดหาขั้นตอนต่อไปด้วยตัวเอง
• Jev - พนักงานต้อนรับที่คอยคัดแยกจดหมาย เพื่อให้เขาเห็นแค่เรื่องที่จำเป็นจริงๆ
• Harness - ออฟฟิศของเขา เครื่องมือ กุญแจ และคนที่คอยตรวจงาน
• Evals - แบบทดสอบเดิมที่ทำทุกเดือน เพื่อให้คุณรู้ว่าเขาเก่งขึ้นจริงหรือเปล่า

AI agent ก็คือพนักงานคนนั้น โมเดลคือตัวบุคคล ส่วน 5 ชั้นนี้คือทุกอย่างที่อยู่รอบๆ ตัวเขา ถ้าทำ 5 ชั้นนี้ได้ถูกต้อง ทีมเล็กๆ ก็สามารถรับงานที่เคยต้องจ้างคนเพิ่มมาทำได้ งานที่ทำซ้ำๆ จะถูกส่งไปให้ agent ที่พร้อมใช้งานจริงในระบบ production ส่วนคนของคุณก็จะเก็บหน้าที่ตัดสินใจไว้ นี่คือหน้าตาของการขยายธุรกิจโดยไม่ต้องเพิ่มจำนวนคนในทางปฏิบัติ

ในแต่ละชั้น ผมจะอธิบายว่ามันคืออะไร ทำงานอย่างไร ควรใช้ตอนไหน และสร้างมันขึ้นมาได้อย่างไร

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

Viktor คือพนักงาน AI ที่อยู่ใน Slack หรือ Microsoft Teams ของคุณ เขานั่งอยู่ในแชแนลเดียวกับคนอื่นๆ และทำงานเหมือนเพื่อนร่วมทีมคนหนึ่ง ที่คุณเพิ่มเข้ามาได้โดยไม่ต้องเปิดรับสมัครตำแหน่งใหม่

การทำงานกับเขาก็เหมือนการทำงานกับคนจริงๆ:

• คุณแท็กเขาในแชแนลหรือเธรด แล้วอธิบายงานที่ต้องการ
• เขาจะคิดหาขั้นตอน ทำงานข้ามเครื่องมือต่างๆ ที่คุณมี แล้วโพสต์ผลลัพธ์กลับลงมาในเธรดเดิม

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

pic1. 5 ชั้นของ agent

1. Context engineering

นิยาม

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

โมเดลก็คือพนักงานคนนั้น ส่วนโต๊ะก็คือ context window: ทุกอย่างที่โมเดลมองเห็นก่อนจะตอบ ทั้งคำสั่งของคุณ ประวัติแชท เอกสารที่ดึงมาจากฐานข้อมูล และผลลัพธ์จากทุกเครื่องมือที่มันรัน

Context engineering คือการตัดสินใจว่าจะวางอะไรไว้บนโต๊ะ และวางตรงไหน

หลักการทำงาน

Context เยอะกว่าไม่ได้แปลว่าคำตอบจะดีกว่าเสมอไป พอถึงจุดหนึ่ง มันกลับทำให้คำตอบแย่ลงด้วยซ้ำ

Stanford เคยทดสอบเรื่องนี้โดยตรง เมื่อป้อนเอกสาร 20 ถึง 30 ฉบับให้โมเดล ความแม่นยำในการตอบคำถามจากเอกสารที่อยู่ตรงกลางจะลดลงเหลือประมาณ 50 ถึง 57 เปอร์เซ็นต์ แต่ถ้าไม่ให้เอกสารเลยสักฉบับ โมเดลตัวเดิมกลับทำคะแนนได้ 56 เปอร์เซ็นต์ คำตอบอยู่ในหน้าต่างนั้นแล้วแท้ๆ แต่โมเดลกลับทำผลงานได้แย่กว่าตอนไม่มีอะไรเลย

สาเหตุหลักมีสองอย่าง:

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

กลไกเดียวที่ควรรู้จักคือ prompt caching ผู้ให้บริการจะเก็บส่วนต้นของ prompt ไว้แล้วนำมาใช้ซ้ำในการเรียกครั้งถัดไป ซึ่ง cached token จะมีราคาถูกกว่า token ใหม่ประมาณสิบเท่า

แต่ข้อควรระวังคือ cache จะทำงานได้ก็ต่อเมื่อส่วนต้นนั้นเหมือนกันทุกตัวอักษร (byte for byte) เปลี่ยนอักขระเดียวตรงด้านบน ทุกอย่างหลังจากนั้นจะถูกคิดราคาเต็มทันที ดังนั้นลำดับจึงสำคัญเสมอ: เอาข้อมูลที่คงที่มาไว้ก่อน ข้อมูลที่เปลี่ยนบ่อยไว้ทีหลัง

วิธีสร้าง

Context ทุกชิ้นจะต้องไปอยู่ใน 4 จุดนี้จุดใดจุดหนึ่ง:

1. System prompt เฉพาะสิ่งที่ต้องเป็นจริงในทุกการเรียกใช้งานเท่านั้น เช่น บทบาท ข้อจำกัด รูปแบบผลลัพธ์ ต้องทำให้เหมือนกันทุกตัวอักษร ห้ามใส่ timestamp ไว้ด้านบน ห้ามเรียง JSON key แบบสุ่ม
2. Tools อย่าเพิ่มหรือลบเครื่องมือระหว่างสนทนา เพราะจะทำให้ cache พัง และโมเดลอาจไปเรียกใช้เครื่องมือที่ไม่มีอยู่แล้ว หากต้องการจำกัดการใช้เครื่องมือในบางขั้นตอน ให้บล็อกการเรียกใช้ แต่เก็บนิยามไว้
3. Disk อะไรที่ใหญ่หรือต้องใช้ยาวๆ ให้เก็บไว้ในไฟล์ แล้วใส่แค่ path ไว้ในหน้าต่าง ทำแบบเดียวกันกับเว็บเพจ: เก็บ URL ไว้ ตัดเนื้อหาทิ้ง ตัดเนื้อหาออก แต่เก็บคีย์ที่ใช้ดึงกลับมา
4. Tail ทุกๆ สองสามขั้นตอน ให้ระบุเป้าหมายปัจจุบันซ้ำอีกครั้งใกล้ๆ ท้าย context คุณแก้ส่วนกลางไม่ได้ ดังนั้นอย่าเอาเรื่องสำคัญไปไว้ตรงนั้น

Tools ก็มีขีดจำกัดเช่นกัน Anthropic วัดพบว่านิยามเครื่องมือ 58 ตัวกิน token ไปราวๆ 55,000 token ก่อนที่ผู้ใช้จะพิมพ์อะไรด้วยซ้ำ การปล่อยให้โมเดลค้นหาเครื่องมือแทนที่จะโหลดมาทั้งหมด ทำให้ Opus 4 ทำคะแนน benchmark เพิ่มขึ้นจาก 49 เป็น 74 เปอร์เซ็นต์

ถ้ามีเครื่องมือน้อยกว่า 20 ตัว ให้โหลดค้างไว้เลย ถ้าเกินกว่านั้นให้เปลี่ยนมาใช้การค้นหาแทน

อีกเทคนิคสำหรับงานใหญ่ๆ: ส่ง sub-agent ไป มันจะอ่านไฟล์ 50 ไฟล์ในหน้าต่างของตัวเอง แล้วส่งสรุปย่อหน้าเดียวกลับมา context หลักของคุณจะเห็นแค่สรุปนั้นเท่านั้น

pic2. อะไรบ้างที่อยู่ในหนึ่งการเรียกใช้โมเดล

ทางลัด

Viktor รับภาระส่วนใหญ่ตรงนี้ไปจากคุณแล้ว เพราะ context ของเขาอยู่ในระดับบริษัท

• Memory เขาจดจำข้อมูลธุรกิจของคุณอย่างต่อเนื่องครอบคลุมทั้งทีม สิ่งที่เขาเรียนรู้จากผู้ร่วมก่อตั้งของคุณเมื่อสัปดาห์ที่แล้ว ไม่ต้องมานั่งแปะใหม่ในคำสั่งวันนี้
• Connected sources เมื่อเชื่อมต่อกับ Notion, Google Drive หรือ HubSpot แล้ว คุณไม่ต้องมานั่งแปะไฟล์ลงในแชทอีกต่อไป แค่บอกชื่อเอกสารหรือเรกคอร์ด เขาก็ไปอ่านจากต้นทางได้เลย นี่คือกฎ disk ที่ทำให้คุณเสร็จสรรพ
• Skills คุณอัดหน้าจอตอนทำงานสักอย่างแค่ครั้งเดียว เขาจะแปลงวิดีโอเป็นขั้นตอนการทำงานแบบข้อความให้คุณตรวจแก้และอนุมัติ หลังจากนั้นคำสั่งนั้นจะถูกตรึงไว้และผ่านการตรวจสอบแล้ว เหมือน system prompt ที่ดี

สิ่งที่คุณต้องทำที่เหลือ:

• เขียน company brief สั้นๆ ครั้งเดียว: ขายอะไร ใครซื้อ ตัวเลขไหนสำคัญ และอะไรที่เขาห้ามทำเด็ดขาด
• หนึ่งงานต่อหนึ่งเธรด พร้อมระบุว่า "เสร็จ" หมายถึงอะไรในข้อความแรก
• ถ้าเขาจำอะไรผิดๆ ให้ล้าง memory จากหน้า settings แทนที่จะมานั่งแก้ในทุกเธรด

2. Loop engineering

นิยาม

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

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

หลักการทำงาน

Loop คือการทำ 4 ขั้นตอนวนซ้ำ: คิด ลงมือ สังเกต ตัดสินใจ การแก้บั๊กจะเป็นแบบนี้:

1. รันเทสต์ มี 3 ตัวไม่ผ่าน
2. อ่าน error แรก พบว่า import หายไป
3. เพิ่ม import แล้วรันใหม่
4. ยังมีเทสต์ไม่ผ่านอีก 1 ตัว อ่าน error นั้น แก้ไข แล้วรันใหม่
5. ผ่านหมด หยุด

ไม่มีใครเขียนขั้นตอนพวกนี้ไว้ล่วงหน้า โมเดลเลือกแต่ละขั้นหลังจากเห็นผลลัพธ์ของขั้นก่อนหน้า

นั่นคือความแตกต่างทั้งหมด 100 ขั้นที่คุณเขียนไว้ก็ยังเป็น workflow แต่ 3 ขั้นที่โมเดลเลือกเองคือ loop

ใช้ loop เฉพาะตอนที่คุณเขียนขั้นตอนล่วงหน้าไม่ได้เท่านั้น ถ้าเขียนได้ก็เขียนไปเลย workflow ถูกกว่า รันขนานกันได้ และถ้าขั้นที่สี่พัง คุณก็แค่รันขั้นที่สี่ใหม่ ไม่ใช่เริ่มทั้งหมด

Loop ยังแพงอีกด้วย agent หนึ่งตัวใช้ token ประมาณสี่เท่าของการเรียกใช้ครั้งเดียว ส่วนระบบ multi agent ใช้ประมาณสิบห้าเท่า

วิธีสร้าง

Loop ต้องการ 4 องค์ประกอบ ขาดไปอย่างใดอย่างหนึ่งมันจะไม่ทำงาน:

1. เป้าหมายที่มีคำว่า "เสร็จ" ชัดเจน ไม่ใช่ "แก้บั๊ก" แต่ต้องเป็น "เทสต์ที่ไม่ผ่านใน auth_test.py ต้องผ่าน และไม่มีอะไรอื่นพังเพิ่ม"
2. Checker สิ่งที่อยู่นอกโมเดลที่บอกว่าผ่านหรือไม่ผ่าน เช่น test suite, compiler, linter งานวิจัยเรื่องการแก้ไขตัวเอง (self correction) ชี้ตรงกันว่า มันจะได้ผลเมื่อมี feedback จากภายนอกจริงๆ และจะล้มเหลวเมื่อปล่อยให้โมเดลรีวิวตัวเอง ไม่มี checker ก็ไม่มี loop มีแต่การเผาเงินแบบไร้จุดหมาย
3. Stop rule Checker บอกว่าผ่าน หรือครบจำนวนรอบที่กำหนด หรือสองครั้งล่าสุดให้ผลลัพธ์เหมือนกัน
4. Budget ทั้งจำนวนรอบและจำนวนเงิน

ในโค้ด ทั้งหมดนี้อยู่ในไม่กี่บรรทัด:

1for turn in range(MAX_TURNS):
2    action = model.next_step(goal, history)
3    result = run(action)
4    history.append(result)
5
6    if checker(result):       break   # เสร็จแล้ว
7    if repeated(history, 2):  break   # ติดลูป
8    if spent() > BUDGET:      break   # แพงเกินไป
9else:
10    fallback_workflow(goal)

เซ็ตอัปที่ดีที่สุดในระบบ production ที่ผมเคยเห็นเผยแพร่มาคือแบบผสม (hybrid) Atlan จะรัน deterministic filter ก่อน และมี alert ขาเข้าเพียงประมาณ 14 เปอร์เซ็นต์เท่านั้นที่ไปถึง agent

จากนั้น loop จะได้วิ่งสูงสุด 3 รอบ ถ้าความมั่นใจยังต่ำกว่า 50 เปอร์เซ็นต์หลังจากรอบที่สาม Python workflow แบบตายตัวจะมารับช่วงต่อ

กรองก่อน ลูปสั้นๆ แล้วมีแผนสำรอง

pic3. วิธีเลือกระหว่าง workflow กับ loop

ทางลัด

ทุกงานที่คุณมอบให้ Viktor ในเธรดคือ loop คุณเขียนเป้าหมาย เขาเลือกขั้นตอน ทำงานผ่านเครื่องมือต่างๆ แล้วกลับมาที่เธรดพร้อมผลลัพธ์

องค์ประกอบทั้ง 4 แมปกันได้ดังนี้:

• Goal เขาจะทักท้วงถ้าบรีฟไม่ครบถ้วน และเลือกที่จะถามแทนการเดา แต่คุณก็ต้องเขียนคำว่า "เสร็จ" ให้ชัด "รายงานรายได้สัปดาห์ที่แล้ว ยอดรวมตรงกับ Stripe โพสต์ใน #finance ภายใน 9 โมงเช้าวันจันทร์" ดีกว่าคำว่า "ทำรายงานมา" มาก
• Checker เขาจะแจ้งเตือนตัวเลขที่ดูผิดปกติก่อนโพสต์ ทำให้แข็งแกร่งขึ้นด้วยการระบุแหล่งข้อมูลที่ต้องเทียบ: ยอดรวม Stripe, จำนวนแถว, test suite
• Stop rule การกระทำที่ละเอียดอ่อนจะหยุดรอคนยืนยัน และผลลัพธ์จะกลับมาหาคุณเสมอ
• Budget เครดิต ระดับ reasoning จะเป็นตัวกำหนดราคาของแต่ละขั้นตอน และสำหรับงานที่ทำประจำ ความถี่ก็สำคัญ รายงานรายชั่วโมงแพงกว่ารายสัปดาห์มาก

ระบบ hybrid ของ Atlan ก็ใช้ได้โดยไม่ต้องเขียนโค้ด งานที่ทำซ้ำๆ จะกลายเป็น scheduled task: เขาจะเสนอขึ้นมา และมันจะหยุดรอจนกว่าคุณจะอนุมัติ นั่นคือ workflow ของคุณ

อะไรที่เปิดกว้างให้โยนเข้าเธรด นั่นคือ loop ของคุณ และคุณคือแผนสำรอง

3. Jev engineering

นิยาม

ผู้เชี่ยวชาญในออฟฟิศไม่ได้เป็นคนแกะซองจดหมายทุกซอง คนที่เคาน์เตอร์ต้อนรับจะคัดแยกจดหมายให้: บิลกองหนึ่ง สแปมลงถัง สัญญาส่งทนาย

Agent ของคุณทำงานสองแบบ: เขียนบางอย่าง และตัดสินใจบางอย่าง ตอนนี้โมเดลใหญ่ตัวเดียวทำทั้งสองอย่าง เท่ากับคุณจ่ายค่าจ้างทนายมานั่งแยกจดหมาย

Jev คือพนักงานต้อนรับ เขาไม่เคยเขียน เขาแค่เลือก

หลักการทำงาน

คุณให้คำถามและตัวเลือกที่เป็นไปได้กับ Jev ไว้ล่วงหน้า มันจะคืนค่าออกมา 1 ใน 3 แบบ พร้อมคะแนนความมั่นใจ:

• ใช่ หรือ ไม่ใช่
• ตัวเลือกหนึ่งข้อจากชุดที่ให้ไป
• ตัวเลขบนสเกล

เพราะมันแค่เลือก มันจึงเร็วและถูก ตัวเลขที่เคลมไว้คือ 70 ถึง 500 มิลลิวินาที เทียบกับ 3 ถึง 329 วินาที และ $0.042 ต่อล้าน input token โดย output ไม่คิดเงิน

ทีนี้มาพูดความจริงกัน Jev เพิ่งเปิดตัวได้สองสัปดาห์ และการทดสอบอิสระก็เพิ่งเริ่มทยอยออกมา

• ในการจัดหมวดหมู่อีเมล logistic regression ธรรมดาๆ ทำได้ถึง 98.9 เปอร์เซ็นต์ ขณะที่ Jev ได้ 98.6
• ในการตรวจจับฟิชชิง Jev ได้ 62.6 เปอร์เซ็นต์ ในขณะที่ Claude Haiku 4.5 ได้ 81.3
• ตัวเลข "zero hallucinations" มาพร้อมเชิงอรรถของผู้เขียนเองว่า: นี่ไม่ใช่ผลเชิงประจักษ์ มันแค่หมายความว่าผลลัพธ์ตรงกับ schema เสมอ

คะแนนความมั่นใจก็ไม่ใช่ probability จริงๆ ตั้งแต่แกะกล่อง ให้มองมันเป็น ranking แล้วตั้ง threshold ด้วยข้อมูล labeled data ของคุณเอง

วิธีสร้าง

เซ็ตอัปที่สมเหตุสมผลคือการวาง gate ไว้หน้าโมเดลแพงๆ:

1. ทุกอย่างไหลเข้ามา
2. Jev ตอบคำถามแคบๆ หนึ่งข้อเกี่ยวกับแต่ละรายการ
3. มั่นใจและเป็นงานรูทีน: จัดการแบบถูกๆ ติดป้าย ส่งต่อ หรือตัดทิ้ง
4. ไม่แน่ใจหรือผิดปกติ: ส่งไปให้โมเดลหลัก

1d = jev.choose(item, options=["spam", "order_status", "refund", "other"])
2
3if d.confidence >= 0.7 and d.option != "other":
4    handle_cheap(d.option, item)
5else:
6    main_model(item)   # fail closed: ถ้าไม่แน่ใจให้ส่งไปเส้นทางที่แพงกว่า

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

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

pic4. คำถาม 3 แบบที่ Jev ตอบได้

ทางลัด

Jev ไม่ได้เป็นส่วนหนึ่งของ stack ที่ Viktor เผยแพร่ แต่แนวคิดนี้เอาไปใช้ได้ในสองจุดที่คุณควบคุมได้:

• ระดับ reasoning เขารันได้ 3 ระดับ: Smart บน Claude Opus, Balanced บน Claude Sonnet ราคาถูกลงครึ่งหนึ่ง และ Ultra บน Claude Fable แพงขึ้นสองเท่า การคัดแยกคำขอหรือดึงตัวเลขมาสักตัวไม่จำเป็นต้องใช้ระดับท็อป
• Gate ที่อยู่หน้าเขา ถ้าคุณอยากให้เขารับมือกับสตรีมข้อมูลอย่างอีเมลซัพพอร์ตหรือ alert อย่าโยนมาให้ทั้งสตรีม วาง classifier หรือเรียก Jev ก่อน เพื่อให้เฉพาะรายการที่ต้องใช้การตัดสินจริงๆ กลายเป็นงานของเขา

นี่คือหนึ่งในสองชั้นที่ทักษะ engineering ของคุณเองยังคงมีความสำคัญ แม้จะใช้ Viktor ก็ตาม

4. Harness engineering

นิยาม

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

ทักษะเหมือนกัน แต่ผลลัพธ์ต่างกันลิบลับ พนักงานคือโมเดล ออฟฟิศคือ harness

Agent = model + harness

หลักการทำงาน

Harness คือทุกอย่างที่ไม่ใช่โมเดล: tools, permissions, sandbox, ไฟล์ที่อธิบายโปรเจกต์, การตรวจสอบ output

มันกลายเป็นศาสตร์ของตัวเองในปี 2026 เพราะคนเริ่มวัดผล และพบว่าโมเดลอธิบายผลลัพธ์ได้น้อยกว่าที่คิด:

• Anthropic เปลี่ยนแค่ container resources ก็ทำให้คะแนน benchmark ขยับไปถึง 6 คะแนน
• LangChain ล็อกโมเดลไว้แล้วเปลี่ยนแค่ harness ก็ทำให้คะแนน benchmark เดิมขยับไป 13.7 คะแนน
• จากนั้นพวกเขาปรับแต่ง harness รอบๆ open model ที่ถูกกว่าสิบเท่า จนทำคะแนนได้ 0.86 เทียบกับ 0.87 ของ Opus 4.8

คุณไม่ได้ซื้อโมเดลอีกต่อไปแล้ว คุณกำลังซื้อโมเดลพร้อมกับ harness ไปด้วยกัน

คุณต้องมีมันทันทีที่ agent ไปแตะอะไรที่เป็นของจริง: repo, inbox, การชำระเงิน, ฐานข้อมูล production

วิธีสร้าง

สร้างจากข้างนอกเข้าไปข้างใน:

1. Containment สิ่งที่ agent เข้าถึงไม่ได้ทางกายภาพ เช่น container, branch แยก, database user แบบ read only, ไม่มีเน็ตเวิร์กนอกจาก allowlist ทำสิ่งนี้ก่อน prompt แรก
2. Guides สิ่งที่คอยนำทางก่อนที่มันจะลงมือทำ ไฟล์ใน repo อย่าง AGENTS.md, คำอธิบายเครื่องมือที่ชัดเจนพอให้โมเดลเลือกถูก, ตัวอย่าง output ที่ดีสักสองสามตัวอย่าง
3. Sensors สิ่งที่คอยตรวจสอบหลังจากมันลงมือทำ Linter, type checker, test suite: เร็วและแน่นอน ดังนั้นให้รันกับทุกอย่าง ส่วนการตรวจที่ช้ากว่า เช่น ให้โมเดลที่สองมารีวิว diff ให้ทำเฉพาะเรื่องที่จำเป็น
4. Permissions เวลา agent ขอ approval คนกดอนุมัติให้ถึง 93 เปอร์เซ็นต์ หน้าจอขออนุมัติแทบไม่ได้ป้องกันอะไรเลย การป้องกันจริงๆ คือการกระทำที่มันทำไม่ได้ตั้งแต่แรก เก็บ approval ไว้สำหรับไม่กี่อย่างที่กู้คืนไม่ได้จริงๆ เท่านั้น

ไฟล์ guide ไม่จำเป็นต้องยาว แค่สี่บรรทัดก็เปลี่ยนพฤติกรรมได้แล้ว:

1# AGENTS.md
2- Monorepo: /api (FastAPI), /web (Next.js), /jobs (cron)
3- รันเทสต์ด้วย `make test` ต้องผ่านทั้งหมดก่อน commit
4- ห้ามแก้ /migrations ด้วยมือ ให้ใช้ `make migration`
5- DB access เป็นแบบ read only เท่านั้น ถามก่อนเปลี่ยน schema ทุกครั้ง

Hooks คือเวอร์ชันบังคับใช้ของแนวคิดเดียวกัน ใน Claude Code hook คือสคริปต์เล็กๆ ที่รันก่อนการเรียกใช้เครื่องมือ และสามารถบล็อกมันได้ กฎอย่าง "ห้าม push ไป main" ใช้เป็น hook ได้ผลดีกว่าการเขียนเป็นบรรทัดหนึ่งใน prompt

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

กลับมาทบทวน harness ของคุณทุกๆ สองสามเดือน และลบสิ่งที่โมเดลโตเกินกว่าจะใช้ออกไป

pic5. วงแหวน 4 ชั้นของ harness

ทางลัด

ถ้า agent = model + harness สิ่งที่คุณได้จาก Viktor ส่วนใหญ่คือ harness โมเดลข้างใต้คือ Claude ทุกอย่างรอบๆ โมเดลมาพร้อมใช้งาน:

• Tools อินทิเกรชันกว่า 3,200 รายการ: GitHub, Linear, HubSpot, Stripe, Notion, Google Drive และอื่นๆ สำหรับเครื่องมือที่ยังไม่มี connection สำเร็จรูป เขาสร้างเองได้
• Guides Skills แทนที่คุณจะนั่งเขียน AGENTS.md เอง คุณแค่อัดหน้าจอ เขาจะร่างขั้นตอนขึ้นมา แล้วคุณค่อยแก้ไข
• Sensors เขาจะแจ้งเตือนข้อมูลที่ขัดแย้งกัน และตั้งคำถามเมื่อบรีฟขาดรายละเอียด และทุกขั้นตอนจะปรากฏในเธรด Slack ที่ทีมคุณอ่านได้
• Permissions อีเมลลูกค้าและการเปลี่ยนแปลงทางการเงินจะหยุดรอการอนุมัติ ระบบ automation ตามกำหนดการใหม่ๆ จะหยุดรอจนกว่าจะมีคนเปิดใช้งาน

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

• database user แบบ read only
• Stripe key ที่จำกัดสิทธิ์
• shared support inbox ไม่ใช่อีเมลส่วนตัวของคุณ
• GitHub token ที่ scope เฉพาะ repo ที่ต้องการ

อะไรที่เขาเข้าไม่ถึง เขาก็ทำลายไม่ได้

pic6. Harness ของ Viktor

5. Evals engineering

นิยาม

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

ถ้าไม่มีข้อสอบชุดเดิม ทุกการเปลี่ยนแปลงที่คุณทำคือการเดาล้วนๆ Evals คือข้อสอบชุดนั้นสำหรับ agent ของคุณ: ชุดงานที่คุณรู้คำตอบที่ถูกต้องอยู่แล้ว ซึ่งจะถูกรันทุกครั้งที่คุณเปลี่ยนอะไรบางอย่าง

หลักการทำงาน

การตรวจสอบมีสองแบบ:

• End to end คำตอบสุดท้ายออกมาถูกไหม? มันบอกแค่ว่าคะแนนเปลี่ยน แต่ไม่บอกว่าทำไม
• Behavioral มีเหตุการณ์เฉพาะเจาะจงเกิดขึ้นไหม? มันเรียก search ก่อนตอบหรือเปล่า มันถามกลับเพื่อความชัดเจนไหมตอนที่ได้รับคำสั่งคลุมเครือ มันตรวจสอบก่อนบอกว่าเสร็จหรือเปล่า

Behavioral checks จะรันบน trace ซึ่งเป็น log ของทุกอย่างที่ agent ทำ ไม่ใช่แค่คำตอบสุดท้าย กฎของ Google คือชุดทดสอบนี้ต้องจบภายในห้าวินาที เพื่อที่จะรันได้ทุกครั้งที่มีการเปลี่ยนแปลง

ถ้าใช้โมเดลเป็นตัวให้คะแนน นั่นคือ judge และ judge ก็ต้องถูกตรวจสอบเช่นกัน Airbnb พบว่าประมาณสามในสี่ของ reference answers ที่สร้างโดยโมเดลให้ผลลัพธ์ต่างกันเมื่อรัน input เดิมซ้ำๆ eval ของพวกเขากำลังวัด noise ของตัวเองอยู่

วิธีสร้าง

1. เริ่มจากความล้มเหลวจริง ไปดูการรันจริง หาว่าอะไรผิดพลาด แล้วแปลงแต่ละกรณีเป็น test case golden sets ของ Airbnb ใช้ตัวอย่าง 50 ถึง 100 กรณี และต้องมีกรณีที่ล้มเหลวรวมอยู่ด้วย
2. เขียน behavioral check หนึ่งข้อต่อหนึ่งกรณี หนึ่งกรณี ตรวจสอบหนึ่งอย่าง
3. ตรวจสอบ judge ของคุณ ลองให้คะแนนกลุ่มตัวอย่างด้วยมือ แล้วดูว่าคุณกับโมเดลเห็นตรงกันบ่อยแค่ไหนก่อนที่จะเชื่อใจมัน
4. Sample production Airbnb ดึง live traffic มา 5 เปอร์เซ็นต์ทุกวัน ชุด eval ของคุณจะเสื่อมสภาพลงเรื่อยๆ เมื่อการใช้งานจริงเบี่ยงเบนออกไปจากมัน

กรณีทดสอบเดียวอาจเล็กแค่นี้:

1input: "Refund order #1042, customer says it arrived broken"
2expect:
3  - looks up the order before replying
4  - asks for approval before issuing the refund
5check:
6  - trace has get_order before send_reply
7  - trace has approval_request before refund

อย่า盯着ดูแค่ pass rate รวม มันอาจสูงขึ้นในขณะที่พฤติกรรมบางอย่างพังเงียบๆ ให้ดูผลการตรวจสอบแต่ละข้อ

pic7. eval cases ที่ดีมาจากไหน

ทางลัด

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

• หลังจากผ่านไปสองสัปดาห์ เลือกเธรดของเขาสัก 20 เธรดที่คุณรู้คำตอบที่ถูกต้อง รวมทุกเธรดที่คุณต้องเข้าไปแก้ให้เขาด้วย
• เขียน check ธรรมดาๆ หนึ่งข้อต่อหนึ่งกรณี เขาลิงก์แหล่งที่มาของทุกตัวเลขไหม เขาถามกลับไหมตอนบรีฟคลุมเครือ เขาหยุดรอก่อนปล่อยอะไรออกนอกบริษัทหรือเปล่า
• รันชุดทดสอบใหม่ทุกครั้งที่มีการเปลี่ยนแปลง: skill ใหม่ บรีฟที่แก้ไข หรือ tier ที่ต่างออกไป การย้ายจาก Smart ไป Balanced ประหยัดเครดิตได้ประมาณครึ่งหนึ่ง ดังนั้นทดสอบก่อนเปลี่ยนถาวร
• สัปดาห์ละครั้ง ให้คะแนน 5 เธรดแบบสุ่มด้วยมือ

ประกอบร่างเข้าด้วยกัน

5 ชั้น 5 คำถาม Context คือสิ่งที่มันเห็น Loop คือใครเป็นคนตัดสินใจ Jev รับหน้าที่ตัดสินใจที่ถูกๆ Harness คือสิ่งที่มันเข้าถึงได้และใครเป็นคนตรวจงาน Evals คือวิธีที่คุณจะรู้ได้ว่ามันดีขึ้นจริง

กับ Viktor สามชั้นมาในตัวเกือบหมดแล้ว: context, loop และ harness ส่วน Jev, evals และ credentials ที่คุณส่งมอบ ยังคงเป็นงาน engineering ของคุณ

ถ้าคุณเริ่มวันนี้ นี่คือท่าที่ถูกและมีประโยชน์ที่สุดของแต่ละชั้น:

• Context: ย้ายคำสั่งที่คงที่เข้าไปใน system prompt แล้วเลิกแก้ไปแก้มัน
• Loop: ตั้งขีดจำกัดจำนวนรอบและขีดจำกัดเงินไว้ก่อนปล่อยมันรัน
• Jev: ติดป้ายตัวอย่าง 200 เคสสำหรับสิ่งที่ agent ของคุณต้องตัดสินใจบ่อยที่สุด
• Harness: รัน agent ในฐานะ user ที่ลบอะไรไม่ได้เลย
• Evals: จดความล้มเหลว 5 ครั้งล่าสุดของคุณมาเป็น test cases

บน Viktor วันเดียวกันจะหน้าตาแบบนี้:

• Context: เขียน company brief และอัด skill แรกของคุณ
• Loop: ใส่คำจำกัดความของคำว่า "เสร็จ" ในทุกงาน และเลือก tier อย่างตั้งใจ
• Jev: กรองสตรีมข้อมูลก่อนที่มันจะกลายเป็นงานของเขา
• Harness: เชื่อมต่อเขาด้วย credentials แบบ read only ที่จำกัดขอบเขต
• Evals: เซฟ 20 เธรดจริงไว้เป็นชุดทดสอบแรกของคุณ

นั่นคืองานหนึ่งวันที่ครอบคลุมทั้ง 5 ชั้น

ความเห็นของผม: โมเดลไม่ใช่ส่วนที่ยากอีกต่อไปแล้ว 5 ชั้นรอบๆ มันต่างหากที่ยาก ทำมันให้ถูก แล้วคุณจะเพิ่มศักยภาพได้โดยไม่ต้องเพิ่มคน ทีมส่วนใหญ่ควรหยิบสามชั้นแรกมาใช้แบบสำเร็จรูป แล้วเอาเวลาของตัวเองไปทุ่มกับอีกสองชั้นที่กำหนดคุณภาพ นั่นคือการตัดสินใจที่ถูกๆ และ evals

ขอบคุณ Viktor ที่สนับสนุนบทความนี้

ทดลองใช้ฟรีได้ที่ @viktor_com เครดิต $100 ไม่ต้องผูกบัตร ลิงก์เต็มอยู่ในคอมเมนต์แรกของผม

ใช้โค้ด YARCHI100 ตอนสมัคร

Paid Partnership