YouMind
ลงชื่อเข้าใช้

วิศวกรรมหน่วยความจำ Grok Bot: วิธีที่ Agent เรียนรู้ร่วมกับทีม

@0xwhrrari
อังกฤษ05 ต.ค. 2569
307K
253
32
40
494

TL;DR

คู่มือนี้เจาะลึกกลยุทธ์วิศวกรรมหน่วยความจำสำหรับ Grok Team Bots โดยแยกแยะระหว่างหน่วยความจำร่วมของทีม, บันทึกส่วนตัว และแหล่งข้อมูลแบบเรียลไทม์ เพื่อรักษาความถูกต้องและความปลอดภัยของข้อมูล

หน่วยความจำที่ใช้ร่วมกัน คอนเท็กซ์ส่วนตัว แหล่งข้อมูลแบบเรียลไทม์ และกฎที่ทำให้ 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"

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

text
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

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

rari - inline image

เลิกเหมาว่าทุกบริบทคือความทรงจำ

ผมจะแบ่งคอนเท็กซ์ของ Bot ออกเป็น 5 กลุ่ม

text
1LIVE SOURCE ข้อเท็จจริงปัจจุบันใน Linear, Datadog, CRM, เอกสาร หรือโค้ด
2TEAM SKILL กระบวนการที่ทำซ้ำได้และได้รับการอนุมัติจากเจ้าของ Bot
3TEAM 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:

text
1claim: "การเปิดตัว API ภายนอกต้องผ่านการตรวจสอบด้านความปลอดภัย"
2scope: team
3source: "ลิงก์ไปยังเช็คลิสต์การเปิดตัวที่ได้รับการอนุมัติ"
4owner: "security-eng"
5status: approved
6review_after: "2026-11-01"

ส่วนที่สำคัญไม่ใช่ syntax แบบ YAML

แต่คือคำถามที่อยู่เบื้องหลังพวกมัน

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

หากทีมของคุณเก็บบัตรเหล่านี้ไว้ใน repository ของตัวเอง คุณก็สามารถสร้าง gate เล็กๆ เพื่อปฏิเสธตัวเลือกที่ไม่สมบูรณ์หรือหมดอายุก่อนที่คนจะมาตรวจทานได้ ระบบนี้จะตรวจสอบ external ledger ไม่ใช่ memory API ของ Grok Bot และมันก็ไม่สามารถพิสูจน์ได้ว่า claim นั้นเป็นความจริงหรือไม่:

python
1from datetime import date, timedelta
2
3def 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"
18
19if __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 บันทึก กฎที่ได้รับการอนุมัติแล้ว ไม่ใช่บทสนทนาที่นำไปสู่กฎนั้น

text
1บันทึกสิ่งนี้ไว้สำหรับทั้งทีม:
2สำหรับการเปิดตัว API ภายนอก ให้ตรวจสอบเช็คลิสต์การเปิดตัวเวอร์ชันปัจจุบัน
3และรับการตรวจสอบด้านความปลอดภัยตามที่กำหนดก่อนเผยแพร่
4เช็คลิสต์ยังคงเป็นแหล่งข้อมูลที่ถูกต้องที่สุดหากกระบวนการมีการเปลี่ยนแปลง

บรรทัดสุดท้ายนั้นสำคัญมาก

ความทรงจำเป็นเพียง pointer และกฎที่ใช้ในการทำงาน

มันไม่ใช่สำเนาของบริษัทที่จะคงอยู่ตลอดไป

Shared memory ต้องมี write path

เมื่อทุกคนสามารถสอน Bot ตัวเดียวกันได้ คำสั่ง "จำสิ่งนี้ไว้ด้วย" จะกลายเป็นการเขียนข้อมูลที่มีผลกระทบตามมา

ดังนั้นผมจะให้ operation นี้มี contract ที่เรียบง่าย:

text
1OBSERVE → CLASSIFY → VERIFY → PROMOTE → RECHECK
  • Observe เพื่อนร่วมทีมแก้ไข Bot เปลี่ยนกระบวนการ หรือยืนยันข้อตัดสินใจ
  • Classify มันเป็นเรื่องส่วนตัว ระดับทีม เฉพาะงาน หรือข้อเท็จจริงแบบ live?
  • Verify Bot สามารถชี้ไปที่ข้อตัดสินใจ เอกสาร PR ticket หรือเจ้าของที่รับผิดชอบได้หรือไม่?
  • Promote บันทึกเฉพาะข้อสรุปที่มีประโยชน์ใน scope ที่ถูกต้อง และต้องผ่านการอนุมัติหาก claim นั้นส่งผลต่อนโยบายของทีม
  • Recheck กลับไปเปิดดูแหล่งข้อมูลต้นทางก่อนดำเนินการที่ส่งผลกระทบ หรือหลังจากถึงวันที่กำหนดให้ตรวจทาน

นี่คือรูปแบบการทำงานที่เสนอขึ้นมา ไม่ใช่ pipeline อัตโนมัติที่ Grok Bot อ้างว่าจะรันให้คุณ

ผลิตภัณฑ์นี้มีทั้ง team memory และ personal memory

แต่คุณยังต้องตัดสินใจเองว่าอะไรสมควรอยู่ในแต่ละส่วน

rari - inline image

แหล่งข้อมูลที่แท้จริงต้องอยู่นอกความทรงจำ

นี่คือจุดที่เดโม agent-memory หลายตัวพังทลายลงมา

Bot จำได้ว่าลูกค้ารายหนึ่งใช้แพ็กเกจ Enterprise

ต่อมาลูกค้าลดระดับแพ็กเกจลง

สองสัปดาห์ต่อมา Bot ใช้ความทรงจำของตัวเองอนุมัติคำขอที่บัญชีนั้นไม่อนุญาตให้ทำแล้ว

ความทรงจำทำหน้าที่ของมันได้อย่างสมบูรณ์แบบ

แต่สถาปัตยกรรมล้มเหลว

คำแนะนำของ Grok Bot เองก็ระบุว่าความทรงจำไม่ใช่ตัวแทนของ authoritative source: ข้อเท็จจริงที่เปลี่ยนแปลงได้ควรอยู่ในระบบต้นทาง และการตัดสินใจที่มีผลกระทบควรเปิดดูหรืออ้างอิงข้อมูลปัจจุบันเสมอ

ความแตกต่างนี้ถูกระบุไว้อย่างชัดเจนในเอกสารของ Bot

ผมจะแบ่งความทรงจำออกเป็น 2 นาฬิกา

text
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 ที่แตกต่างกัน

text
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 ไม่ควรเห็น การอนุมัติให้เข้าถึงแหล่งข้อมูลไม่เหมือนกับการอนุมัติให้เปิดเผยทุกสิ่งที่เป็นไปได้จากแหล่งข้อมูลนั้น

วิธีแก้ไม่ใช่ "บอกให้โมเดลระวังตัว"

วิธีแก้คือการถือว่าปลายทางเป็นส่วนหนึ่งของนโยบายการดึงข้อมูลและการแสดงผล

text
1ก่อนตอบใน channel ที่แชร์กัน:
21. ระบุว่าผู้ชมของเธรดนี้คือใคร
32. ระบุแหล่งข้อมูลและ scope การเข้าถึง
43. สรุปเฉพาะสิ่งที่ผู้ชมกลุ่มนี้เห็นได้
54. ย้ายรายละเอียดส่วนตัวไปคุยแบบ 1:1

กฎ 4 บรรทัดนี้เป็นคำแนะนำเชิงปฏิบัติการ ไม่ใช่การรับประกันในตัวว่า Grok Bot จะทำงานแบบนี้

ค่าเริ่มต้นที่ปลอดภัยกว่าคือเก็บการสืบสวนที่ละเอียดอ่อนไว้ในแชทส่วนตัว และเผยแพร่เฉพาะข้อสรุปที่ได้รับการอนุมัติแล้วให้ทีมรับรู้

rari - inline image

ออกแบบเพื่อรับมือกับความขัดแย้ง ไม่ใช่แค่การเรียกคืนข้อมูล

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 ก่อนตอบ:

text
1release ticket วันที่ปัจจุบันและสถานะ rollout
2launch checklist การอนุมัติที่จำเป็น
3PR และ CI สถานะการ build และ verification
4team memory กลุ่มเป้าหมายที่ได้รับการอนุมัติและประวัติการตัดสินใจ
5private notes ห้ามใช้สำหรับคำตอบใน channel ที่แชร์กัน

