GPT-5.6 Luna Max: นักพัฒนาใช้งานจริงใน Codex อย่างไร — และจุดที่มันพัง

เมื่อวันที่ 1 สิงหาคม ไฟล์คอนฟิกสี่บรรทัดเริ่มถูกแชร์ต่อบน X ไฟล์นี้สร้างเอเจนต์ Codex ที่ชื่อว่า luna_worker, กำหนดโมเดลเป็น gpt-5.6-luna, ตั้งค่าระดับการใช้เหตุผลเป็น max, และมอบงานครึ่งที่น่าเบื่อของคุณให้มัน ขณะที่ GPT-5.6 Sol ยังคงดูแลแผนการอยู่ ภายในไม่กี่วัน สูตรเดียวกันนี้ถูกแชร์ต่อเป็นภาษาอังกฤษ จีน ญี่ปุ่น เกาหลี สเปน และอาหรับ และปลั๊กอินที่สร้างจากแนวคิดเดียวกันก็ทะลุ 1,300 ดาวบน GitHub ภายในสี่วัน นอกจากนี้ มันยังเป็นวิธีเชื่อมต่อที่ผิด เกือบจะตรงกับวันที่มันกลายเป็นไวรัลพอดี: ผู้เขียนปลั๊กอินนั้นดึง GPT-5.6 Luna ออกจากโปรเจกต์ของตัวเองภายใน 48 ชั่วโมง อย่างเปิดเผย เพราะเพื่อนร่วมงานบอกเขาว่ามันใช้ไม่ได้ในฐานะซับเอเจนต์ของ Codex — จากนั้นก็ใส่กลับเข้าไปสองวันต่อมา โดยเชื่อมต่อด้วยวิธีที่แตกต่างไปโดยสิ้นเชิง

เรื่องทั้งหมดนั้นเกิดขึ้นภายในหนึ่งสัปดาห์ และมันเป็นสิ่งที่มีประโยชน์ที่สุดที่ใครก็ตามเคยเผยแพร่เกี่ยวกับโมเดลนี้ มันบอกให้รู้ว่ารูปแบบคนงานราคาถูก (cheap-worker pattern) เป็นเรื่องจริง วิธีที่ดูเหมือนชัดเจนในการต่อมันนั้นเป็นวิธีที่ผิด และความแตกต่างระหว่างสองแบบนี้คือคุณค่าส่วนใหญ่ ทุกอย่างในบทความนี้ที่เกี่ยวกับเทคนิคล้วนมาจากผู้ปฏิบัติจริงที่โพสต์ผลลัพธ์ของตนเองระหว่างวันที่ 30 กรกฎาคม ถึง 5 สิงหาคม 2026 — ไม่ใช่จากเอกสารของบริษัท ซึ่งบรรยาย GPT-5.6 Luna ว่าเป็นโมเดลสำหรับ "งานปริมาณมากที่คำนึงถึงต้นทุน" และไม่ได้พูดถึงสิ่งเหล่านี้เลยสักนิด หากตัวเลขใดวัดโดยบุคคลที่สามที่เป็นอิสระ เราก็บอกไว้อย่างนั้น หากเป็นบันทึกเซสชันของนักพัฒนาคนใดคนหนึ่ง เราก็บอกเช่นกัน รวมถึงเมื่อมันขัดแย้งกันเอง และมันขัดแย้งกันบ่อยมาก

'Luna Max' คืออะไร และทำไมคนส่วนใหญ่จึงไม่เคยเห็นมัน

ไม่มีโมเดลที่ชื่อว่า Luna Max มีตัวปรับสองตัว และ Luna Max คือหนึ่งในชุดค่าผสมของมัน: ระดับที่ถูกที่สุดของตระกูล GPT-5.6 ที่รันด้วยการตั้งค่าการคิดขั้นสูงสุด ตัวปรับระดับเลือกระหว่าง GPT-5.6 Sol, GPT-5.6 Terra และ GPT-5.6 Luna ส่วนตัวปรับความพยายามมีหกตำแหน่ง — none, low, medium, high, xhigh และ max — และเป็นตัวกำหนดว่าโมเดลจะใช้ความคิดมากแค่ไหนก่อนจะตอบ

แทบไม่มีใครรวมระดับราคาถูกเข้ากับการตั้งค่าแบบลึก ด้วยเหตุผลธรรมดาๆ: max ถูกซ่อนไว้ตามค่าเริ่มต้น ในแอปเดสก์ท็อป ChatGPT/Codex มันถูกซ่อนอยู่ใน Settings → Configuration → Available reasoning efforts โดยรายการที่ให้มาจะมีตัวเลือกด้านบนไม่ถูกเลือกไว้ นักพัฒนาที่ไม่เกี่ยวข้องกันหกคนโพสต์วิธีแก้แบบสามคลิกเดียวกันในสัปดาห์แรกของเดือนสิงหาคม ซึ่งเป็นตัวบ่งชี้ที่ดีว่ามีคนจำนวนเท่าไรที่รัน Luna ด้วยความลึกเริ่มต้นและตัดสินโมเดลจากค่านั้น ในฝั่ง API ไม่มีสวิตช์ให้ค้นหา: คุณส่งรหัสโมเดล gpt-5.6-luna และตั้งค่าระดับการใช้เหตุผลเป็น max ใน body ของคำขอ และนั่นคือทั้งหมดที่ต้องเปลี่ยนแปลง.

ผลที่ควรทำความเข้าใจไว้อย่างหนึ่งก่อนที่คุณจะอ่าน benchmark ใดๆ: เมื่อ Artificial Analysis เผยแพร่คะแนนความฉลาดสำหรับโมเดลนี้ หน้าจะมีชื่อว่า GPT-5.6 Luna (max). ตัวเลขจากหน่วยงานอิสระที่ทุกคนอ้างถึงสำหรับ Luna คือการกำหนดค่าแบบใช้ความพยายามสูงสุด หากคุณรันด้วยการตั้งค่าเริ่มต้นและสงสัยว่าทำไมประสบการณ์ของคุณจึงไม่ตรงกับลีดเดอร์บอร์ด นั่นคือสาเหตุ

