หน่วยความจำที่ใช้ร่วมกัน คอนเท็กซ์ส่วนตัว แหล่งข้อมูลแบบเรียลไทม์ และกฎที่ทำให้ Team Bot ยังคงมีประโยชน์หลังจากสัปดาห์แรกผ่านไป
ผู้ช่วย AI ส่วนตัวสามารถจดจำได้ว่าคุณชอบให้รายงานออกมาในรูปแบบไหน
แต่ Team agent มีงานที่ยากกว่านั้น
มันต้องเรียนรู้วิธีการทำงานของ ทุกคน โดยไม่นำบทสนทนาของคนๆ เดียวไปกลายเป็นความทรงจำของคนอื่นทั้งหมด
มันต้องรู้ว่าข้อตัดสินใจใดใช้ร่วมกันได้ ความชอบใดเป็นเรื่องส่วนตัว และข้อมูลใดที่ต้องกลับไปตรวจสอบในระบบต้นทางอีกครั้ง
และนั่นคือจุดที่น่าสนใจของ การเปิดตัว Team Bots ใหม่ของ Grok Bot
ตอนนี้คุณสามารถตั้งค่า Bot ตัวเดียวด้วยไฟล์ สกิล ปลั๊กอิน และความทรงจำที่ใช้ร่วมกัน แล้วเผยแพร่ให้ทีมใช้งานในแอปหรือ Slack ได้เลย
Team Bots เปิดให้ทดสอบแบบ public beta สำหรับแพ็กเกจ Teams และ Enterprise แล้ว
แต่ "Bot ตัวเดียวสำหรับทุกคน" ไม่ได้หมายความว่า "ประวัติแชทยาวเหยียดอันเดียวที่ทุกคนเห็นเหมือนกัน"
ในการแชทแบบ 1:1 แต่ละคนจะมีบทสนทนาส่วนตัวกับ Bot แต่ความทรงจำระดับทีมนั้นใช้ร่วมกัน โน้ตส่วนตัวจะอยู่กับเจ้าของเท่านั้น ปลั๊กอินที่ล็อกอินผ่านบัญชีของใครก็จะใช้สิทธิ์การเข้าถึงของคนที่ร้องขอ ไม่ใช่ของผู้สร้าง Bot ส่วนเธรด Slack ที่แชร์กันและคีย์ระดับ Bot จะมีขอบเขตที่แตกต่างกัน ซึ่งเรื่องนี้สำคัญมากในภายหลัง
นี่คือสถาปัตยกรรมจริงๆ ไม่ใช่แค่ปุ่มเปิดปิดความทรงจำ
https://x.com/bot/status/2104661562715967548
และถ้าคุณตั้งค่ามันไม่ดีพอ Bot ก็ไม่ได้แค่ลืมเรื่องต่างๆ
แต่มันจะเรียนรู้สิ่งที่ผิด จดจำไว้ในที่ที่ไม่ควร หรือเอาข้อตัดสินใจเก่ามาใช้กับสถานการณ์ใหม่
นี่คือวิธีที่ผมจะใช้ในการออกแบบ memory layer
ก่อนเริ่มออกแบบ ขอแยกแยะหนึ่งเรื่อง: promotion gate, external ledger, review dates และ evals ที่กล่าวถึงด้านล่างเป็นกระบวนการที่ผมเสนอขึ้นมาเอง ไม่ใช่ฟีเจอร์ของ Grok Bot ที่ผมยืนยันแล้วว่าอยู่ในผลิตภัณฑ์
ผมเผยแพร่บทความเจาะลึกเชิงปฏิบัติเกี่ยวกับ AI agents, workflows และ production systems บน Substack
Memory engineering ในภาษาที่เข้าใจง่าย
Memory engineering คือการตัดสินใจว่า agent ควรนำอะไรติดตัวไปใช้ในการทำงานครั้งต่อไป
ไม่ใช่ "บันทึกทุกอย่าง"
ไม่ใช่ "สรุปข้อความ 100 ข้อความล่าสุด"
ไม่ใช่ "ยัด company wiki ทั้งหมดลงใน system prompt"
แต่มันคือเส้นทางที่ถูกควบคุม ตั้งแต่การสังเกตสิ่งที่มีประโยชน์ ไปจนถึงการสร้างบริบทการทำงานที่นำกลับมาใช้ซ้ำได้
1มีบางอย่างเกิดขึ้น2 ↓3มันคุ้มค่าที่จะจดจำไว้ไหม?4 ↓5ใครบ้างที่ได้รับอนุญาตให้นำมันไปใช้ต่อ?6 ↓7เมื่อไหร่ที่ควรกลับไปตรวจสอบมันอีกครั้ง?
ความทรงจำที่ดีจะช่วยไม่ให้คนถัดไปต้องมานั่งตัดสินใจในเรื่องเดิมซ้ำ
ส่วนความทรงจำที่แย่จะแอบเข้ามาแทนที่แหล่งข้อมูลที่ถูกต้องโดยไม่มีใครรู้ตัว
ความแตกต่างไม่ได้อยู่ที่คุณเก็บไว้กี่ tokens
แต่อยู่ที่กฎซึ่งตัดสินว่าอะไรจะถูกบันทึกลงในความทรงจำ ใครอ่านมันได้บ้าง และเมื่อไหร่ที่มันไม่ควรได้รับความเชื่อถืออีกต่อไป
Team Bots เปลี่ยนว่าใครจะได้ประโยชน์จากการแก้ไข
ก่อนมี Team Bots การสอน Bot ส่วนตัวมักจะทำให้บทสนทนาในอนาคตของ \คุณ\ ดีขึ้นเท่านั้น
แต่ตอนนี้ การแก้ไขเพียงครั้งเดียวที่ใช้ร่วมกัน สามารถช่วยให้บทสนทนาของเพื่อนร่วมทีมคนถัดไปดีขึ้นได้ด้วย
ฟังดูเป็นเรื่องปกติ จนกว่าคุณจะเริ่มมองกรณีขอบ (edge cases)
"ใช้รายงานสถานะสั้นๆ กว่านี้สำหรับฉันนะ" เป็นเรื่องส่วนตัว
"เจ้าของเหตุการณ์คือวิศวกรที่อยู่เวร ไม่ใช่ PM" อาจเป็นกฎของทีม
"เมตริกการแปลงเปลี่ยนไปเมื่อวันอังคารที่แล้ว" ไม่ใช่ทั้งความชอบที่ใช้ได้ตลอดกาลและกฎถาวร แต่มันคือข้อเท็จจริงที่เปลี่ยนแปลงได้ ซึ่งควรอยู่ในระบบที่เป็น authoritative source
เอกสาร Team Bots ของ Grok Bot อธิบายขอบเขตของผลิตภัณฑ์ไว้อย่างชัดเจนผิดปกติ: ความทรงจำระดับทีมจะถูกอ่านโดยบทสนทนาของทุกคน ในขณะที่แต่ละคนมีโน้ตส่วนตัว Bot จะบันทึกข้อเท็จจริงลงในความทรงจำระดับทีมก็ต่อเมื่อมีคนบอกว่าทั้งทีมควรรู้เรื่องนี้ และมันจะแจ้งให้ทราบเมื่อทำเช่นนั้น
พฤติกรรมของผลิตภัณฑ์นี้คือจุดเริ่มต้น
ส่วนโจทย์ทางวิศวกรรมคือการตัดสินใจว่าผู้คน \ควร\ ขอให้มันแชร์อะไรบ้าง
Data Bot ของ SpaceXAI เองก็เป็นตัวอย่างที่ดี มันใช้ credential แบบ read-only ของ data warehouse และ skill library ที่สร้างขึ้นจากตารางกว่า 45,000 ตาราง มันไม่จำเป็นต้องท่องจำตารางเหล่านั้น สิ่งที่ต้องการคือสกิลในการหาตารางที่ถูกต้อง สิทธิ์เข้าถึงแบบ live เพื่อ query ข้อมูล และความทรงจำเกี่ยวกับการแก้ไขที่ควรทำให้คำตอบของเพื่อนร่วมทีมคนถัดไปดีขึ้น
นั่นคือความแตกต่างที่บทความนี้ต้องการพูดถึง: การตัดสินใจที่นำกลับมาใช้ซ้ำได้ในความทรงจำ กับข้อมูลที่เปลี่ยนแปลงได้ที่ต้นทาง
พฤติกรรมของผลิตภัณฑ์นี้คือจุดเริ่มต้น
ส่วนโจทย์ทางวิศวกรรมคือการตัดสินใจว่าผู้คน ควร ขอให้มันแชร์อะไรบ้าง
Data Bot ของ SpaceXAI เองก็เป็นตัวอย่างที่ดี มันใช้ credential แบบ read-only ของ data warehouse และ skill library ที่สร้างขึ้นจากตารางกว่า 45,000 ตาราง มันไม่จำเป็นต้องท่องจำตารางเหล่านั้น สิ่งที่ต้องการคือสกิลในการหาตารางที่ถูกต้อง สิทธิ์เข้าถึงแบบ live เพื่อ query ข้อมูล และความทรงจำเกี่ยวกับการแก้ไขที่ควรทำให้คำตอบของเพื่อนร่วมทีมคนถัดไปดีขึ้น
นั่นคือความแตกต่างที่บทความนี้ต้องการพูดถึง: การตัดสินใจที่นำกลับมาใช้ซ้ำได้ในความทรงจำ กับข้อมูลที่เปลี่ยนแปลงได้ที่ต้นทาง
https://x.com/elonmusk/status/2104709783999729911
ประกาศนี้อาจสรุปจบได้ในบรรทัดเดียว แต่เส้นแบ่งระหว่างการเรียนรู้ร่วมกันและคอนเท็กซ์ส่วนตัวนั้นทำไม่ได้

