ข้อความชุดเดียวกัน ส่งเข้า Kimi K3 สองครั้ง ค่าอินพุตต่างกันได้สิบเท่า ครั้งหนึ่งคิดที่ $0.30 ต่อหนึ่งล้านโทเคน (หน่วยนับข้อความเพื่อคิดเงิน) อีกครั้งคิดที่ $3.00 ทั้งที่คำถามเหมือนกันทุกตัวอักษร ตัวที่ทำให้ราคาต่างกันจึงไม่ใช่คำถาม แต่เป็นข้อความที่วางอยู่ก่อนหน้าคำถามนั้น

K3 คือรุ่นเรือธงของ Moonshot AI มีพารามิเตอร์ 2.8 ล้านล้านตัว จุดที่ทำให้มันต่างจากโมเดลเปิดรุ่นก่อนหน้า คือมันไปยืนอยู่ในชั้นเดียวกับโมเดลปิดรุ่นท็อปอย่าง GPT 5.6 Sol กับ Claude Fable 5 ได้เป็นตัวแรก นี่คือข้อสรุปจากคู่มือนักพัฒนาของ Together AI เจ้าที่จับมือกับทีม Moonshot เอง เพื่อเปิดให้เรียก K3 ผ่านระบบ API ได้

แต่ราคาที่จ่ายจริงไม่ได้ขึ้นกับตารางราคาอย่างเดียว มันขึ้นกับสองปุ่มที่ต้องตั้งเองตั้งแต่ก่อนกดเรียกครั้งแรก คือ cache หรือระบบบันทึกความจำส่วนหัว ที่ทำงานให้ก็ต่อเมื่อข้อความส่วนหัวไม่ขยับสักตัวอักษร กับระดับการคิดที่มาพร้อมค่าตั้งต้นแรงสุด

Kimi K3 ตัวใหญ่สุดในบรรดาโมเดลเปิด แต่ไม่ได้เปิดทุกอย่าง

พารามิเตอร์ 2.8 ล้านล้านตัวทำให้ K3 นับอยู่ในชั้นสามล้านล้าน และเป็นเจ้าแรกของฝั่งโมเดลเปิดที่ขึ้นมาถึงชั้นนี้ คู่มือฉบับนี้ระบุว่ามันใหญ่ที่สุดในบรรดาโมเดลที่เคยปล่อยน้ำหนักออกมาให้คนอื่นใช้ ตลอดสิบสองเดือนตั้งแต่กรกฎาคม 2025 ถึงกรกฎาคม 2026 มีอยู่เก้าเดือนที่เพดานขนาดของโมเดลเปิดอยู่ในมือตระกูล Kimi

คำว่าเปิดในที่นี้ต้องอ่านให้ตรง มันคือ open weights แปลว่าปล่อยตัวน้ำหนักของโมเดลให้โหลดไปรันเองได้ แต่ไม่ได้เปิดข้อมูลกับโค้ดที่ใช้เทรนตามไปด้วย มีคนพาโมเดลเต็มก้อนขนาดนี้ลงไปรันบน MacBook Pro แรม 64 GB เครื่องเดียวได้จริง ที่ความเร็วราวครึ่งโทเคนต่อวินาที แต่นั่นเป็นคนละเรื่องกับการเรียกผ่าน API ที่คู่มือฉบับนี้พูดถึง

โมเดลไม่ได้ปลุกพารามิเตอร์ทั้งก้อนขึ้นมาทำงานพร้อมกันทุกครั้ง โครงสร้างที่ Moonshot เรียกว่า Stable LatentMoE จะปลุกผู้เชี่ยวชาญย่อยขึ้นมาทำงานแค่ 16 ตัวจากที่มีอยู่ 896 ตัว ในทุกหนึ่งโทเคนที่อ่าน คิดเป็นราว 2% ของทั้งหมด นั่นคือเหตุผลที่โมเดลขนาดนี้ยังเปิดให้เรียกใช้ในราคาระดับนี้ได้

ส่วนที่ทำให้มันอ่านบทสนทนายาวมากๆ ได้ คือสถาปัตยกรรมสองชิ้นที่ Moonshot ออกแบบเอง ชื่อ Kimi Delta Attention กับ Attention Residuals

ผลทดสอบ Kimi K3 นำที่ไหน แล้วตามที่ไหน

รายการที่ K3 ทำคะแนนนำมีห้ารายการ คือ BrowseComp, SWE Marathon, AutomationBench, DeepSearchQA และ OmniDocBench ทั้งหมดเป็นชุดทดสอบงานเขียนโค้ดยาว กับงานที่ปล่อยให้ AI เดินเองหลายขั้นจนจบ แต่บางรายการก็ยังตามโมเดลปิดรุ่นท็อปอยู่

สองแถวล่างคือด้านที่ยังตามอยู่ ส่วนโมเดลเปิดอีกตัวที่เอามาวัดในชุดเดียวกันคือ GLM-5.2 และ K3 ทำได้ดีกว่าชัดเจนทุกรายการที่มีข้อมูล

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

อีกบรรทัดที่ต้องอ่านคู่กับตารางเสมอ คือผลทั้งกระดานนี้วัดตอนตั้งระดับการคิดไว้ที่ max ซึ่งเป็นระดับสูงสุดที่โมเดลมีให้

เรียก Kimi K3 ครั้งแรกด้วยโค้ดไม่กี่บรรทัด

API ของ K3 ใช้รูปแบบเดียวกับ OpenAI ใครเคยเขียนโค้ดเรียก AI มาก่อนจะย้ายมาได้แทบจะทันที เริ่มจากติดตั้งไลบรารีทางการก่อน

python3 -m pip install --upgrade 'together>=2.0.0'

