Cumora คือแอปแชทสำหรับทีมที่มองโปรแกรมปัญญาประดิษฐ์ทำงานอัตโนมัติอย่าง AI Agent เป็นสมาชิกคนหนึ่งในทีมเหมือนคนทั่วไป ในรายชื่อสมาชิกจะมีป้าย "HUMAN" กำกับไว้เฉพาะคนจริง ๆ ส่วนที่เหลือคือ AI ทั้งหมด ตัวโปรเจกต์เป็นโอเพนซอร์สบน GitHub ในชื่อ yetone/cumora ภายใต้ไลเซนส์ MIT ที่เปิดให้ทุกคนนำโค้ดไปใช้งานหรือพัฒนาต่อได้อย่างอิสระ

ปกติเวลาเราทำงานร่วมกับ AI เรามักจะต้องเปิดแท็บใหม่ พิมพ์สั่งงานทีละเรื่อง พอได้ผลลัพธ์ก็ค่อยก๊อปปี้กลับมาส่งในห้องแชททีม แต่ตัว AI ไม่รู้บริบทเลยว่าก่อนหน้านี้ทีมคุยอะไรกันไปบ้าง เพราะไม่ได้อยู่ในห้องแชทด้วยตั้งแต่แรก Cumora เข้ามาแก้ปัญหานี้ด้วยการดึง AI Agent เข้ามาอยู่ในห้องแชทของทีมจริง ๆ ทำให้ Agent เห็นบริบทการพูดคุยทั้งหมดเหมือนที่คนในทีมเห็น เราสามารถทักแชทส่วนตัวกับ Agent ดึงเข้ากลุ่มร่วมกับคนอื่น ให้ช่วยลากการ์ดบนบอร์ด Kanban หรือดูปฏิทินร่วมกันได้ ยิ่งไปกว่านั้น Agent แต่ละตัวยังมีบุคลิก จดจำข้อมูล ทำงานตามที่มอบหมาย และรับส่งอีเมลได้จริงอีกด้วย

สำหรับคนที่ใช้ Claude Code หรือ Codex ที่เป็นเครื่องมือช่วยเขียนโค้ดอัตโนมัติอยู่แล้ว จุดเด่นที่น่าสนใจที่สุดของ Cumora ไม่ใช่แค่เรื่องห้องแชท แต่เป็นความยืดหยุ่นในการเลือก "สมอง" หรือโมเดล AI ที่อยู่เบื้องหลัง Agent แต่ละตัว

Agent ไม่ได้อยู่อีกแท็บ แต่อยู่ในรายชื่อสมาชิกทีม

หน้าตาของ Cumora เหมือนกับแอปแชททั่วไปที่เราคุ้นเคย มีรายการแชทเรียงตามลำดับเวลา มีห้องรวมอย่าง Everyone และมีแถบด้านบนให้เลือกกรองดูเฉพาะ Agents หรือ Humans จุดที่ต่างจากแอปทั่วไปคือ ทั้งคนและ AI อยู่ในรายชื่อเดียวกันทั้งหมด

การเอา Agent มารวมไว้ในที่เดียวกันอาจดูเหมือนแค่การปรับหน้าตาแอป แต่ผลลัพธ์ที่ได้ต่างกันมาก เพราะเมื่อ Agent อยู่ในห้องแชท ก็จะอ่านและเข้าใจสิ่งที่ทีมกำลังคุยกันได้ตลอดเวลา โดยที่เราไม่ต้องคอยก๊อปปี้ข้อความไปป้อนใหม่ ทำให้ Agent พร้อมเริ่มทำงานต่อได้ทันทีโดยไม่ต้องรอเราสั่งงานทีละขั้นตอน

แม้ว่าเครื่องมืออื่น ๆ จะเริ่มพัฒนาไปในทิศทางนี้ เช่น Agent View ของ Claude Code ที่รวมหน้าต่างงานหลาย ๆ อันมาไว้บนหน้าจอเดียว แต่หน้าจอนั้นก็ยังเป็นพื้นที่ส่วนตัวของเราคนเดียว สิ่งที่ Cumora ทำจึงเป็นการขยับ Agent จากพื้นที่ส่วนตัว เข้ามาอยู่ในพื้นที่การทำงานส่วนกลางของทีมจริง ๆ

เลือกสมองของ Agent ได้ 2 ทาง ผ่านคลาวด์ของ Cumora หรือ BYOA บนเครื่องตัวเอง

เวลาสร้าง Agent แต่ละตัว เราจะต้องเลือกว่าจะให้รันอยู่ที่ไหน ในระบบของ Cumora จะเรียกส่วนนี้ว่า "Computer" โดยมี 2 ทางเลือกหลัก

ทางเลือกแรกคือ Cumora Cloud ทางโปรเจกต์จะดูแลระบบให้ทั้งหมด โดย Agent แต่ละตัวจะรันในสภาพแวดล้อมแยกกัน ฝั่งเซิร์ฟเวอร์จะจัดการเรียกใช้เครื่องมือต่าง ๆ ให้อัตโนมัติ ทั้งการสั่งงานผ่าน Command Line, เปิดไฟล์, เปิดเบราว์เซอร์, ส่งอีเมล, บันทึกความจำ ไปจนถึงเรียกใช้สกิลเสริมต่าง ๆ

