pi-autoresearch: โอเพนซอร์สที่ทำให้ไอเดีย "การทดลองอัตโนมัติโดย AI" ของ Karpathy ใช้ได้ทั่วไป

สรุปสั้น ๆ

ลองไอเดีย → วัดผล → ถ้าดีขึ้นก็เก็บไว้ ถ้าไม่ก็ทิ้ง → ทำซ้ำไปเรื่อย ๆ ตลอดไป

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

ก่อนอื่น pi คืออะไร?

pi คือ เอเจนต์ AI สำหรับเขียนโค้ดที่ทำงานบนเทอร์มินัล ต่างจากเครื่องมือแบบ IDE อย่าง Cursor หรือ Windsurf ตรงที่มันถูกออกแบบมาให้เป็นเทอร์มินัลเนทีฟ จึงใช้งานได้ตรง ๆ แม้ในสภาพแวดล้อมที่เชื่อมต่อผ่าน SSH หรือบนเซิร์ฟเวอร์แบบเฮดเลส

จุดเด่นหลักของ pi คือระบบ Extension และ Skill:

• Extension — เพิ่มเครื่องมือ (tool) ใหม่ให้เอเจนต์ นอกจากเครื่องมือพื้นฐานอย่างการอ่าน/เขียนไฟล์หรือรันคำสั่งแล้ว ยังสามารถเสียบเครื่องมือคัสตอมเพิ่มเข้าไปได้แบบปลั๊กอิน
• Skill — สอนรูปแบบงานเฉพาะทาง โดยกำหนดเวิร์กโฟลว์ว่า "ในสถานการณ์แบบนี้ ให้ใช้เครื่องมือเหล่านี้ตามลำดับนี้"

สามารถติดตั้ง Extension และ Skill ที่ชุมชนสร้างไว้ได้ด้วยคำสั่งบรรทัดเดียว pi install <github-url> จึงเป็นโครงสร้างที่ขยายความสามารถของเอเจนต์ได้อย่างอิสระ และ pi-autoresearch ก็เป็นแพ็กเกจ Extension+Skill ที่สร้างขึ้นบนระบบนี้โดยตรง

ภูมิหลัง: autoresearch ของ Karpathy

ในเดือนมีนาคม 2026 Karpathy ได้เผยแพร่ไอเดียของ autoresearch ซึ่งเรียบง่ายมาก:

• ให้โค้ดฝึก LLM (train.py) แก่เอเจนต์ AI
• ให้มันแก้โค้ด แล้วฝึกเป็นเวลา 5 นาที
• ถ้า validation loss ดีขึ้นก็ keep ถ้าไม่ก็ discard
• ทำซ้ำทั้งคืน → ตื่นเช้ามาก็ได้ทั้งบันทึกการทดลอง + โมเดลที่ดีกว่าเดิม

มันเป็นโปรเจ็กต์ที่โฟกัสกับการพิสูจน์คอนเซปต์ว่า "เอเจนต์สามารถทำหน้าที่เป็นนักวิจัยได้อย่างอัตโนมัติ" ด้วยการออกแบบที่มินิมัลมาก ๆ (ไฟล์ 3 ไฟล์, GPU 1 ใบ, เมตริก 1 ตัว) แต่ก็มีข้อจำกัดตั้งแต่ต้นกำเนิดคือใช้ได้เฉพาะกับ NVIDIA GPU และใช้กับการฝึก LLM เท่านั้น

สิ่งที่ pi-autoresearch แตกต่างออกไป

1. ไม่จำกัดโดเมน

ไม่ใช่แค่ loss ของการฝึก LLM เท่านั้น แต่ อะไรก็ตามที่วัดได้ ไม่ว่าจะเป็นความเร็วในการรันเทสต์, ขนาดบันเดิล, เวลาบิลด์, คะแนน Lighthouse ก็สามารถเอามาเป็นเป้าหมายในการปรับให้เหมาะสมได้ ทั้งหมดนี้เป็นเพราะโครงสร้างแยกกันระหว่าง "โครงสร้างพื้นฐาน (Extension)" และ "ความรู้เฉพาะโดเมน (Skill)" ของ pi

• ความเร็วเทสต์ — seconds ↓ — pnpm test
• ขนาดบันเดิล — KB ↓ — pnpm build && du -sb dist
• การฝึก LLM — val_bpb ↓ — uv run train.py
• Lighthouse — perf score ↑ — lighthouse --output=json

2. รีสตาร์ตแล้วก็ไม่ลืมสิ่งที่ทำมา

เอเจนต์ AI มีข้อจำกัดเรื่อง context window ดังนั้นระหว่างการทดลองยาว ๆ คอนเท็กซ์อาจถูกรีเซ็ตหรือโปรเซสอาจตายได้ pi-autoresearch เก็บสถานะของเซสชันทั้งหมดไว้ด้วยไฟล์สองไฟล์:

