การทำงานหลายเอเจนต์ • การส่งมอบ • วงจรข้อเสนอแนะ

ทีมเอเจนต์
ทีมเทคโนโลยีที่แท้จริง, เขียนสคริปต์

ทีม AgentsRoom เชื่อมโยงเอเจนต์การเขียนโค้ด AI ของคุณเหมือนทีมวิศวกรรมจริง นักพัฒนาฟูลสแต็กส่งฟีเจอร์, วิศวกร QA ตรวจสอบ, ผู้จัดการผลิตภัณฑ์ลงนาม ทุกบทบาทถูกเขียนสคริปต์, การทำงานเป็นภาพ, และการส่งมอบแต่ละครั้งมีสรุปฟีเจอร์, diff, ความเสี่ยง และคำแนะนำการทดสอบ ไม่มีเอเจนต์เดียวที่ทำทุกอย่างได้ไม่ดีอีกต่อไป

สร้างทีมพัฒนาปัญญาประดิษฐ์ในฝันของคุณบนผ้าใบภาพ, เหมือนการทำงานของ n8n ขอบเงื่อนไข, วงจรข้อเสนอแนะ, สาขาการตรวจสอบแบบขนาน, ประตูคุณภาพที่ตรวจสอบโดยเครื่อง, การป้องกันรอบสูงสุด บันทึกครั้งเดียว, รันบนทุกตั๋ว, ดูให้เอเจนต์ของคุณส่งไม้ต่อเหมือนผู้มีประสบการณ์

ทีม AgentsRoom: ตัวแก้ไขการทำงานหลายเอเจนต์แบบภาพ, การส่งมอบอัตโนมัติระหว่างเอเจนต์ Claude Code, วงจรข้อเสนอแนะจาก Dev ไปยัง QA, การสื่อสารระหว่างเอเจนต์ที่ใช้ MCP

ทีมเอเจนต์คือคำตอบของ AgentsRoom ต่อความจริงที่โหดร้ายเกี่ยวกับเอเจนต์การเขียนโค้ด AI: เอเจนต์เดียวที่พยายามทำทุกอย่างสุดท้ายทำทุกอย่างได้ไม่ดี เอเจนต์ฟูลสแต็กที่เขียนโค้ด, ทดสอบ, ตรวจสอบ, ส่งไปยังการผลิต และเขียนสเปคในเวลาเดียวกันลืมคำสั่งครึ่งหนึ่งในระหว่างนั้น คำตอบที่ถูกต้อง, คำตอบที่ทุกทีมซอฟต์แวร์ที่จริงจังในโลกใช้คือการแบ่งงานออกเป็นบทบาท นักพัฒนาจะเขียนโค้ด วิศวกร QA จะตรวจสอบ ผู้จัดการผลิตภัณฑ์จะลงนาม ผู้ตรวจสอบความปลอดภัยจะตรวจสอบ ทุกบทบาทมีบริบทของตัวเอง, มีจุดสนใจของตัวเอง, มีเครื่องมือของตัวเอง

นี่คือสิ่งที่ทีมเอเจนต์นำมาสู่ AgentsRoom คุณวางโหนดบนผ้าใบไม่สิ้นสุด (สร้างจาก React Flow, เอนจินเดียวกับ n8n, Make, Retool และ Pipedream) โหนดแต่ละตัวคือเอเจนต์ที่ทำงานบน Claude, Codex, GitHub Copilot CLI, Cursor หรือ CLI ของเอเจนต์อีก 10 ตัวที่ AgentsRoom รองรับ ที่ได้รับมอบหมายให้บทบาทเฉพาะ และคุณเชื่อมต่อพวกเขาเข้าด้วยกัน รันทีมบนตั๋วจากแบ็คล็อกของคุณ หรือแนบไปยังการสร้างเอเจนต์ใหม่ใด ๆ AgentsRoom จะจัดการห่วงโซ่: สร้างเอเจนต์แรก, รอการส่งมอบ, สรุปงาน, สร้างเอเจนต์ถัดไปด้วยสรุปนั้นเป็นบริบทนำเข้า, ทำซ้ำจนกว่าทีมจะถึงโหนดสุดท้าย

เครื่องมืออื่น ๆ พยายามทำเช่นนี้ด้วยเอเจนต์ซุปเปอร์เดียวและคำสั่งที่ช clever เราลองทำแล้ว, มันไม่ได้ผลเกินสามขั้นตอน บทบาทลอย, บริบทหายไป, เอเจนต์ลืมสิ่งที่มันควรจะตรวจสอบ ทีมเอเจนต์ปฏิบัติต่อเอเจนต์เหมือนเพื่อนร่วมทีมจริง: ทุกคนจะได้รับเซสชันที่สะอาด, คำสั่งระบบที่มุ่งเน้น, ข้อมูลการส่งมอบที่มีโครงสร้าง, และกระดานขีดเขียนร่วมกันเพื่อพูดคุยกับคนอื่น นี่คือการทำงานของทีมวิศวกรรม AI ที่คุณต้องการจริงๆ

ตัวแก้ไขการทำงานแบบภาพของทีมเอเจนต์ AgentsRoom: โหนดสำหรับบทบาท Dev, QA, PM, ความปลอดภัย และ DevOps เชื่อมต่อกันบนผ้าใบไม่สิ้นสุดด้วยขอบเงื่อนไขและวงจรข้อเสนอแนะ

ตัวแก้ไขทีม AgentsRoom: วางโหนดสำหรับแต่ละบทบาท, เชื่อมต่อพวกเขา, เพิ่มเงื่อนไข, บันทึกทีม, รันบนตั๋วใด ๆ

การจัดการหลายเอเจนต์ที่สามารถขยายได้จริง

โหนดแต่ละตัวบนผ้าใบคือเอเจนต์ คุณเลือกบทบาทของมัน (ฟูลสแต็ก, ฟรอนต์เอนด์, แบ็กเอนด์, QA, ความปลอดภัย, DevOps, PM, สถาปนิก, มือถือ, การตลาด, Git, SEO, การแปล, หรือบทบาทที่กำหนดเองใด ๆ ที่คุณสร้างขึ้น), โมเดลของมัน (Opus, Sonnet, Haiku, GPT-5, o3, Antigravity Pro, ฯลฯ), โหมดการส่งมอบของมัน (อัตโนมัติผ่าน Stop hook, หรือด้วยตนเองผ่านปุ่ม) และไม่กี่บรรทัดของคำแนะนำเฉพาะขั้นตอน นั่นคือทั้งหมด ไม่มีพิธีกรรมการสร้างคำสั่ง, ไม่มีไฟล์กำหนดค่า YAML ที่ต้องเขียน