แป้นหมุนที่ไม่มีใครอธิบาย: effort เปลี่ยนจำนวนโทเค็น ไม่ใช่ราคาโทเค็น

การเพิ่มความพยายามในการใช้เหตุผลไม่ได้ทำให้คุณย้ายไปยังระดับราคาที่แพงขึ้น GPT-5.6 Luna คิดค่าบริการ 0.20 ดอลลาร์ต่อล้านโทเคนอินพุต และ 1.20 ดอลลาร์ต่อล้านโทเคนเอาต์พุต ในการตั้งค่าระดับความพยายามทุกระดับ สิ่งที่เปลี่ยนแปลงคือจำนวนโทเคนที่โมเดลใช้เพื่อไปถึงคำตอบ — และที่ระดับสูงสุด มันใช้จำนวนมาก

Artificial Analysis วัดค่านี้ในระหว่างการรัน Intelligence Index ของตน และตัวเลขเหล่านี้คือการยืนยันอิสระที่ชัดเจนที่สุดเกี่ยวกับสิ่งที่ผู้ปฏิบัติงานบ่นว่า:

• คะแนน — 51 ใน Artificial Analysis Intelligence Index เทียบกับค่ามัธยฐานที่ 17 ของโมเดลที่วัดผลในระดับเดียวกัน

• ความฟุ่มเฟือย — สร้างโทเค็นเอาต์พุต 130 ล้านตัวตลอดการรันดัชนี เทียบกับค่ามัธยฐาน 61 ล้าน Artificial Analysis ระบุว่าโมเดลนี้ "ฟุ่มเฟือยมาก"

• ความเร็วดิบ — 182.5 โทเค็นเอาต์พุตต่อวินาที อยู่อันดับที่ 16 จาก 163 โมเดล เร็วต่อโทเค็น

• เวลาจนถึงโทเค็นแรก — ประมาณ 136 วินาทีที่ระดับความพยายามสูงสุด ซึ่ง Artificial Analysis ระบุว่าอยู่ในเกณฑ์ที่สูงแม้แต่สำหรับโมเดลใช้เหตุผลในกลุ่มราคานั้น

• ค่าใช้จ่ายทั้งหมด — $174.06 เพื่อประเมินโมเดลบนดัชนีทั้งหมด

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

สำหรับการเปรียบเทียบ: ในหน้าของโมเดลเราเองสำหรับ GPT-5.6 Luna ค่ามัธยฐานของเวลาที่ใช้เพื่อให้ได้โทเค็นแรกจากการใช้งานจริงตลอดเจ็ดวันคือ 1.78 วินาที โดยมีเปอร์เซ็นไทล์ที่ 95 เท่ากับ 9.26 วินาที นั่นไม่ได้ขัดแย้งกับตัวเลข 136 วินาที — เพราะเป็นโมเดลเดียวกันที่วัดจากการตั้งค่าความพยายามแบบผสม ซึ่งส่วนใหญ่ไม่ได้เป็นระดับสูงสุด ความหน่วงที่คุณได้รับเป็นคุณสมบัติของระดับที่คุณตั้งค่า ไม่ใช่ของปลายทางที่คุณเรียก

Luna Max เป็น "Sol Medium ในราคาหนึ่งในหก" จริงหรือ?

นี่คือคำกล่าวอ้างที่ทำให้รูปแบบนี้กลายเป็นไวรัล และมีต้นกำเนิดจาก Dan McAteer ซึ่งระบุว่า Luna ที่ระดับการใช้เหตุผลสูงสุดให้ผลลัพธ์ราว GPT-5.6 ส่วน Sol ที่ระดับกลาง หรือ Claude Opus 5 ที่ระดับกลาง ในราคาประมาณหนึ่งในหกของต้นทุน มันถูกพูดซ้ำโดยหลายบัญชี บางครั้งก็ตัดคำระวังออก และมันคุ้มค่าที่จะแยกสิ่งที่วัดได้ออกจากสิ่งที่มาจากความรู้สึก

กระดานคะแนนอิสระสนับสนุนในส่วนต้นทุนของข้ออ้างอย่างเต็มที่ และสนับสนุนในส่วนความสามารถเพียงบางส่วน ในการรันชุดเกณฑ์มาตรฐานเดียวกันด้วยความพยายามสูงสุดในหลายระดับ Artificial Analysis บันทึกว่า Luna ได้ดัชนี 51 ที่ราคา 174 ดอลลาร์ Terra ได้ 55 ที่ราคา 1,403 ดอลลาร์ Kimi K3 ได้ 57 ที่ราคา 2,437 ดอลลาร์ และ Sol ได้ 59 ที่ราคา 2,824 ดอลลาร์ Luna เสียคะแนนดัชนี 8 จุดให้กับ Sol แต่มีต้นทุนประมาณหนึ่งในสิบหกเมื่อต้องทำงานเดียวกัน

กระดานคะแนนอิสระเข้มข้นขึ้นเมื่อวันที่ 13 สิงหาคม เมื่อ DeepSWE ปล่อย v1.1 ซึ่งเป็นการปรับปรุงเกณฑ์ชี้วัดงานวิศวกรรมระยะยาวที่ยังคงโจทย์ดั้งเดิม 113 งานจาก 91 คลังซอฟต์แวร์ในห้าภาษา แต่ตอนนี้ให้คะแนนการแก้ไขแต่ละครั้งโดยการรัน diff ที่คอมมิตไว้ในคอนเทนเนอร์แบบแยกส่วน ซึ่งยากต่อการโกง บนกระดานที่อัปเดต GPT-5.6 ทั้งสามระดับที่ใช้ความพยายามสูงสุดยังได้ผลตรงตามที่รายงานในเดือนกรกฎาคม: Luna Max ได้ 67.2% pass@1 และ $0.61 ต่องาน Terra Max อยู่ราว 70% ส่วน Sol Max ได้ 73% ด้วยราคา $8.39 ซึ่งคืออัตราความสำเร็จที่สูงขึ้นหกจุด แต่มีค่าใช้จ่ายมากกว่าประมาณสิบสี่เท่า

