คู่มือฉบับสมบูรณ์: วิธีเพิ่ม 'หน่วยความจำไม่จำกัด' ให้กับ Codex ในเวลาเพียง 3 นาที

นี่คือบทความฉบับเต็มที่แปลเป็นภาษาไทยแล้ว โดยคงโครงสร้าง Markdown, โค้ด, ลิงก์, แท็กพิเศษ และโทนเสียงต้นฉบับไว้อย่างครบถ้วน

คุณรู้จักกลไกในการเพิ่ม "สมองที่สอง" ให้กับ Codex เพื่อให้บริบทคงอยู่แม้การสนทนาจะถูกขัดจังหวะหรือไม่? ชื่อของมันคือ Agentmemory ผมได้สรุปทุกอย่างตั้งแต่ขั้นตอนการติดตั้ง การกำหนดค่า ไปจนถึงปัญหาที่พบบ่อย นี่คือบทความที่ต้องอ่านสำหรับคนที่รู้สึกเบื่อหน่ายที่ต้องอธิบายเรื่องเดิมซ้ำแล้วซ้ำเล่า และคนที่ไม่ want เปลือง token

ทุกเช้า ผมเริ่ม Claude Code แล้วพิมพ์ "Continue from yesterday" แต่ก็ต้องเจอคำตอบว่า "Please tell me the contents of the previous session" นี่คือปรากฏการณ์ที่เกิดขึ้นเกือบทุกวัน

เมื่อเซสชันถูกตัด บริบทของโปรเจกต์จะถูกรีเซ็ต แม้ว่าสิ่งที่เขียนใน CLAUDE.md จะถูกอ่าน แต่ "น้ำหนักของบริบท" เช่น การอภิปรายเกี่ยวกับบั๊กจากสามวันที่แล้ว หรือเหตุผลเบื้องหลังนโยบายการออกแบบที่ตัดสินใจเมื่อสัปดาห์ที่แล้ว จะหายไปอย่างสิ้นเชิง

นักพัฒนาคนหนึ่งเขียนไว้ว่า:

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

ระยะเวลาการเก็บรักษาประวัติเซสชันเริ่มต้นคือ 30 วัน ยิ่งไปกว่านั้น สิ่งที่ถูกบันทึกไว้เป็นเพียง "บันทึกในรูปแบบสตริง" ซึ่งไม่ใช่กลไกที่สามารถเรียกใช้เป็นบริบทได้

สถานการณ์บนฝั่ง Codex ก็เหมือนกัน บริบทของ GPT-5.5 คือ 1M token ผ่าน API และ 400K ใน Codex CLI ขนาดทางกายภาพดูเหมือนจะเพียงพอ แต่ในทางปฏิบัติ ความแม่นยำเริ่มลดลง ที่ประมาณ 200K token

นั่นคือตอนที่ Agentmemory ซึ่งสร้างกระแสหลังจากทะลุ 4,000 Stars ได้เข้ามา ผมใช้มันอย่างหนักเป็นเวลาหนึ่งสัปดาห์ นี่คือข้อสรุปของผม:

วลีที่ว่า "การเพิ่มหน่วยความจำไม่จำกัด" ให้กับ Codex/Claude Code นั้น เป็นจริงครึ่งหนึ่งและเกินจริงครึ่งหนึ่ง

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

1. ทำไม Codex/Claude Code ถึงเกิด "ความจำเสื่อม"?

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

แม้ว่า context window จะใหญ่ แต่ในทางปฏิบัติก็ไม่สามารถใช้งานได้เต็มที่

ณ เดือนพฤษภาคม 2026 context window ของโมเดลหลักๆ มีดังนี้:

● Claude Opus 4.7: 1M tokens (ขยายจาก 200K)

● GPT-5.5: 1M tokens (API) / จำกัดที่ 400K ใน Codex CLI

● Gemini 3.1 Pro: 1M tokens

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

อย่างไรก็ตาม Anthropic เองก็เขียนไว้ในบล็อกวิศวกรรมทางการของพวกเขาว่า:

เมื่อจำนวน token ใน context window เพิ่มขึ้น ความสามารถของโมเดลในการเรียกคืนข้อมูลจากบริบทนั้นอย่างแม่นยำจะลดลง

ความจุทางกายภาพไม่เท่ากับความสามารถในการรักษาความแม่นยำ ประสบการณ์แสดงให้เห็นว่าที่ประมาณ 200K ถึง 400K token Claude จะเริ่ม "ลืมสิ่งที่เพิ่งพูดไป" ซึ่งเป็นที่รู้จักกันในชื่อ context rot

"การล่มสลายของความคิด" ที่เกิดขึ้นแม้แต่ใน Claude Code อย่างเป็นทางการ

ขอให้ผมยกตัวอย่างจริง เมื่อวันที่ 23 เมษายน 2026 Anthropic ได้เผยแพร่ postmortem อย่างเป็นทางการ

บั๊กที่ปล่อยออกมาเมื่อวันที่ 26 มีนาคม ทำให้ "ฟีเจอร์ที่เคลียร์ความคิดเก่าหลังจากไม่ได้ใช้งาน 1 ชั่วโมง" ทำงานทุกเทิร์น แม้หลังจากกลับมาใช้เซสชันต่อก็ตาม

ผลลัพธ์คือ ความยาวของความคิดที่มองเห็นได้โดยเฉลี่ยเปลี่ยนแปลงดังนี้:

● มกราคม: 2,200 ตัวอักษร

● มีนาคม: 600 ตัวอักษร

การล่มสลาย 73% ประมาณหนึ่งเดือนเต็ม Claude Code อย่างเป็นทางการกำลังตัดบริบทของตัวเองตามอำเภอใจ