เลิกเหมาว่าทุกบริบทคือความทรงจำ
ผมจะแบ่งคอนเท็กซ์ของ Bot ออกเป็น 5 กลุ่ม
1LIVE SOURCE ข้อเท็จจริงปัจจุบันใน Linear, Datadog, CRM, เอกสาร หรือโค้ด2TEAM SKILL กระบวนการที่ทำซ้ำได้และได้รับการอนุมัติจากเจ้าของ Bot3TEAM MEMORY ข้อตัดสินใจที่ใช้ร่วมกันและนิยามที่เสถียร4PRIVATE NOTE ความชอบและบริบทการทำงานของบุคคลใดบุคคลหนึ่ง5TASK STATE สิ่งที่การทำงานรอบนี้กำลังทำอยู่ ณ ตอนนี้
สิ่งเหล่านี้ใช้แทนกันไม่ได้
กระบวนการจัดการ incident ของทีมควรอยู่ใน skill
ระดับความรุนแรงของ incident ปัจจุบันควรอยู่ในเครื่องมือจัดการ incident
ความหมายที่ตกลงกันไว้ของคำว่า "customer-impacting" อาจอยู่ใน team memory
รูปแบบ briefing ที่คุณชอบควรอยู่ใน private notes ของคุณ
คำถามที่ยังค้างอยู่สำหรับการสืบสวนวันนี้ควรอยู่ใน task state
ถ้าคุณใส่เมตริกที่เปลี่ยนแปลงบ่อยลงใน team memory มันจะกลายเป็นข้อมูลเก่าทันที
ถ้าคุณใส่กฎระดับทีมลงใน private note คนอื่นก็จะไม่มีวันได้รับรู้นั้น
และถ้าคุณใส่ความชอบส่วนตัวลงใน team memory Bot ก็จะเริ่มบังคับใช้มันกับทุกคน
งานแรกของ memory engineering คือการส่งคอนเท็กซ์ไปยังกลุ่มที่ถูกต้อง
โปรโมทข้อเท็จจริง ไม่ใช่บทสนทนา
ลองนึกภาพว่าเพื่อนร่วมทีมบอก Bot ว่า:
"เช็คลิสต์การเปิดตัวแบบใหม่กำหนดให้ต้องมีการตรวจสอบด้านความปลอดภัยก่อนที่เราจะเผยแพร่การเปลี่ยนแปลง API ภายนอก"
อย่างน้อยมีความเป็นไปได้ 4 แบบ
- มันเป็นข้อเสนอการเปลี่ยนแปลง ยังไม่ได้รับการอนุมัติ
- มันเป็นกระบวนการของทีมที่ได้รับการอนุมัติแล้ว
- มันใช้ได้กับผลิตภัณฑ์เดียวเท่านั้น
- มันเคยเป็นความจริงเมื่อเดือนก่อน แต่เช็คลิสต์เปลี่ยนไปแล้ว
ถ้า Bot บันทึกแค่ประโยคนี้ มันจะสูญเสียรายละเอียดที่สำคัญไป
ผมจะใช้ external review card ขนาดเล็กสำหรับทุกสิ่งที่อาจถูกโปรโมทเข้าสู่ shared memory นี่คือตัวอย่าง workflow ไม่ใช่ syntax การตั้งค่าของ Grok Bot:
1claim: "การเปิดตัว API ภายนอกต้องผ่านการตรวจสอบด้านความปลอดภัย"2scope: team3source: "ลิงก์ไปยังเช็คลิสต์การเปิดตัวที่ได้รับการอนุมัติ"4owner: "security-eng"5status: approved6review_after: "2026-11-01"
ส่วนที่สำคัญไม่ใช่ syntax แบบ YAML
แต่คือคำถามที่อยู่เบื้องหลังพวกมัน
ใครเป็นคนพูดแบบนี้? เราจะตรวจสอบได้จากที่ไหน? ใครเป็นเจ้าของกฎนี้? ได้รับการอนุมัติหรือยัง? เมื่อไหร่ที่มันควรหมดอายุหรือต้องถูกตรวจสอบอีกครั้ง?
หากทีมของคุณเก็บบัตรเหล่านี้ไว้ใน repository ของตัวเอง คุณก็สามารถสร้าง gate เล็กๆ เพื่อปฏิเสธตัวเลือกที่ไม่สมบูรณ์หรือหมดอายุก่อนที่คนจะมาตรวจทานได้ ระบบนี้จะตรวจสอบ external ledger ไม่ใช่ memory API ของ Grok Bot และมันก็ไม่สามารถพิสูจน์ได้ว่า claim นั้นเป็นความจริงหรือไม่:
1from datetime import date, timedelta23def eligible_for_review(card: dict) -> tuple[bool, str]:4 for field in ("claim", "source", "owner", "review_after"):5 if not card.get(field):6 return False, f"missing {field}"7 if card.get("scope") != "team":8 return False, "wrong scope"9 if card.get("status") != "approved":10 return False, "not approved"11 try:12 review_date = date.fromisoformat(card["review_after"])13 except (TypeError, ValueError):14 return False, "invalid review date"15 if review_date <= date.today():16 return False, "review date passed"17 return True, "inspect source before saving"1819if __name__ == "__main__":20 card = {21 "claim": "การเปิดตัว API ภายนอกต้องผ่านการตรวจสอบด้านความปลอดภัย",22 "scope": "team",23 "source": "https://intranet.example/launch-checklist",24 "owner": "security-eng",25 "status": "approved",26 "review_after": (date.today() + timedelta(days=30)).isoformat(),27 }28 print(eligible_for_review(card))
ผลลัพธ์ที่ได้คือคิวสำหรับการตรวจทาน ไม่ใช่สิทธิ์ในการเขียนลง team memory ยังคงต้องมีคนเปิดดูแหล่งข้อมูลต้นทางเพื่อยืนยันว่า claim, scope และ owner นั้นถูกต้อง
จากนั้นค่อยขอให้ Bot บันทึก กฎที่ได้รับการอนุมัติแล้ว ไม่ใช่บทสนทนาที่นำไปสู่กฎนั้น
1บันทึกสิ่งนี้ไว้สำหรับทั้งทีม:2สำหรับการเปิดตัว API ภายนอก ให้ตรวจสอบเช็คลิสต์การเปิดตัวเวอร์ชันปัจจุบัน3และรับการตรวจสอบด้านความปลอดภัยตามที่กำหนดก่อนเผยแพร่4เช็คลิสต์ยังคงเป็นแหล่งข้อมูลที่ถูกต้องที่สุดหากกระบวนการมีการเปลี่ยนแปลง
บรรทัดสุดท้ายนั้นสำคัญมาก
ความทรงจำเป็นเพียง pointer และกฎที่ใช้ในการทำงาน
มันไม่ใช่สำเนาของบริษัทที่จะคงอยู่ตลอดไป
Shared memory ต้องมี write path
เมื่อทุกคนสามารถสอน Bot ตัวเดียวกันได้ คำสั่ง "จำสิ่งนี้ไว้ด้วย" จะกลายเป็นการเขียนข้อมูลที่มีผลกระทบตามมา
ดังนั้นผมจะให้ operation นี้มี contract ที่เรียบง่าย:
1OBSERVE → CLASSIFY → VERIFY → PROMOTE → RECHECK
- Observe เพื่อนร่วมทีมแก้ไข Bot เปลี่ยนกระบวนการ หรือยืนยันข้อตัดสินใจ
- Classify มันเป็นเรื่องส่วนตัว ระดับทีม เฉพาะงาน หรือข้อเท็จจริงแบบ live?
- Verify Bot สามารถชี้ไปที่ข้อตัดสินใจ เอกสาร PR ticket หรือเจ้าของที่รับผิดชอบได้หรือไม่?
- Promote บันทึกเฉพาะข้อสรุปที่มีประโยชน์ใน scope ที่ถูกต้อง และต้องผ่านการอนุมัติหาก claim นั้นส่งผลต่อนโยบายของทีม
- Recheck กลับไปเปิดดูแหล่งข้อมูลต้นทางก่อนดำเนินการที่ส่งผลกระทบ หรือหลังจากถึงวันที่กำหนดให้ตรวจทาน
นี่คือรูปแบบการทำงานที่เสนอขึ้นมา ไม่ใช่ pipeline อัตโนมัติที่ Grok Bot อ้างว่าจะรันให้คุณ
ผลิตภัณฑ์นี้มีทั้ง team memory และ personal memory
แต่คุณยังต้องตัดสินใจเองว่าอะไรสมควรอยู่ในแต่ละส่วน

