DeepSeek Harness vs OpenCode: ช่องว่างการใช้ Token ที่นักพัฒนาส่วนใหญ่มองข้าม

คุณเลือกโมเดลราคาถูก คุณคำนวณบนการ์ดโมเดลไว้แล้ว จากนั้นบิลก็มา และมันไม่ตรงกับที่คุณคิดเลย

ช่องว่างนั้นแทบไม่ใช่โมเดลเลย มันคือ "ฮาร์เนส" (harness) ฮาร์เนสเป็นตัวกำหนดว่าโมเดลของคุณจะถูกเรียกกี่ครั้ง ต้องเล่นซ้ำบทสนทนาส่วนไหนบ้างทุกครั้งที่เรียก โครงสร้างเครื่องมือ (tool schema) มีขนาดใหญ่แค่ไหน และเมื่อทดสอบล้มเหลวจะลองใหม่สามครั้งหรือสิบสองครั้ง โมเดลเดียวกัน งานเดียวกัน ฮาร์เนสต่างกัน จำนวนโทเค็นต่างกันอย่างมหาศาล

เมื่อวันที่ 13 สิงหาคม 2026 DeepSeek เปิดซอร์สฮาร์เนสของตัวเอง และการถกเถียงก็เริ่มขึ้นอย่างรวดเร็ว ฝ่ายหนึ่งมี repo ที่เพิ่งสร้างสองสัปดาห์จากห้องแล็บที่สร้างโมเดล อีกฝ่ายมี OpenCode ซึ่งเป็น coding agent ที่มีดาวมากที่สุดบน GitHub ทั้งสองเป็น MIT License ทั้งสองสามารถรันโมเดลอะไรก็ได้ที่คุณชี้ไป

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

ประเด็นสำคัญ

• DeepSeek Harness คือ runtime สำหรับ agent แบบ plugin-first จาก DeepSeek AI, ใช้ MIT License, เขียนด้วย TypeScript, ยังอยู่ในสถานะ developer preview โมเดล, เครื่องมือ, sessions, storage, sandboxes, loops และแม้แต่ agent loop เองก็สามารถเปลี่ยนเป็น plugin ได้
• OpenCode คือ coding agent ที่ใช้ Go, ทำงานบน terminal มีดาวบน GitHub ประมาณ 198k, มี TUI ที่สมบูรณ์, รองรับ LSP และมีแคตตาล็อกผู้ให้บริการขนาดใหญ่ มันคือตัวเลือกที่ปลอดภัยสำหรับวันนี้
• การเลือกฮาร์เนสส่งผลต่อการใช้โทเค็นมากกว่าที่คนส่วนใหญ่คาดคิด ในการวัดประสิทธิภาพ 30 เวิร์กโฟลว์บน DeepSeek V4 Flash ฮาร์เนสที่ทดสอบมีค่าเฉลี่ยโทเค็นต่องานตั้งแต่ประมาณ 192,000 ถึง 1,400,000
• DeepSeek Harness ไม่อยู่ในการวัดประสิทธิภาพนั้น มันเปิดตัวหลังจากที่ตีพิมพ์บทความนั้นสองวัน ดังนั้นใครก็ตามที่อ้างตัวเลขการวัดประสิทธิภาพของ Harness ตอนนี้กำลังเดาอยู่
• ทั้งสองไม่ขึ้นกับโมเดล คุณจึงสามารถชี้ทั้งสองไปยัง endpoint ที่เข้ากันได้กับ OpenAI ตัวเดียวกันและทดสอบแบบเหมือนจริงได้ นั่นคือตัวเลขเดียวที่สำคัญสำหรับโค้ดเบสของคุณ

แล็ปท็อปสองเครื่องวางเคียงกันบนโต๊ะที่มีแสงแดด กำลังรันงานเขียนโค้ดเดียวกันผ่านฮาร์เนส agent สองตัว

วิธีที่ยุติธรรมเท่านั้นในการรัน DeepSeek Harness vs OpenCode: โมเดลเดียว งานเดียว สองเทอร์มินัล