การเปรียบเทียบที่ควรพิจารณาอีกรอบนั้นอยู่ต่ำกว่า Luna ไม่ใช่เหนือกว่า Claude Sonnet 5 Max ได้คะแนน 54% จาก 113 งานชุดเดียวกัน — ตามหลัง Luna Max อยู่ประมาณสิบสามจุด — ที่ราคา 26.40 ดอลลาร์ต่องาน ซึ่งคิดเป็นประมาณ 44 เท่าของที่ Luna จ่ายสำหรับการแก้ปัญหาเดียวกัน Luna Max ยังทำได้เหนือกว่า Gemini 3.7 Flash (65% สำหรับการตั้งค่าแบบใช้ความพยายามสูงบนกระดานเดียวกัน) โพสต์ในชุมชนที่ชี้ให้เห็นรอบนี้ระบุช่องว่างกับ Gemini 3.7 Flash Medium อยู่ที่ประมาณ 1.7 จุด DeepSWE คือโครงสร้างทดสอบอิสระของ Datacurve ไม่ใช่การประเมินของบริษัท — การอ้างสิทธิ์ของบริษัทเองที่ว่าตระกูล GPT-5.6 สร้างผลลัพธ์ระดับ state-of-the-art บน Terminal-Bench 2.1 และ DeepSWE ยังคงเป็นการรายงานที่ vendor เป็นผู้แถลงแยกต่างหาก

แล้วก็ยังมีหลักฐานจากภาคสนาม ซึ่งแบ่งออกเป็นสองฝ่ายจริงๆ Pawel Huryn รันเบนช์มาร์กแก้บั๊กของตัวเอง — บั๊กที่จงใจใส่ไว้ 105 ตัวในโค้ดเบสจริงสองชุด ตัดสินแบบไม่รู้แหล่งที่มา หนึ่งรอบต่อโมเดล — และรายงานว่า Luna ที่ระดับความพยายามสูงสุดแก้บั๊กได้ 33 ตัวในราคา $1.80 ขณะที่ Claude Fable 5 แก้ได้ 24 ตัวในราคา $68 ในอีกด้านหนึ่ง Diego Haz ใช้เวลาสองวันรันเซสชันแบบจับคู่กัน แล้วออกมาสวนทางกับแพตเทิร์นนี้: Luna เฉลี่ย $1.20 ต่อเซสชัน ขณะที่ Sol เฉลี่ย $29 แต่เขาต้องทำเอาต์พุตของ Luna ใหม่เกือบทั้งหมด และไม่ได้อะไรที่พร้อมส่งมอบสำหรับยูสเคสของเขา ซึ่งทำให้การประหยัดนี้เป็นภาพลวงตามากกว่าส่วนลดจริง นักพัฒนาอีกคนที่ใช้ชุดทดสอบเดียวกันรายงานว่า Sol ที่ระดับกลางให้ผลลัพธ์ที่ดีกว่าอย่างเห็นได้ชัดเมื่อเทียบกับ Luna ที่ระดับสูงสุด ในเวลาเพียงประมาณครึ่งเดียว การประลองที่ใช้ภาษาจีนบนโจทย์ฉาก 3D ฉากเดียวทำให้เห็นตัวเลขชัดเจน: Sol Medium เสร็จใน 21 นาที 30 วินาที ได้คะแนนคุณภาพสูงสุดและใช้โทเคนน้อยที่สุด ส่วน Luna Max ใช้เวลา 40 นาที 55 วินาที เผาผลาญโทเคนไปราว 130,000 ได้คะแนนคุณภาพต่ำสุด และกินโควตาการสมัครสมาชิกรายสัปดาห์ไปครึ่งหนึ่ง

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

รูปแบบที่รอดพ้นจากการปะทะ: Sol วางแผน, Luna ลงมือปฏิบัติ, Sol คนใหม่ตรวจทาน

ผู้ที่ยังคงใช้ Luna Max อยู่ ไม่ได้ใช้มันเป็นเอเจนต์เขียนโค้ดเอนกประสงค์ การตั้งค่าที่ใช้งานได้จริง ซึ่งผู้ปฏิบัติงานในทุกเวอร์ชันเห็นพ้องต้องกันนั้น ประกอบด้วยสี่บทบาท:

• Orchestrator — GPT-5.6 Sol ทำงานด้วยความพยายามระดับสูง โดยอยู่ในเธรดหลัก รับผิดชอบข้อกำหนด สถาปัตยกรรม การแบ่งย่อยงาน และการยอมรับผลลัพธ์ขั้นสุดท้าย แต่ไม่ได้เขียนโค้ดเอง

• ผู้ดำเนินงานประจำ — GPT-5.6 Luna ด้วยความพยายามสูงสุด กับงานที่มีขอบเขตจำกัดและระบุรายละเอียดครบถ้วน: การรีแฟกเตอร์เชิงกล, การเขียนเทสต์, การวิเคราะห์โมดูล, การปรับปรุงเอกสาร เป็นงานประเภทที่ปลายทางชัดเจนไม่กำกวม

• ผู้ปฏิบัติการแบบเข้มข้น — GPT-5.6 Terra ที่ใช้ความพยายามสูงสุด สำหรับระบบที่ใช้บริบทจำนวนมาก ซึ่งการเบี่ยงเบนคำสั่งของ Luna จะมีต้นทุนสูง

• ผู้ตรวจสอบ — อินสแตนซ์ GPT-5.6 Sol แบบอ่านอย่างเดียวใหม่เอี่ยมที่เห็นเฉพาะ diff สุดท้ายเท่านั้น ไม่เห็นอย่างอื่น จุดประสงค์ของการเป็น "ใหม่เอี่ยม" ก็คือ ผู้ตรวจสอบที่ถือบริบทของการนำไปปฏิบัติมักจะเห็นชอบกับเหตุผลของตัวเอง