ขอบเชื่อมต่อโหนด โหนดง่ายหมายถึง: เมื่อผู้แทนแรกเสร็จสิ้นขั้นตอนของมัน, ส่งมอบให้กับคนถัดไป ขอบเงื่อนไขจะมีการตรวจสอบธง, ตัวอย่างเช่น qaPassed เท่ากับ true เอเจนต์ QA ตั้งธงนั้นในข้อมูลการส่งมอบของมัน, ผู้รันเลือกขอบที่ตรงกัน นี่คือวิธีที่คุณสร้างวงจรข้อเสนอแนะ: QA เสร็จสิ้น, qaPassed เท่ากับ false, ขอบส่งกลับไปยัง Dev พร้อมคำแนะนำการทดสอบและความเสี่ยง Dev แก้ไข, ส่งมอบอีกครั้ง วนซ้ำจนกว่า QA จะผ่านหรือจนกว่าการป้องกันรอบสูงสุดจะทำงาน

การสื่อสารระหว่างเอเจนต์มีความแข็งแกร่งตามการออกแบบ AgentsRoom ส่งเซิร์ฟเวอร์ MCP ที่กำหนดไว้ (agentsroom-team) ที่ให้เครื่องมือชุดหนึ่งกับเอเจนต์แต่ละตัวในรัน: อ่านบริบททีม, อ่านกระดานขีดเขียน NOTES.md ที่แชร์, โพสต์โน้ตสำหรับเพื่อนร่วมทีม, ส่งคำถามไปยังบทบาทอื่น, อ่านกล่องจดหมาย, อ่านไทม์ไลน์, อ่าน git diff เทียบกับฐานรัน, และทำขั้นตอนให้เสร็จด้วยข้อมูลการส่งมอบที่มีโครงสร้าง เครื่องมือเหล่านี้จะถูกนำกลับเข้าไปในเซสชัน Claude ทุกครั้ง, ดังนั้นพวกเขาจึงรอดชีวิตจากการบีบอัดบริบท แม้หลังจาก /compact หรือ /clear, เอเจนต์ยังคงเห็นเครื่องมือทีมของมัน

นอกจากนี้, hook UserPromptSubmit จะเตือนเอเจนต์เกี่ยวกับโน้ตใหม่จากเพื่อนร่วมทีมก่อนข้อความผู้ใช้แต่ละข้อความ ไฟล์ NOTES.md ในพื้นที่ทำงานจะเป็นแบบเพิ่มเท่านั้นและรอดชีวิตจากการล่ม, การรีสตาร์ท และการบูตเครื่อง ข้อมูลการส่งมอบที่มีโครงสร้างที่ตรวจสอบเซิร์ฟเวอร์ด้านข้างจะป้องกันไม่ให้เอเจนต์ส่งมอบข้อมูลที่ว่างเปล่าหรือขยะ นี่คือส่วนที่การสาธิตหลายเอเจนต์ส่วนใหญ่เงียบข้าม, และเหตุผลที่ส่วนใหญ่ล้มเหลวที่รอบที่ 3

ทุกสิ่งที่คุณต้องการเพื่อรันทีมวิศวกรรม AI

การทำงานแบบภาพ, การส่งมอบจริง, วงจรข้อเสนอแนะจริง, การสื่อสารระหว่างเอเจนต์จริง สร้างขึ้นเพื่อให้คุณสามารถส่งฟีเจอร์ในหนึ่งการแจ้งเตือน Slack แทนที่จะเป็นห้าสิบ

ผ้าใบการทำงานแบบภาพ

ผ้าใบที่ซูมได้ไม่สิ้นสุดที่ขับเคลื่อนโดย React Flow, เอนจินเดียวกับ n8n, Retool, Pipedream และ Make วางโหนด, เชื่อมต่อพวกเขา, บันทึกทีม ไม่มีโค้ด, ไม่มี YAML

14 บทบาทเอเจนต์ในตัว

ฟูลสแต็ก, ฟรอนต์เอนด์, แบ็กเอนด์, DevOps, QA, ความปลอดภัย, PM, สถาปนิก, มือถือ, การตลาด, ผู้เชี่ยวชาญ Git, SEO, i18n, Brainstormer นอกจากนี้ยังมีบทบาทที่กำหนดเองใด ๆ ที่คุณได้บันทึกไว้ในโครงการของคุณ

โมเดลและคำสั่งต่อโหนด

แต่ละโหนดเลือกผู้ให้บริการ โมเดล และคำแนะนำขั้นตอนของตน ใช้ Opus สำหรับสถาปนิก, Haiku สำหรับ QA, Codex สำหรับแบ็คเอนด์ที่หนักหน่วง, Antigravity สำหรับฟรอนต์เอนด์ที่ประหยัด ผสมและจับคู่ได้ตามต้องการ

การส่งมอบอัตโนมัติ

เมื่อเอเจนต์เรียก team_complete_step, AgentsRoom จะสร้างข้อมูลการส่งมอบ (สรุปฟีเจอร์, ไฟล์ที่เปลี่ยนแปลง, ความเสี่ยง, ข้อเสนอแนะแบบทดสอบ, ธง) และสร้างโหนดถัดไปด้วยข้อมูลนั้นเป็นบริบทเริ่มต้น

ตัวเลือกการส่งมอบแบบแมนนวล

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

ขอบเงื่อนไข

การเชื่อมต่อแต่ละเส้นสามารถมีการตรวจสอบแฟล็กหนึ่งรายการหรือหลายรายการ ซึ่งรวมกันด้วย AND หรือ OR ถ้า QA ผ่านก็ไปที่ PM ถ้ารีวิวไม่ผ่านก็ย้อนกลับไปที่ Dev และถ้าทั้งรีวิวและการวิเคราะห์ไม่ผ่านก็หยุดรอมนุษย์ เมื่อมีสองเส้นตรงกันพร้อมกัน เส้นที่มีเงื่อนไขมากที่สุดจะชนะ