แหล่งข้อมูลที่แท้จริงต้องอยู่นอกความทรงจำ
นี่คือจุดที่เดโม agent-memory หลายตัวพังทลายลงมา
Bot จำได้ว่าลูกค้ารายหนึ่งใช้แพ็กเกจ Enterprise
ต่อมาลูกค้าลดระดับแพ็กเกจลง
สองสัปดาห์ต่อมา Bot ใช้ความทรงจำของตัวเองอนุมัติคำขอที่บัญชีนั้นไม่อนุญาตให้ทำแล้ว
ความทรงจำทำหน้าที่ของมันได้อย่างสมบูรณ์แบบ
แต่สถาปัตยกรรมล้มเหลว
คำแนะนำของ Grok Bot เองก็ระบุว่าความทรงจำไม่ใช่ตัวแทนของ authoritative source: ข้อเท็จจริงที่เปลี่ยนแปลงได้ควรอยู่ในระบบต้นทาง และการตัดสินใจที่มีผลกระทบควรเปิดดูหรืออ้างอิงข้อมูลปัจจุบันเสมอ
ความแตกต่างนี้ถูกระบุไว้อย่างชัดเจนในเอกสารของ Bot
ผมจะแบ่งความทรงจำออกเป็น 2 นาฬิกา
1SLOW CLOCK เสียง นิยาม ความเป็นเจ้าของ กระบวนการที่เสถียร2FAST CLOCK สถานะ ยอดคงเหลือ ราคา ผู้รับมอบหมาย สิทธิ์ เมตริก
slow clock สามารถจดจำไว้ได้
แต่ fast clock ควรดึงข้อมูลมาใหม่ทุกครั้ง
กฎง่ายๆ คือ: ถ้าการเข้าใจผิดในเรื่องนั้นอาจเปลี่ยนการกระทำ ให้ตรวจสอบ live source ก่อนลงมือทำ
ยกตัวอย่างเช่น Team Bot สามารถจำได้ว่าทีม triage บั๊ก อย่างไร
แต่มันก็ยังควรเปิดดู issue ปัจจุบันใน Linear, trace ล่าสุดใน Datadog และ PR ที่เชื่อมโยงกัน ก่อนที่จะฟันธงว่าบั๊กนั้นถูกแก้แล้ว
Team skill ไม่ใช่ team memory
นี่คือความแตกต่างที่สองที่ควรระบุให้ชัดเจน
memory คือสิ่งที่ Bot รู้
skill คือสิ่งที่ Bot รู้ว่า ต้องทำอย่างไร
"สำหรับทีมนี้ P0 หมายถึงระบบล่มทั้งลูกค้า" คือนิยาม
"เมื่อมีการแจ้งเตือน P0 เข้ามา ให้ตรวจสอบแดชบอร์ดเหล่านี้ เปิด incident เพจหาตำแหน่งนี้ และโพสต์อัปเดตนี้" คือกระบวนการ
อย่างแรกอาจเป็น team memory
อย่างหลังควรกลายเป็น team skill
ใน Grok Bot สมาชิกทีมทั่วไปสามารถสอนกระบวนการผ่านการแชทส่วนตัวได้ แต่นั่นไม่ได้ทำให้มันกลายเป็น skill ระดับทีม เจ้าของจะเป็นผู้ดูแลการตั้งค่าที่ใช้ร่วมกัน และ การอัปเดตผลิตภัณฑ์เมื่อวันที่ 30 กันยายน อนุญาตให้ผู้สร้างแต่งตั้งผู้จัดการที่สามารถเปลี่ยนแปลง skills, plugins, secrets และแอป Slack ได้ด้วย
gate ของผู้ดูแลนี้สำคัญมาก
หากไม่มีมัน วิธีแก้ปัญหาเฉพาะหน้าเพียงครั้งเดียวอาจแอบกลายเป็น workflow เริ่มต้นของ Bot สำหรับทุกคนไปโดยไม่รู้ตัว
Lauren Tan ผู้สร้าง Grok Bot มีกฎที่เป็นประโยชน์สำหรับการแก้ไข agent ซ้ำๆ: กำจัดต้นตอของความล้มเหลวก่อนที่คุณจะยอมรับการเพิ่มคำสั่งใหม่เข้าไปอีก
https://x.com/poteto/status/2089067865098113024
ลำดับความสำคัญของเธอมีประโยชน์มากในที่นี้: แก้ที่สถาปัตยกรรมก่อนถ้าทำได้ ถัดมาเข้ารหัสความล้มเหลวที่เกิดซ้ำใน tests แล้วค่อยเพิ่ม skill หรือกฎ ข้อสรุปของผมคือ memory ไม่ควรเป็นแพตช์แรกที่นำมาใช้กับระบบที่ทำผิดพลาดเรื่องเดิมซ้ำๆ
ผมจะตั้งกฎสำหรับทุก skill ใหม่ดังนี้:
- มันแก้ปัญหาในงานที่ทำซ้ำได้ ไม่ใช่แค่ ticket เดียว
- input และ output ของมันมองเห็นได้ชัดเจน
- ขอบเขตสิทธิ์การใช้งานชัดเจน
- มีคนในทีมรับผิดชอบการอัปเดต
- การรันที่ล้มเหลวต้องทิ้งหลักฐานไว้ ไม่ใช่แค่ retry loop ที่เงียบหายไป
ความรู้ที่ใช้ร่วมกันไม่ได้หมายถึงตัวตนที่ใช้ร่วมกัน
นี่คือรายละเอียดด้านความปลอดภัยที่สำคัญที่สุดในการเปิดตัวครั้งนี้
Team Bots สามารถใช้ shared context ขณะที่ยังคงแสดงตัวเป็นคนที่ร้องขอได้
สำหรับปลั๊กอินที่ล็อกอินด้วยบัญชีของผู้ใช้ Bot จะใช้การเชื่อมต่อของผู้ใช้นั้น มันจะไม่ยืมบัญชีของเจ้าของ Bot มาใช้แทนทุกคน
แต่ปลั๊กอินหรือ secret ที่ตั้งค่าด้วย shared key สามารถใช้ข้ามบทสนทนาของสมาชิกในทีมได้ ดังนั้น credential นั้นจึงเทียบเท่ากับการเข้าถึงระดับทีม
นี่คือ trust model ที่แตกต่างกัน
1PERSONAL OAUTH การกระทำใช้บัญชีของผู้ร้องขอ2BOT SERVICE KEY การกระทำใช้สิทธิ์การเข้าถึงระดับ Bot ที่แชร์กัน3PRIVATE CHAT บทสนทนาและโน้ตส่วนตัว4SLACK CHANNEL เธรดที่ใช้ร่วมกันและคอมพิวเตอร์ Bot ที่ใช้ร่วมกัน
ความแตกต่างอยู่ที่ credential ไม่ใช่ชื่อของปลั๊กอิน ปลั๊กอินที่ใช้ร่วมกันซึ่งตั้งค่าด้วย OAuth จะยังคงรันภายใต้บัญชีของผู้ร้องขอ ส่วนปลั๊กอินที่ตั้งค่าด้วยคีย์ระดับ Bot จะใช้ credential เดียวกันสำหรับทุกคน ดังนั้นคีย์นั้นจึงควรถูกจำกัด scope ให้เหลือสิทธิ์การเข้าถึงน้อยที่สุดเท่าที่ทีมต้องการ
Grok Bot จะถามก่อนใช้ personal connector ของเพื่อนร่วมทีมในเธรด Slack ที่แชร์กันหรือการสนทนากลุ่ม การอนุมัติ connector นั้นจะระบุบัญชีที่จะใช้ ส่วนปลั๊กอินที่ใช้ร่วมกันซึ่งตั้งค่าไว้ใน Bot แล้วจะไม่ทริกเกอร์ prompt ดังกล่าว นอกจากนี้การอัปเดตเมื่อวันที่ 29 กันยายนยังเพิ่ม action-review card ใน Slack ที่เฉพาะบุคคลที่เกี่ยวข้องเท่านั้นที่สามารถตอบได้
นี่เป็นการเตือนความจำที่มีประโยชน์ว่า "Bot รู้เรื่องนี้" กับ "Bot ทำเรื่องนี้ได้" เป็นคนละคำถามกัน
Bot อาจรู้กระบวนการคืนเงิน
แต่มันไม่ควรทึกทักเอาเองว่าเพื่อนร่วมทีมทุกคนมีสิทธิ์อนุมัติการคืนเงินได้
มันอาจรู้ว่าเอกสารลับถูกเก็บไว้ที่ไหน
แต่มันไม่ควรแปะเอกสารนั้นลงในช่องสาธารณะเพียงเพราะมีคนพูดถึงมันตรงนั้น
memory ตัดสินว่ามีบริบทใดพร้อมใช้งาน
permissions ตัดสินว่าการกระทำใดได้รับอนุญาต
agent ต้องการการตรวจสอบทั้งสองอย่าง
Slack สร้างขอบเขตความทรงจำที่สอง
Team Bot ใน Slack ให้ความรู้สึกเหมือนเพื่อนร่วมงานคนหนึ่ง
แต่ภายใต้พื้นผิว คอนเท็กซ์จะขึ้นอยู่กับว่าบทสนทนานั้นเกิดขึ้นที่ไหน
ในการแชทแบบตัวต่อตัว บุคคลนั้นจะได้รับบทสนทนาและโน้ตส่วนตัวของตัวเอง
ใน Slack channel เธรดจะถูกแชร์ และ Grok Bot จะใช้คอมพิวเตอร์ที่แชร์กันแยกต่างหากสำหรับ Bot ตัวนั้น เอกสารผลิตภัณฑ์เตือนไม่ให้ใส่เนื้อหาในเธรดของ channel ที่ไม่ควรให้ทุกคนใน channel นั้นเห็น
สิ่งนี้สร้าง failure mode ที่ละเอียดอ่อน
มีคนถามคำถามที่ไม่มีพิษภัยใน channel และอนุญาตให้ Bot ใช้ personal connector ของตน
connector นั้นเป็นของผู้ร้องขอ ขอบเขตของบัญชีจึงยังปลอดภัย
แต่คำตอบก็อาจยังมีรายละเอียดที่คนอื่นๆ ใน channel ไม่ควรเห็น การอนุมัติให้เข้าถึงแหล่งข้อมูลไม่เหมือนกับการอนุมัติให้เปิดเผยทุกสิ่งที่เป็นไปได้จากแหล่งข้อมูลนั้น
วิธีแก้ไม่ใช่ "บอกให้โมเดลระวังตัว"
วิธีแก้คือการถือว่าปลายทางเป็นส่วนหนึ่งของนโยบายการดึงข้อมูลและการแสดงผล
1ก่อนตอบใน channel ที่แชร์กัน:21. ระบุว่าผู้ชมของเธรดนี้คือใคร32. ระบุแหล่งข้อมูลและ scope การเข้าถึง43. สรุปเฉพาะสิ่งที่ผู้ชมกลุ่มนี้เห็นได้54. ย้ายรายละเอียดส่วนตัวไปคุยแบบ 1:1
กฎ 4 บรรทัดนี้เป็นคำแนะนำเชิงปฏิบัติการ ไม่ใช่การรับประกันในตัวว่า Grok Bot จะทำงานแบบนี้
ค่าเริ่มต้นที่ปลอดภัยกว่าคือเก็บการสืบสวนที่ละเอียดอ่อนไว้ในแชทส่วนตัว และเผยแพร่เฉพาะข้อสรุปที่ได้รับการอนุมัติแล้วให้ทีมรับรู้

