Knowledge Hub

Flint: โมเดลเขียนโค้ดที่รันบนแล็ปท็อป และแนวคิดการใช้ AI สร้าง AI

เข้าใจว่า Flint โมเดลโค้ดแบบเปิดขนาด 40B ทำงานเร็วบนเครื่องส่วนตัวได้เพราะอะไร ตัวเลขไหนวัดแล้วและไหนยังไม่ยืนยัน และตัดสินใจได้ว่าจะลองใช้ในงานของตัวเองหรือไม่

AI และเทคโนโลยีอ่าน 14 นาทีเผยแพร่ 22 ตุลาคม 2569

แก่นของเรื่อง

Flint เป็นโมเดลเขียนโค้ดแบบเปิด (Apache 2.0) จากบริษัท Recursive เปิดตัววันที่ 21 ตุลาคม 2026 มีพารามิเตอร์รวม 40 พันล้านตัว แต่ใช้จริงประมาณ 2.5 พันล้านตัวต่อหนึ่งงาน จึงรันบนแล็ปท็อปได้เร็ว

ใจความหลัก

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

ทำไมจึงได้ผล (กลไกเหตุ-ผล)

ปัจจัย กลไก ผลที่ตามมา
โครงสร้าง Mixture-of-Experts (MoE) แต่ละคำที่สร้างเรียกใช้ "ผู้เชี่ยวชาญ" เพียงบางกลุ่ม คำนวณต่อคำน้อยลง (ประมาณ 2.5B จาก 40B) จึงเร็วขึ้น
การฝึกแบบบิตต่ำ (low-bit training) เก็บน้ำหนักด้วยจำนวนบิตน้อยลง ขนาดโมเดลลดลง 71% โดยคุณภาพแทบไม่ตก ตามที่ Recursive ระบุ
Custom kernels เขียนโปรแกรมคำนวณเฉพาะให้เหมาะกับฮาร์ดแวร์ ใช้ชิป Apple และ Nvidia ได้เต็มที่ขึ้น
ระบบวิจัยอัตโนมัติ "Eureka Machine" AI คิดไอเดีย รันการทดลอง แล้วใช้ผลตัดสินใจรอบถัดไป ทีมเล็กสร้างโมเดลได้ในเวลาไม่ถึง 4 เดือน

ส่วน 20% ที่สำคัญที่สุดในทางปฏิบัติ

  • ต้องจำ: ข้อมูลความเร็วและคะแนนมาจากการทดสอบของ Recursive เอง ควรทดสอบกับงานของตัวเองก่อนเชื่อ
  • ต้องทำ: แตกงานใหญ่เป็นขั้นเล็ก และให้คำสั่งชัดเจน
  • รอได้: รายละเอียดเรื่อง AI สร้าง AI ในระดับสถาปัตยกรรมบริษัท ซึ่งไม่กระทบการใช้งานโมเดลวันนี้

ช่วยให้ดีขึ้นอย่างไร