วงจรข้อเสนอแนะแบบวนซ้ำ

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

เกณฑ์คุณภาพที่ตรวจสอบโดยเครื่อง

ติดตั้งคำสั่งตรวจสอบบนโหนดใดก็ได้ (npm test, lint, build) ตัวรันเนอร์จะดำเนินการเมื่อเอเจนต์ส่งสัญญาณเสร็จ: รหัสออก 0 จะตั้งค่าสถานะการส่งต่อเป็นจริง ส่วนอย่างอื่นเป็นเท็จ ผลลัพธ์ที่วัดได้จะมีอำนาจเหนือการรายงานตนเองของเอเจนต์เสมอ

การตรวจสอบสาขาพร้อมกัน

วาดขอบเขตที่ไม่มีเงื่อนไขสองขอบออกจากโหนดและเป้าหมายทั้งสองจะทำงานพร้อมกัน: QA และความปลอดภัยตรวจสอบความแตกต่างเดียวกันข้างๆ กัน จากนั้นโหนดรวมจะรวมรายงานของพวกเขา ขอบแดงหนึ่งขอบจะทำให้ประตูปิด

ถามมนุษย์ แล้วไปต่อ

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

ทักษะที่ติดตั้งต่อขั้นตอน

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

การป้องกันรอบสูงสุด

ขีดจำกัดที่กำหนดได้ (ค่าเริ่มต้น 3) ป้องกันการวนซ้ำ QA ปฏิเสธ Dev ที่ไม่มีที่สิ้นสุด เมื่อถึงขีดจำกัด การทำงานจะหยุดชั่วคราวในสถานะรอการสรุปสุดท้ายและคุณตัดสินใจว่าจะทำอย่างไรต่อไป

การทำงานยังคงอยู่แม้จะรีสตาร์ท

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

ห้องสมุดทีมในบัญชีของคุณ

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

โน้ตแชร์ NOTES.md

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

กล่องจดหมายบทบาทต่อบทบาท

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

การสื่อสารระหว่างเอเจนต์ที่ใช้ MCP

เครื่องมือของทีมทั้งหมดถูกเปิดเผยผ่านเซิร์ฟเวอร์ MCP เครื่องมือจะรอดชีวิตจากการบีบอัดบริบทของ Claude (Anthropic จะส่งพวกเขาอีกครั้งในทุกเทิร์น) ทนทานต่อ /clear, /compact และวงจรยาว

สรุปการส่งมอบที่ขับเคลื่อนด้วย Haiku

หากเอเจนต์ไม่เขียนสรุปฟีเจอร์ของตนเอง การเรียก Haiku ขนาดเล็กจะสร้างหนึ่งจาก git diff ประหยัด, รวดเร็ว, และเอเจนต์ถัดไปจะลงจอดพร้อมบริบทเสมอ

การแพร่กระจาย MCP ในเบราว์เซอร์

โหนดทีมที่มี verifyInBrowser จะเปลี่ยนเอเจนต์ของตนเป็นโหมดเข้าถึงเบราว์เซอร์โดยอัตโนมัติ โหนด QA จะลงจอดพร้อมเครื่องมือเบราว์เซอร์เต็มรูปแบบ (นำทาง, คลิก, พิมพ์, ถ่ายภาพหน้าจอ, รับบันทึก)

เอเจนต์ชั่วคราวต่อรอบ

ทุกการทำงานของทีมจะสร้างเอเจนต์ใหม่และทำลายพวกเขาเมื่อถูกปฏิเสธ รายการเอเจนต์ของโครงการของคุณจะยังคงสะอาด ทีมคือการทำงาน, เอเจนต์คือการทำงานในระยะเวลา

ทีมทั่วโลกและทีมโครงการ

บันทึกทีมที่นำกลับมาใช้ใหม่ในห้องสมุดทั่วโลกของคุณ (~/.agentsroom/teams) หรือปักหมุดไปยังโครงการเฉพาะ (บันทึกพร้อมกับห้อง) บรรณาธิการเดียวกัน, ขอบเขตที่แตกต่างกัน

รวมเทมเพลตทีมสี่แบบ

สร้างแล้วตรวจสอบ, สร้างสเปคตรวจสอบ, ล่าหาแมลง (ทำซ้ำ, แก้ไข, พิสูจน์), และป้องกันการปล่อยด้วย QA และความปลอดภัยแบบคู่ขนาน ทำซ้ำ, แก้ไข, รัน เริ่มใน 30 วินาที

UI ไทม์ไลน์การทำงาน

แต่ละการส่งมอบปรากฏเป็นการ์ดในไทม์ไลน์การทำงาน: บทบาทใดเพิ่งเสร็จสิ้น, สรุปกล่าวว่าอย่างไร, ไฟล์ใดที่เปลี่ยนแปลง, ธงใดถูกตั้งค่า สามารถตรวจสอบได้, เล่นซ้ำได้

ทำงานในตั๋วย้อนหลังใด ๆ

วางตั๋วในทีมและการทำงานเริ่มต้นจากตั๋วนั้น เอเจนต์คนแรกอ่านชื่อและเนื้อหาของตั๋ว ทีมที่เหลือจะรับมันต่อจากที่นั่น。

14 บทบาทเฉพาะทาง พร้อมที่จะเชื่อมต่อ

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

Fullstack
End-to-end implementation
Frontend
UI, components, design tokens
Backend
API, database, performance
DevOps
CI/CD, infra, deployment
QA
Tests, edge cases, regression
Security
Audit, OWASP, secrets, auth
Architect
System design, refactor
PM
Specs, priorities, scope
Mobile
iOS, Android, React Native
Marketing
Copy, landing, SEO
Git Expert
Branches, rebase, history
SEO
Rankings, structured data
Localization
i18n, l10n, 14 languages
Custom
Bring your own role

ทำไมทีมจริงจึงดีกว่าซูเปอร์เอเจนต์คนเดียว

การจัดการหลายเอเจนต์ฟังดูเหมือนคำศัพท์ที่เกินจริง นี่คือความแตกต่างที่เป็นรูปธรรมในฟีเจอร์ที่คุณจะส่งจริง