จากนั้นเรียก Kimi K3 บน Together AI ด้วยชื่อโมเดลที่ต้องพิมพ์ให้ตรงคือ moonshotai/Kimi-K3

import os
from together import Together

MODEL = "moonshotai/Kimi-K3"

client = Together(
    api_key=os.environ["TOGETHER_API_KEY"],
)

completion = client.chat.completions.create(
    model=MODEL,
    messages=[{"role": "user", "content": "Introduce Kimi K3 in one sentence."}],
    max_tokens=130_000,
)
print(completion.choices[0].message.content)

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

สามตัวเลขที่ประกอบกันเป็นบิลของ Kimi K3

ช่องอินพุตคือข้อความที่ส่งเข้าไป ส่วนเอาต์พุตคือข้อความที่โมเดลตอบกลับมา

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

ราคาชุดนี้เป็นของ Together AI ไม่ได้แปลว่าทุกเจ้าคิดเท่ากัน ถ้าย้ายไปเรียกที่อื่นก็ต้องเปิดตารางของที่นั่นดูใหม่

ปุ่มแรก cache จะทำงานก็ต่อเมื่อส่วนหัวไม่ขยับ

ทุกครั้งที่เรียก โมเดลจะอ่านบทสนทนาใหม่ตั้งแต่บรรทัดแรก ทั้งคำสั่งตั้งต้นที่เขียนไว้ใน system prompt ทั้งกองเอกสารความรู้ที่แนบไป ทั้งประวัติที่คุยกันมา ระบบจึงเก็บสำเนาของส่วนหัวที่เคยอ่านไปแล้วเอาไว้ ถ้ารอบถัดไปส่วนหัวก้อนนั้นเหมือนเดิมทุกไบต์ มันจะคิดเงินส่วนนั้นที่ราคาพื้น $0.30 แทนที่จะเป็น $3.00

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

คู่มือระบุว่าในงานเขียนโค้ดที่รักษาส่วนหัวไว้ได้ อัตราการจำได้เกิน 90% จะกดต้นทุนอินพุตจริงให้เข้าใกล้ราคาพื้น $0.30

ส่วนความยาวบริบท K3 รับข้อความได้ยาวสุด 1,048,576 โทเคนต่อการเรียกหนึ่งครั้ง หรือราวหนึ่งล้านโทเคน และเป็นตัวแรกในตระกูล Kimi ที่ยาวได้ขนาดนี้

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

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

def _get(obj, key, default=None):
    if obj is None:
        return default
    return obj.get(key, default) if isinstance(obj, dict) else getattr(obj, key, default)

usage = completion.usage
reasoning_tokens = _get(_get(usage, "completion_tokens_details"), "reasoning_tokens", 0)
cached_tokens = _get(_get(usage, "prompt_tokens_details"), "cached_tokens",
                     _get(usage, "cached_tokens", 0))

print(f"prompt={usage.prompt_tokens} cached={cached_tokens} "
      f"completion={usage.completion_tokens} thinking={reasoning_tokens}")
# -> prompt=86 cached=64 completion=133 thinking=111

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

ปุ่มที่สอง ค่าตั้งต้นของระดับการคิดคือแรงสุด

K3 มีระดับการคิดให้เลือกสามระดับผ่านฟิลด์ reasoning_effort คือ low, high และ max ถ้าไม่สั่งอะไรเลย ระบบจะใช้ max ให้เอง ใครไม่เคยใส่ฟิลด์นี้ลงในคำสั่งเรียก ก็เท่ากับสั่งให้โมเดลคิดหนักที่สุดทุกครั้ง รวมถึงคำถามที่ตอบจบได้ในบรรทัดเดียว และโทเคนความคิดทั้งกองนั้นวิ่งเข้าช่องเอาต์พุตที่ $15.00 ต่อหนึ่งล้านโทเคน ตัวเลขในตารางทดสอบข้างบนก็มาจากการตั้งค่าแบบนี้เหมือนกัน

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

# Adjust depth: "low" | "high" | "max"
completion = client.chat.completions.create(
    model=MODEL,
    reasoning_effort="low",
    messages=[{"role": "user", "content": "Prove that the square root of 2 is irrational."}],
    max_tokens=8192,
)

# Instant mode, no thinking tokens billed at all
fast = client.chat.completions.create(
    model=MODEL,
    messages=[{"role": "user", "content": "What is the capital of France?"}],
    reasoning={"enabled": False},
    max_tokens=256,
)

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

สามกับดักที่ทำให้คำตอบเพี้ยนโดยไม่รู้ตัว

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

temperature = 1.0
top_p = 0.95
n = 1
presence_penalty = 0
frequency_penalty = 0

กับดักที่สอง ร่องรอยความคิดที่หายไปจากประวัติ K3 ถูกเทรนมาให้ใช้ร่องรอยความคิดของรอบก่อนหน้า เป็นข้อมูลที่รอบถัดไปต้องใช้ต่อ ถ้าเก็บประวัติบทสนทนาแล้วตัดฟิลด์ reasoning_content ทิ้ง คำถามเดิมจะได้คำตอบใหม่ที่ไม่ตรงกันสักรอบ เพราะโมเดลคิดขึ้นมาใหม่จากศูนย์ทุกครั้ง ในโค้ดจริงไม่ต้องเขียนร่องรอยนั้นเองแม้แต่บรรทัดเดียว แค่เอาข้อความทั้งก้อนที่โมเดลตอบมา ส่งกลับเข้าไปในประวัติของรอบถัดไป หรือเปิด chat_template_kwargs={"preserve_thinking": True}

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

สุดท้ายแล้วสองปุ่มนี้ไม่ใช่ปุ่มประหยัด

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

ที่มา: บทความ Kimi K3: The Complete Developer Guide จาก Together AI