การใช้งานอ้างอิงคือ sol-advisor ซึ่งเป็นปลั๊กอิน Codex ภายใต้ใบอนุญาต MIT โดย Dan McAteer ที่ได้รับดาวประมาณ 1,400 ดวงในสัปดาห์แรก คุณติดตั้งมันผ่านตลาดปลั๊กอิน Codex โดยการเพิ่ม DannyMac180/sol-advisor ซึ่งเป็นรีโพซิทอรี จากนั้นจึงเพิ่ม sol-advisor ซึ่งเป็นปลั๊กอิน. รูปแบบปัจจุบันของมันให้บทเรียนที่ดี: เลนเนทีฟกำหนดให้มีผู้ดำเนินการ Terra/High ตามด้วยผู้ตรวจสอบ Sol/High ใหม่ ขณะที่ Luna ในระดับสูงสุดเป็นเลนที่เลือกเข้าร่วมอย่างชัดเจน ซึ่งทำงานเป็นงานที่ผู้ใช้มองเห็นแยกต่างหาก โดยเซสชัน Sol หลักจะตรวจสอบและยอมรับผลงานของมันโดยตรง แทนที่จะส่งผ่านไปยังผู้ตรวจสอบเนทีฟ

หากคุณไม่อยากติดตั้งอะไรเพิ่มเติม เวอร์ชันมินิมอลที่ถูกคัดลอกกันอย่างแพร่หลายคือคำนิยามของเอเจนต์แบบกำหนดเองที่~/.codex/agents/luna-worker.tomlซึ่งมีการตั้งค่าสองอย่าง — model = "gpt-5.6-luna"และmodel_reasoning_effort = "max"— พร้อมด้วยคำอธิบายและคำแนะนำที่จำกัดให้ทำงานเฉพาะงานที่ได้รับมอบหมายซึ่งมีขอบเขตชัดเจน ห้ามไม่ให้เปลี่ยนเป้าหมายโดยรวมหรือขยายขอบเขตของตัวเอง และส่งการตัดสินใจด้านสถาปัตยกรรมและความต้องการที่คลุมเครือกลับไปยังเอเจนต์หลัก คำแนะนำที่แพร่หลายคือให้ Sol เขียนไฟล์นี้ให้คุณ ตรวจสอบกับเวอร์ชัน Codex ที่คุณติดตั้งไว้ และแสดง diff ให้คุณดูก่อนตัดสินใจยอมรับ ซึ่งเป็นแนวทางที่สมเหตุสมผลไม่ว่าคุณจะเชื่อถือสูตรนี้หรือไม่

กับดักซับเอเจนต์ และวิธีแก้ไขที่ชุมชนเห็นพ้องต้องกัน

นี่คือจุดที่เวอร์ชันไวรัลของรูปแบบนี้และเวอร์ชันที่ใช้งานได้แยกทางกัน

ระบบซับเอเจนต์เนทีฟของ Codex ไม่ได้ปฏิบัติต่อ GPT-5.6 Luna ในฐานะพลเมืองชั้นหนึ่ง McAteer ชนกำแพงแข็ง — Luna ไม่ได้รับอนุญาตให้เป็นซับเอเจนต์ — จึงเลี่ยงด้วยการประกาศให้มันเป็นคัสตอมเอเจนต์แทน จากนั้นก็ชี้ให้สาธารณะเห็นต้นทุนของวิธีเลี่ยงนั้น: คัสตอมเอเจนต์ไม่ได้แชร์บริบทร่วมกับเอเจนต์หลักแบบที่ซับเอเจนต์เนทีฟทำ ไม่กี่วันต่อมา เขาก็ลบเลน Luna ออกจาก sol-advisor โดยสิ้นเชิง โดยอ้างถึงการค้นพบของนักพัฒนาอีกคนที่มุ่งเน้น Codex ว่า Luna มีพฤติกรรมที่แย่ในบทบาทซับเอเจนต์ พร้อมสันนิษฐานว่ามันยังไม่ผ่านการ post-train สำหรับโปรโตคอลมัลติเอเจนต์ v2 Diego Haz บรรยายกำแพงเดียวกันนี้จากอีกด้านหนึ่งอย่างเป็นอิสระ: Sol ไม่สามารถสร้าง Luna เป็นซับเอเจนต์ได้ Luna จึงต้องอยู่ในเธรดระดับบนสุด ซึ่งทำให้การประสานงานยุ่งเหยิง

ข้อสรุป ซึ่งปัจจุบันเป็นจุดยืนของคนส่วนใหญ่ คือการหยุดต่อต้านมัน:

• ให้ Luna Max มีเธรดของตัวเอง ไม่ใช่สล็อตในกราฟของซับเอเจนต์ สั่งให้ Sol orchestrator สร้างงาน Codex ระดับบนสุดแยกต่างหากบน Luna ติดตามมัน และดึงผลลัพธ์กลับมา นี่คือสิ่งที่ McAteer เพิ่มกลับเข้าไปใน sol-advisor เมื่อวันที่ 4 สิงหาคม และเป็นสิ่งที่คนอื่นๆ หลายคนก็ได้ค้นพบโดยอิสระเช่นกัน

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

• หากคุณจำเป็นต้องบังคับให้มันเข้าไปใน multi-agent v2 สาเหตุที่มันถูกกรองออกคือแคตตาล็อก นักพัฒนาคนหนึ่งสืบย้อนพบว่าการถูกตัดออกนี้มาจากแคตตาล็อกโมเดลเริ่มต้นที่ระบุว่า Luna เป็น v1 และรายงานวิธีแก้ไขชั่วคราว: คัดลอก ~/.codex/models_cache.json จากนั้นตั้งค่า multi_agent_version ของ Luna เป็น v2 แล้วชี้ model_catalog_json ไปยังไฟล์ที่คัดลอกไว้ รีสตาร์ท Codex จากนั้นให้ orchestrator เรียกใช้ Luna แบบเต็มกำลังด้วย service tier ที่รวดเร็วและปิด forking ถือว่านี่เป็นแฮกนอกระบบของบุคคลคนหนึ่งบนไฟล์ภายใน — มันเป็นสิ่งที่การอัปเดต Codex จะมาทำให้พังได้พอดี