ออกแบบเพื่อรับมือกับความขัดแย้ง ไม่ใช่แค่การเรียกคืนข้อมูล
team memory จะยากขึ้นทันทีเมื่อคนสองคนเห็นไม่ตรงกัน
หัวหน้าฝ่ายขายบอกว่าวันต่อสัญญาคือวันที่ 14
หัวหน้าฝ่ายการเงินบอกว่าวันที่ 30
CRM บอกว่าวันที่ 28
agent ที่ไร้เดียงสาจะเลือกประโยคล่าสุด
agent ที่มีประโยชน์จะถามว่านี่คือข้อเท็จจริงประเภทใดและมันอยู่ที่ไหน
วันต่อสัญญาเป็นข้อเท็จจริงตามสัญญาแบบ live
CRM ก็อาจผิดได้เช่นกัน ดังนั้น Bot จึงควรตรวจสอบข้อตกลงที่ลงนามแล้วหรือถามเจ้าของที่รับผิดชอบก่อนดำเนินการ
สำหรับ shared memory ทุกอย่างที่ควรเก็บไว้ ผมจะบันทึกข้อตัดสินใจและที่มาของมันไว้ในที่ที่ทีมสามารถตรวจสอบได้
อาจเป็นเอกสาร issue หรือ ledger น้ำหนักเบานอกตัว Bot
แล้วให้ memory ของ Bot ชี้ไปที่สิ่งนั้นแทน
เมื่อเกิดความขัดแย้ง ให้ทำตามลำดับนี้:
- หยุดการกระทำที่ส่งผลกระทบ
- ระบุ authoritative source
- ขอให้เจ้าของช่วยแก้ไขความขัดแย้ง
- อัปเดตที่แหล่งข้อมูลก่อน
- ค่อยแก้ไขหรือลบ memory ของ Bot ทีหลัง
นี่คือการบำรุงรักษา memory ไม่ใช่การปรับแต่ง prompt
ตัวอย่าง Team Bot เชิงปฏิบัติ: การประสานงานการปล่อยเวอร์ชัน
ลองนึกภาพ Team Bot ที่ฝ่ายผลิตภัณฑ์ วิศวกรรม และซัพพอร์ตใช้งานร่วมกัน
มันตอบกลับ mention ใน release channel และช่วยเตรียม launch brief โดยค่าเริ่มต้น Team Bot จะไม่ตอบทุกโพสต์ระดับบนสุดของ channel การเฝ้าดูทั้ง channel ต้องใช้ listener routine แยกต่างหาก และ routine นั้นเป็นของคนที่ตั้งค่ามันขึ้นมา ไม่ใช่ของทีมในฐานะบัญชีที่แชร์กันบัญชีเดียว
วันจันทร์ ฝ่ายผลิตภัณฑ์ยืนยันว่าการเปิดตัวจำกัดเฉพาะทีมแบบชำระเงิน
Bot สามารถจำ ข้อตัดสินใจ นั้นได้ พร้อม pointer ไปที่แผนการปล่อยเวอร์ชัน
วันอังคาร ฝ่ายวิศวกรรมเปลี่ยนวันที่ rollout
Bot ควรอ่าน release ticket ปัจจุบัน ไม่ใช่นึกถึงวันที่ของวันจันทร์
วันพุธ ฝ่ายซัพพอร์ตบอกว่า internal brief ของพวกเขาควรใช้รูปแบบที่สั้นกว่า
นั่นอาจกลายเป็นคำสั่งเฉพาะฝ่ายซัพพอร์ตใน skill ที่มีการดูแลรักษา มันไม่ควรแอบกลายเป็นกฎการจัดรูปแบบสำหรับทุกคนที่คุยกับ Bot
วันพฤหัสบดี เจ้าของฝ่ายความปลอดภัยอนุมัติขั้นตอนการตรวจสอบใหม่
เจ้าของ Bot หรือผู้จัดการที่ได้รับมอบหมายจะอัปเดต launch skill ที่แชร์กัน
วันศุกร์ มีคนถาม Bot ใน Slack ว่า "เราพร้อมประกาศหรือยัง?"
Bot ควรรวบรวมหลักฐานแบบ live ก่อนตอบ:
1release ticket วันที่ปัจจุบันและสถานะ rollout2launch checklist การอนุมัติที่จำเป็น3PR และ CI สถานะการ build และ verification4team memory กลุ่มเป้าหมายที่ได้รับการอนุมัติและประวัติการตัดสินใจ5private notes ห้ามใช้สำหรับคำตอบใน channel ที่แชร์กัน
นี่คือรูปแบบคำตอบที่ผมอยากเห็นในเธรดที่แชร์กัน:
1STATUS: Blocked, อย่าเพิ่งประกาศ2CHECKED: release ticket ปัจจุบัน, launch checklist, การรัน CI3READY: กลุ่มเป้าหมายแบบทีมชำระเงินได้รับการอนุมัติในแผนการปล่อยเวอร์ชันแล้ว4MISSING: การลงนามด้านความปลอดภัยสำหรับการเปลี่ยนแปลง API ภายนอกใหม่5NEXT: ขอให้เจ้าของฝ่ายความปลอดภัยตรวจสอบ แล้วกลับมาดู checklist อีกครั้ง
หากผู้ร้องขอต้องการ brief แบบเฉพาะบุคคลที่อิงจาก private notes, Bot สามารถเตรียมสิ่งนั้นให้ในการสนทนาแบบ 1:1 ได้ ส่วน channel จะได้รับเฉพาะข้อสรุปที่ปลอดภัยสำหรับทีมและหลักฐานที่สนับสนุนเท่านั้น
นี่คือผลลัพธ์ที่ดีกว่า Bot ที่จดจำวันจันทร์ได้อย่างมั่นใจเกินไป
ทดสอบ memory layer ก่อนเผยแพร่ Bot
eval แรกไม่ควรถามว่า Bot เรียกคืนข้อเท็จจริงได้หรือไม่
แต่ควรถามว่า Bot ใช้ข้อเท็จจริงที่ ถูกต้อง ใน scope ที่ ถูกต้อง หรือไม่
ผมจะทดสอบ 5 กรณีนี้ก่อนเชิญทีมเข้าใช้งาน:
- Private-to-team leak คน A บอกความชอบส่วนตัว คน B ไม่ควรได้รับมันไปด้วย
- Explicit promotion เพื่อนร่วมทีมขอให้ Bot บันทึกข้อตัดสินใจที่ได้รับการอนุมัติไว้ให้ทีม เพื่อนร่วมทีมอีกคนควรเห็นข้อตัดสินใจนั้น ไม่ใช่แชทส่วนตัวต้นฉบับ
- Stale fact team memory มีสถานะเก่า แต่ระบบต้นทางมีข้อมูลที่ใหม่กว่า Bot ควรใช้ข้อมูลจากต้นทาง
- Conflicting correction ผู้ใช้สองคนให้ claim ที่ต่างกัน Bot ไม่ควรแอบเปลี่ยน claim ล่าสุดให้เป็นนโยบาย
- Shared-channel boundary เธรด Slack ขอข้อมูลจาก personal connector Bot ควรปฏิบัติตามการอนุมัติ connector และขอบเขตของผู้ชม
ให้รันกรณีทดสอบเหล่านี้จากบัญชีทีมจริง 2 บัญชี ไม่ใช่รันสองครั้งจากแชทของเจ้าของ มิฉะนั้นคุณยังไม่ได้ทดสอบขอบเขตที่สำคัญจริงๆ
สำหรับแต่ละกรณี ให้เก็บ prompt, พฤติกรรมที่คาดหวัง, คำตอบของ Bot และแหล่งข้อมูลที่มันใช้ บันทึกการทดสอบแบบกระชับก็เพียงพอแล้ว:
1M01 private preference -> คน B ไม่ได้รับมันไปเด็ดขาด2M02 shared decision -> คน B เห็นข้อตัดสินใจ ไม่ใช่แชทของ A3M03 changed status -> แหล่งข้อมูลปัจจุบันชนะ memory ที่บันทึกไว้4M04 conflicting claims -> ไม่มีการเปลี่ยนนโยบายอย่างเงียบๆ5M05 private connector -> การอนุมัติ + การตอบกลับที่ปลอดภัยสำหรับ channel
ติดตามมากกว่าแค่ความแม่นยำในการเรียกคืนข้อมูล
1การบันทึกผิด scope2การกระทำที่อิงจาก stale fact3claim ระดับทีมที่ไม่มีการรองรับ4การข้ามขั้นตอนการอนุมัติ5เวลาที่ใช้ในการแก้ไข memory ที่ผิดพลาด
เมตริกสุดท้ายนี้มักถูกประเมินต่ำไป
ทุกระบบ shared memory จะต้องเก็บข้อมูลผิดพลาดในที่สุด
สิ่งที่สำคัญคือทีมสามารถหามันเจอ แก้ไขมัน และรู้หรือไม่ว่ามันส่งผลกระทบต่อผลลัพธ์ใดบ้าง
สำหรับการ rollout ของผม การรั่วไหลจากส่วนตัวไปสู่ทีมหรือการกระทำที่ไม่ได้รับอนุญาตถือเป็นการตกเกณฑ์อย่างสิ้นเชิง ส่วนคำตอบที่ล้าสมัยหรือไม่มีการรองรับจะต้องได้รับการแก้ไขและรันเคสที่เกี่ยวข้องใหม่ก่อนที่ Bot จะไปถึงผู้ใช้จำนวนมากขึ้น เหล่านี้คือเกณฑ์การปล่อยเวอร์ชันที่เสนอขึ้นมา ไม่ใช่การอ้างถึง eval ในตัวของ Grok Bot
เมื่อ Bot เรียนรู้สิ่งที่ผิด
คำถามเชิงปฏิบัติที่สำคัญไม่ใช่เรื่องของความทรงจำที่แย่จะเกิดขึ้นได้หรือไม่
มันเกิดขึ้นได้แน่นอน
คำถามคือความผิดพลาดนั้นจะอยู่ได้นานแค่ไหน และมีใครเห็นมันบ้างก่อนที่คุณจะแก้ไข
สมมติว่า Bot บันทึกไปว่า "การต่อสัญญา enterprise ทั้งหมดต้องได้รับการอนุมัติจาก VP" หลังจากเกิดข้อยกเว้นครั้งเดียว สัปดาห์ต่อมา มันเริ่มหน่วงการต่อสัญญาปกติ
ผมจะจัดการเรื่องนี้เหมือน incident ข้อมูลขนาดเล็ก:
- ขอให้ Bot แสดง team memory ของมันและค้นหา claim ที่แน่ชัด Grok Bot อนุญาตให้คุณถามว่ามันบันทึกอะไรไว้ แล้วบอกให้มันแก้ไขหรือลบรายการนั้นออก
- ระบุบทสนทนาหรือข้อตัดสินใจต้นทาง เจ้าของ และงานที่นำ claim นั้นไปใช้ต่อ ถ้าคุณตามรอยต้นทางไม่ได้ อย่าเก็บกฎนั้นไว้เพียงเพราะมันฟังดูสมเหตุสมผล
- แก้ไขนโยบายการต่อสัญญาที่เป็น authoritative ก่อน จากนั้นค่อยลบหรือแทนที่ memory ที่ผิดพลาดของ Bot หากความผิดพลาดมาจาก skill, ไฟล์ หรือคำอธิบาย Bot ให้แก้ตรงนั้นด้วย
- รันเคสการต่อสัญญาใหม่จากบัญชีของเพื่อนร่วมทีมคนอื่น ตรวจสอบทั้งคำตอบและว่ามีการพยายามดำเนินการใดๆ หรือไม่
- ตรวจทานร่างข้อความหรือ ticket ปลายน้ำที่ถูกสร้างขึ้นในขณะที่ memory ผิดพลาดนั้นยังทำงานอยู่
ขั้นตอนสุดท้ายนี้很容易被มองข้าม การลบ memory จะเปลี่ยนพฤติกรรมในอนาคต ไม่ใช่เปลี่ยนอีเมลที่ร่างไว้แล้วหรือข้อตัดสินใจที่ทำไปแล้ว
บทเรียนที่นำกลับมาใช้ซ้ำได้คือให้เก็บบันทึกน้ำหนักเบาของความทรงจำที่ใช้ร่วมกันซึ่งสำคัญไว้ภายนอก Bot: claim, source, owner, scope และ review date memory ของ Grok Bot คือบริบทการทำงาน แต่ ledger ของคุณคือ audit trail