นี่เป็นสิ่งสำคัญเพราะมันแสดงให้เห็นว่า context rot ไม่ใช่แค่ "ความผิดพลาดของผู้ใช้" แต่สามารถเกิดขึ้นได้จาก สถานการณ์ฝั่งบริการ ด้วย ไม่ว่าคุณจะเขียน CLAUDE.md อย่างสะอาดแค่ไหน การปรับแต่งเพียงครั้งเดียวในฝั่งเครื่องมือก็สามารถเปลี่ยน "บริบทของสัปดาห์ที่แล้ว" ให้เป็นเศษกระดาษได้

ข้อจำกัดของโซลูชันที่มีอยู่ (CLAUDE.md / auto-memory)

Anthropic กำลังดำเนินมาตรการ ฟีเจอร์ auto-memory ของ Claude Code เป็นกลไกที่จดจำสิ่งที่เรียนรู้ระหว่างเซสชันและเรียกคืนเมื่อรีสตาร์ท ทีม Claude Code ประกาศสิ่งนี้ในเดือนพฤษภาคม

อย่างไรก็ตาม สิ่งนี้ ถูกออกแบบให้ทำงานร่วมกับการบีบอัด มันทำงานในโฟลว์ภายในของ "การบีบอัดบริบท → ย้ายข้อมูลสำคัญไปยังหน่วยความจำ" และ AI จะเป็นคนตัดสินใจ "จะเก็บอะไรไว้" ในระหว่างการบีบอัดแต่ละครั้ง ผู้ใช้ไม่สามารถแตะต้องตรรกะการตัดสินใจนี้

ยิ่งไปกว่านั้น auto-memory เป็นเอกสิทธิ์ของ Claude Code ไม่มี API ให้อ่านจากเอเจนต์อื่นๆ เช่น Codex, Cursor, Cline หรือ Hermes สำหรับคนที่ใช้หลายเอเจนต์ สถานการณ์ที่ต้อง "อธิบาย premise เดิมสามครั้ง" กลายเป็นเรื่องปกติ

2. Agentmemory แตกต่างอย่างไร

มาถึงหัวข้อหลักกัน Agentmemory (official repo: rohitg00/agentmemory) เป็น memory engine แบบโอเพนซอร์สที่ถึง 8.8k Stars ณ วันที่ 15 พฤษภาคม 2026 ซึ่งเพิ่มขึ้นมากกว่าสองเท่าจากรายงานแรกเริ่มที่ "4,000+ Stars" มันใช้สัญญาอนุญาต Apache 2.0, สร้างด้วย TypeScript และรุ่นล่าสุดคือ v0.9.12 (13 พฤษภาคม) เป็นแบบ self-hosted อย่างสมบูรณ์ โดยไม่มีข้อมูลใดถูกส่งไปยัง SaaS ภายนอก

ปรัชญาของผู้พัฒนา

Rohit Ghumare (@ghumare64) หัวหน้าผู้พัฒนา ได้สรุปสาระสำคัญของ Agentmemory ไว้ในประโยคเดียว:

สร้างสิ่งนี้เมื่อ 6 เดือนที่แล้วด้วย agentmemory: หน่วยความจำถาวรสำหรับ AI coding agents แนวคิดหลักเดียวกัน: หยุดการทำซ้ำ เริ่มการรวบรวม

"หยุดการทำซ้ำ เริ่มการรวบรวม" นี่คือความแตกต่างทางปรัชญาจากเครื่องมือที่มีอยู่

CLAUDE.md คือ "อินพุตสำหรับการทำซ้ำทุกครั้ง" โครงสร้างโปรเจกต์ ข้อตกลง การตัดสินใจในอดีต AI จะอ่านใหม่ ตีความใหม่ แล้วก็ลืมมันทุกเซสชัน Agentmemory เปลี่ยนแปลงสิ่งนี้โดยแทนที่ "วงจรการทำซ้ำ" ด้วย "เลเยอร์หน่วยความจำที่รวบรวมแล้ว"

สถาปัตยกรรม 3 ระดับ (สรุปจาก README)

ตาม README อย่างเป็นทางการ โครงสร้างภายในแบ่งออกเป็นสามขั้นตอน:

ขั้นแรกคือ Capture มันใช้ 12 Claude Code lifecycle hooks เพื่อจับข้อมูลโดยอัตโนมัติ ดังนั้นไม่จำเป็นต้องรัน memory_save ด้วยตนเอง

ขั้นที่สองคือ Pipeline มันจัดระเบียบการสังเกตผ่านโฟลว์ของการขจัดข้อมูลซ้ำ → ตัวกรองความเป็นส่วนตัว (การลบ API keys/PII อัตโนมัติ) → การบีบอัดโดยใช้ AI

ขั้นที่สามคือ Retrieval มันหลอมรวมการค้นหาแบบไฮบริดสามประเภท (BM25 / vector / graph) โดยใช้ RRF k=60 BM25 จัดการกับการจับคู่คำหลักแบบ stemming และการขยายคำพ้องความหมาย, vector จัดการกับ cosine similarity ของ dense embeddings, และ graph จัดการกับการ traverse กราฟความรู้ โดยการหลอมรวมด้วย Reciprocal Rank Fusion ถ้าวิธีหนึ่งพลาด อีกวิธีจะเก็บไว้ ผลลัพธ์จะถูกส่งกลับมาพร้อมการกระจายตามเซสชัน (สูงสุด 3 ต่อเซสชัน) ซึ่งแก้ปัญหาการได้ผลลัพธ์จากเซสชันเดียวกันเท่านั้น

หน่วยความจำ 4 ระดับ (ได้แรงบันดาลใจจาก Ebbinghaus)

อีกแง่มุมที่น่าสนใจคือการออกแบบที่แบ่งหน่วยความจำออกเป็นสี่ระดับที่ "เติบโต" ตามเวลา

