โมเดลเดียวกัน แต่ทำงานได้มากกว่าเท่าตัว? ทำไม OpenCode กับ Codex ใช้โควตา ChatGPT ต่างกัน (อธิบาย Harness และ MCP แบบเข้าใจง่าย)

นักพัฒนาคนหนึ่งโพสต์ในโซเชียลว่า พอย้ายจาก Codex ไปใช้ OpenCode โดยยังใช้ GPT-5.6 Sol ตัวเดิมผ่านการล็อกอินบัญชี ChatGPT รู้สึกว่าทำงานได้มากกว่าสองเท่าภายใน…

วิธีใช้เครื่องมืออ่าน

ฟังจะอ่านบทความออกเสียง อ่านเร็วแสดงวลีทีละช่วงตามความเร็วที่เลือก ฝึกภาษาใช้เปรียบเทียบบทความฉบับแปลที่มีอยู่ บันทึกจะเก็บบุ๊กมาร์กในเบราว์เซอร์นี้ และเปิดอีกครั้งได้จากรายการที่บันทึกในเครื่องเล่น อ่านแบบเกมทุบอิฐจะเปลี่ยนตัวอักษรในบทความเป็นก้อนอิฐให้ทุบเล่น

แชร์บทความนี้

แชร์บทความนี้

โมเดลเดียวกัน แต่ทำงานได้มากกว่าเท่าตัว? ทำไม OpenCode กับ Codex ใช้โควตา ChatGPT ต่างกัน (อธิบาย Harness และ MCP แบบเข้าใจง่าย)
ภาพที่สร้างโดย AI

สรุปใน 5 วินาที: ต่อให้ใช้โมเดลเดียวกันเป๊ะ ปริมาณที่ใช้ไปก็ต่างกันได้มาก ขึ้นอยู่กับว่าแต่ละรอบยัดอะไรลงไปใน context บ้าง เรียกโมเดลกี่ครั้ง ลากผลลัพธ์จากเครื่องมือติดตัวไปเท่าไร และย่อข้อมูลตอนไหน ถ้าโมเดลคือเครื่องยนต์ harness อย่าง Codex หรือ OpenCode ก็คือเกียร์ ระบบหัวฉีด GPS และช่างซ่อมรวมไว้ในตัว เครื่องยนต์เดียวกันไม่ได้แปลว่าจะกินน้ำมันเท่ากัน

1. "โควตา 5 ชั่วโมงเท่าเดิม แต่วิ่งได้ไกลกว่าเท่าตัว" — ต้องบอกก่อนว่านี่คือประสบการณ์ส่วนตัว ไม่ใช่ผลทดสอบ

นักพัฒนาคนหนึ่งโพสต์ในโซเชียลว่า พอย้ายจาก Codex ไปใช้ OpenCode โดยยังใช้ GPT-5.6 Sol ตัวเดิมผ่านการล็อกอินบัญชี ChatGPT รู้สึกว่าทำงานได้มากกว่าสองเท่าภายในโควตา 5 ชั่วโมงและโควตารายสัปดาห์เท่าเดิม

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

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

อีกด้านหนึ่ง OpenAI อธิบายว่าการใช้ Codex ไม่ได้นับเป็นจำนวนข้อความตายตัว แต่เปลี่ยนไปตามโมเดล ที่ที่งานรัน ความซับซ้อน context การคิดวิเคราะห์ ความเร็ว และเครื่องมือ บางแพ็กเกจมีทั้งโควตา 5 ชั่วโมงและโควตารายสัปดาห์

แปลว่าเรื่อง "เปลี่ยน harness แล้วอัตราสิ้นเปลืองเปลี่ยน" นั้น ถ้าดูจากหลักการทำงานก็ถือว่าเป็นเรื่องปกติมาก

2. Harness คืออะไร — "ทุกอย่าง" ที่อยู่นอกตัวสมองของ AI

ถ้ามองแค่ตัวโมเดลก็ง่ายมาก

Sol = สมอง