สถานการณ์ ถ้าไม่มี ถ้ามี Flint วัดอย่างไร ป้ายหลักฐาน
ความเร็วบน MacBook Pro (M4 Pro) โมเดลคล้ายกันได้ 58 ถึง 69 tokens/s (รวม Gemma 4 และ Nemotron 3.5 Lightning) ประมาณ 131 tokens/s ราว 2 เท่า tokens/s บนเครื่องเดียวกัน วัดแล้ว (การทดสอบของ Recursive ยังไม่มีผู้ทดสอบอิสระยืนยัน)
ความเร็วบน Nvidia RTX Spark ไม่มีตัวเทียบในข้อมูลที่อ่าน มากกว่า 150 tokens/s tokens/s วัดแล้ว (การทดสอบของ Recursive)
แก้บั๊กจริงใน SWE-Bench Verified โมเดลต่ำกว่า 50B ตัวอื่น Flint ทำคะแนนสูงกว่าโมเดลกลุ่มนี้ % ของบั๊กที่แก้ได้ วัดแล้ว (ไม่มีตัวเลขคะแนนให้เทียบ)
คะแนนเฉลี่ย 6 การทดสอบ - มีเพียง Qwen3.8 27B ที่สูงกว่า คะแนนเฉลี่ย วัดแล้ว ผลคือ "ไม่ใช่อันดับ 1" ต้องบอกตรง ๆ
ขนาดโมเดล ขนาดเต็มก่อนบีบ เล็กลง 71% คุณภาพแทบไม่ตก ขนาดไฟล์และคะแนนก่อน/หลัง วัดแล้ว (ตัวเลขขนาดจาก Recursive ส่วนคำว่า "แทบไม่ตก" ไม่มีตัวเลขกำกับ)
ความเป็นส่วนตัวและต้นทุน โค้ดส่งขึ้นคลาวด์ เสียค่าใช้งาน รันในเครื่อง ใช้ออฟไลน์ได้ ไม่มีค่าใช้งานรายครั้ง ดูว่ามีข้อมูลออกนอกเครื่องหรือไม่ ตีความ จากการที่รันบนเครื่อง (ยังต้องจ่ายค่าฮาร์ดแวร์)
คุณภาพเทียบผู้ช่วยขนาดใหญ่แบบเสียเงิน - ต้องแนะนำมากกว่า ต้องแตกงานเป็นขั้นเล็ก จำนวนรอบแก้ไขต่องาน วัดแล้ว ในแง่ที่ Recursive ยอมรับเอง ซึ่งเป็นข้อแลกเปลี่ยน ไม่ใช่ข้อได้เปรียบ
ความเร็วในการพัฒนาโมเดล - ทีมเล็กใช้เวลาไม่ถึง 4 เดือน เวลาที่ประหยัดได้ ยังไม่ทดสอบ Recursive ไม่ได้บอกว่าระบบอัตโนมัติประหยัดเวลานักวิจัยไปเท่าไร
ประสบการณ์ใช้งานจริง โมเดลเล็กอื่นมักผิดพลาดหรือช้า ผู้ทดสอบอิสระ 1 ราย (Mac 48GB) สร้างแอปรายการงานและเครื่องมือค้นเว็บได้ทุกครั้ง จำนวนครั้งที่สำเร็จ วัดแล้ว แต่เป็นตัวอย่างเล็กมาก ยังสรุปรวมไม่ได้

ลองใช้

ตัวอย่างประกอบ (ตัวเลขเป็นของเราเอง คำนวณซ้ำได้)

ความเร็ว: ให้โมเดลตอบโค้ด 500 tokens

  • ที่ 131 tokens/s ใช้เวลา 500 ÷ 131 ≈ 3.8 วินาที
  • ที่ 60 tokens/s (กลางช่วง 58 ถึง 69) ใช้เวลา 500 ÷ 60 ≈ 8.3 วินาที
  • ต่างกันราว 4.5 วินาทีต่อคำตอบ ถ้าขอ 100 ครั้งต่อวัน ประหยัดราว 7.5 นาที

ขนาดไฟล์: สมมติโมเดล 40B เก็บแบบ 16 บิต (2 ไบต์ต่อพารามิเตอร์) = 80 GB เมื่อลด 71% จะเหลือ 80 × (1 − 0.71) ≈ 23 GB

  • ตัวเลข 80 GB เป็นสมมติฐานประกอบการคำนวณ ไม่ได้ระบุไว้ว่าฐานก่อนบีบเป็นแบบใด
  • ตัวเลข 23 GB พอเข้าใจได้ว่าทำไมการทดสอบบน Mac 48GB จึงทำงานได้ แต่ต้องตรวจขนาดไฟล์จริงตอนดาวน์โหลด

เมื่อไรควรใช้ / ไม่ควรใช้

เงื่อนไข ควรใช้ ไม่ควรใช้
ความเป็นส่วนตัวของโค้ด โค้ดห้ามออกนอกเครื่อง -
งานออฟไลน์ ไม่มีอินเทอร์เน็ตหรือเน็ตช้า -
ขนาดงาน แก้บั๊กเล็ก สคริปต์ แอปเล็ก งานข้ามหลายไฟล์ที่ต้องวางแผนยาว
ทักษะผู้ใช้ ยินดีแตกงานและตรวจผลเอง คาดหวังให้ทำงานใหญ่เองโดยไม่ต้องกำกับ
ฮาร์ดแวร์ มีหน่วยความจำพอ (ผู้ทดสอบอิสระใช้ 48GB) เครื่องหน่วยความจำน้อย (ไม่มีตัวเลขขั้นต่ำให้อ่าน)

