Flint: Codiermodell mit 40B Parametern soll auf Laptops laufen

โดย Nokka (นก-กา) | ตรวจข้อมูล 27 ต.ค. 2026

บทความนี้เขียนโดย AI (deepseek-v4.1-flash · ผู้ให้บริการโมเดล: ollama-cloud) ผ่าน Hermes Agent ภายใต้การควบคุมและตรวจสอบคุณภาพโดยมนุษย์ - Nokka (นก-กา)

ในกลุ่ม DGX Spark Community Thailand มีโพสต์หนึ่งเล่าเรื่องโมเดลเขียนโค้ดตัวใหม่ที่คนใช้ Spark กำลังลองกันเยอะ

โมเดลนั้นชื่อ Flint จากบริษัท Recursive ปล่อยเมื่อ 21 ตุลาคม 2026 แบบเปิดน้ำหนักและใช้สัญญา Apache 2.0

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

Flint เป็นโมเดลแบบ mixture-of-experts หรือ MoE ที่มีพารามิเตอร์รวม 39.8 พันล้านตัว

แต่ในแต่ละโทเคนมันเปิดใช้งานเพียงประมาณ 2.5 พันล้านตัวเท่านั้น

นี่คือเหตุผลที่มันเร็วได้แม้ขนาดรวมจะใหญ่ เพราะการคำนวณต่อโทเคนไม่ได้ใช้ทั้งโมเดล

ทีม Recursive เขียนไว้ในบล็อกว่าทีมเล็ก ๆ ของคนและ agent สร้างมันขึ้นมาใหม่ตั้งแต่ต้นในเวลาไม่ถึงสี่เดือน

ระบบที่ช่วยงานนี้ชื่อ Eureka Machine ซึ่งเป็นระบบวิจัย AI อัตโนมัติของบริษัท

ข้อความนี้สำคัญเพราะมันบอกว่าคำโฆษณาของ Flint ไม่ได้มีแค่เรื่องความเร็ว แต่รวมถึงคำถามใหญ่ว่า AI ช่วยสร้าง AI ได้แค่ไหน

โมเดลมี 49 ชั้น เป็นชั้น dense 2 ชั้น ตามด้วยชั้น MoE 47 ชั้น

ในแต่ละชั้น MoE มีผู้เชี่ยวชาญ 256 ตัว เลือกใช้ 6 ตัวต่อโทเคน พร้อมผู้เชี่ยวชาญร่วมที่ทำงานตลอด

ชั้น attention แบ่งเป็นแบบ sliding window 35 ชั้น และแบบ full attention 14 ชั้น โดยหน้าต่างเลื่อนกว้าง 513 โทเคน

หน้าโมเดลระบุบริบทที่ตั้งค่าไว้ 262,144 โทเคน รวมพรอมป์และผลลัพธ์

แต่บล็อกเปิดตัวเขียนว่ามันรองรับบริบทสูงสุด 512,000 โทเคน และแนะนำให้อยู่ในช่วง 256,000 โทเคนเพื่อผลลัพธ์ที่ดีที่สุด

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

หน้าโมเดลให้ตัวเลขสามชุด คือ Terminal-Bench 2.1 ที่ 54.9 เปอร์เซ็นต์, SWE-bench Pro v2 ที่ 89.7 เปอร์เซ็นต์ และ SWE-bench Verified ที่ 74.2 เปอร์เซ็นต์

ตัวเลขทั้งหมดเป็นผลประเมินของ Recursive เอง ไม่ใช่ผลจากการทดสอบโดยทีมอื่น

การประเมินใช้ temperature 1.0, top-p 0.95 และ top-k 20 และรายงานค่าเฉลี่ย pass@1 จากการลองอย่างน้อยห้าครั้ง

Terminal-Bench ใช้ Terminus 2 และนับคำตอบที่ได้จากการค้นเว็บว่าไม่ผ่าน ส่วน SWE-bench ใช้ mini-swe-agent โดยไม่ต่ออินเทอร์เน็ต

เงื่อนไขพวกนี้สำคัญมาก เพราะโมเดลเดียวกันให้คะแนนต่างกันได้ถ้าใช้ scaffold หรือเครื่องมือคนละชุด

ผมค้นแล้วยังไม่พบทีมอิสระที่รัน benchmark ทั้งสามชุดซ้ำแล้วได้ตัวเลขใกล้เคียง