แต่ AI ช่วยเขียนโค้ดที่ใช้งานจริงมีอุปกรณ์รายล้อมสมองอยู่เต็มไปหมด

  • จะเรียบเรียงคำสั่งระบบ (system instruction) ยังไง
  • จะอ่านไฟล์ไหนบ้าง
  • จะเก็บบทสนทนาเก่าไว้กี่โทเคน
  • จะให้โมเดลเห็นเครื่องมือกี่ตัว เช่น shell หรือ GitHub
  • จะยกผลลัพธ์จากเครื่องมือไปรอบถัดไปมากแค่ไหน
  • ถ้าพลาดจะลองใหม่กี่ครั้ง
  • จะวนวางแผน ลงมือทำ และตรวจทานกี่รอบ
  • จะย่อ context ก่อนมันล้นหรือไม่
  • จะแบ่งงานให้ agent ย่อยหรือไม่
  • จะตัดสินตอนไหนว่า "เสร็จแล้ว"

ทั้งชุดนี้แหละคือ harness ในความหมายกว้าง

OpenAI เองก็ใช้คำว่า "harness" กับ Codex และอธิบายถึง App Server ที่เชื่อมโมเดลเข้ากับไคลเอนต์แต่ละตัว เครื่องมือ และสถานะของบทสนทนา

เพราะฉะนั้น

โมเดลเดียวกัน ≠ ทั้งระบบเหมือนกัน

เหมือนเอาเครื่อง V8 ตัวเดียวกันไปใส่ทั้งรถ SUV หนัก 2 ตันกับรถตัวถังเบา อัตราสิ้นเปลืองก็ไม่มีทางเท่ากัน

3. ตัวการที่ทำให้ AI กินโควตาหนัก ส่วนใหญ่คือ "สัมภาระที่ต้องแบกไปทุกรอบ"

ปริมาณการใช้ของ agent ไม่ได้วัดแค่ว่าตอบกลับมากี่ตัวอักษร

ใน session ยาวๆ ทุกครั้งที่คิดอาจต้องแบก

  • ประวัติบทสนทนายาวเหยียด
  • คำสั่งระบบขนาดใหญ่
  • AGENTS.md และกฎต่างๆ
  • คำอธิบายเครื่องมือของ MCP
  • ไฟล์จำนวนมากที่อ่านมาจาก GitHub
  • log จาก shell ที่ยาวมาก
  • ผลการเทสต์
  • ความผิดพลาดที่ผ่านมา
  • ข้อมูลสำหรับการลองใหม่รอบหน้า

แค่ครั้งเดียวก็ไม่หนักเท่าไร

ปัญหาคือต้องส่งซ้ำและอ่านซ้ำ 10 ครั้ง 20 ครั้ง 30 ครั้ง

บางทีการ "อ่าน log 100KB ครั้งเดียว" ยังไม่หนักเท่า การเรียกโมเดลซ้ำแล้วซ้ำเล่าโดยแบก context ระดับ 100KB ไปด้วยตลอด

แถมถ้า harness A จบงานใน 15 รอบ แต่ harness B ใช้ 30 รอบกับการ วางแผน → ตรวจ → ค้น → ค้นซ้ำ → ตรวจทาน → ตรวจทานซ้ำ ต่อให้โมเดลเดียวกันก็ต้องต่างกันอยู่แล้ว

อัตราสิ้นเปลืองไม่ได้ขึ้นกับเครื่องยนต์อย่างเดียว แต่พังเพราะ

สัมภาระ × จำนวนเที่ยวไปกลับ × จำนวนครั้งที่ลองใหม่

4. ทำไม OpenCode น่าสนใจ — ล็อกอิน ChatGPT, MCP และการย่ออัตโนมัติอยู่ในกล่องเดียว

เอกสารทางการของ OpenCode บอกว่า ตอนเชื่อมต่อ OpenAI เลือก ChatGPT Plus/Pro แล้วล็อกอินผ่านเบราว์เซอร์ได้ ซึ่งแยกจากวิธีกรอก API key เอง

นอกจากนี้ OpenCode ยังทำหน้าที่เป็นไคลเอนต์ MCP เพิ่มได้ทั้ง MCP ในเครื่องและ MCP ระยะไกล

เลยจัดแบบนี้ได้

OpenCode → GitHub MCP → MCP ฐานข้อมูล → API ที่ทำเอง → เครื่องมือภายนอกอื่นๆ