ระดับล่างสุดคือ Working ซึ่งเป็นความจำระยะสั้น เช่น การสังเกตการทำงานของเครื่องมือดิบ, บันทึกข้อผิดพลาด, และประวัติคำสั่ง ถัดขึ้นมาคือ Episodic ซึ่งเป็นบทสรุปเซสชันของ "สิ่งที่เกิดขึ้น" ที่ระดับ Semantic มันจะกลายเป็น "สิ่งที่ฉันรู้" ความรู้ที่สกัดได้ และรูปแบบ ระดับสูงสุดคือ Procedural ซึ่งประกอบด้วยเวิร์กโฟลว์และขั้นตอนเกี่ยวกับ "วิธีการดำเนินการ"

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

การวางตำแหน่งเมื่อเทียบกับคู่แข่ง

บอกตามตรง มองแค่ GitHub Stars แล้ว Agentmemory ยังเล็ก เมื่อเทียบกับคู่แข่ง

● Mem0: 55.7k Stars, memory layer เอนกประสงค์, API/Cloud เป็นหลัก

● Letta (เดิมคือ MemGPT): 22.7k Stars, ระบบปฏิบัติการเอเจนต์, การจัดการบริบทเสมือน

● Agentmemory: 8.8k Stars, เฉพาะทางสำหรับ coding agents, local SQLite

มันแพ้ในเกมตัวเลข อย่างไรก็ตาม จุดที่ Agentmemory โดดเด่นคือ ความเชี่ยวชาญเฉพาะทางสำหรับ coding agents และการออกแบบแบบแยกส่วน Rohit เองเขียนไว้ว่า:

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

คุณสามารถเชื่อมต่อกับ Cursor, Cline, Claude Code, Codex และ Hermes โดยใช้หน่วยความจำเดียวกัน นี่คือจุดแตกต่างจาก Mem0 และ Letta Mem0 มีความทั่วไปเกินไปและมีการจับภาพอัตโนมัติที่อ่อนแอสำหรับบริบทการเขียนโค้ด ในขณะที่ Letta เป็น OS ของเอเจนต์ ทำให้ยากที่จะดึงเฉพาะเลเยอร์หน่วยความจำออกมา

Agentmemory เข้าถึงจุดศูนย์กลางของกลุ่มเฉพาะ "นักพัฒนาที่ใช้ coding agents หลายตัวพร้อมกัน"

3. เริ่มต้นใน 3 นาที — การติดตั้งและตั้งค่าเริ่มต้น

มาลงมือปฏิบัติกันเลย ขั้นตอนพื้นฐานเหมือนกันสำหรับ Mac, Linux และ Windows ตราบใดที่คุณมีสภาพแวดล้อม Node.js

ขั้นตอนที่ 1: เริ่ม Memory Server

แค่เปิดเทอร์มินัลแล้วรันคำสั่งนี้:

Start the memory server (keep it running)

npx @agentmemory/agentmemory

ครั้งแรกจะใช้เวลา 1-2 นาทีในการดาวน์โหลด dependencies เมื่อสำเร็จ REST API จะเริ่มทำงานที่ http://localhost:3111 คุณสามารถตรวจสอบสถานะด้วย:

curl http://localhost:3111/agentmemory/health

→ {"status":"ok","version":"0.9.12"}

วิวเวอร์ก็เริ่มทำงานเช่นกัน ดังนั้นคุณสามารถเห็นภาพเนื้อหาหน่วยความจำได้โดยเปิด http://localhost:3113 ในเบราว์เซอร์ของคุณ

ขั้นตอนที่ 2: แทรกข้อมูลตัวอย่าง

มันยากที่จะเห็นภาพด้วยเนื้อหาที่ว่างเปล่า ดังนั้นมาเพิ่มข้อมูลตัวอย่างกัน

Run in a separate terminal

npx @agentmemory/agentmemory demo

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

ขั้นตอนที่ 3: ผสานรวมกับ Claude Code

วิธีที่เร็วที่สุดจากฝั่ง Claude Code คือผ่านตลาดปลั๊กอิน

Execute within Claude Code

/plugin marketplace add rohitg00/agentmemory

/plugin install agentmemory

การดำเนินการนี้จะลงทะเบียนสิ่งต่อไปนี้โดยอัตโนมัติ:

● 12 hooks (ทุกระบบ lifecycle รวมถึง SessionStart / PostToolUse / Stop)

● 4 skills (recall / consolidate / export / governance)

● 51 MCP tools (AGENTMEMORY_TOOLS=all สำหรับทั้งหมด, ค่าเริ่มต้นคือ 15 core tools)

ขั้นตอนที่ 4: ผสานรวมกับ Codex CLI

Codex ก็ใช้รูปแบบที่คล้ายกัน

codex plugin marketplace add rohitg00/agentmemory

codex plugin install agentmemory

สำหรับ Codex, AGENTMEMORY_URL=http://localhost:3111 จะถูกตั้งเป็นตัวแปรสภาพแวดล้อมโดยอัตโนมัติ โปรดทราบว่า Codex เข้มงวดกว่า Claude Code ในเรื่อง MCP synchronicity ดังนั้นมันจะแสดงข้อผิดพลาดทันทีหากเซิร์ฟเวอร์หยุดทำงาน อย่าลืมให้มันทำงานอยู่

ขั้นตอนที่ 5: เชื่อมต่อกับ Cursor / Cline ฯลฯ

หากต้องการใช้ผ่าน Cursor ให้เพิ่มใน ~/.cursor/mcp.json:

{

"mcpServers": {

"agentmemory": {

"command": "npx",

"args": ["-y", "@agentmemory/mcp"],

"env": { "AGENTMEMORY_URL": "http://localhost:3111" }

}

}

}