สถานการณ์: เพิ่มกระบวนการชำระเงิน Stripe ลงในเว็บไซต์อีคอมเมิร์ซ

ซูเปอร์เอเจนต์คนเดียว

  • อ่านตั๋ว เขียน 600 บรรทัดใน API, ฟอร์ม React, webhook, การโยกย้าย, การทดสอบ
  • ลืมคีย์ idempotency ใน webhook ลืมทดสอบเส้นทางความล้มเหลว ลืมตัวแปรสภาพแวดล้อม staging
  • พูดว่า 'เสร็จแล้ว' คุณใช้เวลาสองชั่วโมงในการตามหาข้อผิดพลาดในผลิตภัณฑ์

ทีมเอเจนต์ (จาก Dev ไปยัง Security ไปยัง QA)

  • เอเจนต์ Fullstack ส่งมอบการดำเนินการ คอมมิต ส่งต่อพร้อมสรุปและรายการความเสี่ยงที่ชี้ให้เห็นการเปลี่ยนแปลงการอนุญาต
  • เอเจนต์ความปลอดภัยอ่านความแตกต่าง ตรวจสอบการตรวจสอบลายเซ็น webhook เขียนคำแนะนำการทดสอบสำหรับ QA ในข้อมูลที่ส่งต่อ
  • เอเจนต์ QA รันคำแนะนำการทดสอบในเบราว์เซอร์ที่ฝังอยู่ พบข้อผิดพลาด idempotency ตั้งค่า qaPassed เท่ากับ false ส่งตั๋วกลับไปที่ Dev พร้อมการทำซ้ำที่แน่นอน
  • Dev แก้ไข ส่งต่ออีกครั้ง QA ผ่าน PM สรุป การทำงานไปที่เสร็จสิ้น

ตั๋วเดียวกัน โมเดลเดียวกัน โปรเจกต์เดียวกัน รูปแบบการทำงานที่แตกต่างกัน วิธีการของทีมจับสิ่งที่เอเจนต์คนเดียวพลาด เพราะแต่ละบทบาทมีการมอบหมายที่มุ่งเน้นและการส่งต่อที่มีโครงสร้าง

สองวิธีในการรันทีมเดียวกัน

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

เอเจนต์ตัวเดียว ทุกบทบาท

โหมดผลัด

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

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

เลือกแบบนี้กับไปป์ไลน์ที่ความต่อเนื่องสำคัญกว่าความเห็นที่สอง เช่น การรีแฟกเตอร์ การย้ายระบบ หรือฟีเจอร์ยาว ๆ ที่คอนเท็กซ์คือตัวงานเอง

Agent Morphing ทำงานอย่างไร

หนึ่งบทบาทหนึ่งเอเจนต์ ที่คุยกัน

โหมดทีม

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

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

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

การส่งข้อความระหว่างเอเจนต์ทำงานอย่างไร

สนทนาแบบอิสระ หรือเดินตามกราฟ

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

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

ความเชื่อถือวัดได้ ไม่ได้ประกาศ

เอเจนต์ที่ให้คะแนนการบ้านของตัวเองจะผ่านตัวเองในที่สุด Agent Teams ทำให้ท่อส่งมีความซื่อสัตย์ด้วยกลไกสองอย่าง

รหัสออกตัดสินใจ

โหนดใด ๆ สามารถประกาศคำสั่งตรวจสอบ: npm test, lint, build, อะไรก็ตามที่ส่งคืนรหัสออก เมื่อเอเจนต์เรียก team_complete_step ตัวรันจะดำเนินการคำสั่งในพื้นที่ทำงานและเขียนผลลัพธ์ที่วัดได้ลงในธงการจัดเส้นทาง สีเขียวหมายถึงการรันดำเนินต่อไป สีแดงหมายถึงผลลัพธ์ที่ล้มเหลวจะไปอยู่ที่ด้านบนของบริบทของเอเจนต์ถัดไป โดยมี stderr ที่แท้จริง เอเจนต์ที่อ้างว่าทดสอบทั้งหมดผ่านในขณะที่ชุดสีแดงจะถูกจัดเส้นทางโดยชุดสีแดง ไม่ใช่โดยการอ้างสิทธิ์ของมัน

สี่ตาในเวลาเดียวกัน

แฟนโหนดออกเป็นสาขาขนาน: QA ทดสอบการไหลในขณะที่ Security ตรวจสอบความแตกต่าง แต่ละตัวในเอเจนต์ของตนเอง ไม่รู้จักข้อสรุปของกันและกัน โหนดเข้าร่วมรอทุกสาขา รวมสรุป ความเสี่ยง และธง และจัดเส้นทางตามผลลัพธ์รวม ความขัดแย้งแบบบูลีนจะถูกแก้ไขเป็น false โดยการออกแบบ: ผู้ตรวจสอบที่ล้มเหลวเพียงคนเดียวก็เพียงพอที่จะหยุดการปล่อย

Dev → [ QA ∥ Security ] → ประตูปล่อย

วิธีการทำงานของทีม

01

เปิดแท็บทีม

ในมุมมองโปรเจกต์ของคุณ แท็บทีมจะแสดงเทมเพลตเริ่มต้นสี่แบบ (สร้างแล้วตรวจสอบ, สร้างสเปคตรวจสอบ, ล่าข้อผิดพลาด, ป้องกันการปล่อย) พร้อมกับทีมใดๆ ที่คุณได้บันทึกไว้แล้ว ทำสำเนาเทมเพลตหรือคลิก 'ทีมใหม่'

02

สร้างเวิร์กโฟลว์บนผืนผ้าใบ

วางโหนดเอเจนต์บนผืนผ้าใบ React Flow สำหรับแต่ละโหนด เลือกบทบาท (Fullstack, QA, Security, PM, ฯลฯ), ผู้ให้บริการ, โมเดล และบรรทัดคำแนะนำขั้นตอนเล็กน้อย เชื่อมต่อพวกเขาด้วยขอบ เพิ่มเงื่อนไขบนขอบหากคุณต้องการการแยก

Dev → QA → PM
03

ตั้งโหมดการส่งมอบต่อโหนด