ทำไม DeepSeek Harness vs OpenCode ถึงกลายเป็นประเด็นถกเถียงแห่งเดือน

กรอบความคิดของ DeepSeek คือสโลแกน: Agent = Model + Harness โมเดลคิด ฮาร์เนสอ่านไฟล์ รัน terminal และเรียกใช้เครื่องมือ เป็นเวลาสองปีที่ทุกคนปรับแต่งส่วนแรกและมองว่าส่วนหลังเป็นแค่ท่อประปา

ท่อประปานั้นกลายเป็นว่ามีราคาแพง

Composio รันเวิร์กโฟลว์หลายแอปที่ซับซ้อน 30 รายการผ่านฮาร์เนส agent 8 ตัว โดยใช้โมเดล DeepSeek V4 Flash ตัวเดียวกัน มีขีดจำกัด 900 วินาทีต่องาน และให้คะแนนแบบ binary ผ่านโปรแกรม 240 รัน (Composio, สิงหาคม 2026) โมเดลเดียวกันทุกที่ ผลลัพธ์ไม่ใกล้เคียงกันเลย

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

ตอนนี้ส่วนที่บทความส่วนใหญ่ข้ามไป DeepSeek Harness ไม่ได้อยู่ในตารางนั้น การวัดประสิทธิภาพตีพิมพ์เมื่อวันที่ 11 สิงหาคม และ Harness เปิดตัวในวันที่ 13 สิงหาคม ยังไม่มีตัวเลขโทเค็นแบบ head-to-head ที่น่าเชื่อถือสำหรับ DeepSeek Harness และใครก็ตามที่แสดงให้คุณเห็นในเดือนนี้ไม่ว่าจะรันเองบนงานที่แคบหรือสร้างขึ้นมาเอง สิ่งที่ตารางให้คุณคือพื้นฐานที่มั่นคงและมีแหล่งที่มาสำหรับ OpenCode: 692,000 โทเค็นต่องาน อัตราผ่าน 46.7% ค่ามัธยฐานเวลา 129.7 วินาที

นั่นคือตัวเลขที่คุณพยายามจะเอาชนะ และส่วนที่เหลือของบทความนี้คือวิธีทดสอบอย่างซื่อสัตย์

DeepSeek Harness vs OpenCode: โมเดลเดียวกัน หนึ่ง endpoint สอง runtime

นี่คือรูปร่างที่ใช้งานได้จริงของแต่ละเครื่องมือก่อนที่เราจะรันอะไร

บรรทัดที่สำคัญคือแถวสถาปัตยกรรม OpenCode ให้ agent ที่สร้างมาอย่างดีแก่คุณและให้คุณขยายขอบได้ DeepSeek Harness ให้โครงกระดูกแก่คุณและให้คุณเปลี่ยนกระดูกสันหลัง รวมถึง agent loop ซึ่งเป็น plugin เอง นั่นเป็นสิ่งที่ผิดปกติอย่างแท้จริง และนั่นคือเหตุผลว่าทำไมมันยังเป็นรุ่น preview

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

สำหรับการสาธิตนี้ ฉันใช้ DeepSeek V4 Flash จาก Atlas Cloud เพราะมันเปิดเผย endpoint ที่เข้ากันได้กับ OpenAI แบบธรรมดาที่ฮาร์เนสทั้งสองยอมรับโดยไม่ต้องใช้โค้ดอะแดปเตอร์ และคีย์เดียวกันใช้ได้ทั้งสองรัน รายการ deepseek-v4-flash-0731 ที่นั่นมีราคา $0.14 ต่อล้านโทเค็นนำเข้า และ $0.28 ต่อล้านโทเค็นส่งออก พร้อมหน้าต่างบริบท 1,048,576 โทเค็น และเอาต์พุตสูงสุด 393,216 ณ เดือนสิงหาคม 2026 ผู้ให้บริการที่เข้ากันได้กับ OpenAI ใดๆ ก็ใช้ได้สำหรับการทดสอบนี้ ประเด็นคือฮาร์เนสทั้งสองต้องเข้าถึงอันเดียวกัน