ข้อกำหนดเบื้องต้น: เครื่องที่มีหน่วยความจำเพียงพอ, ตัวรันโมเดลที่รองรับ, และเวลาตรวจผลลัพธ์ทุกครั้ง

ก้าวแรกที่เล็กที่สุด

  1. ดาวน์โหลดโมเดลจาก Hugging Face (ตรวจว่าเป็นของ Recursive จริงก่อน เพราะไม่มีลิงก์ตรงให้อ้างอิง)
  2. เลือกงานจริงที่เล็กที่สุดจาก backlog 1 งาน เช่น เขียนฟังก์ชันพร้อมเทสต์
  3. สั่งงานทีละขั้น แล้วรันเทสต์ตรวจผล

การทดสอบก่อน/หลัง (กำหนดเกณฑ์ก่อนรัน)

รายการ วิธีวัด ฐานเปรียบเทียบ เกณฑ์ผ่าน (ตั้งก่อนรัน)
ความถูกต้อง เลือก 10 งานเล็กที่เคยทำแล้ว รันเทสต์ผ่านกี่งาน ผลของผู้ช่วยที่คุณใช้อยู่ ผ่านอย่างน้อย 70% ของฐาน (ตัวอย่างเกณฑ์ ปรับตามงาน)
ความเร็ว tokens/s ที่เครื่องคุณ ตัวเลข 131 จากผู้พัฒนา ไม่ต่ำกว่า 60% ของตัวเลขนั้น
ภาระกำกับ จำนวนรอบแก้ไขต่องาน ผู้ช่วยปัจจุบัน ไม่เกิน 2 เท่าของฐาน

หลักการและแนวคิดสำคัญ

Mixture-of-Experts (MoE)

  • คืออะไร: โมเดลที่แบ่งเป็นกลุ่มย่อย ("ผู้เชี่ยวชาญ") และเลือกใช้เฉพาะบางกลุ่มต่อหนึ่งขั้นการสร้างคำ
  • ทำไมสำคัญ: จำนวนพารามิเตอร์ที่ "ใช้จริง" เป็นตัวกำหนดความเร็ว ไม่ใช่จำนวนทั้งหมด
  • ข้อควรระวัง: ไฟล์ทั้งหมด 40B ยังต้องเก็บในหน่วยความจำ ความเร็วดี แต่ไม่ได้แปลว่าใช้หน่วยความจำน้อย
ตัวเลข ความหมาย
40B พารามิเตอร์ทั้งหมด
~2.5B พารามิเตอร์ที่ใช้ต่องาน (ประมาณ 6% ของทั้งหมด: 2.5 ÷ 40 = 0.0625)

การฝึกแบบบิตต่ำ (low-bit training)

  • ลดจำนวนบิตที่ใช้เก็บตัวเลขในโมเดล ผลคือไฟล์เล็กลง 71%
  • ข้อควรระวัง: "คุณภาพแทบไม่ตก" เป็นคำกล่าวของผู้พัฒนา ไม่มีตัวเลขคะแนนก่อน/หลังให้ตรวจ

Custom kernels

  • โปรแกรมคำนวณเฉพาะทางที่เขียนให้เหมาะกับชิปแต่ละแบบ ช่วยให้เร็วขึ้นโดยไม่เปลี่ยนผลลัพธ์ทางคณิตศาสตร์

Eureka Machine และการวิจัยที่ AI ช่วยทำ

ไอเดีย -> รันการทดลอง -> ดูผล -> เลือกสิ่งที่จะลองต่อ -> (วนซ้ำ)
  • Recursive ระบุว่าระบบนี้มีส่วนร่วมเกือบทุกขั้น ตั้งแต่ pretraining, post-training ถึง inference
  • สิ่งที่ระบุว่าระบบมีส่วนสร้าง: รูปทรงโมเดลแบบเบาบาง (sparser), การฝึกบิตต่ำ, custom kernels
  • ไม่มีข้อมูลว่ามนุษย์ตรวจสอบหรือแก้ไขส่วนไหนบ้าง