ทางเลือกที่สองคือแนวทาง Bring Your Own Agent หรือ BYOA โดยนำเครื่อง Mac ส่วนตัว หรือเซิร์ฟเวอร์เสมือนอย่าง VPS ที่เราเช่าไว้ มาเชื่อมต่อกับห้องแชทของ Cumora โดยตรง สมองของ Agent จะรันผ่านเครื่องมือ AI Agent ที่ติดตั้งอยู่ในเครื่องเราเอง ปัจจุบันรองรับทั้งหมด 7 ตัว ได้แก่ Claude Code, Codex CLI, Grok Build, Cursor Agent, OpenCode, pi และ Gemini CLI

จุดเด่นของ BYOA ที่ตอบโจทย์คนที่จ่ายค่าบริการ AI รายเดือนอยู่แล้ว คือเรื่องความคุ้มค่าและความเป็นส่วนตัว คำสั่งทั้งหมดจะประมวลผลผ่านบัญชีโมเดลของเราเอง ค่าใช้จ่ายและโควตาการใช้งานจึงนับรวมอยู่ในแพ็กเกจเดิมที่เราจ่ายอยู่แล้ว โดยไม่ต้องเสียค่า API ซ้ำซ้อน อีกทั้งเซิร์ฟเวอร์ของ Cumora จะไม่เก็บหรือเข้าถึง API Key ของเราเลยแม้แต่น้อย

การเชื่อมต่อเครื่องเข้ากับระบบทำได้ง่าย ๆ ด้วยคำสั่งเพียงบรรทัดเดียว:

npx cumora@latest agent computer --pair <code>

โดยเปลี่ยน <code> เป็นรหัสจับคู่ที่ได้จากหน้าเว็บ เมื่อรันคำสั่งแล้ว โปรแกรมจะทำงานอยู่เบื้องหลังบนเครื่องเพื่อรอรับงานจากห้องแชท สิ่งเดียวที่ต้องมีในเครื่องคือ Node.js เวอร์ชัน 18 ขึ้นไป โดยไม่จำเป็นต้องโคลนโปรเจกต์ลงมา และไม่ต้องตั้งค่าฐานข้อมูลใด ๆ เพราะการสื่อสารทั้งหมดทำผ่าน HTTPS เท่านั้น ดูรายละเอียดของ Agent แต่ละตัวเพิ่มเติมได้ในเอกสาร BYOA

ข้อควรระวังคือ การเลือกใช้ BYOA ไม่ได้หมายความว่าข้อมูลทั้งหมดจะอยู่แค่ในเครื่องเรา เพราะเครื่องของเราทำหน้าที่เป็นสมองประมวลผล ส่วนห้องแชทและข้อความสนทนายังคงอยู่บนเซิร์ฟเวอร์ตามปกติ

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

เมื่อ Agent หลายตัวอยู่ในห้องเดียวกัน ปัญหาคือจะพูดทับกัน

นี่คือปัญหาที่จะเกิดขึ้นทันทีเมื่อในห้องแชทมี Agent มากกว่าหนึ่งตัว และเป็นประเด็นที่เอกสาร COORDINATION.md ของโปรเจกต์อธิบายวิธีแก้ปัญหาไว้อย่างละเอียดที่สุด

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

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

ชั้นที่ 1: ตรวจสอบว่าข้อมูลยังเป็นปัจจุบันหรือไม่ ก่อนส่งคำตอบของ Agent เข้าห้องแชท เซิร์ฟเวอร์จะตรวจสอบว่าข้อความล่าสุดในห้องเปลี่ยนไปจากตอนที่ Agent เริ่มประมวลผลหรือไม่ ถ้ามีคนพิมพ์ข้อความใหม่เข้ามาแทรกระหว่างนั้น ระบบจะระงับคำตอบเดิมไว้ แล้วส่งข้อความใหม่ให้ Agent อ่านเพื่อพิจารณาใหม่อีกรอบ

ชั้นที่ 2: งานหนึ่งชิ้น ให้ทำได้ทีละตัว หรือ Job Locking สำหรับงานที่ระบุไว้ชัดเจน เช่น การ์ดบนบอร์ด Kanban ตัว Agent ที่กดรับงานก่อนจะได้สิทธิ์ทำงานนั้นไป ส่วน Agent ตัวอื่นจะไม่สามารถหยิบการ์ดใบเดียวกันไปทำซ้ำได้ นอกจากนี้ยังป้องกันไม่ให้สร้างเอกสารหรือนัดหมายในปฏิทินซ้ำซ้อน ถ้ามี Agent ตัวใดเพิ่งสร้างรายการชื่อเดียวกันไปภายใน 15 นาที ตัวถัดไปก็จะไม่สามารถสร้างซ้ำได้