• autoresearch.jsonl — ล็อกแบบ append-only ของทุกการทดลอง
• autoresearch.md — สรุปเป้าหมาย สิ่งที่ลองแล้ว ทางตันที่เจอ และผลลัพธ์สำคัญ

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

3. แยกความดีขึ้นจริงออกจากสัญญาณรบกวน

การเบนช์มาร์กให้ผลต่างกันได้ทุกครั้ง แม้จะรันโค้ดเดิมก็ตาม หลังจากทดลอง 3 ครั้งขึ้นไป ระบบจะคำนวณ confidence score บนพื้นฐาน MAD (Median Absolute Deviation) โดยอัตโนมัติ เพื่อแสดงให้เห็นอย่างชัดเจนว่าการดีขึ้นนั้นเป็นของจริงหรือเป็นเพียง noise

• 🟢 ≥ 2.0× — มีโอกาสสูงว่าดีขึ้นจริง
• 🟡 1.0–2.0× — มากกว่า noise แต่ยังเล็กน้อย
• 🔴 < 1.0× — ยังอยู่ในช่วง noise แนะนำให้รันใหม่

อย่างไรก็ตาม ระบบจะไม่ทิ้งการทดลองให้อัตโนมัติ และมอบการตัดสินใจสุดท้ายไว้ให้เอเจนต์

4. ป้องกันไม่ให้การปรับจูนทำลายความถูกต้องของระบบ

หากมี autoresearch.checks.sh อยู่ หลังจากผ่านเบนช์มาร์กแล้ว ระบบจะ รันการตรวจสอบความถูกต้องอย่างเทสต์, type check, lint โดยอัตโนมัติ ช่วยกันกับดักคลาสสิกอย่าง "ทำให้เร็วขึ้นก็จริง แต่เทสต์พัง" ตั้งแต่ระดับระบบ

5. สรุปผลการทดลองออกมาเป็น PR ที่อ่านง่าย

เมื่อการทดลองสิ้นสุดลง สกิล autoresearch-finalize จะจัดกลุ่มการทดลองที่ถูก keep ไว้เป็น changeset ตามตรรกะ แล้วแยกออกเป็น git branch ที่เป็นอิสระต่อกัน โดยรับประกันว่าไฟล์จะไม่ทับซ้อนกัน ทำให้แต่ละ branch สามารถถูกรีวิวและ merge ได้อย่างอิสระ

เวิร์กโฟลว์

1. /autoresearch optimize unit test runtime  
   → ตั้งค่าเป้าหมาย คำสั่ง และเมตริก → วัด baseline → เริ่มลูป  
  
2. ลูปอัตโนมัติ (วนไม่สิ้นสุด)  
   → แก้โค้ด → git commit → benchmark → ตรวจสอบความถูกต้อง  
   → ดีขึ้น? keep / แย่ลง? revert → บันทึกลง .jsonl → ทำซ้ำ  
  
3. /skill:autoresearch-finalize  
   → จัดการทดลองที่ keep ไว้เป็น branch อิสระ → รีวิว·เมิร์จ  

การควบคุมค่าใช้จ่าย

ลูปอัตโนมัติจะใช้โทเคนต่อเนื่อง จึงมีราวกันสองชั้นคือการตั้งเพดาน API key และ maxIterations (จำนวนการทดลองสูงสุดต่อเซสชัน)

ทำไมถึงน่าจับตา

ถ้า autoresearch ของ Karpathy เป็นการพิสูจน์คอนเซปต์ที่น่าสนใจว่า "AI สามารถทดลองเองได้" pi-autoresearch ก็คือความพยายามที่จะทำให้มันกลายเป็น เครื่องมืออเนกประสงค์ที่ใช้ได้จริงในงานพัฒนาซอฟต์แวร์ และเพราะมันสร้างอยู่บนสถาปัตยกรรม Extension/Skill ของ pi จึงสามารถนำไปต่อเข้ากับเวิร์กโฟลว์ pi เดิมได้ทันทีด้วยการติดตั้งเพียงบรรทัดเดียว ซึ่งช่วยลดอุปสรรคในการเริ่มต้นได้มาก

สิ่งที่น่าประทับใจคือมันแก้ปัญหาเชิงปฏิบัติได้อย่างเป็นระบบ ทั้งการเก็บสถานะเซสชัน การตรวจสอบความน่าเชื่อถือทางสถิติ การปกป้องความถูกต้องของระบบ และเวิร์กโฟลว์แบบ Git เนทีฟ จึงน่าจับตาว่าแนวทางแบบรันไว้ตอนกลางคืนแล้วตื่นมารีวิว PR ตอนเช้าจะกลายเป็นเรื่องใช้งานได้จริงหรือไม่

[tensun]

สมแล้วที่เป็น pi

[unqocn]

ชอบ pi มาก