ความผิดพลาดที่ผมคาดว่าจะเจอก่อนเป็นอันดับแรก
การคัดลอก Bot ส่วนตัวไปเป็น Team Bot โดยไม่ได้ตรวจสอบความทรงจำของมัน\\ Grok Bot มีตัวเลือกการคัดลอกสำหรับทีม รวมถึงตัวเลือกในการเริ่มต้นใหม่หรือเก็บรายการส่วนตัวออกไป ให้ถือว่าการตรวจสอบนั้นเป็นขั้นตอนด้านความปลอดภัย ไม่ใช่ความยุ่งยากในการตั้งค่า
- ใช้ team memory เป็นฐานข้อมูลของบริษัท Bot ควรจดจำบริบทที่คงที่ได้ และเปิดข้อมูลที่เปลี่ยนแปลงขึ้นมาใหม่
- ปล่อยให้ทุกคนแก้ไขกระบวนการผ่านการสนทนา ทักษะที่ใช้ร่วมกัน (shared skills) มีเจ้าของด้วยเหตุผลของมัน
- ลืมไปว่างานบน Slack ทำงานอย่างไร Thread ใน Channel คือสภาพแวดล้อมที่ใช้ร่วมกัน ไม่ใช่ DM ส่วนตัวที่มีคนดูเยอะกว่า
- ให้ service key กว้าง ๆ กับ Bot เพราะรู้สึกว่า OAuth ช้า คีย์ที่ใช้ร่วมกันจะขยายอำนาจการเข้าถึงของ Bot ให้กับเพื่อนร่วมทีมทุกคน
- วัดผลที่ "ตอบแล้ว" แทนที่จะเป็น "กำหนดขอบเขตถูกต้อง" Bot อาจตอบได้เร็วแต่ก็ยังทำข้อมูลส่วนตัวรั่วไหล หรือลงมือทำตามข้อเท็จจริงที่ล้าสมัยไปแล้ว
- คิดว่า memory คือการเทรนโมเดล ประเด็นที่ใช้งานได้จริงคือ Bot สามารถนำบริบทใดกลับมาใช้ในงานครั้งต่อไปได้ ไม่ใช่เรื่องที่ว่า weight ของโมเดลเบื้องหลังเปลี่ยนไปหรือไม่
การตั้งค่าที่ผมจะนำไปใช้งานจริง
- สร้าง Team Bot หนึ่งตัวสำหรับงานที่ใช้ร่วมกันงานเดียว อย่าสร้างเป็นผู้ช่วยทั่วไปของบริษัท
- เขียนความรับผิดชอบและขอบเขตการอนุมัติไว้ในคำอธิบายของ Bot
- เพิ่มไฟล์และปลั๊กอินเท่าที่จำเป็นเท่านั้น ควรใช้ personal OAuth สำหรับการกระทำเฉพาะผู้ใช้ และใช้ shared credentials แบบอ่านอย่างเดียวสำหรับข้อมูลที่ใช้ร่วมกัน
- นำกระบวนการที่ทำซ้ำได้ไปใส่ใน skill ที่ดูแลโดยเจ้าของหรือผู้จัดการที่ได้รับมอบหมาย
- เพิ่ม team memory ที่ยืนยันแล้วเพียงไม่กี่รายการ โดยแต่ละรายการต้องมีแหล่งที่มาหรือเจ้าของที่ชัดเจน
- ทดสอบบันทึกส่วนตัว ข้อมูลที่ล้าสมัย ข้อความที่ขัดแย้งกัน และขอบเขตผู้ชมบน Slack จากบัญชีที่แยกกัน
- เผยแพร่ให้ทีมขนาดเล็ก ตรวจสอบข้อผิดพลาด และตกลงวิธีแก้ไข team memory ที่ผิดพลาดก่อนจะขยายสิทธิ์การเข้าถึง
นี่คือส่วนหนึ่งของ "AI coworker" ที่เดโมไม่สามารถแสดงให้คุณเห็นได้
Agent จะมีประโยชน์ก็ต่อเมื่อทีมสามารถสอนมันได้
และมันจะเชื่อถือได้ก็ต่อเมื่อทีมบอกได้ว่า มันเรียนรู้อะไร เรียนรู้จากที่ไหน และควรลืมสิ่งนั้นเมื่อไหร่
การเปลี่ยนแปลงที่แท้จริง
เรื่องราวแรกของ Grok Bot คือความต่อเนื่อง
มอบงาน เครื่องมือ คอมพิวเตอร์ และเวลาให้ Bot ทำงานจนเสร็จ
Team Bots เพิ่มคำถามที่ต่างออกไป:
จะเกิดอะไรขึ้นเมื่อ Bot เป็นของทีมแทนที่จะเป็นของคนคนเดียว?
คำตอบไม่ใช่ context window ที่ใหญ่ขึ้น
แต่มันคือ memory architecture
บันทึกส่วนตัวสำหรับบริบทของแต่ละคน
Shared memory สำหรับความรู้ของทีมที่กำหนดไว้อย่างชัดเจน
Team skills ที่ได้รับการดูแลอย่างต่อเนื่องสำหรับกระบวนการทำงาน
ระบบแบบเรียลไทม์สำหรับข้อเท็จจริงที่เปลี่ยนแปลงอยู่ตลอด
สิทธิ์การเข้าถึงสำหรับสิ่งที่ Bot ทำได้จริง
ถ้ากำหนดขอบเขตเหล่านี้ได้ถูกต้อง การแก้ไขเพียงครั้งเดียวจะช่วยให้งานของคนถัดไปดีขึ้น
แต่ถ้ากำหนดผิด Bot จะขยายความผิดพลาดนั้นไปทั่วทั้งทีม
นั่นคือเหตุผลที่ memory engineering ถึงสำคัญมาก
ถ้าคุณอ่านมาถึงตรงนี้
-> สมัครรับข่าวสารผ่าน Substack ของผม
-> เข้าร่วมกลุ่ม Telegram ของผม
-> บุ๊กมาร์กบทความนี้ไว้
-> ติดตาม @0xwhrrari