ชั้นที่ 3: ใช้โมเดลขนาดเล็กช่วยคัดกรองก่อนเรียกโมเดลใหญ่ เมื่อมีข้อความเข้ามา ระบบจะส่งให้โมเดลขนาดเล็กที่มีค่าใช้จ่ายต่ำช่วยประเมินก่อนว่า มีงานที่ต้องทำจริงหรือไม่ โดยโมเดลเล็กจะตอบเพียง "ใช่" หรือ "ไม่ใช่" เท่านั้น ถ้าจำเป็นต้องทำงานจริง จึงจะส่งต่อไปให้โมเดลใหญ่ประมวลผล โดยมีกฎสำคัญคือ ถ้าเป็นการสนทนาที่มีคนอยู่ด้วยหรือมีคนรอคำตอบ ระบบจะส่งให้ทำเสมอ ชั้นนี้จึงช่วยตัดปัญหาไม่ให้ Agent คุยโต้ตอบกันเองไปเรื่อย ๆ โดยไม่มีเนื้องานจริง

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

แนวคิดเบื้องหลังการแบ่งระดับนี้ชัดเจนมาก ปัญหาที่ตรวจสอบลำดับก่อนหลังได้จากฐานข้อมูล จัดการได้ด้วยโค้ดอย่างเด็ดขาด ส่วนปัญหาที่ Agent เข้าใจสถานการณ์แต่ยังตัดสินใจผิดพลาด เป็นเรื่องของข้อความสั่งงานอย่าง Prompt และความสามารถของโมเดล ซึ่งโค้ดควบคุมไม่ได้ทั้งหมด นี่จึงเป็นเรื่องที่ต้องวางแผนให้ชัดเจนก่อนนำ Agent หลายตัวมาทำงานร่วมกัน ว่าส่วนไหนควรคุมด้วยกฎของระบบ และส่วนไหนต้องปล่อยให้เป็นดุลยพินิจของตัวโมเดล

โจทย์เรื่องการประสานงานนี้ไม่ได้เกิดขึ้นแค่กับ Cumora เท่านั้น ในฝั่งการเขียนโค้ดก็พบปัญหาแบบเดียวกัน จนต้องใช้ระบบคิวรวมโค้ดอย่าง Merge Queue เพื่อป้องกันไม่ให้ Agent หลายตัวส่งโค้ดชนกัน ต่างกันตรงที่ระบบนั้นคอยกันไม่ให้ไฟล์โค้ดชนกัน ส่วน Cumora เข้ามาช่วยกันไม่ให้ข้อความในบทสนทนาตีกันเอง

ทุกครั้งที่เรียกโมเดล ลงบัญชีเดียวกันหมด

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

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

ของที่ยังไม่พร้อม ต้องรู้ก่อนโหลด

ตัวเลขบน GitHub ตอนนี้อยู่ที่ราว 3,200 ดาว มีคน Fork ไป 396 ครั้ง มีผู้ร่วมพัฒนา 21 คน และปล่อย release ออกมาแล้ว 10 ครั้ง ส่วนโค้ดล่าสุดในโปรเจกต์ติดแท็กไว้ที่ v0.9.1 หมายความว่ายังไม่ถึงเวอร์ชัน 1.0 อย่างเป็นทางการ

การพัฒนาบนสมาร์ทโฟนยังตามหลังฝั่งเดสก์ท็อปอยู่พอสมควร โดยแอปบน iOS ยังเป็นเวอร์ชันทดสอบที่ต้องติดตั้งผ่าน TestFlight ของ Apple เท่านั้น ส่วนฝั่ง Android ยังไม่มีไฟล์ติดตั้งสำเร็จรูปให้ดาวน์โหลด ถ้าต้องการใช้งานจะต้องคอมไพล์และบิลด์แอปขึ้นมาเองจากซอร์สโค้ด

ถ้าต้องการโฮสต์และรันเซิร์ฟเวอร์ของ Cumora ด้วยตัวเองทั้งหมด สิ่งที่ต้องเตรียมคือฐานข้อมูล PostgreSQL, ระบบเก็บข้อมูลชั่วคราวในหน่วยความจำอย่าง Redis และ API Key ของโมเดล AI โดยค่า Environment ที่จำเป็นต้องมีคือ OPENAI_API_KEY ส่วนการเชื่อมต่อไปยัง PostgreSQL และ Redis มีค่าเริ่มต้นสำหรับรันในเครื่องตัวเองหรือ Localhost มาให้พร้อมแล้ว ทั้งนี้ การรันเซิร์ฟเวอร์เองเป็นคนละส่วนกับการใช้ BYOA เพราะ BYOA ต้องการแค่ Node.js บนเครื่องเพื่อเชื่อมต่อไปยังเซิร์ฟเวอร์ที่มีอยู่แล้วเท่านั้น

คำถามที่ต้องตอบก่อนดึง Agent เข้ามาร่วมทีม

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

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

ที่มา:

• Cumora — Where agent teams gather: cross-platform team chat where AI agents are first-class teammates จาก yetone/cumora บน GitHub
• docs/BYOA.md — Bring Your Own Agent จาก yetone/cumora บน GitHub
• docs/COORDINATION.md — multi-agent coordination จาก yetone/cumora บน GitHub