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

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

แชตไม่ใช่ที่เก็บสถานะของงาน

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

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

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

อย่างที่สี่หนักกว่านั้น คือ AI ทำงานต่อไปเรื่อยๆ ทั้งที่งานไม่คืบหน้า กว่าจะรู้ตัว โควตาก็หมดไปกับการวนอยู่ที่เดิม

LoopX วางตัวอยู่ตรงไหนของกองงาน

LoopX ทำงานร่วมกับเครื่องมือที่ใช้อยู่แล้ว Codex หรือ Claude Code ยังรับหน้าที่ลงมือทำงาน ทั้งเขียน แก้ และรันงานเหมือนเดิม ส่วน LoopX มีหน้าที่จำว่าเป้าหมายคืออะไรและงานไปถึงไหนแล้ว

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

• Codex App
• Codex App ผ่าน SSH
• Codex CLI
• Claude Code
• OpenCode
• Pi
• Cursor
• เชลล์และตัวรันที่เขียนขึ้นเอง

แต่ละเครื่องมือมีวิธีเชื่อมต่อที่แนะนำต่างกัน แต่สุดท้ายจะอ่านและเขียนสถานะชุดเดียวกัน

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

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

ห้าคำถามที่ต้องตอบได้ตลอดเวลา

แก่นของ LoopX สรุปได้ด้วยคำถามห้าข้อ ซึ่งสถานะของงานต้องมีคำตอบให้อยู่เสมอ

• ตอนนี้เป้าหมายคืออะไร
• สิ่งที่จะเกิดขึ้นต่อไปคืออะไร
• อะไรที่ต้องให้คนตัดสิน
• หลักฐานอะไรที่เพิ่งเปลี่ยน
• ลูปนี้ไปต่อได้ไหม

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

gate ที่ตอบได้จริง กับคำว่ารอเจ้าของ

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

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

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

โควตาหักตอนงานผ่าน ไม่ใช่ตอนโมเดลขยับ

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

LoopX เปลี่ยนลำดับการทำงาน ก่อนเริ่มแต่ละเทิร์นหรือรอบการทำงาน ตัวรันต้องตรวจสถานะโควตาด้วยคำสั่ง should-run ก่อนว่าควรทำงานตอนนี้หรือไม่ ระบบจะบันทึกว่าใช้โควตาแล้วต่อเมื่องานในเทิร์นนั้นเสร็จและผ่านการตรวจเท่านั้น

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

ให้ Claude ลงมือเขียน แล้วให้ Codex เป็นคนรีวิว

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

ตัวอย่างในรีโปคือให้ Claude แก้โค้ด แล้วให้ Codex รีวิวงานนั้น ทั้งคู่เห็นเป้าหมาย หลักฐาน โควตา และจุดส่งต่องานชุดเดียวกัน จึงไม่ต้องเล่าเรื่องให้อีกฝ่ายฟังก่อน

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

ลองจริงต้องเตรียมอะไรบ้าง

สิ่งที่ต้องมี ได้แก่

• เครื่อง macOS หรือ Linux
• Python เวอร์ชัน 3.11 ขึ้นไป
• curl
• tar

ส่วน Git จำเป็นเฉพาะเมื่อต้องการโคลนรีโปไปร่วมพัฒนา ตัวแพ็กเกจไม่ได้ใช้ไลบรารีอื่นนอกเหนือจากที่มากับ Python

การติดตั้งที่แนะนำใช้สคริปต์ทางการ ไม่ต้องโคลนรีโป

curl -fsSL https://huangruiteng.github.io/loopx/install.sh | bash
export PATH="$HOME/.local/bin:$PATH"
loopx doctor

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

cd /path/to/your-project
loopx connect
loopx status

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

โปรเจกต์มีเช็กลิสต์สำหรับตรวจว่าเชื่อมต่อสำเร็จหรือไม่ ได้แก่ ต้องผ่านคำสั่งตรวจสภาพ มีไฟล์ .loopx/registry.json และมีสถานะของเป้าหมายที่กำลังทำอยู่ ส่วนหน้าสถานะต้องแสดงทั้งเป้าหมาย จุดที่รอคนตัดสิน และงานย่อยชิ้นถัดไป

อีกเรื่องที่ต้องทำตั้งแต่วันแรกคือไม่ commit ไฟล์สถานะเหล่านี้ขึ้นรีโป โฟลเดอร์ที่ควรใส่ไว้ในรายการยกเว้นมีดังนี้

• .loopx/
• .codex/goals/
• .local/

ถ้าใช้ OpenCode ให้เพิ่ม .opencode/goals/ เข้าไปด้วย

เส้นแบ่งที่โปรเจกต์บอกเอาไว้เอง

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

ตัวเลขในหน้าโชว์เคสต้องอ่านให้ตรงความหมาย ตัวอย่างหนึ่งที่เปิดให้ดูได้คือชุด PR ที่ช่วยพัฒนาโปรเจกต์โอเพนซอร์ส OpenViking โดยใช้เวลาเกิน 200 ชั่วโมงนับตั้งแต่ PR แรกจนถึงการรีวิวรอบล่าสุด อีกตัวอย่างเป็นการทดลองด้าน Auto ML ที่เจ้าของโปรเจกต์รันเอง และใช้เวลาเกิน 200 ชั่วโมงเช่นกัน

ส่วนตัวอย่างจากผู้ใช้อิสระเป็นข้อมูลที่ผู้ใช้รายงานเข้ามาเอง โปรเจกต์ระบุชัดว่ายังไม่ได้ตรวจสอบหรือทดลองซ้ำ ตัวอย่างเหล่านี้มีทั้งงานตรวจความแม่นยำของโค้ด C++ ซึ่งรันนานเกิน 13 ชั่วโมงและยังทำตามโจทย์เดิมได้ตลอดหลายขั้นตอน อีกงานหนึ่งปล่อยให้รันเองสี่วันโดยมีรายงานสรุปเป็นระยะ ส่วนงานปรับโครงสร้างเอนจินได้ PR ที่ merge แล้ว 7 ตัว พร้อมตัวเลขระดับพันล้านโทเคน ทั้งคำกล่าวอ้างและตัวเลขเหล่านี้มาจากผู้ใช้เอง

ณ ตอนที่เก็บข้อมูล รีโปมีดาวราว 3.5 พันดวง และมีคนฟอร์ก 283 ครั้ง

สองอย่างที่หยิบไปทำได้ตั้งแต่วันนี้

ต่อให้ไม่ติดตั้ง LoopX เลย หลักคิดสองข้อในนี้ก็ใช้กับงาน AI ยาวๆ ได้ทันที

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

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

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

ที่มา:

• โปรเจกต์ LoopX บน GitHub
• เอกสารทางการของ คู่มือเริ่มต้นใช้งาน LoopX