การส่งมอบอัตโนมัติ: เอเจนต์จะเรียก team_complete_step เมื่อทำงานเสร็จแล้ว ผู้รันจะเข้ามาดูแล การส่งมอบด้วยตนเอง: เอเจนต์จะรอให้คุณคลิก 'ส่งมอบ' ผสมผสานทั้งสองแบบตามต้องการ

04

รันทีม

จากตั๋วใน backlog คลิก 'รันกับทีม' จากช่องเอเจนต์ที่ว่าง คลิก 'สร้างเป็นทีม' โหนดแรกจะถูกสร้างเป็นเอเจนต์ชั่วคราวในพื้นที่ทำงานของโปรเจกต์

05

ดูการส่งมอบเกิดขึ้น

เมื่อเอเจนต์ N เสร็จสิ้น AgentsRoom จะสร้างข้อมูลการส่งมอบ (สรุปฟีเจอร์ผ่านเอเจนต์หรือผ่าน Haiku, git diff, ความเสี่ยง, ข้อแนะนำการทดสอบ, ธง) เพิ่มบันทึกลงใน NOTES.md เลือกขอบเขตที่ออกไปที่เหมาะสมตามธง และส่งต่อให้กับเอเจนต์ N+1 โดยใช้ข้อมูลนั้นเป็นบริบทขาเข้า หากโหนดประกาศคำสั่งตรวจสอบ ผู้รันจะดำเนินการก่อน: รหัสออกที่วัดได้ ไม่ใช่การอ้างสิทธิ์ของเอเจนต์ จะตั้งธงการกำหนดเส้นทาง

06

วนซ้ำ, สิ้นสุด, สรุป

วงจรข้อเสนอแนะจะกลับเข้าสู่เอเจนต์เดิม (ข้อมูลทั้งหมดถูกเก็บรักษาไว้) โหนดรอคำตอบจะพักการรันไว้ที่คำถามสำหรับคุณ และเริ่มเดินต่อทันทีที่คุณตอบ โหนดสิ้นสุดจะกระตุ้นการรอการสรุปและแจ้งเตือนคุณ รวมถึงบนมือถือ คุณคลิก 'เสร็จสิ้นการรัน' เอเจนต์จะถูกทำลาย PTYs ถูกปล่อย และตั๋ว backlog ที่เป็นต้นทางของการรันจะถูกปิด

การสื่อสารระหว่างเอเจนต์ที่อยู่รอดจากทุกสิ่ง

รายละเอียดที่การสาธิตหลายเอเจนต์ส่วนใหญ่ข้ามไป นี่คือสิ่งที่ทำให้ Agent Teams ยืนยาวในระยะเวลานานและหลายรอบ

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

การประสานงานของทีมทั้งหมดอยู่ในสามสถานที่ที่อยู่รอดจากการบีบอัด ประการแรก เซิร์ฟเวอร์ MCP (agentsroom-team) เปิดเผยเครื่องมือ (team_get_context, team_read_notes, team_post_note, team_read_inbox, team_ask, team_read_timeline, team_read_diff, team_complete_step) เครื่องมือ MCP จะถูกส่งกลับไปยัง Claude ในทุกเทิร์นโดย CLI ดังนั้นจึงไม่ถูกบีบอัดบริบท

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

ประการที่สาม NOTES.md และ state.json จะอยู่บนดิสก์ในพื้นที่ทำงาน เอเจนต์สามารถอ่านกลับได้ทุกเมื่อด้วยการอ่านง่ายๆ หรือด้วย team_read_notes พวกเขาจะอยู่รอดจากการชน, การเริ่มต้นใหม่, /clear, /compact และการรีบูตเครื่อง คำสั่งระบบไม่เคยเป็นแหล่งความจริง ดิสก์และเครื่องมือ MCP เป็นแหล่งความจริง

เลยจากรันนั้นไป

กล่องจดหมายของทีมจบลงพร้อมรัน แต่รายชื่อสมาชิกของโปรเจกต์ไม่จบ

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

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

ดูการส่งข้อความระหว่างเอเจนต์
ทำงานโดยไม่ต้องมีคุณ

การรันไม่จำเป็นต้องเริ่มจากคลิกของคุณ

ทีมเป็นหนึ่งในสองสิ่งที่ทริกเกอร์ชี้ไปหาได้ อีกอย่างคือเอเจนต์ตัวเดียว ถ้าเป็นแบบกำหนดเวลา มันจะเริ่มตามจังหวะปฏิทิน หรือตามช่วงโควตาการใช้งานของแพ็กเกจ AI ของคุณ ถ้าเป็นแบบ webhook มันจะเริ่มเมื่อ GitHub, GitLab, Slack, Linear, Sentry หรือ CI ของคุณส่งเหตุการณ์เข้ามา พรอมต์ของคุณจะไปถึงขั้นตอนแรกของทีม ไปป์ไลน์เดินไปเอง บนเครื่องของคุณ และคุณจะได้รับการแจ้งเตือนตามปกติตอนที่มันเริ่ม

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

ดูทริกเกอร์: กำหนดเวลาและ webhooks

สิ่งที่ผู้คนสร้างด้วย Agent Teams

สายการผลิต Dev ไปยัง QA

คลาสสิก ฟูลสแต็คจัดส่งฟีเจอร์ QA ตรวจสอบในเบราว์เซอร์ที่ฝังอยู่, รันข้อแนะนำการทดสอบ, ลงนาม สองโหนดทีม รันบนตั๋วทุกใบจาก backlog

Dev ไปยัง QA พร้อมวงจรข้อเสนอแนะ

เหมือนกับข้างต้น แต่มีขอบเขตเงื่อนไข: qaPassed เท่ากับ false ส่งตั๋วกลับไปที่ Dev พร้อมข้อแนะนำการทดสอบ สูงสุด 3 รอบ จับการถดถอยก่อนที่จะถึงผู้ตรวจสอบมนุษย์

Dev ไปยัง Security ไปยัง QA

สำหรับฟีเจอร์ที่เกี่ยวข้องกับการตรวจสอบ, การชำระเงิน หรือ PII เอเจนต์ด้านความปลอดภัยตรวจสอบความแตกต่าง, ตั้งธงความเสี่ยง, เขียนข้อแนะนำการทดสอบสำหรับ QA ใช้โดยทีมที่จัดส่งฟินเทค, เฮลท์เทค และ B2B SaaS