Cline, Hermes และโปรแกรมแก้ไขอื่นๆ ที่รองรับ MCP ก็เชื่อมต่อในรูปแบบเดียวกัน มีกับดักอยู่ที่การตั้งค่า MCP ของ Cursor จะไม่สะท้อนทันทีโดยการปิดแล้วเปิดใหม่ ผมจะลงรายละเอียดในส่วน "5 กับดัก"

ขั้นตอนที่ 6: พิธีกรรมการตรวจสอบสถานะ

หลังจากตั้งค่าเสร็จ นี่คือรายการตรวจสอบที่จำเป็น:

1. Memory server connectivity

curl http://localhost:3111/agentmemory/health

2. Check iii-engine version (v0.11.2 required)

iii --version

3. Check memory in the viewer

open http://localhost:3113

ถ้าคุณเห็นการสังเกตที่บันทึกไว้ในวิวเวอร์ แสดงว่าการตั้งค่าสำเร็จ ถ้าติดตั้ง Node.js ไว้แล้ว จะใช้เวลาไม่ถึง 3 นาที

4. 3 การกระทำพื้นฐาน — บันทึก, ค้นหา, บีบอัดอัตโนมัติ

การใช้งาน Agentmemory สามารถจัดระเบียบได้เป็นสามการกระทำหลัก

การกระทำที่ 1: บันทึก (การจับภาพอัตโนมัติเป็นค่าเริ่มต้น)

ใน Mem0 หรือ Letta การบันทึกมักจะใช้คำสั่ง manual เช่น memory_add(...) Agentmemory มีปรัชญาที่แตกต่าง: มันจับภาพทุกอย่างโดยอัตโนมัติโดยใช้ 12 hooks

ตัวอย่างเช่น การสังเกตต่อไปนี้จะถูกบันทึกโดยที่คุณไม่ต้องทำอะไรเลย:

● คำสั่งและเอาต์พุตระหว่างการทำงานของ Bash tool (PostToolUse hook)

● ความแตกต่างก่อนและหลังการแก้ไขไฟล์ (PreToolUse / PostToolUse hook)

● การฉีดหน่วยความจำที่เกี่ยวข้องโดยอัตโนมัติเมื่อเริ่มเซสชัน (SessionStart hook)

● การบีบอัดสรุปเมื่อสิ้นสุดเซสชัน (Stop hook)

คุณค่าที่ยิ่งใหญ่ที่สุดคือ "ภาระของผู้ใช้ในการตัดสินใจว่าจะบันทึกอะไร" กลายเป็นศูนย์ ในขณะที่เมื่อก่อนเราต้องคิดว่า "นี่สำคัญ, มาเขียนไว้" หรือ "ลบอันนี้ทิ้ง" ใน CLAUDE.md แนวคิดที่นี่คือปล่อยให้ตรรกะการตัดสินใจนั้นเป็นหน้าที่ของ AI

คุณยังสามารถบันทึกด้วยตนเอง โดยการเรียก memory_save ผ่าน MCP tool คุณสามารถทำเครื่องหมาย "นี่สำคัญ" อย่างชัดเจนได้ การบันทึกการตัดสินใจออกแบบที่สำคัญด้วยตนเองนั้นปลอดภัยกว่าการพึ่งพาการจับภาพอัตโนมัติเพียงอย่างเดียว

การกระทำที่ 2: ค้นหา (3 ระบบไฮบริด + RRF)

การค้นหาทำได้ผ่าน MCP tools หรือโดยเรียก REST API โดยตรง นี่คือ MCP tools ที่เป็นตัวแทน:

● memory_recall — ดึงหน่วยความจำที่เกี่ยวข้องโดยใช้ภาษาธรรมชาติ

● memory_smart_search — เวอร์ชันเต็มรูปแบบของการค้นหาแบบไฮบริด

● memory_sessions — แสดงรายการตามเซสชัน

● memory_timeline — เรียงตามเวลา

● memory_relations — กราฟ traversal ของเอนทิตีที่เกี่ยวข้อง

ถ้าเรียก REST API โดยตรง:

Search for "previous fix regarding Supabase auth"

curl -X POST http://localhost:3111/agentmemory/search \

-H "Content-Type: application/json" \

-d '{"query": "supabase auth fix", "limit": 5}'

ผลลัพธ์ที่ส่งกลับมาเป็นการหลอมรวมของ BM25 / vector / graph โดยใช้ RRF k=60 เวลาแฝงต่ำกว่า 20ms ที่ P50 (เร็วเพราะ local SQLite)

ความแม่นยำในเกณฑ์มาตรฐานอย่างเป็นทางการ (LongMemEval-S, 500 คำถาม, ICLR 2025) มีดังนี้:

● R@5: 95.2% (ความน่าจะเป็นที่คำตอบที่ถูกต้องอยู่ใน 5 อันดับแรก)

● R@10: 98.6%

● MRR: 88.2%

โปรดทราบว่านี่คือ "ความแม่นยำในการค้นหา" ไม่ใช่ "ความแม่นยำของ Q&A แบบ end-to-end" มันคือความน่าจะเป็นที่คำตอบที่ถูกต้องอยู่ในตัวเลือก ไม่ใช่ว่า Claude จะใช้มันตอบถูกหรือไม่นั้นเป็นอีกเรื่องหนึ่ง อย่าพึ่งพามันมากเกินไปโดยสับสนระหว่างสองสิ่งนี้

การกระทำที่ 3: การบีบอัดอัตโนมัติ (การเติบโต 4 ระดับตามเวลา)

ทุกครั้งที่ Stop hook ทำงาน การบีบอัดสามขั้นตอนจะเกิดขึ้นตามลำดับ:

ขั้นแรก Working → Episodic จะย่อบันทึกเครื่องมือดิบเป็นบทสรุปเซสชัน ถัดมา Episodic → Semantic จะสกัด "รูปแบบ" และ "ความรู้" จากเหตุการณ์หลายเซสชัน สุดท้าย Semantic → Procedural จะทำให้ขั้นตอนที่ทำซ้ำบ่อยๆ กลายเป็น "เวิร์กโฟลว์"

