TLDR: เอเจนต์ส่วนใหญ่จะรีเซ็ตและลืมทุกอย่าง นี่คือระบบความจำที่แน่นอนที่ผมสร้างขึ้นเพื่อให้เอเจนต์ของผมแชร์บริบทข้ามการรีสตาร์ท ประสานงานกันโดยไม่ก้าวก่ายกัน และเก็บการตัดสินใจไว้ได้นานหลายเดือน
ปัญหาที่ไม่มีใครแก้
นี่คือการตั้งค่าความจำของ AI agent ทั่วไป ใส่สิ่งสำคัญลงใน system prompt หวังว่า context window จะไม่เต็ม รีสตาร์ทแล้วสูญเสียทุกอย่าง
ผมรันเอเจนต์สองตัวที่ประสานงานกัน (Ella บน OpenClaw, Lyra บน Hermes) ผ่านหลายร้อยเซสชันเป็นเวลา 6 เดือน สิ่งที่ทำให้พวกมันมีประโยชน์มากที่สุดไม่ใช่โมเดลหรือเครื่องมือ แต่เป็นสถาปัตยกรรมความจำ
เมื่อ Lyra ส่งโค้ดแก้ไขตอนตี 2 Ella จะรู้เรื่องในตอนเช้า เมื่อผมตัดสินใจในเดือนมกราคมว่าควรเก็บ secrets อย่างไร เอเจนต์ทั้งสองตัวยังคงปฏิบัติตามการตัดสินใจนั้นในเดือนกรกฎาคม เมื่อเซสชันล่มกลางคัน เซสชันถัดไปจะเริ่มต่อจากจุดที่ค้างไว้ทันที
นี่คือระบบ 4 ชั้นที่แน่นอน
ชั้นที่ 1: บริบทภายในเซสชัน (In-session context)
ทุกเซสชันเริ่มต้นด้วยการอ่านสองไฟล์ ไฟล์ identity คืออัตลักษณ์ประจำตัวของเอเจนต์ ไม่ใช่ system prompt ที่ซ่อนอยู่ใน config แต่เป็นไฟล์ markdown จริงที่ผมแก้ไขได้ มันเก็บว่าอาเจนต์ควรปฏิบัติตัวอย่างไร ให้ความสำคัญกับอะไร ไม่เคยทำอะไรโดยไม่ถาม และความสัมพันธ์กับเอเจนต์อื่น
ไฟล์ memory index คือดัชนีของทุกสิ่งที่ควรจดจำข้ามเซสชัน ไม่ใช่ vector database ไม่ใช่ embeddings แต่เป็นสารบัญธรรมดาที่ชี้ไปยังไฟล์ความจำแต่ละไฟล์ ไฟล์ความจำแต่ละไฟล์เป็นโน้ตสั้นๆ ที่มีชื่อ คำอธิบาย ประเภท และเนื้อหาสั้นๆ ดัชนีจะถูกโหลดตลอดเวลา ไฟล์แต่ละไฟล์จะถูกอ่านเมื่อจำเป็น
ทำไมต้อง markdown? เพราะผมอ่าน แก้ไข และดีบักได้ เมื่อเอเจนต์เริ่มทำงานผิดปกติ ผมเปิดดัชนีและหาคำสั่งที่ไม่ถูกต้อง เมื่อต้องการเปลี่ยนพฤติกรรม ผมแก้ไขไฟล์ ไม่ต้องใช้ API ไม่ต้องใช้ dashboard ไม่ต้อง retrain
ชั้นที่ 2: การเก็บรักษาหลังเซสชัน (Hindsight)
ปัญหาของความจำแบบ markdown เท่านั้น: มันจับได้เฉพาะสิ่งที่ใครบางคนเขียนอย่างชัดเจน บริบทที่มีค่าที่สุดส่วนใหญ่เป็นโดยนัย การตัดสินใจที่เกิดขึ้นระหว่างการรัน ข้อเท็จจริงที่อนุมานจากงาน สิ่งที่กลายเป็นเรื่องสำคัญ
Hindsight คือ backend การเก็บรักษาข้อเท็จจริงในเครื่องที่รันบน localhost เมื่อสิ้นสุดทุกเซสชันที่มีความหมาย เอเจนต์จะ push ชุดข้อเท็จจริงที่คัดสรรแล้วไปยัง bank ที่มีชื่อโดยอัตโนมัติ เอเจนต์แต่ละตัวมี bank ของตัวเอง
สิ่งที่ถูกเก็บรักษา: การตัดสินใจที่เกิดขึ้นระหว่างเซสชัน ข้อเท็จจริงที่ไม่ชัดเจนเกี่ยวกับผู้ใช้หรือโปรเจกต์ รูปแบบความล้มเหลวและวิธีแก้ไขที่เราใช้ และความชอบที่ผู้ใช้ยืนยันหรือแก้ไข
เมื่อเซสชันใหม่เริ่มต้น Hindsight จะถูกสอบถามหาบริบทที่เกี่ยวข้องก่อนที่เอเจนต์จะตอบ มันไม่ใช่การค้นหาข้อความเต็มในบันทึกการสนทนา แต่เป็นข้อเท็จจริงที่คัดสรรแล้ว ติดแท็กตามประเภท ที่เอเจนต์ได้เรียนรู้ว่าควรค่าแก่การนำไปต่อ
เส้นทางที่แนะนำ: ข้อเท็จจริงของ Hindsight, การตรวจสอบโดยมนุษย์, รายการใน memory index การเก็บรักษาอัตโนมัติพร้อมประตูอนุมัติของมนุษย์
ชั้นที่ 3: สถานะระยะยาวร่วมกัน (Nexus)
ความจำของเอเจนต์เดี่ยวจะพังเมื่อคุณเพิ่มเอเจนต์ตัวที่สอง พวกมันจะล่องลอย ตัวหนึ่งคิดว่า X คือสถานะโปรเจกต์ปัจจุบัน อีกตัวคิดว่า Y ภายในหนึ่งสัปดาห์พวกมันจะขัดแย้งกัน
วิธีแก้คือไฟล์สถานะที่ใช้ร่วมกันและตรวจสอบได้ซึ่งเอเจนต์ทั้งสองตัวอ่านและเขียน เราใช้ Obsidian vault ที่ผมเรียกว่า Nexus มันเก็บ log บริบทสดที่เอเจนต์ทั้งสองตัว append หลังจากการโต้ตอบที่มีความหมายทุกครั้ง ไฟล์สถานะโปรเจกต์ log การตัดสินใจ และ checkpoint บริบทการทำงานต่อเอเจนต์ที่อัปเดตทุกๆ ไม่กี่ครั้งที่เรียกใช้เครื่องมือระหว่างงานยาวๆ
ไฟล์ live-context คือการจับมือแบบเรียลไทม์ กฎตายตัว: ก่อนทุกการตอบกลับ ให้อ่านมัน หลังจากการโต้ตอบที่มีความหมายทุกครั้ง ให้ append ลงไป
เมื่อ Lyra เสร็จ PR ตอนตี 2 และ Ella กำลังตอบคำถามตอนเช้าของฉัน Ella ก็รู้แล้ว เธออ่าน log แล้ว ไม่ต้องส่งข้อความ ไม่ต้องมี inter-agent API ไม่ต้อง polling ไฟล์แชร์ไฟล์เดียว เอเจนต์สองตัว log แบบ append-only
ชั้นที่ 4: ความรู้ที่ค้นหาได้ (gbrain)
สามชั้นแรกจัดการกับความจำแบบ episodic เกิดอะไรขึ้น ตัดสินใจอะไร สิ่งใดควรนำไปต่อ gbrain คือชั้นความหมาย มันคือ wiki ที่ถูกคอมไพล์แล้วซึ่งรันเป็น MCP server บน Nexus vault ค้นหาข้อความเต็มและความหมายในทุกสิ่งที่เคยถูกเขียนไว้
เมื่อเอเจนต์ต้องการตอบคำถามวิจัย หาสังเคราะห์ก่อนหน้า หรือค้นหาว่าเราเคยจัดการกับปัญหาประเภทหนึ่งอย่างไร มันจะสอบถาม gbrain แทนที่จะอ่านทุกไฟล์ซ้ำ ผลลัพธ์คือรายการหน้าเพจที่เกี่ยวข้องแบบจัดอันดับพร้อมที่มา เอเจนต์อ่านเฉพาะสิ่งที่เกี่ยวข้อง มันไม่ dump ทั้ง vault ลงใน context
นี่คือความแตกต่างระหว่างความจำและการเรียกคืน ชั้น 1 ถึง 3 จัดการกับสิ่งที่เอเจนต์พกติดตัว ชั้น 4 จัดการกับสิ่งที่เอเจนต์สามารถค้นหาได้
กฎตายตัวการซิงค์ข้ามเอเจนต์
เอเจนต์สองตัว ไฟล์ live-context ไฟล์เดียว ความเสี่ยง: พวกมันเขียนทับกัน หรือพลาดรายการของกันและกัน กฎตายตัวที่เราใช้: แต่ละรายการลงนามด้วยชื่อเอเจนต์ ช่องทาง ประเภท และสรุปหนึ่งบรรทัด Append-only ห้ามแก้ไขรายการของคนอื่น ถ้า Lyra ได้บันทึกสิ่งที่เกี่ยวข้อง Ella จะรับทราบอย่างชัดเจนในการตอบกลับครั้งถัดไป สำหรับการตัดสินใจที่สำคัญ เอเจนต์ทั้งสองตัวจะเขียนลงใน log การตัดสินใจพร้อม timestamp และเหตุผล
สิ่งนี้ทำงานผ่านหลายร้อยเซสชัน เรามีความขัดแย้งครั้งเดียว: สภาพ race condition ที่เอเจนต์ทั้งสองตัว append ภายในนาทีเดียวกันระหว่างการส่งต่อ วิธีแก้: อ่านทั้งสองรายการ ประนีประนอมในเทิร์นถัดไป ไม่ต้อง merge อัตโนมัติ
สิ่งที่ระบบนี้แทนที่
ก่อนสถาปัตยกรรมนี้: เซสชันแชทที่แยกกันห้าเซสชัน แต่ละเซสชันมีบริบทที่เก่า เอเจนต์ขัดแย้งกันเพราะไม่มีตัวไหนเห็นสิ่งที่อีกตัวรู้ คำแนะนำที่ผมให้เมื่อสามสัปดาห์ก่อน ถูกลืม การตัดสินใจที่อยู่ในหัวของผมแทนที่จะอยู่ในไฟล์
หลังจาก: เอเจนต์สองตัวที่สรุปสถานการณ์ให้ตัวเองก่อนทุกการตอบกลับ log สถานะร่วมที่ไม่มีตัวไหนปฏิเสธได้ การตัดสินใจที่คงอยู่ข้ามการรีเซ็ตบริบทหลายเดือน ทุกความชอบด้านพฤติกรรมอยู่ในไฟล์ที่ผมแก้ไขและตรวจสอบได้
ข้อแลกเปลี่ยนที่ตรงไปตรงมา: ระบบนี้ต้องมีวินัย คุณต้องเขียนสิ่งต่างๆ ลงไป คุณต้องดูแลไฟล์ คุณต้องตรวจสอบสิ่งที่ถูกเก็บรักษาก่อนที่จะกลายเป็นถาวร มันไม่ใช่ระบบที่เปิดตลอดเวลาแบบวิเศษ มันคือวินัยแบบมีโครงสร้างที่ทำด้วยมือบวกกับระบบอัตโนมัติที่จุดเชื่อมต่อ
วิธีเริ่มต้น
คุณไม่จำเป็นต้องมีเอเจนต์สองตัวหรือ vault เต็มรูปแบบเพื่อรันเวอร์ชันแรกของสิ่งนี้
ขั้นตอนที่ 1: ไฟล์ identity บวก memory index สร้างมันขึ้นมา อ่านมันเมื่อเริ่มเซสชัน เขียนทุกความชอบด้านพฤติกรรมลงในดัชนีในครั้งที่สองที่คุณแก้ไขเอเจนต์สำหรับสิ่งเดียวกัน
ขั้นตอนที่ 2: ไฟล์สถานะร่วมหนึ่งไฟล์ ถ้าคุณรันเอเจนต์มากกว่าหนึ่งตัว หรือใช้ Claude ผ่านหลายหน้าต่าง ให้สร้างไฟล์ live-context แต่ละเซสชัน append ลงไปเมื่อสิ้นสุดและอ่านเมื่อเริ่มต้น
ขั้นตอนที่ 3: กฎการเก็บรักษา เมื่อเซสชันสร้างการตัดสินใจที่ควรคงอยู่ ให้เขียนลงในดัชนีด้วยตนเอง ทำด้วยมือจนกว่าคุณจะเชื่อถือรูปแบบ จากนั้นจึงทำให้การแจ้งเตือนเป็นอัตโนมัติ
ขั้นตอนที่ 4: ไฟล์ต่อข้อเท็จจริง ไม่ใช่เอกสารใหญ่ไฟล์เดียว ดัชนีชี้ไปยังไฟล์แต่ละไฟล์ ทำให้ง่ายต่อการลบความจำที่ล้าสมัยโดยไม่กระทบไฟล์อื่น
stack 4 ชั้นเต็มใช้เวลาประมาณ 6 เดือนในการทำให้เสถียร ชั้น 1 และ 3 ใช้เวลาหนึ่งสุดสัปดาห์ เริ่มจากตรงนั้น
ข้อสรุป
การตั้งค่าความจำของเอเจนต์ส่วนใหญ่คือการจัดการ context window ที่มีขั้นตอนพิเศษ มันใช้ได้จนกว่าหน้าต่างจะรีเซ็ตหรือคุณเพิ่มเอเจนต์ตัวที่สอง
ความจำของเอเจนต์ที่คงทนคือปัญหาโครงสร้างพื้นฐาน ไม่ใช่ปัญหาการเขียน prompt คำตอบคือหลายชั้นที่มีขอบเขตเวลาต่างกัน: บริบทภายในเซสชัน ข้อเท็จจริงข้ามเซสชัน สถานะร่วม ความรู้ที่ค้นหาได้
ทั้งหมดของเราเป็น markdown ธรรมดา ไม่มี vector database ไม่มี embeddings ไม่ต้อง retrain แค่ไฟล์ที่ผมเปิด แก้ไข และดีบักได้
เอเจนต์ที่มีประโยชน์อย่างแท้จริงไม่ใช่ตัวที่มี context window ใหญ่ที่สุด แต่เป็นตัวที่จำสิ่งที่สำคัญและลืมสิ่งที่ไม่สำคัญ
ถ้าคุณกำลังสร้างเอเจนต์ที่คุณต้องการให้เชื่อถือได้กับงานจริง ให้เริ่มต้นด้วยสถาปัตยกรรมความจำก่อนที่จะเพิ่มเครื่องมืออื่นๆ
เครื่องมือที่อ้างถึง
Hindsight (การเก็บรักษาความจำในเครื่อง): https://github.com/vectorize-io/hindsight
gbrain (wiki ที่คอมไพล์แล้ว / การค้นหาความหมาย): https://github.com/garrytan/gbrain
OpenClaw (runtime ของเอเจนต์): https://openclaw.ai
Hermes (runtime ของเอเจนต์): hermes-agent.nousresearch.com