PM ไปยังสถาปนิกไปยัง Dev

การทำงานตามสเปค PM เอเจนต์เปลี่ยนตั๋วให้เป็นสเปคที่มีโครงสร้าง สถาปนิกเลือกแนวทาง Dev ดำเนินการ สามบทบาท แยกกันอย่างชัดเจน การตัดสินใจที่สามารถติดตามได้

Frontend, Backend, DevOps แฟนเอาท์

การแยกแบบต่อเนื่องสำหรับฟีเจอร์แบบฟูลสแต็ค ฟรอนต์เอนด์จัดส่ง UI แบ็กเอนด์จัดส่ง API DevOps เพิ่มการกำหนดค่าของโครงสร้างพื้นฐาน แต่ละบทบาททำงานในพื้นที่ของตน ส่งต่อด้วยความแตกต่างที่ชัดเจน

การตลาดไปจนถึง SEO จนถึง i18n

ใช่, AgentsRoom Teams ไม่ได้มีไว้สำหรับโค้ดเท่านั้น การตลาดเขียนสำเนาสำหรับหน้าแลนดิ้ง SEO แทรกคำสำคัญ การแปลภาษาทำให้เป็น 14 ภาษา ทีมเดียว ตั๋วเดียว เรือเดียว

โล่การปล่อย: QA และความปลอดภัยขนาน

โหนดพัฒนาหนึ่งตัวแยกออกไปยัง QA และความปลอดภัยที่ทำงานเคียงข้างกัน จากนั้นประตูการปล่อยจะรวมรายงานทั้งสอง รายการจะถูกจัดส่งพร้อมกับแอปในฐานะแม่แบบ โล่ทั้งหมดจะวนกลับไปที่ Dev หากสาขาใดรายงานปัญหา

การล่าหาข้อผิดพลาด: ทำซ้ำก่อนที่จะแก้ไข

เอเจนต์ QA ทำซ้ำข้อผิดพลาดและเขียนขั้นตอนที่แน่นอน นักพัฒนาจะแก้ไขสาเหตุที่แท้จริง QA ตัวที่สองเล่นซ้ำขั้นตอนเดียวกันเพื่อพิสูจน์การแก้ไข ไม่มีอีกแล้ว 'ทำงานบนเครื่องของฉัน'

เปรียบเทียบกับวิธีการหลายเอเจนต์อื่นๆ

การจัดการหลายเอเจนต์เป็นคำที่มีเสียงดังมาก นี่คือสิ่งที่กำลังจัดส่งจริง และที่ที่ AgentsRoom Teams เหมาะสม

Anthropic Subagents (เครื่องมือ Task, .claude/agents) อนุญาตให้เซสชัน Claude เดียวมอบหมายให้เอเจนต์ช่วยเหลือเฉพาะทาง ยอดเยี่ยมสำหรับการมอบหมายแบบในบรรทัด แต่เซสชันหลักยังคงเป็นผู้ประสานงานและมีบริบทเดียว AgentsRoom Teams อยู่ในระดับที่สูงขึ้น: แต่ละโหนดทีมเป็นเซสชัน Claude ระดับสูงที่แยกต่างหากพร้อมหน้าต่างของตนเอง, สถานะของตนเอง, และการเลื่อนกลับของตนเอง CrewAI, AutoGen และ LangGraph เป็นเฟรมเวิร์ก Python ที่ยอดเยี่ยมสำหรับการไหลของหลายเอเจนต์ แต่พวกเขาอยู่ภายนอก IDE ของคุณและไม่ทำงานจริงกับ Claude Code, Codex หรือ Antigravity CLIs แบบ end-to-end บน repo ท้องถิ่นของคุณ n8n, Make, Pipedream และ Retool จัดส่งเครื่องมือแก้ไขผืนผ้าใบประเภทเดียวกันที่เราใช้ แต่พวกเขาเป็นแพลตฟอร์มอัตโนมัติทั่วไป ไม่ได้สร้างขึ้นสำหรับเอเจนต์การเขียน AI AgentsRoom Teams เป็นเครื่องมือแก้ไขการทำงานของหลายเอเจนต์แบบผืนผ้าใบ แต่เชื่อมต่อโดยเฉพาะกับเอเจนต์ CLI ของคุณ, โปรเจกต์ของคุณ, git ของคุณ, เทอร์มินัลของคุณและเบราว์เซอร์ของคุณ

Claude subagentsTask toolCrewAIAutoGenLangGraphn8nMakePipedreamRetoolTemporalAirflowPrefectDagster

หากคุณสร้างระบบเอเจนต์ใน Python ให้ใช้ CrewAI หรือ LangGraph สำหรับสายการผลิต หากคุณจัดส่งโค้ดด้วย Claude, Codex, GitHub Copilot CLI, Cursor หรือ CLI ของเอเจนต์อีก 10 ตัวที่ AgentsRoom รองรับ Agent Teams คือการทำงานร่วมกันของทีมที่ทำงานในที่ที่คุณเขียนโค้ดจริงๆ

FAQ

นี่แตกต่างจาก Claude Code subagents (เครื่องมือ Task, .claude/agents) อย่างไร?

Claude subagents เป็นการมอบหมายในบรรทัดจากเซสชัน Claude หลักเดียว ผู้ปกครองตัดสินใจว่าเมื่อใดที่จะเรียก subagent, subagent ทำงานในหน้าต่างบริบทที่แยกออกมา ส่งผลลัพธ์กลับมา และผู้ปกครองยังคงดำเนินต่อไป AgentsRoom Teams อยู่ในระดับที่สูงกว่า: โหนดแต่ละตัวคือเซสชัน Claude Code ระดับสูงสุดที่มีเทอร์มินัลของตัวเอง สถานะของตัวเอง และการเลื่อนกลับของตัวเอง คุณเห็นเอเจนต์แต่ละคนทำงานสดในแท็บของตัวเอง คุณสามารถพูดคุยกับพวกเขาได้ทุกเมื่อ คุณสามารถหยุดทีม เปลี่ยนกระบวนการทำงานและดำเนินการต่อ มันไม่ใช่การทดแทนสำหรับ Claude subagents คุณสามารถใช้ทั้งสองอย่างได้อย่างแน่นอน โหนดทีมสามารถใช้ subagents ภายในได้