แล้ว OpenCode ยังมีการย่ออัตโนมัติ (compaction) ที่เปลี่ยน context เก่าๆ ของ session ยาวให้กลายเป็นจุดบันทึก ในเอกสารปัจจุบันเปิดการย่ออัตโนมัติไว้เป็นค่าเริ่มต้น และมีตัวอย่างการตั้งค่าที่เก็บสรุปที่สร้างขึ้นกับโทเคนล่าสุดราว 15,000 โทเคนไว้

มันไม่ได้เป็น "การลบบทสนทนาเก่าทิ้ง" แต่ใกล้กับ

เก็บประวัติไว้ในโกดัง แล้วขนไปแค่ของที่จำเป็นในการออกงานรอบหน้า

แต่ก็ไม่ได้วิเศษไปทุกอย่าง OpenCode เตือนเองว่า ยิ่งเพิ่มเซิร์ฟเวอร์ MCP คำอธิบายเครื่องมือต่างๆ ก็ยิ่งกิน context และ MCP ตัวใหญ่อย่าง GitHub MCP ทำให้ context เต็มได้ง่ายเป็นพิเศษ

ต่อ MCP ไป 20 ตัวแล้วคิดว่า "เทพสุดแล้ว!" ก็เหมือนให้ฮีโร่สวมทั้งโกดังไว้ในช่องอุปกรณ์

5. สั่งงานทุกอย่างจาก ChatGPT ผ่าน MCP ก็แนวคิดเดียวกันแทบทั้งหมด

การให้ ChatGPT อยู่ตรงกลาง แล้วจัดการ GitHub เซิร์ฟเวอร์ คลาวด์ และพื้นที่เก็บข้อมูลผ่าน MCP หรือตัวเชื่อมต่อภายนอก โดยแก่นแท้แล้วก็คือ "โมเดล + harness + เครื่องมือ" เหมือนกัน

วาดเป็นแผนผังสายไฟก็ง่ายๆ

ChatGPT → MCP / connector → GitHub, เซิร์ฟเวอร์, คลาวด์, ที่เก็บข้อมูล

ChatGPT เป็นคนตัดสินใจ MCP เป็นมือเป็นเท้า และแต่ละบริการเก็บสถานะจริงเอาไว้

OpenCode ก็เหมือนกัน

OpenCode → MCP / shell / API → repository, เซิร์ฟเวอร์, คลาวด์

ที่ต่างคือ จะเก็บสถานะบทสนทนาไว้ที่ไหน จะวนเรียกเครื่องมือที่ไหน และจะย่อ context ที่ไหน

เพราะฉะนั้นคำถาม "นี่ก็เหมือนกับสั่งทุกอย่างจาก ChatGPT ผ่าน MCP ไหม?" คำตอบคือ เกือบจะ YES

แนวคิดการออกแบบเดียวกัน ต่างกันแค่ยี่ห้อของห้องควบคุม

6. แล้ว ChatGPT ส่งงานต่อให้ OpenCode ได้ไหม

OpenCode รองรับอย่างเป็นทางการในฐานะ "ฝั่งที่ใช้ MCP" ส่วนในเอกสารที่อ้างถึง แทนที่จะมีโหมดเปิด OpenCode เองให้เป็นเซิร์ฟเวอร์ MCP ทั่วไป สิ่งที่เขียนไว้ชัดเจนคือทางเข้าแบบเซิร์ฟเวอร์ HTTP/OpenAPI กับ SDK หรือ ACP

ถ้าใช้ opencode serve ก็รัน OpenCode เป็นเซิร์ฟเวอร์ HTTP แบบไม่มีหน้าจอได้ แล้วควบคุม session และ agent ด้วยโปรแกรมผ่าน OpenAPI มี SDK สำหรับ JS/TS ด้วย

ถ้าอยากให้ ChatGPT ส่งงานไปให้ OpenCode โครงสร้างที่เรียบร้อยจะเป็นแบบนี้

ChatGPT → สะพาน MCP บางๆ → OpenCode Server → Sol → MCP / shell / API → GitHub, คลาวด์ ฯลฯ

เครื่องมือที่สะพาน MCP เปิดให้ใช้มีน้อยสุดๆ ก็ได้

  • opencode_run_task
  • opencode_get_status
  • opencode_get_result