สิ่งนี้ช่วยแก้ปัญหาการ "บันทึกทุกอย่างและสร้างสัญญาณรบกวนในการค้นหา" โดยอัตโนมัติ งบประมาณ token ที่ฉีดเมื่อเริ่มเซสชันคือ 2,000 token โดยค่าเริ่มต้น ซึ่งออกแบบมาเพื่อกู้คืน "บริบทก่อนหน้า" ในรูปแบบที่จำเป็นและเพียงพอ

5. เวิร์กโฟลว์สำหรับการใช้ Codex / Claude Code แบบคู่

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

รูปแบบที่ 1: โฟลว์รายวันสำหรับการพัฒนาเดี่ยว

โดยให้เซิร์ฟเวอร์ agentmemory ทำงานอยู่ SessionStart hook จะทำงานเมื่อ Claude Code เริ่มต้น โดยฉีดหน่วยความจำ Episodic ของวันก่อนหน้าโดยอัตโนมัติ แม้จะไม่ได้พูดว่า "Continue from yesterday" การสนทนาก็เริ่มต้นโดย Claude เข้าใจแล้วว่า "มาต่อเรื่องที่ค้างอยู่เกี่ยวกับ Supabase RLS กัน"

ระหว่างการเขียนโค้ด PostToolUse hook จะเขียนคำสั่ง เอาต์พุต และ diffs ลงใน SQLite อย่างต่อเนื่อง เมื่อปิดเซสชัน Stop hook จะบีบอัด Working เป็น Episodic เช้าวันรุ่งขึ้น สิ่งนั้นจะถูกอ่านโดยอัตโนมัติ ครบวงจร

รูปแบบที่ 2: การจัดการหลายโปรเจกต์

Agentmemory สามารถแบ่งหน่วยความจำออกเป็นสามขอบเขต ขอบเขต user ผูกติดกับตัวบุคคล มี "นิสัยส่วนตัว" เช่น การตั้งค่ากฎการเขียนโค้ด ขอบเขต project ถูกจัดการแยกกันสำหรับแต่ละโปรเจกต์ โดยมีไฟล์ SQLite แยกกัน ขอบเขต local ยังคงอยู่บนเครื่องนั้นเท่านั้น และไม่ถูกส่งออกไปแม้ในโหมดการแชร์เป็นทีม

โดยการเปลี่ยนตัวแปรสภาพแวดล้อมเป็น AGENTMEMORY_PROJECT=foo-app เมื่อสลับโปรเจกต์ ไฟล์ SQLite ที่ต่างกันจะถูกอ้างอิง ซึ่งมีประสิทธิภาพอย่างเหลือเชื่อสำหรับคนที่ทำงานหลายโปรเจกต์พร้อมกัน ปรากฏการณ์ที่การตัดสินใจออกแบบจากโปรเจกต์ A รั่วไหลไปยังการอภิปรายสำหรับโปรเจกต์ B เกิดขึ้นบ่อยกับ CLAUDE.md เมื่อใช้ Agentmemory พวกมันจะถูกแยกทางกายภาพ จึงไม่มีการปนกัน

รูปแบบที่ 3: การแชร์ทีมและการพัฒนาร่วมกับบริษัทจดทะเบียน

ปัจจุบันเรากำลังพัฒนา AI agents ร่วมกับบริษัทจดทะเบียน และโหมดการแชร์ MCP server ก็มีประสิทธิภาพในทางปฏิบัติ ด้วยการตั้งค่าแฟล็ก collab=true อินสแตนซ์ Codex / Claude Code หลายตัวสามารถอ้างอิงเซิร์ฟเวอร์หน่วยความจำเดียวกันได้

Server side

AGENTMEMORY_COLLAB=true npx @agentmemory/agentmemory --bind 0.0.0.0

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

กับดักเฉพาะสำหรับการใช้งานสองเอเจนต์

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

6. วิธีอ่าน Benchmarks — แปลงตัวเลขเป็น "ประสบการณ์"

ผจะแปลตัวเลขทางการเป็นความรู้สึกในทางปฏิบัติ

ความจริงเบื้องหลัง "การลด Token 92%"

"การลดลง 92%" ที่ถูกโหมกระหน่ำในข่าวสั้นและบทความ Medium นั้นเป็น ต่อเซสชัน

● การทำงานด้วยตนเองแบบ CLAUDE.md ทั่วไป: ประมาณ 22,000 tokens ต่อเซสชัน

● ผ่าน Agentmemory: ประมาณ 1,900 tokens ต่อเซสชัน

● อัตราการลดลง: ประมาณ 91-92%

token ที่ฉีดเข้าไปในบริบทเมื่อเริ่มเซสชันลดลงอย่างมาก เมื่อคิดเป็นรายปี ตัวเลขจะเปลี่ยนไป และตาราง Token Savings ใน README ระบุว่า:

● การทำงานแบบสรุปด้วย LLM: ประมาณ 650K tokens / ปี (ประมาณ $500 / ปี)

● Agentmemory: ประมาณ 170K tokens / ปี (ประมาณ $10 / ปี)

ในแง่ของ token มันลดลงประมาณ 74% แต่ ในแง่ของต้นทุน มันลดลง 98% จาก $500 เหลือ $10 สาเหตุของความแตกต่างคือ Agentmemory ทำงานบน local SQLite + local embeddings ซึ่งแตกต่างจาก Mem0 หรือ Letta ที่รันการบีบอัดโดยใช้ LLM ทุกครั้ง ต้นทุนการดำเนินการจึงน้อยมาก

ความหมายของ "LongMemEval-S R@5 95.2%"