แต่มีนักข่าวที่ทดลองใช้จริง วิล ไนต์ จาก WIRED ลอง Flint บนแมคหน่วยความจำ 48 GB เพื่อสร้างโปรแกรมเล็ก ๆ หลายชิ้น และรายงานว่ามันทำตามคำขอได้ทุกครั้ง ซึ่งเป็นการทดลองเชิงคุณภาพ ไม่ใช่การรัน benchmark ซ้ำ

บทวิเคราะห์จากนักพัฒนาอิสระก็ระบุตรงกันว่าไม่ควรอ่านตัวเลขเหล่านี้เป็นข้อเท็จจริงจนกว่าจะมีคนลองเอง

นี่ไม่ใช่ข้อเสียของ Flint แต่เป็นสถานะปกติของโมเดลที่เพิ่งออกใหม่

บล็อกระบุว่า Flint ทำความเร็วได้กว่า 125 โทเคนต่อวินาทีบน MacBook Pro ชิป M4 Pro

และกว่า 150 โทเคนต่อวินาทีบน NVIDIA RTX Spark ขนาด 64 GB ในบริบทสั้น

ตัวเลข 150 เป็นค่าที่บล็อกระบุว่าวัดในบริบทสั้น ส่วนค่าในกราฟเป็นค่าเฉลี่ยตลอดเซสชัน 128,000 โทเคน โดยไม่นับเวลา prefill จึงไม่ควรนำสองตัวนี้มาเทียบกันตรง ๆ

PCMag รายงานว่า DGX Spark รุ่น 64 GB เปิดตัว 23 ตุลาคม ที่ราคาเริ่ม 4,999 ดอลลาร์ ส่วนรุ่น 128 GB อยู่ที่ 5,999 ถึง 9,000 ดอลลาร์

ถ้าจะซื้อในไทยต้องบวกภาษีนำเข้าและค่าขนส่งเข้าไปด้วย และผมยังไม่พบข้อมูลราคาขายไทยจากแหล่งที่ตรวจได้

ถ้าโมเดลระดับ 40B รันบนเครื่องพวกนี้ได้จริงในความเร็วที่ใช้งานได้ มันเปลี่ยนวิธีทำงานของฟรีแลนซ์และสตูดิโอเล็กได้

แต่คำว่าใช้งานได้ของแต่ละคนไม่เท่ากัน คนที่รอ 30 วินาทีต่อคำตอบได้ กับคนที่ต้องการทันทีจะรู้สึกต่างกันมาก

ไฟล์ BF16 ทั้งชุดมีขนาดรวมประมาณ 79.6 GB และหน้าโมเดลระบุว่าต้องใช้ B300 หรือ H200 หนึ่งใบต่อหนึ่งอินสแตนซ์

นี่คือเหตุผลที่คนส่วนใหญ่ไม่ได้เริ่มจาก BF16 แต่เริ่มจากไฟล์บีบอัด

ไฟล์ NVFP4 รวมกันประมาณ 22.9 GB ส่วนไฟล์ int4 GGUF อยู่ที่ประมาณ 26.0 GB ซึ่งเป็นรีโปควอนไทซ์ที่แยกออกมาต่างหาก

ระดับนี้ทำให้รันในเครื่อง 64 GB ได้สบาย และเก็บบริบทได้ยาวขึ้นบนเครื่อง 128 GB

แต่การบีบอัดแลกมาด้วยคุณภาพที่อาจต่างจาก BF16 และต้องวัดกับงานของคุณเอง

หน้าโมเดลมีชุดคำสั่งสำหรับเสิร์ฟผ่าน SGLang และตัวอย่างไคลเอนต์ที่ใช้ API แบบเดียวกับ OpenAI

from openai import OpenAI client = OpenAI ( base_url = " http://localhost:30000/v1 ", api_key = " unused " ) response = client. chat. completions. create ( model = " flint ", messages = [{ " role ": " user ", " content ": " Write a Python function that merges overlapping intervals. " }], max_tokens = 32768, ) choice, = response. choices print ( choice. message. content ) Enter fullscreen mode Exit fullscreen mode จุดที่คนมักพลาดคือการตั้ง max_tokens ต่ำเกินไป เพราะโมเดลใช้โทเคนจำนวนมากไปกับการคิดก่อนตอบ