เอกสารส่งต่องาน: ห้าคำถามที่แก้ไขข้อร้องเรียนที่พบบ่อยที่สุด

ความล้มเหลวที่ถูกรายงานมากที่สุดเพียงอย่างเดียวของ Luna Max คือมันไม่ปฏิบัติตามคำแนะนำอย่างใกล้ชิด โดยเฉพาะเมื่อคุณส่งเวิร์กโฟลว์เฉพาะหรือลูปการวนซ้ำให้มันรัน ข้อร้องเรียนนี้มาจากนักพัฒนาที่ชื่นชอบโมเดลและนักพัฒนาที่เลิกใช้มัน แนวทางแก้ไขที่ผู้ปฏิบัติงานมักจะสรุปลงไม่ใช่พรอมป์ที่ดีกว่าในเชิงรูปแบบการเขียน แต่เป็นสัญญาที่เข้มงวดกว่า ก่อนที่เธรด Luna จะเริ่มต้น ให้ตอบห้าสิ่ง:

• เอเจนต์นี้ควรทำงานอะไรให้เสร็จกันแน่? ไม่ใช่ขอบเขตงาน — แต่เป็นสภาพที่เสร็จสมบูรณ์

• ไฟล์ เอกสาร หรือระบบใดบ้างที่อยู่ในขอบเขต? เฉพาะที่ระบุไว้เท่านั้น ไม่รวมถึงโดยนัย

• สิ่งใดที่มันต้องไม่เปลี่ยนแปลง? อินเทอร์เฟซ ไมเกรชัน คอนฟิก และสัญญาสาธารณะที่ห้ามเปลี่ยนแปลง.

• หลักฐานใดที่พิสูจน์ว่าสำเร็จ? การทดสอบที่มีชื่อระบุ, ผลลัพธ์ของคำสั่งเฉพาะ, หรือ diff ที่กระทบเฉพาะไฟล์ที่ระบุไว้เท่านั้น

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

นี่คือจุดที่คำแนะนำด้านพรอมต์ของบริษัทเองก็ควรนำมาพิจารณารวมด้วย พร้อมกับป้ายกำกับที่สมควรได้รับ: บริษัทรายงานว่าในการประเมินเอเจนต์เขียนโค้ดภายใน พรอมต์ระบบที่กระชับขึ้นช่วยเพิ่มคะแนนประเมิน 10–15% พร้อมกับลดโทเคนรวม 41–66% และลดต้นทุน 33–67% และบริษัทแนะนำให้ตรวจสอบพรอมต์ที่สืบทอดมาจาก GPT-5.5 หรือ GPT-5.4 แทนที่จะยกไปใช้ต่อ ตัวเลขเหล่านั้นเป็นตัวเลขที่ผู้จำหน่ายรายงาน แต่ทิศทางสอดคล้องกับสิ่งที่วงการพบ: อธิบายปลายทางให้แม่นยำ แล้วลบการบรรยายทุกย่างก้าว โปรดสังเกตความตึงเครียดกับย่อหน้าด้านบน — ความแม่นยำเกี่ยวกับขอบเขตและข้อจำกัดไม่ใช่สิ่งเดียวกับความยืดยาว และความเห็นพ้องของชุมชนคือ Luna Max ต้องการสิ่งแรกมากกว่าและสิ่งหลังน้อยลง

รูปแบบความล้มเหลวที่ต้องวางแผนรับมือ

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

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

• การเผาผลาญบริบทนักพัฒนารายหนึ่งรายงานว่า Luna Max ใช้หน้าต่างเธรดของ Codex ขนาด 258k หมดไปอย่างรวดเร็วจนน่าตกใจ และสงสัยว่าปริมาณโควตาจะพุ่งสูงขึ้นเมื่อ Codex เริ่มบีบอัดข้อมูลใกล้ถึงขีดจำกัด ส่วนเรื่องการบีบอัดเป็นเพียงความเห็นของเขา ไม่ใช่ผลจากการวัด — แต่อัตราการเผาผลาญนี้เป็นผลที่คาดไว้ได้จากความเวิ่นเว้อที่ Artificial Analysis วัดได้อย่างอิสระ ในฝั่ง API ให้สังเกตขั้นตอนบริบทยาว: กำหนดราคาแบบส่งผ่านสำหรับโมเดลนี้จะเปลี่ยนจาก $0.20/$1.20 เป็น $0.40/$1.80 เมื่อคำขอหนึ่ง ๆ ผ่านประมาณ 272k โทเคน ดังนั้นเธรดที่ยาวขึ้นเรื่อย ๆ จะมีราคาต่อโทเคนสูงขึ้น ไม่ใช่แค่ราคารวมที่สูงขึ้นเท่านั้น

• อะไรก็ตามที่เกี่ยวกับภาพ นี่คือเส้นแบ่งที่คมชัดที่สุดในรายงานภาคสนาม ผู้ปฏิบัติงานคนหนึ่งซึ่งมีผู้อ่านอย่างกว้างขวาง ยกเลิกการสมัครสมาชิกโค้ดดิ้ง Kimi K3 เพื่อหันไปใช้ Luna Max และให้คะแนนว่ามันดีพอๆ กับบริการที่เขาเลิกใช้ แต่ถูกกว่ามาก — โดยมีข้อยกเว้นชัดเจนสำหรับงาน frontend อีกคนหนึ่งพูดตรงกว่า: อย่าใช้ Luna ทำงานออกแบบ กราฟิก จัดรูปแบบ หรือสไลด์ การแบ่งงานแบบวางแผนด้วย Sol แล้วลงมือทำด้วย Luna เหมาะสำหรับงานสอนแบบทีละขั้นตอน ไม่ใช่งานด้านความสวยงาม