สิ่งที่น่ารู้ก่อนเลือกโมเดล: OpenCode เผยแพร่ข้อมูลการใช้งานรวมของตัวเอง และโมเดล DeepSeek ได้เคลื่อนย้ายโทเค็น 233 ล้านล้านผ่านมัน โดย V4 Flash คิดเป็น 85.5% และ V4 Pro คิดเป็น 14.5% ที่เหลือ (OpenCode, สิงหาคม 2026) Flash คือสิ่งที่ระบบนิเวศใช้งานจริง

ขั้นตอนที่ 1: ชี้ DeepSeek Harness และ OpenCode ไปยังโมเดลเดียวกัน

รับคีย์ API หนึ่งอันและ base URL หนึ่งอัน จากนั้นป้อนเครื่องมือทั้งสองด้วยคู่ที่เหมือนกันทุกประการ สร้างคีย์ใน คอนโซล Atlas Cloud และส่งออกครั้งเดียว:

bashCopy
1export ATLAS_API_KEY="your-api-key"
2

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

bashCopy
1curl https://api.atlascloud.ai/v1/chat/completions \
2  -H "Authorization: Bearer $ATLAS_API_KEY" \
3  -H "Content-Type: application/json" \
4  -d '{
5    "model": "deepseek-ai/deepseek-v4-flash-0731",
6    "messages": [{"role": "user", "content": "ตอบกลับด้วยคำเดียว: พร้อม"}]
7  }'
8

การเห็นโมเดลตอบงานจริงครั้งเดียวผ่าน endpoint โดยตรงก่อนส่งให้ agent ช่วยได้มาก จากนั้นคุณจะรู้ว่ารันที่ล้มเหลวนั้นเป็นฮาร์เนส ไม่ใช่เส้นทาง:

พรอมต์งานของบทความที่โพสต์ไปที่ api.atlascloud.ai ถัดจากคำตอบจริงที่ DeepSeek V4 Flash 0731 ส่งคืนและการใช้โทเค็นที่การเรียกนั้นรายงาน

การเรียกจริงหนึ่งครั้งไปยัง deepseek-ai/deepseek-v4-flash-0731 ซึ่งเป็นรหัสโมเดลเดียวกันที่ฮาร์เนสทั้งสองจะใช้: โทเค็นนำเข้า 148 ตัว, โทเค็นส่งออก 6,879 ตัว, ในจำนวนนี้เป็นเหตุผล 5,731 ตัว นั่นคือพื้นของคุณก่อนที่ฮาร์เนสจะเพิ่ม schema เครื่องมือแม้แต่ตัวเดียว

ตอนนี้กำหนดค่าแต่ละด้าน DeepSeek Harness อ่าน $DSH_HOME/settings.yaml และผู้ให้บริการที่เข้ากันได้กับ OpenAI แบบกำหนดเองจะอยู่ภายใต้ plugin llm-pi-ai (เอกสาร DeepSeek Harness, สิงหาคม 2026):

yamlCopy
1llm-pi-ai:
2  providers:
3    atlas:
4      apiKeyEnv: ATLAS_API_KEY
5      api: openai-completions
6      baseURL: https://api.atlascloud.ai/v1
7      models:
8        - id: deepseek-ai/deepseek-v4-flash-0731
9

ฟิลด์ api ยอมรับ openai-completions, openai-responses หรือ anthropic-messages ใช้ openai-completions ที่นี่ หากคุณไม่ต้องการแก้ไข YAML ด้วยตนเอง Web UI มี Settings จากนั้น Models จากนั้น Add a custom provider ซึ่งจะเขียนบล็อกเดียวกันและเก็บคีย์ไว้ใน $DSH_HOME/.credentials.yaml แทน

OpenCode อ่าน opencode.json ในรากโปรเจกต์ของคุณหรือไดเรกทอรีการกำหนดค่าส่วนกลาง (เอกสาร OpenCode, สิงหาคม 2026):