นี่คือรูปแบบคำตอบที่ผมอยากเห็นในเธรดที่แชร์กัน:

text
1STATUS: Blocked, อย่าเพิ่งประกาศ
2CHECKED: release ticket ปัจจุบัน, launch checklist, การรัน CI
3READY: กลุ่มเป้าหมายแบบทีมชำระเงินได้รับการอนุมัติในแผนการปล่อยเวอร์ชันแล้ว
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 และแหล่งข้อมูลที่มันใช้ บันทึกการทดสอบแบบกระชับก็เพียงพอแล้ว:

text
1M01 private preference -> คน B ไม่ได้รับมันไปเด็ดขาด
2M02 shared decision -> คน B เห็นข้อตัดสินใจ ไม่ใช่แชทของ A
3M03 changed status -> แหล่งข้อมูลปัจจุบันชนะ memory ที่บันทึกไว้
4M04 conflicting claims -> ไม่มีการเปลี่ยนนโยบายอย่างเงียบๆ
5M05 private connector -> การอนุมัติ + การตอบกลับที่ปลอดภัยสำหรับ channel

ติดตามมากกว่าแค่ความแม่นยำในการเรียกคืนข้อมูล

text
1การบันทึกผิด scope
2การกระทำที่อิงจาก stale fact
3claim ระดับทีมที่ไม่มีการรองรับ
4การข้ามขั้นตอนการอนุมัติ
5เวลาที่ใช้ในการแก้ไข memory ที่ผิดพลาด

เมตริกสุดท้ายนี้มักถูกประเมินต่ำไป

ทุกระบบ shared memory จะต้องเก็บข้อมูลผิดพลาดในที่สุด

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

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

เมื่อ Bot เรียนรู้สิ่งที่ผิด

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

มันเกิดขึ้นได้แน่นอน

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

สมมติว่า Bot บันทึกไปว่า "การต่อสัญญา enterprise ทั้งหมดต้องได้รับการอนุมัติจาก VP" หลังจากเกิดข้อยกเว้นครั้งเดียว สัปดาห์ต่อมา มันเริ่มหน่วงการต่อสัญญาปกติ

ผมจะจัดการเรื่องนี้เหมือน incident ข้อมูลขนาดเล็ก:

  1. ขอให้ Bot แสดง team memory ของมันและค้นหา claim ที่แน่ชัด Grok Bot อนุญาตให้คุณถามว่ามันบันทึกอะไรไว้ แล้วบอกให้มันแก้ไขหรือลบรายการนั้นออก
  2. ระบุบทสนทนาหรือข้อตัดสินใจต้นทาง เจ้าของ และงานที่นำ claim นั้นไปใช้ต่อ ถ้าคุณตามรอยต้นทางไม่ได้ อย่าเก็บกฎนั้นไว้เพียงเพราะมันฟังดูสมเหตุสมผล
  3. แก้ไขนโยบายการต่อสัญญาที่เป็น authoritative ก่อน จากนั้นค่อยลบหรือแทนที่ memory ที่ผิดพลาดของ Bot หากความผิดพลาดมาจาก skill, ไฟล์ หรือคำอธิบาย Bot ให้แก้ตรงนั้นด้วย
  4. รันเคสการต่อสัญญาใหม่จากบัญชีของเพื่อนร่วมทีมคนอื่น ตรวจสอบทั้งคำตอบและว่ามีการพยายามดำเนินการใดๆ หรือไม่
  5. ตรวจทานร่างข้อความหรือ ticket ปลายน้ำที่ถูกสร้างขึ้นในขณะที่ memory ผิดพลาดนั้นยังทำงานอยู่

ขั้นตอนสุดท้ายนี้很容易被มองข้าม การลบ memory จะเปลี่ยนพฤติกรรมในอนาคต ไม่ใช่เปลี่ยนอีเมลที่ร่างไว้แล้วหรือข้อตัดสินใจที่ทำไปแล้ว

บทเรียนที่นำกลับมาใช้ซ้ำได้คือให้เก็บบันทึกน้ำหนักเบาของความทรงจำที่ใช้ร่วมกันซึ่งสำคัญไว้ภายนอก Bot: claim, source, owner, scope และ review date memory ของ Grok Bot คือบริบทการทำงาน แต่ ledger ของคุณคือ audit trail