• แคตตาล็อกซับเอเจนต์ กล่าวถึงข้างต้นแล้ว — หาก Luna ไม่ถูกเลือกเลยอย่างเงียบ ๆ ในการรันแบบหลายเอเจนต์ แสดงว่ามันถูกกรองออก ไม่ได้ล้มเหลว

• ความประหยัดปลอม. โหมดความล้มเหลวเพียงหนึ่งเดียวที่ไม่ปรากฏในเกณฑ์มาตรฐานใดๆ เลย: เซสชันที่เสียค่าใช้จ่ายเพียง 1.20 ดอลลาร์แทนที่จะเป็น 29 ดอลลาร์ แต่ให้ผลงานที่คุณต้องเขียนใหม่ด้วยมือ เท่ากับว่าคุณสูญเสียทั้ง 1.20 ดอลลาร์และเวลาช่วงบ่ายของคุณ

เมื่อใดที่ไม่ควรเลือกค่าสูงสุด

Max ไม่ใช่การอัปเกรดฟรี และแนวทางที่ยังคงใช้ได้นั้นคือบันไดมากกว่าการตั้งค่า:

• การแปลงที่ตรงไปตรงมา — การเปลี่ยนชื่อฟิลด์ การดึงข้อมูลแบบกลไก การจัดรูปแบบ ใช้ความพยายามน้อยถึงปานกลางบน Luna โดยใช้การทดสอบที่ระบุชื่อเป็นเกณฑ์ตัดสิน

• การใช้งานตามปกติ — สูงหรือสูงมาก ค่าเริ่มต้นของชุมชนสำหรับ Luna worker คือ xhigh ไม่ใช่ max ก็เพราะว่า max เสียเวลาและโทเคนไปกับงานที่ไม่เคยยากเลย

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

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

• ข้อมูลสรุปที่คลุมเครือ — แก้ที่ข้อกำหนด ไม่ใช่ที่ตัวแบบ การตั้งค่าความพยายามใดๆ ก็ไม่สามารถชดเชยเกณฑ์การยอมรับที่ไม่ได้ระบุไว้ได้.

ข้อควรระวังเฉพาะสำหรับการสมัครสมาชิก จากคู่มือของบุคคลที่สาม และอาจเข้าใจผิดได้ง่าย: อัตราเครดิตที่ Codex คิดต่อโมเดลนั้นไม่ได้มีอัตราส่วนเดียวกันกับราคาตามรายการของ API ดังนั้นคุณจึงไม่สามารถนำอัตราส่วนราคาของ API มาใช้เป็นกฎการจัดเส้นทางสำหรับการสมัครสมาชิกได้ โควตาข้อความห้าชั่วโมงที่มีรายงานในระดับ Plus แสดงให้เห็นประเด็นนี้ — ประมาณ 15–90 ข้อความในเครื่องบน Sol, 20–110 บน Terra, 50–280 บน Luna ช่วงที่กว้างเช่นนี้เพราะ "ข้อความ" ไม่ใช่หน่วยการทำงานที่ตายตัว หากการตัดสินใจจัดเส้นทางของคุณขับเคลื่อนด้วยขีดจำกัดของการสมัครสมาชิกมากกว่าใบแจ้งหนี้ ก็ให้วัดเทียบกับขีดจำกัดนั้น

นอกเหนือจาก Codex: ผู้คนกำลังชี้สิ่งนี้ไปที่อะไรอีก

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

• เอเจนต์เบราว์เซอร์. นักพัฒนาคนหนึ่งใช้สแตกอัตโนมัติของเบราว์เซอร์บน GPT-5.6 Luna เพื่อเปิดโพสต์ Hacker News 15 อันดับแรก อ่านทุกหน้าที่เชื่อมโยงและเขียนรายงาน — ต้นทุนรวม 3 เซนต์ ขอบเขตยาว, ผลกระทบต่ำ, โทเค็นสูง: คือรูปแบบที่โมเดลนี้ถูกตั้งราคาไว้พอดี

• ทักษะแบบลูกโซ่. ผู้ปฏิบัติสองคนรายงานอย่างเป็นอิสระว่าขับเคลื่อนไปป์ไลน์สองทักษะ — การสร้างภาพไปยังตัวแปลงภาพเป็น Three.js — จากเป้าหมาย Luna Max เดียวเพื่อให้ได้วัตถุ 3D low-poly แบบโต้ตอบ โดยแต่ละคนสังเกตว่ามันแทบไม่กระทบตัวนับการใช้งานรายสัปดาห์ของพวกเขา ควรอ่านคู่กับคำเตือน "อย่าใช้ Luna สำหรับงานภาพ": Luna จัดการเครื่องมือที่ทำงานภาพ ไม่ใช่ตัดสินความสวยงามด้วยตัวเอง

• รักษาเซสชันเดียวให้ร้อนอยู่เสมอ อินพุตที่ถูกแคชบนโมเดลนี้มีค่าใช้จ่าย $0.02 ต่อล้านโทเค็น เทียบกับ $0.20 สำหรับอินพุตใหม่ — ส่วนลด 90% ที่ Artificial Analysis ระบุไว้บนแผงราคา — และระยะเวลาของแคชประมาณ 30 นาที นัยเชิงปฏิบัติที่คู่มือหลายฉบับต่างลงเอยด้วยข้อสรุปเดียวกันก็คือ: เซสชันที่ทำงานยาวนานหนึ่งเซสชันซึ่งอ่านโค้ดเบสเดียวกันซ้ำๆ จะถูกกว่าเซสชันใหม่ต่อหนึ่งงานอย่างมาก