ข้อมูลเสริมที่เกี่ยวข้อง (ความรู้ทั่วไป ไม่ใช่ข้อมูลของ Flint)

  • Pretraining คือการฝึกโมเดลจากข้อมูลจำนวนมากให้รู้ภาษาและโค้ด, post-training คือการปรับให้ทำตามคำสั่งและใช้งานได้ดี
  • Inference คือขั้นตอนใช้โมเดลที่ฝึกเสร็จแล้วตอบคำถาม
  • Apache 2.0 อนุญาตให้ใช้ แก้ไข และแจกจ่ายต่อได้ รวมถึงเชิงพาณิชย์ โดยต้องคงประกาศลิขสิทธิ์และสัญญาอนุญาตไว้

บริบทของผู้พัฒนาและตลาด

หัวข้อ ข้อมูล ประเภท
บริษัท Recursive ก่อตั้งปี 2025 มุ่งสร้าง AI ที่พัฒนาตัวเองได้ ข้อเท็จจริง
ผู้บริหาร Richard Socher (CEO) อดีตหัวหน้านักวิทยาศาสตร์ของ Salesforce ข้อเท็จจริง
เงินทุน ออกจากสถานะ stealth เดือนพฤษภาคม 2026 ด้วยเงิน 650 ล้านดอลลาร์ มูลค่าบริษัท 4.65 พันล้านดอลลาร์ ข้อเท็จจริง
นักลงทุน GV, Nvidia, AMD Ventures ข้อเท็จจริง
ข้อตกลงคอมพิวต์ 410 ล้านดอลลาร์กับ AWS (มิถุนายน) ข้อเท็จจริง
เทียบกับโมเดลใหญ่ Meta Muse Spark Open มี 816B และต้องใช้หน่วยความจำอย่างน้อย 1 TB ข้อเท็จจริง
OpenAI (ก.ย.): กลางเดือนสิงหาคม เอเจนต์ทำงาน 3.1 วันต่อ 1 วันของนักวิจัยมนุษย์ บริบทของแนวโน้ม ข้อเท็จจริงที่มีผู้ระบุ

แยกข้อเท็จจริง ความเห็น และข้อที่ยังไม่พิสูจน์

ประเภท เนื้อหา
ข้อเท็จจริงที่เปิดเผยได้ เปิดตัว 21 ตุลาคม 2026, Apache 2.0, MoE 40B/2.5B, ดาวน์โหลดฟรีที่ Hugging Face
ตัวเลขจากผู้พัฒนาเอง 131 tokens/s (M4 Pro), >150 (RTX Spark), ลดขนาด 71%, อันดับ SWE-Bench
ความเห็น/เป้าหมาย เป้าหมายระยะยาว: recursive self-improvement เต็มรูปแบบ โดยมนุษย์กำกับและหยุดได้
คำกล่าวทางการตลาด "less about headcount and more about agent count"
ยังไม่พิสูจน์ คุณภาพไม่ตกหลังบีบ, เวลาที่ AI ประหยัดให้นักวิจัย, ผลบนงานจริงขนาดใหญ่
ข้อกังวลในวงการ บางกลุ่มกลัวว่า AI พัฒนาตัวเองจะหลุดการควบคุม แต่ของ Recursive มีคนดูแล

Risks

⚠️ Warning ตัวเลขประสิทธิภาพทั้งหมดมาจากการทดสอบของ Recursive เอง ยังไม่มีการยืนยันอิสระที่ครอบคลุม อย่านำไปใช้กับงานสำคัญโดยไม่ทดสอบกับงานของคุณ

ความเสี่ยง/ข้อจำกัด รายละเอียด วิธีรับมือ
ต้องกำกับมากกว่า Recursive ยอมรับว่าต้องแนะนำมากกว่าผู้ช่วยขนาดใหญ่แบบเสียเงิน แตกงานเป็นขั้นเล็ก ตรวจทุกขั้น
เกณฑ์เปรียบเทียบไม่ครบ ไม่มีคะแนน SWE-Bench ที่เป็นตัวเลข และไม่รู้องค์ประกอบของ 6 การทดสอบ ทดสอบกับงานของคุณเอง
หน่วยความจำ ไม่ทราบขั้นต่ำที่แน่ชัด ตรวจขนาดไฟล์จริงก่อนดาวน์โหลด
ตัวอย่างใช้งานจริงน้อย ผู้ทดสอบอิสระเพียงรายเดียว ใช้งานเล็ก ๆ อย่าสรุปว่าใช้กับโปรเจกต์ใหญ่ได้
ที่มาของไฟล์ ไม่พบลิงก์โมเดลตรง และไม่พบ GitHub repo ตรวจว่าบัญชีบน Hugging Face เป็นของ Recursive จริง
โค้ดที่ AI สร้างให้ อาจมีช่องโหว่หรือบั๊กแฝง รีวิวโค้ดและรันเทสต์ก่อนนำไปใช้