rari - inline image

ความผิดพลาดที่ผมคาดว่าจะเจอก่อนเป็นอันดับแรก

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

  • ใช้ team memory เป็นฐานข้อมูลของบริษัท Bot ควรจดจำบริบทที่คงที่ได้ และเปิดข้อมูลที่เปลี่ยนแปลงขึ้นมาใหม่
  • ปล่อยให้ทุกคนแก้ไขกระบวนการผ่านการสนทนา ทักษะที่ใช้ร่วมกัน (shared skills) มีเจ้าของด้วยเหตุผลของมัน
  • ลืมไปว่างานบน Slack ทำงานอย่างไร Thread ใน Channel คือสภาพแวดล้อมที่ใช้ร่วมกัน ไม่ใช่ DM ส่วนตัวที่มีคนดูเยอะกว่า
  • ให้ service key กว้าง ๆ กับ Bot เพราะรู้สึกว่า OAuth ช้า คีย์ที่ใช้ร่วมกันจะขยายอำนาจการเข้าถึงของ Bot ให้กับเพื่อนร่วมทีมทุกคน
  • วัดผลที่ "ตอบแล้ว" แทนที่จะเป็น "กำหนดขอบเขตถูกต้อง" Bot อาจตอบได้เร็วแต่ก็ยังทำข้อมูลส่วนตัวรั่วไหล หรือลงมือทำตามข้อเท็จจริงที่ล้าสมัยไปแล้ว
  • คิดว่า memory คือการเทรนโมเดล ประเด็นที่ใช้งานได้จริงคือ Bot สามารถนำบริบทใดกลับมาใช้ในงานครั้งต่อไปได้ ไม่ใช่เรื่องที่ว่า weight ของโมเดลเบื้องหลังเปลี่ยนไปหรือไม่

การตั้งค่าที่ผมจะนำไปใช้งานจริง

  1. สร้าง Team Bot หนึ่งตัวสำหรับงานที่ใช้ร่วมกันงานเดียว อย่าสร้างเป็นผู้ช่วยทั่วไปของบริษัท
  2. เขียนความรับผิดชอบและขอบเขตการอนุมัติไว้ในคำอธิบายของ Bot
  3. เพิ่มไฟล์และปลั๊กอินเท่าที่จำเป็นเท่านั้น ควรใช้ personal OAuth สำหรับการกระทำเฉพาะผู้ใช้ และใช้ shared credentials แบบอ่านอย่างเดียวสำหรับข้อมูลที่ใช้ร่วมกัน
  4. นำกระบวนการที่ทำซ้ำได้ไปใส่ใน skill ที่ดูแลโดยเจ้าของหรือผู้จัดการที่ได้รับมอบหมาย
  5. เพิ่ม team memory ที่ยืนยันแล้วเพียงไม่กี่รายการ โดยแต่ละรายการต้องมีแหล่งที่มาหรือเจ้าของที่ชัดเจน
  6. ทดสอบบันทึกส่วนตัว ข้อมูลที่ล้าสมัย ข้อความที่ขัดแย้งกัน และขอบเขตผู้ชมบน Slack จากบัญชีที่แยกกัน
  7. เผยแพร่ให้ทีมขนาดเล็ก ตรวจสอบข้อผิดพลาด และตกลงวิธีแก้ไข 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

บันทึกในคลิกเดียว

อ่านบทความไวรัลเชิงลึกด้วย AI ใน YouMind

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

สำรวจ YouMind
สำหรับครีเอเตอร์

เปลี่ยน Markdown ของคุณให้เป็นบทความ 𝕏 ที่สะอาดตา

เวลาคุณเผยแพร่งานเขียนยาวของตัวเอง การจัดรูปแบบรูปภาพ ตาราง และบล็อกโค้ดให้เข้ากับ 𝕏 นั้นน่าปวดหัว YouMind เปลี่ยนร่าง Markdown ทั้งฉบับให้เป็นบทความ 𝕏 ที่สะอาดตาและพร้อมโพสต์ทันที

ลอง Markdown เป็น 𝕏

แพตเทิร์นให้ถอดรหัสเพิ่มเติม

บทความไวรัลล่าสุด

สำรวจบทความไวรัลเพิ่มเติม