• การอาร์บิทราจโควตา. การกล่าวอ้างที่แรงที่สุดในชุดทั้งหมด และมีการระบุชัดเจนว่าเป็นเพียงข้อกล่าวอ้าง: นักพัฒนารายหนึ่งรายงานว่า เนื่องจากความพยายามแทบไม่มีค่าใช้จ่าย ในขณะที่ตัวคูณระดับสูงมาก การใช้ความพยายามสูงสุดบนระดับราคาถูกทำให้เขาส่งโทเคน 4.9 พันล้านได้ในสามสัปดาห์ด้วยแผน $200 ซึ่งคิดเป็นเงินหกหลักตามอัตรา API และว่าเขาเก็บโมเดล Kimi K3, Grok และ DeepSeek ไว้ในตัวเลือกเดียวกันด้านหลังเราเตอร์ท้องถิ่น เพื่อที่การชนขีดจำกัดของผู้ให้บริการรายหนึ่งจะไม่ทำให้งานหยุดชะงัก ไม่มีใครพิสูจน์ซ้ำตัวเลขโทเคนดังกล่าวได้โดยอิสระ อย่างไรก็ตาม นิสัยการจัดเส้นทางที่อยู่เบื้องหลังคือส่วนที่ควรค่าแก่การลอกเลียนแบบ

การรันสปลิตเดียวกันโดยไม่ต้องสมัครสมาชิก Codex

ทุกอย่างที่กล่าวมาข้างต้นเป็นเรื่องราวที่วางโครงตามระบบสมัครสมาชิก: เหตุผลที่ผู้คนสนใจ Luna Max ก็คือมันขยายขีดจำกัดรายสัปดาห์ ในฝั่ง API สถาปัตยกรรมแบบเดียวกันนี้สร้างได้ง่ายกว่าและทำความเข้าใจได้ง่ายกว่า เพราะคุณจ่ายใบแจ้งหนี้แทนที่จะจัดการวงเงินอนุญาต — และการแยก orchestrator/worker จะไม่ใช่ปลั๊กอินอีกต่อไป แต่กลายเป็นการจัดเส้นทางแบบธรรมดา

GPT-5.6 Luna พร้อมใช้งานผ่าน OrcaRouter ในราคา $0.20 ต่อล้านอินพุตและ $1.20 ต่อล้านเอาต์พุต — เป็นราคารายการของผู้ให้บริการที่ส่งผ่านโดยไม่บวกกำไร (0% markup) ซึ่งเป็นเหตุผลว่าทำไมการลดราคาเมื่อวันที่ 30 กรกฎาคมจึงมีผลบนฝั่งเราในวันที่บริษัทประกาศ ไม่ใช่ในรอบการเรียกเก็บเงินถัดไป โดยให้บริการผ่าน API ที่เข้ากันได้บน /v1/chat/completions และ /v1/responsesดังนั้นฟิลด์ reasoning-effort จะถูกส่งไปใน body ของคำขอเช่นเดียวกับการเรียกโดยตรง และ model id คือ openai/gpt-5.6-luna. GPT-5.6 Sol และ GPT-5.6 Terra อยู่ภายใต้คีย์เดียวกัน ซึ่งเป็นส่วนสำคัญของรูปแบบนี้: ออร์เคสเตรเตอร์บนเทียร์หนึ่งและเวิร์กเกอร์บนอีกเทียร์หนึ่งคือ model id สองตัวในการอินทิเกรชันเดียว ไม่ใช่สัญญากับผู้ให้บริการสองราย routing DSL ช่วยให้คุณระบุการแยกนั้นได้ในการเรียกเพียงครั้งเดียว แทนที่จะต้องเชื่อมเธรดเข้าด้วยกันด้วยมือ และ automatic failover ครอบคลุมกรณีที่กลุ่ม quota-arbitrage จัดการด้วย local router — เมื่อผู้ให้บริการรายหนึ่งประสิทธิภาพลดลง คำขอจะไปลงที่อื่นแทนที่จะหยุดชะงัก

ข้อควรระวังที่ตรงไปตรงมาสองข้อ กลไกเฉพาะของ Codex — กราฟซับเอเจนต์ ตลาดปลั๊กอิน แคตตาล็อกโมเดล ค่าเผื่อรายสัปดาห์ — เป็นของบริษัท และไม่มีสิ่งใดมาพร้อมกับคีย์ API หากรูปแบบที่คุณต้องการคือ sol-advisorภายในแอป Codex คุณต้องสมัครสมาชิก Codex และโหมดความล้มเหลวข้างต้นเป็นคุณสมบัติของโมเดล ไม่ใช่ของตัวส่งข้อมูล: การกำหนดเส้นทางเปลี่ยนว่าการเรียกใช้มีค่าใช้จ่ายเท่าใดและเกิดอะไรขึ้นเมื่อผู้ให้บริการล่ม ไม่ใช่เรื่องที่ว่า Luna จะทำตามคำแนะนำของคุณหรือไม่

ใครควรคัดลอกสิ่งนี้ และใครไม่ควร

หากงานของคุณมีปริมาณสูงและสามารถระบุเป็นกลไกได้ — การรีแฟกเตอร์, การสร้างโครงทดสอบ, การแยกโค้ด, เอกสาร, การวิเคราะห์ทั่วทั้งรีโพขนาดใหญ่ — ให้เปิดโหมดสูงสุด, วาง Luna ไว้ในเธรดของตัวเองพร้อมการส่งต่องานด้วยคำถามห้าข้อ, เก็บอินสแตนซ์ของ Sol ไว้ข้างหน้าเพื่อการวางแผนและข้างหลังเพื่อการทบทวน, และคาดหวังว่าจะใช้เวลาน้อยลงหนึ่งลำดับความสำคัญ ผู้ที่รายงานผลลัพธ์ดีที่สุดต่างก็ทำในลักษณะนั้น และตัวเลขต้นทุนอิสระก็สนับสนุนทิศทางนี้ แม้ในจุดที่ไม่สนับสนุนกรอบคิดที่ว่า “ดีเท่า Sol” ก็ตาม

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

สิ่งที่ต้องจับตา: ว่าบริษัทจะ post-train Luna สำหรับโปรโตคอล v2 subagent หรือไม่ ทุกจุดที่อึดอัดของ playbook ปัจจุบัน — เธรดที่แยกจากกัน, shared context ที่หายไป, catalog hack, รวมถึงตอน retract-and-rewire ทั้งหมด — ล้วนเกิดขึ้นเพราะช่องว่างจุดนั้นเพียงจุดเดียว ถ้าปิดมันได้ เวอร์ชันที่ดีที่สุดของแพตเทิร์นนี้จะง่ายลงอีกหลายขั้น