jsonCopy
1{
2  "$schema": "https://opencode.ai/config.json",
3  "provider": {
4    "atlas": {
5      "npm": "@ai-sdk/openai-compatible",
6      "name": "Atlas Cloud",
7      "options": {
8        "baseURL": "https://api.atlascloud.ai/v1",
9        "apiKey": "{env:ATLAS_API_KEY}"
10      },
11      "models": {
12        "deepseek-ai/deepseek-v4-flash-0731": {
13          "name": "DeepSeek V4 Flash 0731",
14          "limit": { "context": 1048576, "output": 393216 }
15        }
16      }
17    }
18  },
19  "model": "atlas/deepseek-ai/deepseek-v4-flash-0731"
20}
21

ใช้ @ai-sdk/openai-compatible ไม่ใช่ @ai-sdk/openai เนื่องจาก endpoint นี้ให้บริการ /v1/chat/completions ตั้งค่า limit เป็นค่าบริบทและเอาต์พุตจริง เพราะ OpenCode ใช้เพื่อตัดสินใจเมื่อจะสรุป และขีดจำกัดที่ผิดจะทำให้การเปรียบเทียบโทเค็นของคุณคลาดเคลื่อนอย่างมาก

ขั้นตอนที่ 2: รันงานวัดประสิทธิภาพใน DeepSeek Harness

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

นี่คือพรอมต์งานที่แน่นอน วางตามตัวอักษรลงในฮาร์เนสทั้งสอง:

textCopy
1ใน repository นี้ ให้เพิ่ม middleware rate limiter แบบ token-bucket สำหรับแอป Express
2ใน src/server.js จำกัดแต่ละ IP ไว้ที่ 60 คำขอต่อนาที เมื่อถูกปฏิเสธ ให้ส่งคืน HTTP 429
3พร้อม body JSON {"error":"rate_limited","retryAfter":<seconds>}
4ต่อ middleware เข้ากับทุก route /api/* เพิ่ม unit tests ใน
5test/rate-limit.test.js ครอบคลุมสามกรณี: คำขอที่ต่ำกว่าขีดจำกัดถูกอนุญาต,
6คำขอที่เกินขีดจำกัดถูกบล็อกด้วย 429, และตัวนับรีเซ็ตหลังจาก window หมดอายุ
7รันชุดทดสอบและแก้ไขข้อผิดพลาดจนกว่าจะผ่าน
8ห้ามแก้ไขไฟล์ใดๆ นอก src/ และ test/
9

เริ่ม Harness จากไดเรกทอรีโปรเจกต์ของคุณ:

bashCopy
1cd /path/to/your/repo
2npx @deepseek-ai/dsh web
3

จะให้บริการ Web UI ที่ http://127.0.0.1:3080 เลือกผู้ให้บริการ atlas และโมเดล deepseek-ai/deepseek-v4-flash-0731 วางงาน และปล่อยให้มันรันจนเสร็จ อย่าแทรกแซง อย่าตอบคำถามที่ชี้แจงด้วยคำใบ้ ความช่วยเหลือใดๆ ที่คุณให้ฮาร์เนสหนึ่งแต่ไม่ให้อีกอันจะทำให้การเปรียบเทียบใช้ไม่ได้

เมื่อเสร็จแล้ว ให้เปิดมุมมอง Trajectory นั่นคือบันทึก session และเป็นที่ที่ตัวเลขโทเค็นอยู่

ขั้นตอนที่ 3: รันซ้ำใน OpenCode เพื่อการทดสอบ DeepSeek Harness vs OpenCode ที่ยุติธรรม

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

bashCopy
1git checkout -- . && git clean -fd
2

จากนั้นรัน OpenCode กับโมเดลเดียวกัน:

bashCopy
1opencode --model atlas/deepseek-ai/deepseek-v4-flash-0731
2

วางพรอมต์งานที่เหมือนกันจากขั้นตอนที่ 2 ใช้ agent build เริ่มต้น เนื่องจากเป็นตัวที่มีสิทธิ์เข้าถึงไฟล์และ shell เต็มรูปแบบ อีกครั้ง ไม่มีคำใบ้ ไม่มีการแก้ไขแนวทาง ปฏิบัติแบบไม่แทรกแซงเหมือนกัน

ปล่อยให้มันเสร็จ จากนั้นตรวจสอบทั้งสองรันด้วยวิธีเดียวกับที่คุณให้คะแนน PR ใดๆ:

bashCopy
1npm test
2

รันที่ทำให้ชุดทดสอบเป็นสีแดงถือว่าไม่ผ่าน ไม่ว่าสรุปจะฟังดูมั่นใจแค่ไหน ให้คะแนนแบบ binary เช่นเดียวกับวิธีการของ Composio rate limiter ที่ทำงานได้ครึ่งเดียวคือความล้มเหลว

ขั้นตอนที่ 4: อ่านการใช้โทเค็นของ DeepSeek Harness vs OpenCode

ตอนนี้รวบรวมตัวเลข ฮาร์เนสทั้งสองติดตามการใช้งาน แต่แสดงออกแตกต่างกันมาก และนี่คือความแตกต่างที่ใหญ่ที่สุดในแต่ละวันระหว่างพวกมัน

DeepSeek Harness มีมิเตอร์โทเค็นติดตั้งตามค่าเริ่มต้น มันแสดงการคาดการณ์ session สามแบบที่คุณอ่านได้โดยตรง: tokenUsage สำหรับยอดรวมปัจจุบัน contextPressure สำหรับความใกล้ชิดกับหน้าต่าง และ contextBreakdown สำหรับตำแหน่งที่โทเค็นไปจริงๆ อันสุดท้ายมีประโยชน์ เพราะมันบอกคุณว่าใบเรียกเก็บเงินของคุณคือพรอมต์ระบบ, schema เครื่องมือ, การอ่านไฟล์ หรือการเล่นซ้ำบทสนทนา มิเตอร์ใช้ฮิวริสติกแบบตายตัวประมาณหนึ่งโทเค็นต่อสี่อักขระ ไม่ใช่ tokenizer จริง ดังนั้นให้ถือว่าเป็นค่าประมาณที่แม่นยำ ไม่ใช่ใบแจ้งหนี้

Harness ยังจัดการกับบริบทที่เต็มแตกต่างกัน แทนที่จะตัดทิ้ง เอ็นจิ้นการบีบอัดจะพับ (fold): มันแทนที่พื้นผิวที่โมเดลมองเห็นด้วยบทสรุป ในขณะที่บันทึกแบบเต็มยังคงอยู่ในเลเยอร์การคงอยู่ คุณสูญเสียโทเค็นจากพรอมต์ ไม่ใช่ประวัติจากบันทึก

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

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

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

การใช้โทเค็นของ DeepSeek harness: อะไรทำให้ค่าใช้จ่ายเพิ่มขึ้นจริงๆ

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

การเล่นซ้ำบทสนทนามักจะเป็นรายการที่ใหญ่ที่สุด Agent ส่งบทสนทนาที่เพิ่มขึ้นทุกขั้นตอน งาน 40 ขั้นตอนไม่ได้มีค่าใช้จ่าย 40 พรอมต์ แต่มีค่าใช้จ่ายใกล้เคียงกับผลรวมของพรอมต์ที่ยาวขึ้นเรื่อยๆ 40 อัน นี่คือสาเหตุที่การวัดประสิทธิภาพกระจายจาก 192,000 ถึง 1,400,000 โทเค็นบนงานที่เหมือนกัน ฮาร์เนสที่สรุปอย่างรุนแรงจะอยู่ที่ด้านล่างของช่วงนั้น

การแคช hit คือการปรับแต่งที่ถูกที่สุดที่มี DeepSeek V4 Flash แคช hit มีราคาประมาณ $0.0028 ต่อล้านโทเค็น เทียบกับ $0.14 ต่อล้านเมื่อ miss ซึ่งถูกกว่าประมาณ 98% การแคชจะทำงานได้ก็ต่อเมื่อคำนำหน้าคำขอเหมือนกันทุกไบต์ ซึ่งเป็นเหตุผลที่ DeepSeek Harness บังคับใช้การแทนที่ {{variable}} อย่างเคร่งครัดด้วยความหมาย fail loud และรักษาส่วนหัวคำขอที่เสถียร ฮาร์เนสที่สับเปลี่ยนพรอมต์ระบบระหว่างการเรียกจะเปลี่ยน hit ทุกครั้งเป็น miss อย่างเงียบๆ

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

ผลลัพธ์เครื่องมือที่ใหญ่เกินไปจะทำให้บริบทเป็นพิษ การ cat ไฟล์ 3,000 บรรทัดหนึ่งครั้ง หรือ test runner ที่ verbose ที่ทิ้ง stack traces เต็มๆ จะอยู่ในบทสนทนาตลอดช่วงที่เหลือของรัน Harness มี companion การตัดแต่งผลลัพธ์แบบเลือกได้ที่จะเขียนผลลัพธ์เครื่องมือที่ใหญ่เกินไปใหม่ก่อนสรุป มันคุ้มค่าที่จะเปิดใช้งาน

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

ในเรื่องต้นทุน เลขคณิตนั้นง่ายเมื่อคุณมีจำนวนโทเค็น ที่อัตรา Atlas Cloud สำหรับ DeepSeek V4 Flash งาน 692,000 โทเค็นที่ถ่วงน้ำหนักไปทางนำเข้าจะอยู่ในหลักเซนต์ต่ำๆ นั่นคือข่าวดีเกี่ยวกับหมวดหมู่ทั้งหมดนี้: โมเดลมีราคาถูกพอที่การสิ้นเปลืองของฮาร์เนสเป็นปัญหาด้านประสิทธิภาพมากกว่าภาวะฉุกเฉินด้านงบประมาณ มันจะกลายเป็นตัวเลขจริงก็ต่อเมื่อคุณคูณด้วยทีมที่รันตลอดทั้งวันทุกวัน เรียกดู แคตตาล็อกโมเดล ทั้งหมด หากคุณต้องการรันการทดสอบเดียวกันกับโมเดลที่สองและแยกผลกระทบของโมเดลออกจากผลกระทบของฮาร์เนส

ข้อควรระวังหนึ่งข้อที่ควรกำหนดการตัดสินใจของคุณมากกว่าตัวเลขโทเค็นใดๆ: DeepSeek Harness อยู่ใน developer preview อย่างชัดเจน และ README ของมันเองเตือนด้วยตัวพิมพ์ใหญ่ว่าจะมีการเปลี่ยนแปลงที่ทำลายความเข้ากันได้ นั่นเป็นสิ่งที่ดีสำหรับการวัดประสิทธิภาพ แต่เป็นความเสี่ยงสำหรับการทำให้ทีมของคุณใช้เป็นมาตรฐานในเดือนนี้ OpenCode เป็นตัวเลือกที่น่าเบื่อ และความน่าเบื่อเป็นคุณสมบัติเมื่อมันรันบน repo การผลิตของคุณ

คำถามที่พบบ่อย

DeepSeek Harness ดีกว่า OpenCode หรือไม่?

ยังไม่ใช่ สำหรับคนส่วนใหญ่ OpenCode โตเต็มที่ ทำงานบน terminal มีดาวประมาณ 198k และแคตตาล็อกผู้ให้บริการขนาดใหญ่ และมันทำงานได้ในวันนี้ DeepSeek Harness อายุสองสัปดาห์ อยู่ใน developer preview และเตือนเกี่ยวกับการเปลี่ยนแปลงที่ทำลายล้าง Harness น่าสนใจกว่าในเชิงสถาปัตยกรรม เนื่องจากทุกส่วนประกอบรวมถึง agent loop เป็น plugin ที่เปลี่ยนได้ หากคุณต้องการเขียน agent internals ใหม่ Harness สร้างมาเพื่อสิ่งนั้น หากคุณต้องการส่งโค้ดในสัปดาห์นี้ ใช้ OpenCode

DeepSeek Harness ทำงานกับโมเดล DeepSeek เท่านั้นหรือไม่?

ไม่ มันไม่ขึ้นกับโมเดล มันมีผู้ให้บริการในตัวสำหรับ DeepSeek, Anthropic, OpenAI, Bedrock, Vertex, Azure และ Codex และคุณสามารถเพิ่มผู้ให้บริการที่กำหนดเองที่พูด openai-completions, openai-responses หรือ anthropic-messages ได้โดยเพิ่มบล็อกใน $DSH_HOME/settings.yaml การกำหนดค่าในขั้นตอนที่ 1 ชี้ไปยัง endpoint ที่เข้ากันได้กับ OpenAI ของบุคคลที่สามโดยไม่ต้องใช้โค้ดอะแดปเตอร์

ฉันจะตรวจสอบการใช้โทเค็นของ DeepSeek harness ได้อย่างไร?

ใช้มิเตอร์โทเค็นในตัวซึ่งติดตั้งตามค่าเริ่มต้นและแสดงการคาดการณ์ tokenUsage, contextPressure และ contextBreakdown ซึ่งมองเห็นได้ในมุมมอง Trajectory โปรดทราบว่ามันประมาณด้วยฮิวริสติกแบบตายตัวประมาณหนึ่งโทเค็นต่อสี่อักขระ แทนที่จะใช้ tokenizer จริง เพื่อความถูกต้องในการเรียกเก็บเงิน ให้อ่านแดชบอร์ดการใช้งานของผู้ให้บริการแทน โดยดีที่สุดคือใช้คีย์ API ที่เฉพาะเจาะจงต่อรัน Plugin ของชุมชนเช่นแดชบอร์ดการใช้โทเค็นจะเพิ่มบันทึกต่อ session แบบถาวร

ฮาร์เนสใดใช้โทเค็นน้อยกว่า DeepSeek Harness หรือ OpenCode?

ยังไม่มีการเปรียบเทียบแบบ head-to-head ที่ตีพิมพ์ การวัดประสิทธิภาพ 8 ฮาร์เนสบน DeepSeek V4 Flash วัด OpenCode ที่ 692,000 โทเค็นเฉลี่ยต่องาน แต่มันรันสองวันก่อนที่ DeepSeek Harness จะเปิดตัว ดังนั้น Harness จึงไม่รวมอยู่ ใครก็ตามที่อ้างตัวเลข Harness จากการวัดประสิทธิภาพนั้นกำลังอ้างสิ่งที่ไม่มีอยู่ รันการทดสอบขั้นตอนที่ 2 ถึงขั้นตอนที่ 4 บน repo ของคุณเอง เนื่องจากการใช้โทเค็นขึ้นอยู่กับขนาดโค้ดเบส การกำหนดค่า MCP และรูปร่างงานของคุณอย่างมาก

ฉันสามารถรัน DeepSeek Harness และ OpenCode กับคีย์ API เดียวกันได้หรือไม่?

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

ความแตกต่างระหว่าง agent และ harness คืออะไร?

กรอบความคิดของ DeepSeek คือ Agent = Model + Harness โมเดลทำการให้เหตุผล ฮาร์เนสคือทุกสิ่งที่เชื่อมต่อกับโลกจริง: การอ่านและเขียนไฟล์, การรันคำสั่ง shell, การเรียกเครื่องมือ, การจัดการ session, การจัดการการอนุมัติ และการขับเคลื่อนลูปที่ตัดสินใจว่าจะเกิดอะไรขึ้นต่อไป โมเดลเดียวกันบวกฮาร์เนสที่แตกต่างกันให้ agent ที่แตกต่างกันอย่างวัดได้ ซึ่งเป็นประเด็นทั้งหมดของการเปรียบเทียบนี้