หน้าโมเดลแนะนำอย่างน้อย 32,768 โทเคนสำหรับปัญหายาก และให้เก็บ reasoning_content ไว้ในประวัติบทสนทนา

น้ำหนักโมเดลใช้สัญญา Apache 2.0 ซึ่งอนุญาตให้ใช้เชิงพาณิชย์และดัดแปลงได้

แต่เงื่อนไขการใช้งานผ่าน API ที่ Recursive ให้บริการนั้นแยกจากสัญญาน้ำหนักโมเดล

แปลว่าการโหลดไปรันเองกับการใช้บริการคลาวด์ของเขาไม่เหมือนกัน

หน้าโมเดลเตือนว่าแม้จะฝึกด้วยตัวอย่างด้านความปลอดภัย แต่ก็ยังสร้างโค้ดผิดหรือเรียกเครื่องมือผิดได้

และเตือนอีกว่าการมี grammar ของ tool call ที่ถูกต้องไม่ได้รับประกันว่าโมเดลจะเลือกการกระทำที่ปลอดภัย

ถ้าคุณให้มันรันคำสั่งในเครื่อง ต้องกำหนดสิทธิ์และขอบเขตการทำงานเอง

เอกสารของ Flint ไม่ได้กล่าวถึงการประเมินภาษาไทยหรือภาษาเอเชียตะวันออกเฉียงใต้ไว้เลย

ผมจึงไม่สามารถบอกได้ว่ามันเขียนโค้ดจากคอมเมนต์ภาษาไทยได้ดีแค่ไหน จนกว่าจะมีคนทดสอบจริง

ถ้างานของคุณมีคอมเมนต์หรือ requirement เป็นภาษาไทย นี่คือจุดที่ต้องลองเองก่อนตัดสินใจ

คุณมีเครื่อง 64 GB ขึ้นไป และงานหลักคือแก้บั๊กในโค้ดเบสที่ส่งออกนอกองค์กรไม่ได้

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

คุณต้องการตัวเลข benchmark ที่มีคนอื่นตรวจซ้ำแล้ว หรือต้องใช้กับงานที่ต้องการความแม่นสูงมากในโดเมนเฉพาะ

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

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

ถ้าผลออกมาดีกว่าหรือใกล้เคียงในต้นทุนที่ต่ำกว่า นั่นคือเหตุผลที่ดีพอจะย้าย

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

Flint เป็นโมเดลโค้ด 40B แบบ MoE ที่เปิดน้ำหนักและใช้ Apache 2.0 อย่างแท้จริง

จุดที่น่าจับตาคือมันออกแบบมาให้เร็วบนเครื่องเดี่ยว ซึ่งเป็นทิศทางที่ต่างจากโมเดลใหญ่ที่ต้องพึ่งคลาวด์

แต่ตัวเลขความเร็วและ benchmark ทั้งหมดยังเป็นของบริษัทผู้พัฒนาเอง

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

DGX Spark Community Thailand (ต.ค. 2026) · โพสต์แนะนำ Flint. https://www.facebook.com/groups/1574708491001421/posts/1678850977253838/ Recursive (21 ต.ค. 2026) · RecursiveSI/flint model card. https://huggingface.co/RecursiveSI/flint Recursive (ต.ค.

2026) · Introducing Flint. https://www.recursive.com/updates/introducing-recursive-flint Recursive (2026) · LICENSE (Apache 2.0). https://huggingface.co/RecursiveSI/flint/raw/main/LICENSE Jamil (22 ต.ค. 2026) · Flint Is a Coding Model. The Bigger Test Is Whether AI Can Build the Next One. https://dev.to/jamilxt/flint-is-a-coding-model-the-bigger-test-is-whether-ai-can-build-the-next-one-27jo PCMag (ต.ค.

2026) · Facing Memory Crunch, Nvidia Creates 64GB DGX Spark. https://www.pcmag.com/news/facing-memory-crunch-nvidia-creates-64gb-rtx-spark-it-still-costs-4999 TechCrunch (21 ต.ค. 2026) · Recursive launches Flint, a laptop coding model it says was largely built by AI. https://techcrunch.com/2026/10/21/recursive-launches-flint-a-laptop-coding-model-it-says-was-largely-built-by-ai/