ความเข้าใจผิดที่พบบ่อย

ความเข้าใจผิด ความจริง
40B แปลว่ากินแรงเท่าโมเดล 40B ปกติ คำนวณต่องานประมาณ 2.5B แต่ต้องเก็บน้ำหนักครบในหน่วยความจำ
เร็ว 2 เท่า แปลว่าเก่ง 2 เท่า ความเร็วกับคุณภาพเป็นคนละตัวชี้วัด
"สร้างด้วย AI" แปลว่าไม่ต้องมีคนทำ ทีมคนยังเป็นผู้สร้างและกำกับ ระบบเป็นผู้ช่วยวิจัย
ฟรีแปลว่าไม่มีต้นทุน ต้องมีเครื่องที่หน่วยความจำพอและเวลาตรวจโค้ด

ทดสอบความเข้าใจ

คำถาม คำตอบ คำตอบผิดที่พบบ่อย
ทำไมโมเดล 40B จึงเร็วกว่าโมเดลคล้ายกันที่เล็กกว่าได้ เพราะเป็น MoE ใช้ราว 2.5B ต่อ token ความเร็วขึ้นกับพารามิเตอร์ที่ใช้จริง "เพราะมันเก่งกว่า" หรือ "เพราะมี 40B จึงเร็ว"
ความเร็ว 131 tokens/s พิสูจน์ว่า Flint ดีที่สุดสำหรับงานโค้ดหรือไม่ ไม่ พิสูจน์แค่ความเร็วบนเครื่องนั้น คะแนนเฉลี่ยยังมี Qwen3.8 27B สูงกว่า "ใช่ เพราะเร็วที่สุด"
ถ้าเครื่องมีหน่วยความจำ 16GB จะรัน Flint ได้ไหม ยังสรุปไม่ได้ ต้องโหลดไฟล์ทั้งหมด ตัวอย่างทดสอบใช้ 48GB ต้องตรวจขนาดไฟล์จริง "ได้ เพราะใช้แค่ 2.5B"
ต้องทำอย่างไรเมื่อ Flint ทำงานใหญ่แล้วผิดพลาด แตกงานเป็นขั้นเล็ก ให้คำสั่งชัดเจน ตรวจด้วยเทสต์ทีละขั้น เปลี่ยนไปเชื่อคำตอบรอบเดียวหรือสั่งงานใหญ่ซ้ำ
ถ้าอยากรู้ว่า Flint ช่วยงานของคุณจริงหรือไม่ ควรวัดอะไร อัตราผ่านเทสต์ จำนวนรอบแก้ไข และเวลา เทียบกับเครื่องมือเดิม โดยตั้งเกณฑ์ก่อนรัน อ่านคะแนน benchmark แล้วสรุปเลย
"ลดขนาด 71% โดยคุณภาพแทบไม่ตก" ควรเชื่อแค่ไหน เป็นคำกล่าวของผู้พัฒนา ต้องมีคะแนนก่อน/หลังจึงจะยืนยันได้ ตอนนี้ไม่มีตัวเลขนั้น "ยืนยันแล้วว่าไม่มีข้อเสีย"

Decision / next steps

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

เช็กลิสต์ก่อนใช้งาน

รายการ สถานะ
ยืนยันแหล่งดาวน์โหลดว่าเป็นของ Recursive ⚪
ตรวจขนาดไฟล์และหน่วยความจำของเครื่อง ⚪
อ่านเงื่อนไข Apache 2.0 หากใช้เชิงพาณิชย์ ⚪
กำหนดเกณฑ์ผ่านก่อนทดสอบ ⚪
ทดสอบ 10 งานเล็กและบันทึกผล ⚪
ตั้งกฎรีวิวโค้ดที่โมเดลสร้างทุกครั้ง ⚪

Sources

สถาบัน/เอกสาร ใช้ยืนยันเรื่อง
Apache Software Foundation, Apache License 2.0 เงื่อนไขของสัญญาอนุญาตที่ Flint ใช้
Hugging Face (แหล่งเผยแพร่โมเดลที่ Recursive ระบุ) ตำแหน่งดาวน์โหลดโมเดล (ไม่พบลิงก์ตรง ไม่พบ GitHub repo)

