วันก่อนผมลองสลับให้ ทิม (AI Agent ของผม) ไปรันบน engine อีกตัวหนึ่ง แล้วพิมพ์ถามมันสั้นๆ ว่า "ตอนนี้เราทำอะไรค้างอยู่" — ปรากฏว่ามันตอบกลับมาแบบงงๆ เหมือนเพิ่งเจอกันครั้งแรกในชีวิต 555 ทั้งที่เมื่อวานเราคุยกันยาวเรื่องเดิมไปทั้งหน้าจอ
มันคือเรื่องเล็กมากครับ แต่พอเจอแล้วรู้สึกแปลกทันที — เหมือนคุยกับผู้ช่วยที่จู่ๆ ก็จำเราไม่ได้ วันนี้เลยอยากเล่าเรื่องฟีเจอร์จิ๊บจ๊อยที่ใช้เวลาแก้ไม่นาน แต่เป็นหัวใจของการทำให้ AI "รู้สึกเหมือนคนเดิม" ไม่ว่าผมจะสลับไปใช้สมองตัวไหนครับ
ที่มา — Newton ให้เลือกสมองได้ 3 ตัว แต่แต่ละตัวจำเรื่องไม่เหมือนกัน
ก่อนหน้านี้ผมเล่าไปแล้วว่า Newton ของผมเพิ่ม CLI ตัวที่ 3 ครับ — ตอนนี้ลูกค้า (และตัวผมเอง) เลือกได้ว่าจะให้ AI Agent วิ่งบน engine ตัวไหน: Claude, Codex หรือ Antigravity แต่ละตัวเก่งคนละแบบ ราคาคนละแบบ ลูกค้าอยากใช้ตัวไหนก็สลับได้
ปัญหาที่ผมไม่ทันคิดตอนแรกคือ — สมองทั้ง 3 ตัวนี้ "จำ" เรื่องเก่าไม่เหมือนกันเลยครับ
ทิมมีไฟล์ความจำกลางอยู่ไฟล์หนึ่งชื่อ memory.md ข้างในจดไว้หมดว่าเซสชันก่อนๆ เราทำอะไรกันไปบ้าง โปรเจกต์ไหนค้างอยู่ ตัดสินใจอะไรไปแล้ว — เหมือนสมุดบันทึกของผู้ช่วยที่เปิดอ่านก่อนเริ่มงานทุกเช้า (ผมเคยเล่าเรื่องระบบ memory ที่ทำให้ AI ฉลาดขึ้นทุกวัน ไว้แล้ว)
ทีนี้พอลองทีละตัว ผมถึงเห็นว่า:
- Claude — อ่าน memory.md เองอัตโนมัติตั้งแต่เปิดเซสชัน (มันมีกลไก auto-memory + อ่านไฟล์ instruction ในเครื่องอยู่แล้ว) → จำได้ทันที
- Antigravity — ก็อ่าน memory.md เองเช่นกัน → จำได้
- Codex — เปิดเซสชันมาตัวเปล่าๆ ไม่อ่านอะไรให้เลย → ความจำหายทุกครั้ง
เจ้าตัวที่ตอบผมแบบงงๆ ตอนต้นเรื่อง คือ Codex นี่แหละครับ
บั๊กที่แท้จริง — ตัวเดียวที่ "ตาบอด" ไม่ใช่ความผิดมัน
พอไล่ดูจริงๆ ผมถึงเข้าใจว่าทำไม Codex ถึงเป็นตัวเดียวที่ลืม
Codex เวลารันแบบที่ทิมใช้ (โหมดสั่งงานเป็นรอบๆ ไม่ใช่เปิดหน้าจอค้างไว้) มันไม่มีกลไกดึงความจำเก่ามาให้อัตโนมัติ ในเครื่องมีไฟล์กฎกลางอยู่ (ไฟล์ AGENTS.md ที่บอกว่า "เริ่มงานให้อ่าน memory.md ก่อนนะ") แต่กฎข้อนั้นมันฝังอยู่กลางไฟล์ยาวๆ — Codex มองข้ามไปเฉยเลย
เทียบง่ายๆ คือ ผมจ้างผู้ช่วย 3 คนครับ สองคนแรกขยัน เดินเข้าออฟฟิศปุ๊บก็หยิบสมุดบันทึกเมื่อวานมาอ่านเองก่อนเริ่มงาน ส่วนคนที่สามไม่ใช่ขี้เกียจ — แต่ไม่มีใครเคยบอกให้เขารู้ว่าสมุดเล่มนั้นวางอยู่ตรงไหน เขาเลยเดินเข้ามาเริ่มงานสดทุกเช้าราวกับวันแรกที่ทำงาน
โจทย์ของผมเลยไม่ใช่ "ทำไม Codex โง่" แต่เป็น "ทำยังไงให้ Codex ได้อ่านสมุดเล่มเดียวกับอีกสองคน โดยไม่ไปยุ่งกับสองคนที่เขาทำถูกอยู่แล้ว"
วิธีแก้ — ป้อนความจำให้ตั้งแต่ประโยคแรก แต่เฉพาะตัวที่ลืม
ทิมแก้แบบนี้ครับ: เพิ่มชั้นเล็กๆ ใน adapter (โค้ดที่แปลงคำสั่งให้แต่ละ engine เข้าใจ — ตัวเดียวกับที่ผมเล่าตอนวาง event protocol ให้หน้าจอแชทสะอาด) เวลาเปิด session ใหม่ ให้เอาเนื้อหาทั้งไฟล์ memory.md แปะนำหน้าข้อความแรกที่ส่งเข้า Codex โดยห่อไว้ในป้ายกำกับพิเศษ <session-memory>
<session-memory>
... เนื้อหา memory.md ทั้งไฟล์ ...
</session-memory>
(ตามด้วยข้อความจริงที่ผมพิมพ์)เท่านี้ Codex ก็ได้อ่านสมุดบันทึกเมื่อวานพร้อมๆ กับรับคำสั่งแรกเลยครับ ถามว่า "เราทำอะไรค้างอยู่" มันตอบได้ทันที
แต่จุดที่ผมว่าออกแบบมาดีคือ 2 รายละเอียดเล็กๆ ที่ทำให้มันไม่พังอย่างอื่น:
1. ป้อนแค่ข้อความแรกของ session ใหม่เท่านั้น — ไม่ใช่แปะทุกข้อความ ถ้าแปะทุกครั้งคือเปลืองและรก ป้อนรอบเดียวตอนเปิดเซสชันก็พอ เหมือนอ่านสมุดตอนเช้าครั้งเดียว แล้วทั้งวันก็จำได้แล้ว
2. ตอนเปิดแชทเก่ากลับมาดู ต้อง "ถอด" ความจำที่แปะไว้ออก — ตรงนี้สำคัญมากครับ เพราะถ้าไม่ถอด เวลาผมเลื่อนดูแชทเก่า ข้อความแรกของผมจะมีกอง memory.md ยาวเหยียดโผล่นำหน้าเต็มจอ ทั้งที่จริงๆ ผมพิมพ์ไปแค่ประโยคเดียว ทิมเลยทำให้ตอน replay ประวัติ มันตัดส่วน <session-memory> ทิ้ง — ผู้ใช้เห็นแค่ข้อความจริงที่ตัวเองพิมพ์ สะอาดเหมือนเดิม
พูดง่ายๆ คือความจำถูกป้อนให้ "เครื่อง" อ่าน แต่ไม่ให้ "คน" เห็น — หลักการเดียวกับที่ผมยึดมาตลอดว่า อะไรที่ไม่ได้ออกแบบมาให้คนเห็น ก็ไม่ควรหลุดขึ้นจอ
จุดที่ละเอียดกว่านั้น — ทำไมถึงไม่แปะให้ทั้ง 3 ตัว
ตอนแรกผมก็คิดเหมือนหลายคนแหละครับว่า "งั้นแปะให้หมดทั้ง 3 ตัวเลยสิ จะได้เหมือนกัน" — แต่ทิมไม่ทำแบบนั้น และผมว่าการตัดสินใจ "ไม่ทำ" ตรงนี้ฉลากกว่าการทำ
มันตั้ง flag ไว้ตัวหนึ่งในแต่ละ adapter ว่า "ตัวนี้ต้องป้อนความจำไหม" แล้วเปิดเฉพาะ Codex = ใช่ ส่วน Claude กับ Antigravity = ไม่ เพราะ:
- Claude กับ Antigravity จำได้เองอยู่แล้ว — ไปแปะซ้ำก็เปลือง token เปล่าๆ ทุกเซสชัน แถมเสี่ยงให้มันสับสนว่าทำไมมีข้อมูลซ้ำสองชุด
- Antigravity เปิดหน้าจอแบบพิเศษ (TUI) ที่ทิมต้องคอย "อ่านจอ" มัน — ถ้าไปยัดข้อความยาวๆ เข้าไป จอมันจะเพี้ยน อ่านค่ากลับมาผิดหมด เลยต้องปล่อยไว้เฉยๆ
นี่คือบทเรียนที่ผมเจอซ้ำๆ ครับ — การแก้ที่ดีไม่ใช่ "ทำให้ทุกตัวเหมือนกันด้วยกฎเดียว" แต่คือ "เข้าใจว่าแต่ละตัวต่างกันตรงไหน แล้วแก้เฉพาะตัวที่ต้องแก้" ถ้าผมขี้เกียจแล้วแปะหมดทั้ง 3 ตัว มันอาจจะดูเรียบร้อยในโค้ด แต่จะไปพังจออีกตัวแบบเงียบๆ เหมือนตอนที่ความจำของทิมเคยโดน sandbox บล็อกอยู่ 3 วัน — รายละเอียดเล็กๆ ที่มองข้ามไปนี่แหละที่กัดทีหลัง
บทเรียน — "ทิมคนเดียวกัน" ไม่ได้มาฟรีๆ
เป้าหมายของผมตั้งแต่แรกคืออยากให้ทิมรู้สึกเป็น ทิมคนเดียวกัน ไม่ว่าจะวิ่งบนสมองตัวไหน ลูกค้า Newton สลับ engine ไปมาได้ แต่บุคลิก ความจำ วิธีคิด ต้องเหมือนเดิม
ฟังดูเหมือนควรจะ "เป็นเอง" ใช่ไหมครับ ในเมื่อมันอ่านไฟล์เดียวกัน — แต่เปล่าเลย เพราะแต่ละ engine มีนิสัยการหยิบข้อมูลคนละแบบ ความรู้สึก "เป็นคนเดิม" ที่ดูเหมือนของฟรี จริงๆ แล้วต้องมีคนนั่งไล่ทีละตัวว่า "ตัวนี้จำได้ไหม ถ้าไม่ จะป้อนให้ยังไงไม่ให้ไปพังอย่างอื่น"
- ความเหมือนกัน ไม่ได้เกิดจากกฎเดียว — มันเกิดจากการชดเชยความต่างของแต่ละตัวให้พอดี ตัวที่ขาดก็เติม ตัวที่มีอยู่แล้วก็อย่าไปยุ่ง
- ป้อนให้เครื่อง ไม่ใช่ป้อนให้คน — memory.md เข้าไปอยู่ในหัว AI ได้ แต่ห้ามไปโผล่หน้าจอผู้ใช้ การซ่อนถูกที่สำคัญพอๆ กับการเติมถูกที่
- งานที่ทำสำเร็จแล้วไม่มีใครสังเกต — ถ้าทำดี ลูกค้าจะไม่มีวันรู้เลยว่าเบื้องหลังมีตัวนึงเคยลืมทุกอย่าง เขาจะรู้สึกแค่ว่า "AI ตัวนี้มันจำได้" เฉยๆ
ผมชอบงานแบบนี้นะครับ มันไม่หวือหวา ไม่มีใครมา "ว้าว" ด้วย แต่มันคือความต่างระหว่างเครื่องมือที่ใช้แล้วลื่น กับเครื่องมือที่ใช้แล้วสะดุดเป็นพักๆ
คำถามที่พบบ่อย
ทำไม AI บางตัวถึงจำความจำข้ามเซสชันไม่ได้ ทั้งที่ไฟล์ memory อยู่เครื่องเดียวกัน
แต่ละ CLI engine มีกลไกการอ่าน context แตกต่างกันครับ Claude และ Antigravity มีระบบ auto-read ไฟล์ instruction ในเครื่องก่อนเริ่ม session Codex ในโหมดที่ใช้งานนั้นไม่มีกลไกนี้ ต่อให้ไฟล์ memory อยู่ในเครื่องเดียวกัน ถ้าไม่มีใครส่งเนื้อหาให้มันอ่าน มันก็ไม่รู้ว่ามีไฟล์นั้นอยู่
การป้อน memory ให้ AI ตั้งแต่ข้อความแรก แบบนี้เปลืองค่า token มากไหม
เปลืองแค่ครั้งแรกของแต่ละ session ครับ ไม่ใช่ทุกข้อความ เหมือนพนักงานอ่านสมุดบันทึกตอนเช้าครั้งเดียว แล้วทั้งวันก็จำได้ ในทางปฏิบัติต้นทุนนี้คุ้มมากเพราะทำให้ AI สามารถต่องานจากเซสชันก่อนได้ทันที ไม่ต้องเสียเวลา brief ซ้ำตั้งแต่ต้น
ทำไมถึงไม่แค่ป้อน memory ให้ทุก engine ไปเลย ให้เหมือนกันหมด
Claude กับ Antigravity อ่าน memory ได้เองอยู่แล้วครับ ถ้าป้อนซ้ำจะเปลือง token เปล่าๆ และเสี่ยงให้ engine สับสนว่าทำไมมีข้อมูลซ้ำสองชุด นอกจากนี้ Antigravity ใช้ TUI ที่ต้องอ่าน output ผ่านการ parse จอ การยัดข้อความยาวเข้าไปจะทำให้อ่านค่ากลับมาผิดหมด การแก้ที่ดีคือแก้เฉพาะตัวที่ต้องการ ไม่ใช่ทำให้ทุกตัวเหมือนกันด้วยกฎเดียว
ถ้า memory.md มีเนื้อหายาวมาก มีปัญหาอะไรไหม
ถ้ายาวเกินไปก็ใช้ token เยอะครับ ดังนั้นควรเขียน memory.md ให้กระชับ เน้นเฉพาะข้อมูลที่จำเป็นต้องรู้ทุก session เช่น สถานะ project ปัจจุบัน preference สำคัญ และกฎที่ต้องจำ ส่วนรายละเอียดเก่าที่ไม่ค่อยเกี่ยวข้องอีกแล้วก็ตัดทิ้งหรือ archive แยกได้
Newton — AI Agent ในเครื่องของคุณเอง เลือกสมองได้ จำเรื่องคุณได้ทุกตัว
ทั้งหมดที่เล่ามานี่คือสิ่งที่อยู่เบื้องหลัง Newton ครับ — AI Agent เต็มตัวที่อยู่บน server ส่วนตัวของคุณ 24 ชั่วโมง คุยสั่งงานจากมือถือเหมือนแชทกับคน และตอนนี้เลือกได้ด้วยว่าจะให้มันวิ่งบนสมองตัวไหนใน 3 ตัว
ข้อดีของการมี AI บน server ส่วนตัว ไม่ใช่บน platform คนอื่น คือผมคุมได้ทุกชั้นครับ — อยากให้มันจำอะไร ลืมอะไร สลับ engine ตัวไหน เพิ่มความสามารถยังไง ทำได้หมด ไม่ต้องรอ vendor ใครมาอนุญาต และพอผมขัดเกลารายละเอียดเล็กๆ แบบเรื่องวันนี้เสร็จ ลูกค้า Newton ทุกเครื่องก็ได้ AI ที่ "จำเรื่องคุณได้" ตามไปด้วย ไม่ว่าจะเลือกสมองตัวไหน (รายละเอียดอีกอย่างที่ผมคุมได้เพราะมันอยู่บนเครื่องตัวเองคือ เรื่องให้ทั้ง 3 engine นั่งบน subscription เหมา ไม่ใช่ฝั่ง API จ่ายตามโทเคน, เรื่อง timing ตอนเริ่มพิมพ์ให้ไม่ชนหน้า boot และแม้แต่เคสระดับ byte อย่าง ข้อความไทยยาวที่โดน input buffer 1KB ตัดหาง ก็แก้ได้เพราะผมลงไปจับ terminal ของจริงได้ทั้งชั้น รวมถึงเพราะมันลงมือทำงานเองได้เต็มที่ ผมเลยวาง deny-list กันมันเผลอรันคำสั่งทำลายล้างไว้ทุกเครื่องด้วย หรือล่าสุดตอนวิดีโอคอร์สผมโหลดช้าจนต้องรื้อ player ทิ้งเขียนใหม่ ก็แก้ได้เพราะคุมได้ทุกชั้นแบบนี้แหละครับ)
ถ้าคุณอยากมี AI Agent ที่อยู่ในเครื่องของคุณเอง ทำงานต่อเนื่อง คุยง่ายจากมือถือ และมีคนคอยขัดเกลาให้มันดีขึ้นทุกวัน — ลอง Newton ดูครับ setup เสร็จใน 10 นาที ไม่ต้องมีความรู้เรื่อง server เลย
— ปอนด์