นี่ทำงานเฉพาะกับ Claude Code หรือไม่?

มันทำงานกับ CLI ของเอเจนต์ทั้ง 14 ตัวที่ AgentsRoom รองรับ (Claude Code, Codex CLI, GitHub Copilot CLI, Cursor และอีก 10 ตัว) โหนดทีมแต่ละตัวเลือกผู้ให้บริการและโมเดลของตนเอง เครื่องมือการประสานงานของทีมที่ใช้ MCP ทำงานเหมือนกันกับผู้ให้บริการทั้งหมดเพราะถูกเปิดเผยผ่าน Model Context Protocol มาตรฐาน คุณสามารถเรียกใช้ทีมด้วย Codex บนโหนดแบ็กเอนด์ที่หนักและ Haiku บนโหนด QA หากนั่นคือสิ่งที่เหมาะกับงบประมาณและความหน่วงของคุณ

payload การส่งต่อคืออะไร?

วัตถุที่มีโครงสร้างซึ่งเดินทางจากเอเจนต์หนึ่งไปยังอีกเอเจนต์หนึ่ง ฟิลด์: featureSummary (คำอธิบายสั้น ๆ ของสิ่งที่เพิ่งจัดส่ง), changedFiles (git diff name-status), touchedAreas (UI, API, DB, config), risks (สิ่งใดก็ตามที่เอเจนต์ถัดไปควรเป็นห่วง), testHints (ลำดับความสำคัญสำหรับ QA), flags (บูลีนเช่น qaPassed, ใช้โดยขอบเขตเงื่อนไข) เอเจนต์เรียก team_complete_step ด้วย payload นี้ ผู้รันจะตรวจสอบความถูกต้องที่ฝั่งเซิร์ฟเวอร์ เอเจนต์ถัดไปจะได้รับเป็นบริบทเริ่มต้น

เอเจนต์สามารถย้อนกลับไปกลับมาได้จริงหรือไม่ (Dev ไป QA ไป Dev)?

ใช่ เมื่อมีการเข้าใหม่ในโหนด (รอบมากกว่า 1) AgentsRoom จะไม่สร้างเอเจนต์ใหม่ มันจะนำเอเจนต์เดิมของรอบ 1 กลับมาใช้ เขียน payload การส่งต่อใหม่โดยตรงลงในเทอร์มินัลที่มีอยู่ และเอเจนต์จะเก็บความจำเซสชัน Claude เต็มรูปแบบจากรอบก่อนหน้านี้ นี่เป็นสิ่งสำคัญ: เอเจนต์ Dev ที่รู้ว่า QA ชี้ให้เห็นอะไรในครั้งก่อนจะแก้ไขข้อผิดพลาด เอเจนต์ Dev ใหม่ที่ไม่มีความจำจะทำผิดซ้ำอีก

จะเกิดอะไรขึ้นถ้า QA ปฏิเสธ Dev ตลอดไป?

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

เอเจนต์ทีมทั้งหมดแชร์พื้นที่ทำงาน git เดียวกันหรือไม่?

ใช่ ทีมทำงานในพื้นที่ทำงานเดียวและสาขาเดียว (หรือ worktree หากคุณใช้ฟีเจอร์ AgentsRoom Worktrees) เอเจนต์แต่ละคนเห็นผลงานของเอเจนต์ก่อนหน้าผ่าน git payload การส่งต่อรวมถึง git diff เทียบกับฐานการทำงานเพื่อให้เอเจนต์ถัดไปทราบว่ามีอะไรใหม่

นี่ต้องการการสมัครสมาชิกเพิ่มเติมหรือไม่?

ไม่ ทีมเป็นส่วนหนึ่งของ AgentsRoom คุณนำกุญแจผู้ให้บริการของคุณเอง (Claude, Codex, GitHub Copilot CLI, Cursor และ CLI ของเอเจนต์อีก 10 ตัว) และคุณจ่ายเฉพาะสำหรับโทเค็นที่คุณใช้ เช่นเดียวกับเอเจนต์เดียว การเรียกใช้ทีม Dev ไปยัง QA บนตั๋วขนาดเล็กมักมีค่าใช้จ่ายเท่ากับการเรียกใช้เอเจนต์ Fullstack เดียว เพราะ Haiku/Sonnet ในขั้นตอน QA มีค่าใช้จ่ายต่ำ

ทีมถูกเก็บไว้ที่ไหน? พวกเขาถูกบันทึกใน git หรือไม่?

ทีมที่มีขอบเขตโครงการจะอยู่กับห้องซิงค์กับบัญชีของคุณและแคชใน {project}/.agentsroom/teams-cache.json (gitignored) ทีมระดับโลกก็ซิงค์กับบัญชีของคุณเช่นกัน ดังนั้นห้องสมุดทีมของคุณจึงติดตามคุณข้ามเครื่องด้วย ~/.agentsroom/teams/ เป็นแคชออฟไลน์ เทมเพลตที่ถูกเพาะปลูกจะอยู่ในเครื่อง: เครื่องแต่ละเครื่องจะเพาะปลูกในภาษาของตนเอง

จะเกิดอะไรขึ้นถ้าเอเจนต์ล้มเหลวหรือแอปเริ่มใหม่ระหว่างการทำงาน?

สถานะการทำงานจะถูกเก็บรักษาไว้ในดิสก์ใน {workspace}/.agentsroom/team-runs/{runId}/ (state.json, NOTES.md, inbox/, timeline.jsonl) โดยมีการเขียนแบบอะตอมิกและไฟล์บันทึกที่เพิ่มเท่านั้น การทำงานที่ถูกขัดจังหวะจะดำเนินการต่อเมื่อแอปเริ่มใหม่: orchestrator จะกลับเข้าสู่ขั้นตอนที่ทำงานอยู่ เปิดเทอร์มินัลใหม่ และเอเจนต์จะได้รับบริบทกลับจากบันทึกและเครื่องมือทีม การทำงานที่การกำหนดทีมถูกลบจะถูกปิดโดยอัตโนมัติแทนที่จะค้างอยู่ตลอดไป