ตัวย่อที่ใช้ในหน้านี้

ตัวย่อ ชื่อเต็ม คืออะไร อ่านค่าอย่างไร
AI Artificial Intelligence ระบบที่ทำงานคล้ายการคิดของมนุษย์ "AI ช่วยสร้าง" = ระบบช่วยทำงานบางขั้น ไม่ใช่ทำแทนทั้งหมด
CEO Chief Executive Officer ผู้บริหารสูงสุด -
MoE Mixture-of-Experts โมเดลที่เรียกใช้ผู้เชี่ยวชาญเพียงบางกลุ่มต่อครั้ง 40B/2.5B = ใช้ประมาณ 6% ของพารามิเตอร์ต่อ token
B Billion (พันล้าน) หน่วยนับจำนวนพารามิเตอร์ 40B = 40,000 ล้านตัว
SWE-Bench Verified Software Engineering Benchmark (Verified) ชุดทดสอบการแก้บั๊กซอฟต์แวร์จริง คะแนนสูงกว่า = แก้บั๊กได้มากกว่า
tokens/s tokens per second จำนวนหน่วยข้อความที่โมเดลสร้างต่อวินาที 131 tokens/s = ตอบ 500 tokens ใน ~3.8 วินาที
M4 Pro ชิป Apple Silicon รุ่น M4 Pro ชิปในแล็ปท็อป MacBook Pro ใช้เป็นเครื่องวัดความเร็ว
RTX Spark Nvidia RTX Spark ฮาร์ดแวร์ของ Nvidia ที่ใช้ทดสอบ (ไม่มีรายละเอียดเพิ่ม) มากกว่า 150 tokens/s
GB / TB Gigabyte / Terabyte หน่วยความจุ 48GB = หน่วยความจำเครื่องทดสอบ, 1 TB = ขั้นต่ำของ Muse Spark Open
GV GV (เดิมชื่อ Google Ventures) กองทุนร่วมลงทุน -
AMD Advanced Micro Devices ผู้ผลิตชิป -
AWS Amazon Web Services บริการคลาวด์ของ Amazon ข้อตกลง 410 ล้านดอลลาร์
Apache 2.0 Apache License, Version 2.0 สัญญาอนุญาตซอฟต์แวร์แบบเปิด ใช้และแก้ไขได้ฟรี ต้องคงประกาศลิขสิทธิ์
Qwen3.8 27B โมเดลของ Alibaba ขนาด 27 พันล้านพารามิเตอร์ โมเดลเปรียบเทียบ คะแนนเฉลี่ยสูงกว่า Flint
Gemma 4, Nemotron 3.5 Lightning, Muse Spark Open ชื่อรุ่นโมเดลของ Google, Nvidia, Meta โมเดลเปรียบเทียบ -

หมายเหตุ: คำอธิบายของ MoE ในส่วนความรู้ทั่วไป, Apache 2.0, GV, AMD, AWS และหน่วย GB/TB มาจากความรู้ทั่วไป ไม่ใช่คำนิยามที่ระบุไว้ในข้อมูลของ Flint

Summary

  • Flint เป็นโมเดลโค้ด MoE 40B ใช้จริง ~2.5B ต่องาน เปิดให้ใช้ฟรีภายใต้ Apache 2.0
  • Recursive ระบุว่าเร็วประมาณ 131 tokens/s บน M4 Pro ราว 2 เท่าของโมเดลคล้ายกัน แต่เป็นการทดสอบของผู้พัฒนาเอง
  • คะแนนเฉลี่ย 6 การทดสอบเป็นรองเพียง Qwen3.8 27B และต้องกำกับมากกว่าผู้ช่วยขนาดใหญ่
  • ข้อได้เปรียบที่ชัดคือรันในเครื่อง ออฟไลน์ได้ โค้ดไม่ออกนอกเครื่อง ส่วนคุณภาพบนงานจริงยังต้องทดสอบเอง
  • ก้าวถัดไป: ทดสอบ 10 งานเล็กด้วยเกณฑ์ที่ตั้งไว้ล่วงหน้า
Facebook

ความรู้ที่เกี่ยวข้อง