LongMemEval-S เป็นเกณฑ์มาตรฐานความจำระยะยาวที่เผยแพร่ใน ICLR 2025 (500 คำถาม, ประมาณ 48 เซสชันต่อคำถาม, บริบทประมาณ 115K tokens) การเปรียบเทียบเครื่องมือหลัก:

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

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

Codex 400K กับ Opus 4.7 1M: "ทางกายภาพกับทางปฏิบัติ"

เมื่อดูตัวเลขเกณฑ์มาตรฐาน ผมสังเกตเห็นประเด็นสำคัญอีกประเด็นหนึ่ง

Claude Opus 4.7 ขยายบริบทเป็น 1M tokens GPT-5.5 ก็ 1M tokens ผ่าน API เช่นกัน เมื่อดูแค่นี้ดูเหมือนว่า "เราไม่ต้องการเครื่องมือความจำอีกต่อไป"

อย่างไรก็ตาม Codex CLI จริงๆ แล้ว ถูกจำกัดที่ 400K ขีดจำกัดทางกายภาพและขีดจำกัดในทางปฏิบัติไม่สอดคล้องกัน ยิ่งไปกว่านั้น ดังที่ Anthropic เขียนไว้เอง context rot เริ่มต้นที่ 200K-400K tokens เมื่อบริบทเพิ่มขึ้น

กล่าวอีกนัยหนึ่ง แม้ว่าขนาดทางกายภาพจะเพิ่มขึ้น ความจำเป็นสำหรับ memory engine ก็ไม่ได้ลดลง แต่ "วิธีการใช้ context window ที่กว้างอย่างมีประสิทธิภาพ" กลายเป็นความท้าทายทางเทคนิคใหม่

7. 5 กับดัก — กับระเบิดที่ผมเจอจริงๆ

ผมจะพูดตรงนี้ นี่คือกับระเบิด 5 อย่างที่ผมเหยียบขณะใช้งานจริง ซึ่งไม่มีอยู่ใน README อย่างเป็นทางการหรือทวีตของอินฟลูเอนเซอร์ ผมเลือกเฉพาะที่สามารถทำซ้ำได้จาก GitHub Issues

กับดักที่ 1: iii-engine เวอร์ชัน v0.11.2 ไม่ตรงกัน

ทันทีหลังการตั้งค่า บางคนอาจเจอข้อผิดพลาดนี้:

iii: command not found

Or

Version mismatch: expected v0.11.2, got v0.11.0

Agentmemory ขึ้นอยู่กับไบนารีที่ชื่อว่า iii-engine ภายใน และ เวอร์ชันถูกตรึงไว้ที่ v0.11.2 หากติดตั้งเวอร์ชันอื่นไว้แล้ว มันจะล้มเหลวในขั้นตอนการเริ่มต้น วิธีแก้ไขคือการดึงเวอร์ชันที่ตรึงไว้จาก releases สำหรับแต่ละ OS

macOS arm64

curl -fsSL https://github.com/iii-hq/iii/releases/download/iii/v0.11.2/iii-aarch64-apple-darwin.tar.gz \

Linux x64

curl -fsSL https://github.com/iii-hq/iii/releases/download/iii/v0.11.2/iii-x86_64-unknown-linux-gnu.tar.gz \

Verification

iii --version # Should show v0.11.2

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

กับดักที่ 2: Issue #181 — การผลิต Ghost Session จำนวนมากผ่าน Infinite Loop

อันนี้เป็นอันตรายร้ายแรง เป็นบั๊กที่ร้ายแรงที่รายงานใน v0.9.1 ซึ่งการเรียก /summarize จาก Stop hook โดยไม่ได้ตั้งค่า API key ทำให้เกิดการสร้าง child session อย่างไม่สิ้นสุด

Stop hook → /summarize → Child session generated

↓

Child session's Stop hook also fires → /summarize → More child sessions

↓

(Infinite loop)

มีรายงานใน GitHub Issue #181 ว่ามี ghost session ประมาณ 579 ตัวถูกสร้างขึ้นภายในไม่กี่นาที มีสามวิธีแก้ไข:

Option 1: Disable agent-sdk mode (Recommended)

export AGENTMEMORY_ALLOW_AGENT_SDK=false

Option 2: Force error with a fake API key

export AGENTMEMORY_ANTHROPIC_API_KEY="fake-key"

Option 3: Set a real API key

export AGENTMEMORY_ANTHROPIC_API_KEY="sk-ant-..."

สำหรับการใช้งานจริง ตัวเลือก 1 หรือ 3 ปลอดภัย ตัวเลือก 2 เหมาะสำหรับวันแรกที่คุณ "แค่อยากให้มันทำงาน"

กับดักที่ 3: Issue #159 — MCP และ REST API ทำงานบน KV แยกกัน

นี่คืออีกปรากฏการณ์หนึ่งที่จะทำให้คุณเกาหัวถ้าไม่รู้ การเรียก MCP tool (เช่น memory_search) คืนผลลัพธ์ว่างเปล่าทุกครั้ง ในขณะที่ REST API (POST /agentmemory/search) เจอ Hits ด้วยข้อมูลเดียวกัน

REST API: GET /agentmemory/sessions → 69 observations

MCP tool: memory_sessions → [] (empty)