แค่นี้ก็พอ

ไม่ต้องขนคำอธิบายเครื่องมือ GitHub หลายสิบตัวหรือ log ยักษ์เข้าไปใน ChatGPT ทุกครั้ง ให้ OpenCode ทำงานยาวๆ จนจบ แล้วส่งกลับมาแค่ผลลัพธ์สุดท้าย

ถึงตรงนี้ "การประหยัดโควตา" ถึงจะกลายเป็นเรื่องของการออกแบบจริงๆ

7. ถ้าอยากลดการใช้จริงจัง อย่าลด AI แต่ให้ลด "จำนวนครั้งที่ต้องกลับไปถาม AI"

ความผิดพลาดที่เจอบ่อยที่สุดคือคิดว่าเปลี่ยนไปใช้โมเดลถูกๆ แล้วทุกอย่างจะจบ

แน่นอนว่าการเลือกโมเดลก็ช่วยได้

แต่กับงานอัตโนมัติที่รันนานๆ การแบ่งงานแบบนี้มักได้ผลกว่า

  1. งานที่ผลลัพธ์ตายตัว ทำเป็นขั้นตอน ให้สคริปต์ทำ
  2. เก็บสถานะและบันทึกการทำงานไว้ฝั่งเครื่อง
  3. เปิดเฉพาะเครื่องมือที่จำเป็น
  4. log ยาวๆ ให้สรุปหรือดึงเฉพาะส่วนสำคัญก่อนส่งให้โมเดล
  5. ไม่อ่านไฟล์เดิมซ้ำไปซ้ำมา
  6. เก็บสาเหตุที่พลาดและงานถัดไปไว้เป็นสถานะ
  7. ส่งกลับไปหาโมเดลตัวเก่งเฉพาะเรื่องที่ตัดสินยาก
  8. ส่งกลับมาให้คนดูแค่ผลตรวจสุดท้ายว่าขึ้นระบบจริงเรียบร้อยแล้ว

รูปแบบในอุดมคติคือ

AI = รับผิดชอบเรื่องที่คลุมเครือ

สคริปต์ / เวิร์กโฟลว์ = รับผิดชอบรันขั้นตอนที่กำหนดไว้แล้ว

GitHub / ฐานข้อมูล / สถานะที่บันทึกไว้ = รับผิดชอบการจดจำ

ถ้าให้ AI มานั่งคิดทุกครั้งว่า "เอ๊ะ ต่อไปต้องทำอะไรนะ?" ทุกครั้งก็จะเริ่มนับสต็อกทั้งโกดังใหม่

ถ้าให้เครื่องจดงานถัดไปไว้ ก็เรียก AI แค่ตอนที่จำเป็นจริงๆ

8. แต่ยังพูดไม่ได้ว่า "ใช้ OpenCode แล้วคุ้มกว่าแน่นอนด้วยโควตาเท่าเดิม"

สิ่งที่ยืนยันได้จากเอกสารทางการของ OpenAI คือ Codex กับ Work ใช้โควตาร่วมกัน บางแพ็กเกจมีโควตา 5 ชั่วโมงและโควตารายสัปดาห์ และปริมาณการใช้เปลี่ยนไปตาม context เครื่องมือ ฯลฯ

สิ่งที่ยืนยันได้จากเอกสารทางการของ OpenCode คือ ล็อกอินด้วย ChatGPT Plus/Pro ได้

แต่ไม่มีตารางเปรียบเทียบในเอกสารทางการของทั้งสองฝั่งเลยว่า การใช้ล็อกอิน ChatGPT ผ่าน OpenCode ถูก OpenAI หักโควตาด้วยสูตรเดียวกันและค่าน้ำหนักภายในเดียวกับ Codex หรือเปล่า หรือ OpenCode คุ้มกว่ากี่เท่าเสมอ

ดังนั้น

"ของฉันวิ่งได้เท่าตัว" เป็นรีวิวจากการใช้จริงที่น่าสนใจ

"วิ่งได้เท่าตัวแน่นอน" ยังไม่ได้รับการยืนยัน

ไม่ควรเอาสองอย่างนี้มาปนกัน