คำถามที่ควรค่าแก่คำตอบที่แท้จริง

การใช้ความพยายามในการใช้เหตุผลระดับสูงสุดมีต้นทุนต่อโทเคนสูงกว่าค่าเริ่มต้นหรือไม่

ไม่ใช่ และนี่คือความเข้าใจผิดที่พบบ่อยที่สุดเกี่ยวกับการตั้งค่านี้ GPT-5.6 Luna คิดค่าบริการ $0.20 ต่อล้านโทเคนสำหรับ input และ $1.20 ต่อล้านโทเคนสำหรับ output โดยไม่ขึ้นกับระดับ effort สิ่งที่ระดับ max เปลี่ยนคือจำนวนโทเคนที่ใช้ไป — โมเดลวางแผนมากขึ้น ตรวจสอบตัวเอง และแก้ไขก่อนที่จะตอบ Artificial Analysis วัดได้ว่าโมเดลนี้สร้างโทเคน output 130M บนชุด benchmark ที่โมเดลค่ากลางสร้าง 61M ดังนั้นเซสชันแบบ max-effort จึงมีค่าใช้จ่ายสูงกว่าแบบ medium-effort ในงานเดียวกัน โดยทั้งหมดมาจากปริมาณโทเคนที่มากขึ้น และยังใช้เวลานานขึ้นในการสร้างโทเคนแรกด้วย Effort คือปุ่มปรับจำนวนโทเคนที่ติดฉลากว่าเป็นคุณภาพ

GPT-5.6 Luna สามารถทำงานเป็น native subagent ของ Codex ได้แล้วหรือยัง?

ณ วันที่ 5 สิงหาคม 2026 ไม่ — และชุมชนได้เลิกพยายามแล้ว เส้นทางซับเอเจนต์เนทีฟของ Codex ไม่ยอมรับ Luna; วิธีแก้ไขชั่วคราวแบบเอเจนต์กำหนดเองทำให้มันรันได้แต่สูญเสียบริบทร่วมกับเอเจนต์หลัก; และนักพัฒนาที่อยู่เบื้องหลังปลั๊กอินที่รู้จักกันดีที่สุดสำหรับรูปแบบนี้ได้นำ Luna ออก แล้วเพิ่มกลับเข้าไปเป็นงานระดับบนสุดที่สร้างแยกต่างหากซึ่งออร์เคสเตรเตอร์คอยติดตาม หากคุณเห็นการรันแบบหลายเอเจนต์ที่ Luna ไม่เคยถูกเลือก เป็นไปได้ว่ามันถูกกรองออกเพราะแคตตาล็อกโมเดลมาตรฐานระบุว่าเป็น v1 ไม่ใช่ v2 ซึ่งนักพัฒนารายหนึ่งได้แพตช์ด้วยตนเองโดยยอมรับความเสี่ยงเอง นี่คือสิ่งเดียวในรายการที่มีแนวโน้มจะเปลี่ยนแปลงมากที่สุดเมื่อมีการอัปเดต Codex ดังนั้นควรตรวจสอบกับเวอร์ชันที่คุณติดตั้งไว้ แทนที่จะเชื่อสูตรใดๆ รวมถึงสูตรนี้ด้วย

มันดีพอที่จะแทนที่การสมัครสมาชิก Claude หรือ Kimi K3 สำหรับการเขียนโค้ดได้หรือไม่?

นักพัฒนาหลายคนได้ประกาศยกเลิกแผนราคา $200 ต่อเดือนต่อสาธารณะด้วยเหตุผลนี้โดยตรง โพสต์ที่ทำให้คำถามนี้ถูกเปิดเผยขึ้นมาอย่างชัดเจนมาจากนักภูมิคุ้มกันวิทยาที่เขียนโค้ดทุกวัน เขายกเลิกการสมัครสมาชิกเขียนโค้ด Kimi K3 ไม่ใช่เพราะมันแย่ แต่เพราะเขาให้เหตุผลกับตัวเองไม่ได้ ในเมื่อ GPT-5.6 Luna ในประสบการณ์ของเขา ทำงานได้ดีพอ ๆ กันและถูกกว่ามาก ยกเว้นงานฟรอนต์เอนด์ ตัวเลขต้นทุนจากแหล่งอิสระทำให้ข้อโต้แย้งนี้ยากที่จะมองข้าม บนชุดเบนช์มาร์กเดียวกัน Kimi K3 ที่ระดับความพยายามสูงสุดทำได้ 57 คะแนนด้วยค่าใช้จ่าย $2,437 ขณะที่ GPT-5.6 Luna ที่ระดับสูงสุดทำได้ 51 คะแนนด้วยค่าใช้จ่าย $174 แต่จงอ่านเสียงคัดค้านก่อนที่คุณจะยกเลิกอะไรก็ตาม นักพัฒนาที่วัดเซสชันที่จับคู่กันแล้วได้ผลลัพธ์ออกมาเป็นลบไม่ได้กำลังทดสอบโมเดลอื่น พวกเขากำลังทดสอบงานอีกประเภทหนึ่ง ซึ่งเป็นงานแบบเปิดกว้าง ต้องใช้ภาพ หรือระบุรายละเอียดไว้หลวม ๆ และในงานประเภทนั้น โมเดลที่ถูกกว่าแพ้มากพอที่จะลบข้อประหยัดนั้นจนหมดไป คำตอบที่ปกป้องได้ก็คือ Luna Max เข้ามาแทนที่งานเขียนโค้ดส่วนใหญ่ของคุณ ไม่จำเป็นต้องเป็นโมเดลเขียนโค้ดที่ดีที่สุดของคุณ และนักปฏิบัติที่ได้ประโยชน์สูงสุดจากมันคือผู้ที่ยังเก็บโมเดลระดับแนวหน้าไว้ใช้วางแผนและตรวจสอบ