ฉันสามารถเรียกใช้หลายทีมพร้อมกันในตั๋วที่แตกต่างกันได้หรือไม่?

ใช่ การทำงานของแต่ละทีมจะแยกจากกันและระบุด้วย runId ของมัน คุณสามารถมีทีมที่แตกต่างกันสามทีมทำงานอยู่บนตั๋วสามใบในโครงการเดียว ภายในการทำงานเดียว การดำเนินการจะตามกราฟของคุณ: ตามลำดับตามค่าเริ่มต้น ขนานเมื่อคุณวาดสาขาขนาน (เช่น QA และความปลอดภัยตรวจสอบพร้อมกัน) และจะรวมกลับไปที่โหนดการเข้าร่วมที่กำหนดไว้เสมอ

เอเจนต์สองตัวสามารถทำงานพร้อมกันได้จริงหรือไม่?

ใช่ วาดขอบเขตที่ไม่มีเงื่อนไขสองขอบออกจากโหนดและเป้าหมายทั้งสองจะทำงานเป็นสาขาขนานแต่ละตัวในเอเจนต์และเทอร์มินัลของตนเอง สาขาจะลึกหนึ่งโหนดและต้องรวมกันที่โหนดการเข้าร่วมทั่วไป ซึ่งผู้แก้ไขจะตรวจสอบก่อนที่คุณจะสามารถทำงานได้ เมื่อสาขาทุกสาขาเสร็จสิ้น การเข้าร่วมจะได้รับ payload ที่รวมกัน: สรุปที่ติดป้ายโดยบทบาท ความเสี่ยงที่ไม่ซ้ำกันและคำแนะนำการทดสอบ และธงที่รวมกันด้วยกฎความปลอดภัย (ความขัดแย้งบูลีนจะถูกแก้ไขเป็น false)

ประตูคุณภาพทำงานอย่างไร?

คุณพิมพ์คำสั่งเชลล์บนโหนด เช่น npm test และอาจเลือกชื่อธง (checkPassed โดยค่าเริ่มต้น) เมื่อเอเจนต์ส่งสัญญาณเสร็จสิ้น AgentsRoom จะรันคำสั่งในพื้นที่ทำงานโดยมีเวลาจำกัดห้านาที รหัสออก 0 จะเขียน true ลงในธง ข้อความอื่นใดจะเขียน false ซึ่งจะเขียนทับสิ่งที่เอเจนต์รายงานเกี่ยวกับตัวเอง ในกรณีที่ล้มเหลว ข้อมูลขนาดกิโลไบต์สุดท้ายจะถูกส่งไปยังเอเจนต์ถัดไปเพื่อให้การวนกลับมีสแต็กแทรซที่แท้จริง และผลลัพธ์จะแสดงในไทม์ไลน์การรัน.

ขั้นตอนสามารถโหลดขั้นตอนใน Skills Library ของฉันได้หรือไม่?

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

AgentsRoom ตรวจกราฟทีมของฉันก่อนรันหรือไม่?

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

เอเจนต์สามารถแก้ไขทีมที่มันกำลังทำงานอยู่ได้หรือไม่?

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

ฉันเริ่มและติดตามการรันทีมจากโทรศัพท์ได้หรือไม่?

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

ควรเลือกโหมดผลัดหรือโหมดทีม?

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

ในโหมดทีม เอเจนต์ทั้งหมดเริ่มพร้อมกันหรือไม่?

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

เพื่อนร่วมทีมจำได้ไหมว่าคนอื่นทำอะไรไปบ้าง?

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

ฉันห้ามไม่ให้เอเจนต์ส่งข้อความหากันตามลำดับไหนก็ได้ ได้หรือไม่?

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

การรันทีมเริ่มเองได้ไหม ทั้งตามกำหนดเวลาหรือเมื่อ webhook ทำงาน?

ได้ ทริกเกอร์ชี้ไปที่ทีมแทนเอเจนต์ตัวเดียวได้ ไปป์ไลน์เดิมจึงทำงานโดยไม่ต้องมีคนเฝ้า ไม่ว่าจะตามจังหวะปฏิทิน ตามช่วงโควตาการใช้งานของแพ็กเกจ AI ของคุณ หรือตามเหตุการณ์ที่ GitHub, GitLab, Slack, Linear, Sentry หรือ CI ของคุณส่งมา พรอมต์จะไปถึงขั้นตอนแรกของทีม การรันเกิดขึ้นบนเครื่องของคุณเองเหมือนการรันอื่น ๆ มันจะไปลงในประวัติของทริกเกอร์ และการแจ้งเตือนจะบอกคุณว่ามันเริ่มแล้ว ทริกเกอร์อยู่ในแผงทริกเกอร์ของโปรเจกต์ เคียงข้างกับงานที่กำหนดเวลา

เจาะลึกเพิ่มเติม

สร้างทีมพัฒนา AI ในฝันของคุณ

แอปมีเทมเพลตสี่แบบ เปิด AgentsRoom วางโหนด วาดขอบ รันในตั๋วใดก็ได้ ทีมวิศวกรรม AI ของคุณอยู่แค่คลิกเดียว

ฟรีดาวน์โหลด AgentsRoom

แอปคู่หู: ตรวจสอบเอเจนต์ของคุณได้ทุกที่

นำของคุณเอง: Claude, Codex, Antigravity CLI, หรือผู้ให้บริการ AI อื่น ๆ

รับส่วนขยาย
Chrome Web Store

ส่งข้อบกพร่องและคำขอไปยังแบ็คล็อกสาธารณะของคุณโดยตรง

มองเห็น AgentsRoom ในการทำงาน

หลายโปรเจกต์
ผู้ให้บริการหลายราย
หลาย agents
สถานะสด
ไฟล์ diff & commit
คู่หูมือถือ
ตัวอย่างสด
ทีมเอเจนต์
การทำงานอัตโนมัติในเบราว์เซอร์
การพัฒนาที่ขับเคลื่อนด้วย backlog
ห้องสมุดคำสั่ง
ห้องสมุดทักษะ
ดูฟีเจอร์ทั้งหมด