ถ้าจะเปรียบเทียบจริงๆ ให้ใช้ repository เดียวกัน โมเดลเดียวกัน งานเดียวกัน และเงื่อนไข "เสร็จ" แบบเดียวกัน แล้วเก็บ

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

อย่าดูแค่ว่า "ใช้ได้กี่ชั่วโมง" แต่ให้ดูว่า งานที่สำเร็จ 1 ชิ้นกินโควตาไปเท่าไร

นั่นแหละคืออัตราสิ้นเปลืองที่แท้จริง

9. สรุป — ยุค AI หลังเลือกโมเดลแล้ว สิ่งที่มีผลรองลงมาคือ "การเดินสาย"

เมื่อก่อนเรื่องหลักคือ "โมเดลไหนฉลาดที่สุด"

แต่ในยุค agent แค่นั้นไม่พอแล้ว

ต่อให้โมเดลเดียวกัน ปริมาณงานที่ทำได้ก็เปลี่ยนไปตาม

  • วิธีจัด context
  • จำนวนเครื่องมือ
  • การจัดการสถานะ
  • การย่อข้อมูล
  • การลองใหม่
  • การตัดสินว่าจบงาน
  • การแบ่งงานกับเวิร์กโฟลว์ภายนอก

โมเดลคือเครื่องยนต์

harness คือทั้งระบบที่รวมหัวฉีด เกียร์ GPS ทีมช่างในพิต ไปจนถึงขนาดท้ายรถ

เพราะงั้นคำถามว่า "Sol ตัวเดียวกันแท้ๆ ทำไมต่างกันขนาดนี้" จึงเป็นคำถามที่เป็นธรรมชาติมาก

และทันทีที่เริ่มใช้ MCP เชื่อมหลายบริการเข้าด้วยกัน สิ่งที่เราทำก็เปลี่ยนจาก "ใช้ AI" ไปเป็น

การออกแบบที่ทำงานรอบตัว AI

สุดท้ายขอพูดตรงๆ แบบไม่อ้อมค้อม MCP ที่เก่งที่สุดไม่ใช่ "การถาม AI ทุกเรื่อง"

แต่คือการเพิ่มขั้นตอนที่ไม่ต้องถาม AI เลย

แหล่งข้อมูล

[1] https://openai.com/index/unlocking-the-codex-harness/
[2] https://help.openai.com/en/articles/11369540
[3] https://help.openai.com/en/articles/20001516
[4] https://opencode.ai/docs/providers
[5] https://opencode.ai/v2/docs/mcp-servers
[6] https://opencode.ai/v2/docs/compaction
[7] https://dev.opencode.ai/docs/server/
[8] https://opencode.ai/v2/docs/cli/acp/


เอกสารอ้างอิง (8 รายการ)

  1. OpenAI, Unlocking the Codex harness: how we built the App Server openai.com
  2. OpenAI Help Center, ChatGPTプランでCodexを使う help.openai.com
  3. OpenAI Help Center, WorkとCodexでのGPT-6 Astraの利用量管理 help.openai.com
  4. OpenCode Docs, Providers opencode.ai
  5. OpenCode Docs, MCP servers opencode.ai
  6. OpenCode Docs, Compaction opencode.ai
  7. OpenCode Docs, Server / SDK https://dev.opencode.ai/docs/ja/sdk/ dev.opencode.ai
  8. OpenCode Docs, ACP opencode.ai

แชร์บทความนี้

หากบทความนี้มีประโยชน์ คุณสามารถสนับสนุนเว็บไซต์ได้ สนับสนุน

วันนี้อ่านเรื่องนี้

แต่ละบทความตอบคำถามที่ผู้อ่านบทความนี้มักสงสัยต่อ

ดูบทความทั้งหมด

หาบทความอื่น

บทความทั้งหมด

Mendoi-chan

ผู้ดูแลเว็บไซต์

Mendoi-chan

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

บทความล่าสุด

  1. 1"น่าจะทำได้" ไม่ใช่กำลังรบ: จะให้ทำงานจริงได้ต้องแตกงานออกเป็นขั้นตอน
  2. 2ทำไมงานบริษัทกับปาร์ตี้ดื่มสังสรรค์ถึงเหนื่อยนัก? ความจริงของ "งานที่แต่งตัวเป็นเรื่องส่วนตัว"