สาเหตุคือแพ็คเกจ @agentmemory/mcp และเซิร์ฟเวอร์ Agentmemory ถูกออกแบบให้มี KV store ที่แยกจากกันโดยสิ้นเชิง (Issue #159) MCP คือ "local KV" และเซิร์ฟเวอร์คือ "อีก KV" โดยไม่มีเส้นทางโค้ดการสื่อสารระหว่างกัน ณ เดือนพฤษภาคม 2026 ปัญหายังคงเปิดอยู่ วิธีแก้ไขคือ:

● ตัวเลือก 1: ใช้ REST API โดยตรง (ผ่าน curl หรือ fetch แทน MCP tools)

● ตัวเลือก 2: ปิดการทำงานของ /mcp hook ชั่วคราวและรันเฉพาะเซิร์ฟเวอร์

มีแผนที่จะแก้ไขในอนาคต แต่สำหรับตอนนี้ คุณต้องสร้างงานรอบสเปคนี้

กับดักที่ 4: MCP ไม่สะท้อนใน Cursor / VSCode

คุณแก้ไข ~/.cursor/mcp.json และรีสตาร์ท Cursor แล้ว แต่ Agentmemory ไม่ปรากฏใน /mcp list สิ่งนี้เกิดขึ้นไม่เฉพาะกับ Cursor แต่กับ Windows Store apps โดยทั่วไป

การปิดด้วยปุ่ม "X" ของ GUI จะปล่อยให้ WindowsApps background process ทำงานอยู่ โดยค่าเริ่มต้น กระบวนการเก่ายังคงทำงานต่อโดยถือการตั้งค่าเก่าไว้ในหน่วยความจำ จำเป็นต้องมีพิธีกรรมสำหรับการยุติอย่างสมบูรณ์

macOS

pkill -9 Cursor

Windows (PowerShell as Admin)

taskkill /F /IM "Cursor.exe"

net stop "Windows Store Service (WSService)" 2>$null; net start "Windows Store Service (WSService)

...

กับดักที่ 5: ปัญหาการซิงค์เมื่อเชื่อมต่อกับ Codex / Claude Code พร้อมกัน

เมื่อใช้ Agentmemory กับทั้ง Codex และ Claude Code พร้อมกัน คุณอาจพบว่าการเปลี่ยนแปลงจากเซสชันหนึ่งไม่สะท้อนในอีกเซสชันหนึ่งทันที สาเหตุมาจากกลไกการแคชของ MCP ที่แต่ละเอเจนต์มี cache unit memory ของตัวเอง

วิธีแก้ไข: ตั้งค่า AGENTMEMORY_CACHE_TTL=0 เพื่อปิดแคช หรือใช้ REST API โดยตรงเมื่อต้องการข้อมูลล่าสุด

นอกจากนี้ เมื่อทั้งสองเอเจนต์เขียนหน่วยความจำพร้อมกัน อาจเกิด race condition ได้ แม้ SQLite จะมีกลไก locking แต่การเขียนพร้อมกันจากหลายเอเจนต์อาจทำให้ข้อมูลสูญหายได้

ข้อแนะนำ: ใช้เอเจนต์หลักเพียงตัวเดียวในการเขียนหน่วยความจำ และให้เอเจนต์อื่นๆ อ่านอย่างเดียว

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

สรุป

Agentmemory เป็นเครื่องมือที่มีศักยภาพสูงในการแก้ปัญหา "context rot" ที่เกิดขึ้นกับ Claude Code และ Codex โดยเฉพาะอย่างยิ่งสำหรับนักพัฒนาที่ใช้เอเจนต์หลายตัว แต่ก็มีข้อควรระวังหลายอย่างที่ต้องรู้ก่อนเริ่มใช้งาน

ข้อดี:

• จับภาพบริบทอัตโนมัติด้วย 12 hooks
• หน่วยความจำ 4 ระดับที่เลียนแบบความจำมนุษย์
• รองรับการใช้งานข้ามเอเจนต์ (Codex, Claude Code, Cursor, Cline, Hermes)
• ต้นทุนต่ำเพราะใช้ local SQLite
• Open source และ self-hosted

ข้อควรระวัง:

• ต้องระวังเรื่อง version mismatch ของ iii-engine
• ปัญหา infinite loop จาก Issue #181
• MCP กับ REST API ใช้ KV store แยกกัน
• ต้องปิดกระบวนการให้สนิทเมื่อเปลี่ยนการตั้งค่า
• ปัญหาการซิงค์เมื่อใช้หลายเอเจนต์พร้อมกัน

โดยรวมแล้ว Agentmemory เป็นเครื่องมือที่ "ต้องมี" สำหรับนักพัฒนาที่จริงจังกับการใช้ AI coding agents แต่ต้องใช้ด้วยความเข้าใจในข้อจำกัดของมัน

บทความนี้เขียนขึ้นจากประสบการณ์การใช้งานจริงเป็นเวลา 1 สัปดาห์ ข้อมูล ณ วันที่ 15 พฤษภาคม 2026

open /Applications/Cursor.app

Windows (PowerShell)

→ Restart

ถ้าคุณตั้งค่าให้ "ตรวจสอบกระบวนการที่เหลือค้าง" เป็นค่าเริ่มต้นก่อนที่จะสงสัยไฟล์ config คุณจะประหยัดเวลาได้เยอะตรงนี้

ข้อผิดพลาดที่ 5: Observations ถูกทิ้งอย่างเงียบ ๆ โดย Privacy Filter

ปรากฏการณ์ที่ "เซิร์ฟเวอร์ทำงานอยู่ แต่ observations ไม่แสดงใน viewer" ก็เกิดขึ้นบ่อยในสัปดาห์แรกเช่นกัน เมื่อดูที่ logs คุณจะเห็นคำเตือนแบบนี้:

[warn] observation dropped: private_tag detected

[warn] observation dropped: private_email detected

นี่คือ โดยการออกแบบ ไม่ใช่บั๊ก privacy filter ของ Agentmemory จะตรวจจับ API keys, passwords, อีเมล และ PII โดยอัตโนมัติ และ ทิ้ง observations เหล่านั้นโดยไม่บันทึกไว้ มันเป็นฟีเจอร์ที่ยอดเยี่ยมสำหรับความปลอดภัย แต่ถ้าคุณไม่รู้เกี่ยวกับมัน คุณจะคิดว่ามัน "ไม่ทำงาน" กลยุทธ์การอยู่ร่วมกันคือ:

ยกเว้นโดยใช้ไฟล์ .agentmemoryignore

echo ".env" >> .agentmemoryignore

echo ".env.local" >> .agentmemoryignore

echo "*/.key" >> .agentmemoryignore

echo "*/password*" >> .agentmemoryignore

โดยเฉพาะอย่างยิ่งเมื่อรันโค้ดทดลองที่รวม API keys ไว้ใน observations การวางไฟล์นี้ไว้ล่วงหน้าถือว่าปลอดภัย

8. สรุป — "หน่วยความจำไม่จำกัด" ไม่ใช่แค่การขยาย Context Window

หลังจากใช้ Agentmemory อย่างหนักเป็นเวลาหนึ่งสัปดาห์ นี่คือความรู้สึกที่คลิกได้มากที่สุด: การพูดว่า "หน่วยความจำไม่จำกัด" ไม่ได้หมายถึงการขยายขนาด physical context window

แม้ว่าจะเพิ่มเป็น 1M tokens ถ้าความแม่นยำลดลงที่ 200K มันก็ไร้ประโยชน์ในที่สุด ฉันรู้สึกว่าการแข่งขันเรื่องขนาด physical ได้จบลงแล้ว สิ่งที่ Agentmemory ช่วยให้คุณได้รับคือ สมองภายนอกเชิงความหมาย (semantic external brain)

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

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

ทั้งอุตสาหกรรมกำลังเดินไปในทิศทางนี้ หลักสูตร agent memory ของ DeepLearning.AI, ข้อความของ Mem0 ที่ว่า "ทำให้ stateless agents กลายเป็น stateful", เอกสาร MemGPT ที่ว่า "LLMs as Operating Systems" — ท้ายที่สุดแล้ว ทั้งหมดนี้เกี่ยวกับ external memory และ Agentmemory ก็เป็นหนึ่งในโซลูชันในบริบทของ coding agent

ไม่ว่าจะเป็น Mem0, Letta หรือการ implement ด้วยตัวเอง สำหรับผู้ที่ใช้ Codex / Claude Code อย่างจริงจัง มันคือ เครื่องมือที่เร็วที่สุดในตอนนี้ในการลองสัมผัส "ความรู้สึกของหน่วยความจำไม่จำกัด" ตามตรง มันคุ้มค่าที่จะติดตั้ง

9. เกี่ยวกับบัญชีนี้

สำหรับผู้ที่อ่านมาถึงตรงนี้: บัญชีนี้ @Codestudiopjbk ดำเนินการโดยผู้ใช้ Codex ตัวยงสามคน

● การเข้าร่วมโปรแกรมพัฒนาสำหรับนักศึกษาปริญญาโทและปริญญาเอก

● ชนะรางวัลเงินสด 300,000 เยน

● ปัจจุบันร่วมพัฒนา AI agents กับบริษัทจดทะเบียน

เนื้อหาทั่วไปของเราประกอบด้วย:

● ตัวอย่างการนำไปใช้โดยใช้ GPT-5.5 / OpenAI Codex

● การใช้ Codex, CLI automation และแนวโน้มการพัฒนา

● การแปลและตรวจสอบข้อมูลล่าสุดเกี่ยวกับ GPT-5.5 / Codex จากต่างประเทศ

● การเปรียบเทียบเชิงปฏิบัติกับ Claude Code (อิงจากการใช้งานหลายร้อยชั่วโมง)

● บทเรียนจากการพัฒนาร่วมกับบริษัทจดทะเบียน

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

สำหรับการปรึกษาเรื่องการพัฒนา โปรดส่งข้อความโดยตรง (DM) อย่าลังเลที่จะติดต่อเพื่อขอคำแนะนำเกี่ยวกับ Codex, การออกแบบระบบอัตโนมัติ หรือการนำ AI agents ไปใช้

ข้อมูลอ้างอิงและแหล่งที่มา

● [Rohit Ghumare (rohitg00/agentmemory)] (2026-05-13) Agentmemory v0.9.12 — Memory Engine for Coding Agents — Repository ทางการ, Apache-2.0, 8.8k Stars, TypeScript

● [Rohit Ghumare] (2026-04) "สร้างสิ่งนี้เมื่อ 6 เดือนที่แล้วด้วย agentmemory: หน่วยความจำถาวรสำหรับ AI coding agents" — ปรัชญาของนักพัฒนา

● [GitHub Issue #181] Stop-hook → /summarize → agent-sdk infinite recursion — แหล่งที่มาหลักสำหรับข้อผิดพลาดที่ 2

● [GitHub Issue #159] Standalone MCP tools ไม่สามารถ proxy ไปยัง running agentmemory server — แหล่งที่มาหลักสำหรับข้อผิดพลาดที่ 3

● [Anthropic Engineering] Effective Context Engineering for AI Agents — คำแนะนำอย่างเป็นทางการเกี่ยวกับ context engineering

● [Anthropic] (2026-04-23) April 23 Postmortem — หลักฐานทางสังคมเกี่ยวกับเหตุการณ์การยุบตัวของความยาวความคิดของ Claude Code

● [Mem0] รู้จักกับ Mem0 — ปรัชญาของ Mem0 และการอ้างอิงจาก Taranjeet Singh

● [Letta] การวัดประสิทธิภาพหน่วยความจำของ AI Agent — แหล่งที่มาสำหรับตัวเลขการวัดประสิทธิภาพของ Letta

● [Charles Packer และคณะ] (2023-10) MemGPT: Towards LLMs as Operating Systems — เอกสารเกี่ยวกับการจัดการบริบทเสมือน (virtual context management) ซึ่งเป็นรากฐานทางทฤษฎีของ Agentmemory

● [DeepLearning.AI] Agent Memory: Building Memory-Aware Agents — หลักสูตรโดย Andrew Ng / Oracle