Agent Teams.
एक असली tech crew, scripted।
AgentsRoom Teams आपके AI coding agents को एक असली engineering team की तरह चेन करता है। एक Fullstack Dev feature ship करता है, एक QA Engineer उसे validate करता है, एक PM उसे sign-off देता है। हर role scripted है, workflow visual है, और हर handoff feature summary, diff, risks और test hints लेकर चलता है। अब कोई एक agent सब कुछ बुरी तरह नहीं करेगा।
अपनी dream AI dev team को एक visual canvas पर बनाएँ, ठीक n8n workflow की तरह। Conditional edges, feedback loops, retries, max-cycles guard। एक बार save करें, हर ticket पर run करें, और देखें कि आपके agents seniors की तरह बैटन पास करते हैं।
AgentsRoom Teams: visual multi-agent workflow editor, Claude Code agents के बीच automatic handoff, Dev to QA feedback loop, MCP-based inter-agent communication।
Agent Teams AI coding agents के बारे में एक कड़वी सच्चाई का AgentsRoom का जवाब है: एक अकेला agent जो सब कुछ करने की कोशिश करता है, अंत में सब कुछ बुरी तरह करता है। Fullstack agent जो एक साथ code करता है, test करता है, review करता है, deploy करता है और spec लिखता है, बीच में आधे instructions भूल जाता है। सही जवाब, जो दुनिया की हर serious software team इस्तेमाल करती है, वह है काम को roles में बाँटना। एक developer code करता है। एक QA engineer validate करता है। एक product manager sign-off देता है। एक security reviewer audit करता है। हर role का अपना context, अपना focus, अपना tooling होता है।
यही चीज़ Agent Teams AgentsRoom में लाता है। आप एक infinite canvas पर nodes drop करते हैं (React Flow पर बना है, वही engine जो n8n, Make, Retool और Pipedream चलाता है), हर node एक Claude Code, Codex, OpenCode, Gemini CLI या Aider agent है जिसे एक specific role assigned किया गया है, और आप उन्हें wire करते हैं। Team को अपने backlog के एक ticket पर run करें, या किसी भी नए agent spawn पर attach करें। AgentsRoom chain को orchestrate करता है: पहला agent spawn करें, handoff का इंतज़ार करें, काम को summarize करें, अगले agent को उस summary को inbound context के तौर पर देकर spawn करें, end node तक repeat करें।
दूसरे tools यह एक super-agent और clever prompts से करने की कोशिश करते हैं। हमने वह try किया, यह तीन steps के बाद काम नहीं करता। Roles drift करते हैं, context खो जाता है, agent भूल जाता है उसे क्या verify करना था। Agent Teams agents को असली teammates की तरह treat करता है: हर एक को एक clean session, एक focused system prompt, एक structured handoff payload, और दूसरों से बात करने के लिए एक shared scratchpad मिलता है। यह वही AI engineering team workflow है जो आप वाकई चाहते हैं।
AgentsRoom Teams editor: हर role के लिए node drop करें, उन्हें wire करें, conditions जोड़ें, team save करें, किसी भी ticket पर run करें।
Multi-agent orchestration जो वाकई scale करता है
Canvas पर हर node एक agent है। आप उसका role चुनते हैं (Fullstack, Frontend, Backend, QA, Security, DevOps, PM, Architect, Mobile, Marketing, Git, SEO, Localization, या कोई भी custom role जो आपने बनाया है), उसका model (Opus, Sonnet, Haiku, GPT-5, o3, Gemini Pro, आदि), उसका handoff mode (Stop hook के ज़रिए auto, या button के ज़रिए manual) और step-specific instructions की कुछ lines। बस यही। कोई prompt engineering ceremony नहीं, कोई YAML config file लिखनी नहीं।
Edges nodes को जोड़ते हैं। एक simple edge का मतलब: जब पहला agent अपना step finish करे, तो अगले को handoff करें। Conditional edge एक flag check लेकर चलता है, उदाहरण के लिए qaPassed equals true। QA agent वह flag अपने handoff payload में set करता है, runner matching edge चुनता है। इसी तरह आप feedback loops बनाते हैं: QA finish करता है, qaPassed equals false, edge वापस Dev को test hints और risks के साथ भेजता है। Dev fix करता है, फिर handoff करता है। QA pass होने तक या max-cycles guard आने तक loop चलता है।
Inter-agent communication design से ही robust है। AgentsRoom एक dedicated MCP server (agentsroom-team) ship करता है जो run में हर agent को tools का एक set देता है: team context पढ़ें, shared NOTES.md scratchpad पढ़ें, teammates के लिए note post करें, किसी और role को सवाल भेजें, inbox पढ़ें, timeline पढ़ें, run baseline के against git diff पढ़ें, और step को structured payload के साथ complete करें। ये tools हर turn पर Claude session में फिर से inject किए जाते हैं, इसलिए ये context compaction से बच जाते हैं। /compact या /clear के बाद भी, agent को अभी भी अपने team tools दिखते हैं।
इसके अलावा, एक UserPromptSubmit hook हर user message से पहले agent को teammates से किसी भी नए notes की याद दिलाता है। Workspace में एक NOTES.md file append-only है और crashes, restarts और Mac reboots से बच जाती है। एक handoff payload schema server-side validated है जो agents को empty या junk payloads handoff करने से रोकता है। यह वह हिस्सा है जिसे ज़्यादातर multi-agent demos चुपचाप skip करते हैं, और इसी वजह से उनमें से ज़्यादातर cycle 3 पर बिखर जाते हैं।
AI engineering crew चलाने के लिए जो भी चाहिए
Visual workflow, असली handoff, असली feedback loops, असली inter-agent communication। ऐसा बना है कि आप पचास के बजाय एक Slack ping में feature ship कर सकें।
Visual workflow canvas
React Flow द्वारा संचालित infinite zoomable canvas, वही engine जो n8n, Retool, Pipedream और Make के पीछे है। Nodes drop करें, उन्हें connect करें, team save करें। कोई code नहीं, कोई YAML नहीं।
14 built-in agent roles
Fullstack, Frontend, Backend, DevOps, QA, Security, PM, Architect, Mobile, Marketing, Git Expert, SEO, i18n। साथ ही कोई भी custom role जो आपने अपने project पर पहले से save किया है।
हर node के लिए model और prompt
हर node अपना provider, अपना model और अपनी step instructions चुनता है। Architect के लिए Opus, QA के लिए Haiku, heavy backend के लिए Codex, सस्ते frontend के लिए Gemini इस्तेमाल करें। मिलाएँ और match करें।
Automatic handoff
जब कोई agent team_complete_step call करता है, AgentsRoom handoff payload बनाता है (feature summary, changed files, risks, test hints, flags) और अगले node को उस payload के साथ starting context के तौर पर spawn करता है।
Manual handoff option
हर step validate करना पसंद करते हैं? Node को manual mode पर switch करें। Agent इंतज़ार करता है, आप 'Hand off' पर click करते हैं जब आप result से खुश हों। दोनों दुनियाओं का सबसे अच्छा।
Conditional edges
हर edge एक flag check ले सकता है (जैसे qaPassed equals true)। Branches बनाएँ: अगर QA pass हो तो PM पर जाएँ, वरना Dev पर loop back करें। असली workflow logic, कोई scripting नहीं।
Feedback loops
Dev to QA to Dev to QA। जब QA ticket वापस भेजता है, original Dev agent पिछले cycle की पूरी memory के साथ reuse होता है, इसलिए वह scratch से शुरू करने के बजाय regression को सच में fix करता है।
Max-cycles guard
Configurable cap (default 3)। QA-rejects-Dev infinite loops से बचाता है। जब cap पहुँच जाता है, run awaiting-finalization पर pause हो जाता है और आप तय करते हैं क्या करना है।
Shared NOTES.md scratchpad
Run में हर agent workspace में एक markdown file पढ़ता और लिखता है। Compaction, crash, restart से बच जाता है। Team की reasoning के लिए single source of truth।
Role-to-role inbox
QA को mid-run में Architect से सवाल पूछना है? team_ask role के inbox में message post करता है। उस role का अगला agent उसे पढ़ता है और reply करता है। Agents के बीच असली chat।
MCP-based inter-agent comm
सारे team tools MCP server के ज़रिए expose होते हैं। Tools Claude context compaction से बच जाते हैं (Anthropic उन्हें हर turn पर फिर से भेजता है)। /clear, /compact और long loops के लिए resilient।
Haiku-powered handoff summary
अगर agent अपना feature summary नहीं लिखता, एक छोटा Haiku call git diff से एक बना देता है। सस्ता, तेज़, और अगला agent हमेशा context के साथ land करता है।
Browser MCP propagation
verifyInBrowser के साथ एक team node अपने agent को automatic browser-access mode पर switch करता है। QA node पूरे browser tools (navigate, click, type, screenshot, get logs) के साथ land करता है।
हर run के लिए ephemeral agents
हर team run fresh agents spawn करता है और dismiss पर उन्हें destroy करता है। आपके project की agent list साफ रहती है। Team workflow है, agents runtime हैं।
Global और project teams
Reusable teams अपनी global library (~/.agentsroom/teams) में save करें या specific project पर pin करें (room के साथ committed)। Same editor, different scope।
Team templates शामिल
App के साथ तीन seed templates आते हैं: Dev to QA, feedback loop के साथ Dev to QA, और Dev to Security to QA। Duplicate, edit, run। 30 seconds में शुरू करें।
Run timeline UI
हर handoff run timeline में एक card के रूप में दिखता है: कौन सा role अभी finish हुआ, summary क्या कहता है, कौन सी files बदलीं, कौन से flags set हुए। Auditable, replayable।
किसी भी backlog ticket पर run करें
एक team पर ticket drop करें और chain उस ticket पर शुरू हो जाती है। पहला agent ticket title और body पढ़ता है, बाकी team वहाँ से उठाती है।
14 specialized roles, wire होने के लिए तैयार
हर role का अपना system prompt, focus areas और example tasks है। Canvas पर मिलाएँ और match करें। कभी भी अपने custom roles जोड़ें।
क्यों एक असली team एक super-agent से बेहतर है
Multi-agent orchestration buzzword जैसा लगता है। यहाँ practical फर्क है, उस feature पर जिसे आप वाकई ship करेंगे।
Scenario: एक e-commerce site पर Stripe checkout flow जोड़ना
Solo super-agent
- • Ticket पढ़ता है। API, React form, webhook, migration, tests में 600 lines लिखता है।
- • Webhook पर idempotency key भूल जाता है। Failure path test करना भूल जाता है। Staging env var भूल जाता है।
- • 'Done' कहता है। आप production में bugs ढूँढते हुए दो घंटे बिताते हैं।
Agent Team (Dev to Security to QA)
- • Fullstack agent implementation ship करता है, commit करता है, summary और auth change को flag करती risks list के साथ handoff करता है।
- • Security agent diff पढ़ता है, webhook signature check audit करता है, handoff payload में QA के लिए test hints लिखता है।
- • QA agent embedded browser में test hints run करता है, idempotency bug मिलता है, qaPassed equals false set करता है, exact reproduction के साथ ticket Dev को वापस भेजता है।
- • Dev fix करता है, फिर handoff करता है। QA pass होता है। PM finalize करता है। Run done पर जाता है।
वही ticket, वही models, वही project। काम का अलग shape। Team approach वह पकड़ता है जो solo agent miss करता है, क्योंकि हर role के पास focused brief और structured handoff है।
Team run कैसे काम करता है
Teams tab खोलें
अपने project view में, Teams tab तीन seed templates list करता है (Dev to QA, feedback loop के साथ Dev to QA, Dev to Security to QA) साथ ही कोई भी team जो आपने पहले से save की है। एक template duplicate करें या 'New team' पर click करें।
Canvas पर workflow बनाएँ
React Flow canvas पर agent nodes drop करें। हर node के लिए, role चुनें (Fullstack, QA, Security, PM, आदि), provider, model, और step instructions की कुछ lines। उन्हें edges से wire करें। अगर branching चाहिए तो edges पर conditions जोड़ें।
Dev → QA → PMहर node पर handoff mode set करें
Auto handoff: agent अपना काम पूरा होने पर team_complete_step call करता है, runner take over करता है। Manual handoff: agent आपके 'Hand off' click का इंतज़ार करता है। ज़रूरत के हिसाब से दोनों मिलाएँ।
Team run करें
एक backlog ticket से, 'Run with team' पर click करें। एक खाली agent slot से, 'Create as team' पर click करें। पहला node project workspace में एक ephemeral agent के रूप में spawn होता है।
Handoff होते देखें
जब agent N finish करता है, AgentsRoom handoff payload बनाता है (agent या Haiku के ज़रिए feature summary, git diff, risks, test hints, flags), NOTES.md पर note append करता है, flags के आधार पर सही outgoing edge चुनता है, और agent N+1 को उस payload के साथ inbound context के रूप में spawn करता है।
Loop, end, finalize
Feedback loops original agent में फिर से enter करते हैं (पूरी memory preserved)। End node awaiting-finalization trigger करता है। आप 'Finish run' पर click करते हैं। Banner dismiss करें ताकि agents destroy हो जाएँ और PTYs free हो जाएँ।
Inter-agent communication जो किसी भी चीज़ से बच जाता है
वह detail जिसे ज़्यादातर multi-agent demos skip करते हैं। यहाँ है क्या Agent Teams को long runs और बहुत सारे cycles पर hold करता है।
Claude Code agents के पास एक context window है और वे उसे compact करते हैं। Multi-agent systems की classic गलती है team coordination को सिर्फ system prompt में डालना। /compact के दो cycles के बाद, agent को कोई idea नहीं होता कि वह team में है। AgentsRoom वह नहीं करता।
सारी team coordination तीन जगहों पर रहती है जो compaction से बचती हैं। पहला, एक MCP server (agentsroom-team) tools expose करता है (team_get_context, team_read_notes, team_post_note, team_read_inbox, team_ask, team_read_timeline, team_read_diff, team_complete_step)। MCP tools हर turn पर CLI द्वारा Claude को फिर से भेजे जाते हैं, इसलिए वे context compression से immune हैं।
दूसरा, एक UserPromptSubmit hook हर user message से पहले run होता है और अगर उस role के लिए कोई नए notes या नए inbox messages हैं तो एक छोटा reminder prepend करता है। कुछ नहीं होता तो सस्ता, होता है तो decisive।
तीसरा, NOTES.md और state.json workspace में disk पर रहते हैं। Agent किसी भी moment पर एक simple Read से या team_read_notes से उन्हें फिर से पढ़ सकता है। वे crashes, restarts, /clear, /compact और Mac reboots से बचते हैं। System prompt कभी source of truth नहीं है, disk और MCP tools हैं।
लोग Agent Teams से क्या बनाते हैं
Dev to QA pipeline
Classic। Fullstack feature ship करता है। QA embedded browser में validate करता है, test hints run करता है, sign-off करता है। दो-node team, backlog के हर ticket पर run करता है।
Feedback loop के साथ Dev to QA
ऊपर वाला, लेकिन conditional edge के साथ: qaPassed equals false ticket को test hints के साथ Dev को वापस भेजता है। Max 3 cycles। Regressions को human reviewer तक पहुँचने से पहले पकड़ता है।
Dev to Security to QA
उन features के लिए जो auth, payments या PII को छूते हैं। Security agent diff review करता है, risks flag करता है, QA के लिए test hints लिखता है। Fintech, healthtech और B2B SaaS ship करने वाली teams द्वारा इस्तेमाल।
PM to Architect to Dev
Spec-first workflow। PM agent ticket को structured spec में बदलता है। Architect approach चुनता है। Dev implement करता है। तीन roles, clean separation, traceable decisions।
Frontend, Backend, DevOps fan-out
Full-stack features के लिए sequential split। Frontend UI ship करता है। Backend API ship करता है। DevOps infra config जोड़ता है। हर role अपने area में काम करता है, clean diff के साथ handoff करता है।
Marketing to SEO to i18n
हाँ, AgentsRoom Teams सिर्फ code के लिए नहीं है। Marketing landing copy लिखता है। SEO keywords inject करता है। Localization 14 languages में translate करता है। एक team, एक ticket, एक ship।
यह दूसरे multi-agent approaches से कैसे compare करता है
Multi-agent orchestration एक crowded buzzword है। यहाँ है actually क्या ship हो रहा है, और AgentsRoom Teams कहाँ fit होता है।
Anthropic Subagents (Task tool, .claude/agents) एक single Claude session को specialized helper agents को delegate करने देते हैं। Inline delegation के लिए बढ़िया, लेकिन parent session अभी भी coordinator है और एक single context है। AgentsRoom Teams एक level ऊपर है: हर team node एक अलग top-level Claude session है अपनी window, अपनी state, अपने scrollback के साथ। CrewAI, AutoGen और LangGraph multi-agent flows के लिए excellent Python frameworks हैं, लेकिन वे आपके IDE के बाहर रहते हैं और वे आपके local repo पर real Claude Code, Codex या Gemini CLIs को end-to-end run नहीं करते। n8n, Make, Pipedream और Retool वही canvas editor ship करते हैं जो हम इस्तेमाल करते हैं, लेकिन वे general-purpose automation platforms हैं, AI coding agents के लिए नहीं बने। AgentsRoom Teams canvas-style multi-agent workflow editor है, लेकिन specifically आपके CLI agents, आपके project, आपके git, आपके terminals और आपके browser से wired है।
अगर आप Python में agentic systems बनाते हैं, production pipelines के लिए CrewAI या LangGraph इस्तेमाल करते रहें। अगर आप Claude Code, Codex CLI, OpenCode, Gemini CLI या Aider के साथ code ship करते हैं, Agent Teams वह team workflow है जो वहीं run होता है जहाँ आप वाकई code करते हैं।
FAQ
यह Claude Code subagents (Task tool, .claude/agents) से कैसे अलग है?
Claude subagents एक single parent Claude session से inline delegations हैं। Parent तय करता है कि subagent को कब call करना है, subagent एक isolated context window में run होता है, एक result return करता है, और parent चलता रहता है। AgentsRoom Teams एक level ऊपर है: हर node एक top-level Claude Code session है अपने terminal, अपनी state और अपने scrollback के साथ। आप हर agent को अपने tab में live देखते हैं, किसी भी moment किसी से भी बात कर सकते हैं, team को pause कर सकते हैं, workflow बदल सकते हैं और resume कर सकते हैं। यह Claude subagents का replacement नहीं है, आप दोनों bilkul इस्तेमाल कर सकते हैं। एक team node internally subagents इस्तेमाल कर सकता है।
क्या यह सिर्फ Claude Code के साथ काम करता है?
यह हर AgentsRoom-supported provider (Claude Code, Codex CLI, OpenCode, Gemini CLI, Aider) के साथ काम करता है। हर team node अपना provider और model चुनता है। MCP-based team coordination tools providers में identically काम करते हैं क्योंकि वे standard Model Context Protocol के ज़रिए expose होते हैं। आप एक team चला सकते हैं heavy backend node पर Codex के साथ और QA node पर Haiku, अगर वह आपके budget और latency के लिए fit है।
Handoff payload क्या है?
एक structured object जो एक agent से अगले तक travel करता है। Fields: featureSummary (अभी ship हुई चीज़ का छोटा description), changedFiles (git diff name-status), touchedAreas (UI, API, DB, config), risks (कुछ भी जिसकी अगले agent को चिंता करनी चाहिए), testHints (QA के लिए priorities), flags (qaPassed जैसे booleans, conditional edges द्वारा इस्तेमाल)। Agent इस payload के साथ team_complete_step call करता है, runner server-side validate करता है, अगला agent इसे starting context के तौर पर receive करता है।
क्या agents वाकई आगे-पीछे जा सकते हैं (Dev to QA to Dev)?
हाँ। जब एक node को re-enter किया जाता है (cycle 1 से ज़्यादा), AgentsRoom नया agent spawn नहीं करता। यह cycle 1 के original agent को reuse करता है, नया handoff payload सीधे उसके existing terminal में लिखता है, और agent पिछले cycles की पूरी Claude session memory रखता है। यह critical है: एक Dev agent जिसे पहले से पता है कि QA ने पिछली बार क्या flag किया था, bug fix करता है। Memory के बिना एक fresh Dev agent वही गलती दोहराएगा।
क्या होता है अगर QA हमेशा Dev को reject करता रहे?
Team config में max-cycles guard है, default 3। जब cap पहुँच जाता है, run 'blocked' status के साथ pause होता है और आपका इंतज़ार करता है। आप run finalize कर सकते हैं, manually एक बार और handoff कर सकते हैं, या सब cancel कर सकते हैं। कोई infinite loops नहीं, कोई surprise overnight bills नहीं।
क्या सारे team agents एक ही git workspace share करते हैं?
हाँ। Team एक single workspace और एक single branch में run होता है (या worktree अगर आप AgentsRoom Worktrees feature इस्तेमाल करते हैं)। हर agent पिछले वाले का काम git के ज़रिए देखता है। Handoff payload में run baseline के against git diff शामिल है ताकि अगला agent exactly जान सके क्या नया है।
क्या इसके लिए extra subscription चाहिए?
नहीं। Teams AgentsRoom का हिस्सा हैं। आप अपनी provider keys लाते हैं (Claude, Codex, OpenCode, Gemini, Aider) और सिर्फ उन tokens का pay करते हैं जो आप इस्तेमाल करते हैं, single agent की तरह। एक छोटे ticket पर Dev to QA team चलाना typically वही cost करता है जो single Fullstack agent चलाना, क्योंकि QA step पर Haiku/Sonnet सस्ता है।
Teams कहाँ store होती हैं? क्या वे git में commit होती हैं?
Project-scoped teams room के साथ रहती हैं, cloud में synced होती हैं और {project}/.agentsroom/teams-cache.json (gitignored) में cached होती हैं। Global teams आपकी machine पर ~/.agentsroom/teams/{teamId}.json में रहती हैं, हर team के लिए एक file। आप तय करते हैं कौन सा scope किस workflow के लिए fit है।
अगर agent crash कर जाए या app mid-run restart हो जाए तो क्या?
Run state {workspace}/.agentsroom/team-runs/{runId}/ (state.json, NOTES.md, inbox/, timeline.jsonl) में disk पर persist होता है। NOTES.md append-only है, हर state write atomic है। Agents किसी भी समय team_read_notes या team_get_context से सब कुछ फिर से पढ़ सकते हैं। App restart पर interrupted run को पूरी तरह replay करने के लिए orchestration layer को harden किया जा रहा है, लेकिन on-disk story पहले से crash-safe है।
क्या मैं अलग-अलग tickets पर कई teams parallel में run कर सकता हूँ?
हाँ। हर team run independent है और अपने runId से identified है। आप ticket A पर एक Dev to QA team run कर सकते हैं, ticket B पर Dev to Security to QA team और ticket C पर PM to Architect to Dev team, सब same project में live। एक single run के अंदर, predictability के लिए execution sequential है (एक समय पर एक active node)।
अपनी dream AI dev team बनाएँ
App के साथ तीन templates आते हैं। AgentsRoom खोलें, nodes drop करें, edges draw करें, किसी भी ticket पर run करें। आपकी AI engineering crew एक click दूर है।
कंपेनियन ऐप: चलते-फिरते अपने एजेंट्स मॉनिटर करें
Claude, Codex, OpenCode, Gemini CLI और Aider के साथ काम करता है
बग और अनुरोध सीधे अपने सार्वजनिक बैकलॉग में भेजें।