Agent Teams.
Uma verdadeira equipa tech, com script.
AgentsRoom Teams encadeia os teus agentes IA de código como uma verdadeira equipa de engenharia. Um Fullstack Dev entrega a feature, um QA Engineer valida-a, um PM assina. Cada papel tem script, o workflow é visual, e cada handoff transporta o resumo da feature, o diff, os riscos e as pistas de teste. Acabou-se o agente único que faz tudo mal.
Monte seu time de desenvolvimento IA ideal em um canvas visual, como um workflow do n8n. Ligacoes condicionais, loops de feedback, ramos de revisao paralelos, portoes de qualidade verificados pela maquina, teto de ciclos. Salve uma vez, rode em cada ticket e veja seus agentes passarem o bastao como seniors.
AgentsRoom Teams: editor visual de workflow multi-agente, handoff automático entre agentes Claude Code, loop de feedback Dev para QA, comunicação inter-agente via MCP.
Agent Teams é a resposta do AgentsRoom a uma verdade brutal sobre os agentes IA de código: um agente único que tenta fazer tudo acaba a fazer tudo mal. O agente Fullstack que codifica, testa, faz review, faz deploy e escreve a spec ao mesmo tempo esquece metade das suas instruções pelo caminho. A resposta certa, a que toda equipa de software séria do mundo usa, é dividir o trabalho em papéis. Um developer codifica. Um QA engineer valida. Um product manager assina. Um security reviewer audita. Cada papel tem o seu próprio contexto, o seu próprio focus, o seu próprio tooling.
É exatamente isto que o Agent Teams traz ao AgentsRoom. Pões nodes num canvas infinito (baseado em React Flow, o mesmo motor que n8n, Make, Retool e Pipedream), cada node é um agente Claude Code, Codex, OpenCode, Antigravity CLI, Aider, Grok Build, Mistral Vibe ou Kimi Code atribuído a um papel específico, e ligas-os. Lança a equipa num ticket do teu backlog, ou anexa-a a qualquer novo spawn de agente. AgentsRoom orquestra a cadeia: spawn do primeiro agente, espera do handoff, resume do trabalho, spawn do agente seguinte com esse resume como contexto de entrada, repete até a equipa atingir o node final.
Outras ferramentas tentam fazer isto com um super-agente único e prompts engenhosos. Tentámos, não funciona para além de três passos. Os papéis derivam, o contexto perde-se, o agente esquece-se do que tinha de verificar. Agent Teams trata os agentes como verdadeiros companheiros de equipa: cada um recebe uma sessão limpa, um system prompt focado, um payload de handoff estruturado, e um scratchpad partilhado para falar com os outros. Este é o workflow de equipa dev IA que tu queres mesmo.

Editor AgentsRoom Teams: põe nodes para cada papel, liga-os, adiciona condições, guarda a equipa, lança em qualquer ticket.
Orquestração multi-agente que escala a sério
Cada node no canvas é um agente. Escolhes o seu papel (Fullstack, Frontend, Backend, QA, Security, DevOps, PM, Architect, Mobile, Marketing, Git, SEO, Localization, ou qualquer papel custom que tenhas criado), o seu modelo (Opus, Sonnet, Haiku, GPT-5, o3, Antigravity Pro, etc.), o seu modo de handoff (auto via Stop hook, ou manual via botão) e algumas linhas de instruções específicas do passo. É só isso. Sem cerimónia de prompt engineering, sem ficheiro YAML para escrever.
Os edges ligam os nodes. Um edge simples significa: quando o primeiro agente termina o seu passo, passa ao seguinte. Um edge condicional carrega um check de flag, por exemplo qaPassed equals true. O agente QA põe essa flag no seu payload de handoff, o runner escolhe o edge correspondente. É assim que constróis loops de feedback: QA termina, qaPassed equals false, o edge devolve ao Dev com as pistas de teste e os riscos. Dev corrige, faz handoff outra vez. Loop até o QA passar ou até o guard de max-cycles disparar.
A comunicação inter-agente é robusta por design. AgentsRoom inclui um servidor MCP dedicado (agentsroom-team) que dá a cada agente do run um conjunto de tools: ler o contexto da equipa, ler o scratchpad NOTES.md partilhado, postar uma nota para os colegas, enviar uma pergunta a outro papel, ler a inbox, ler a timeline, ler o diff git contra a baseline do run, e completar o passo com um payload estruturado. Estas tools são reinjetadas na sessão Claude em cada turn, por isso sobrevivem à compactação de contexto. Mesmo depois de um /compact ou /clear, o agente continua a ver as suas tools de equipa.
Para além disso, um hook UserPromptSubmit lembra ao agente quaisquer notas novas dos colegas antes de cada mensagem do utilizador. Um ficheiro NOTES.md no workspace é append-only e sobrevive a crashes, reinícios e reboots de Mac. Um schema de payload de handoff validado do lado do servidor impede que os agentes façam handoffs vazios ou de lixo. Esta é a parte que a maioria das demos multi-agente saltam em silêncio, e a razão pela qual a maioria desmorona-se no cycle 3.
Tudo o que precisas para gerir uma equipa de engenharia IA
Workflow visual, handoff real, loops de feedback reais, comunicação inter-agente real. Construído para entregares uma feature num ping de Slack em vez de cinquenta.
Canvas de workflow visual
Canvas zoomável infinito impulsionado por React Flow, o mesmo motor por trás de n8n, Retool, Pipedream e Make. Põe nodes, liga-os, guarda a equipa. Sem código, sem YAML.
14 papéis de agente integrados
Fullstack, Frontend, Backend, DevOps, QA, Security, PM, Architect, Mobile, Marketing, Git Expert, SEO, i18n. Mais qualquer papel custom que já tenhas guardado no teu projeto.
Modelo e prompt por node
Cada node escolhe o seu provider, o seu modelo e as suas instruções de passo. Usa Opus para Architect, Haiku para QA, Codex para o backend pesado, Antigravity para o frontend barato. Mix and match.
Handoff automático
Quando um agente chama team_complete_step, AgentsRoom constrói o payload de handoff (resumo de feature, ficheiros alterados, riscos, pistas de teste, flags) e spawna o node seguinte com esse payload como contexto inicial.
Opção de handoff manual
Preferes validar cada passo? Põe o node em modo manual. O agente espera, tu carregas em 'Hand off' quando estiveres satisfeito com o resultado. O melhor de dois mundos.
Edges condicionais
Cada edge pode carregar um check de flag (por exemplo qaPassed equals true). Constrói branches: se QA passa, vai ao PM, senão volta em loop ao Dev. Lógica de workflow real, sem scripting.
Loops de feedback
Dev para QA para Dev para QA. Quando o QA devolve o ticket, o agente Dev original é reutilizado com memória completa do cycle anterior, por isso corrige a regressão a sério em vez de começar do zero.
Portoes de qualidade verificados pela maquina
Fixe um comando de verificacao em um no (npm test, um lint, um build). O runner o executa quando o agente se declara pronto: codigo de saida 0 poe a flag de roteamento em true, qualquer outro em false. O resultado medido substitui sempre a declaracao do agente.
Ramos de revisao paralelos
Trace duas ligacoes sem condicao a partir de um no e os dois destinos rodam ao mesmo tempo: QA e Seguranca revisam o mesmo diff lado a lado, e um no de juncao funde os relatorios. Um unico ramo vermelho mantem o portao fechado.
Skills fixadas por etapa
Anexe entradas da sua Skills Library a um no. O agente as carrega antes de comecar a etapa: sua checklist de revisao ou seu runbook de deploy e aplicado em toda execucao, nao apenas quando o agente lembra.
Guard de max-cycles
Tecto configurável (3 por defeito). Evita loops infinitos QA-rejeita-Dev. Quando o tecto é atingido, o run pausa em awaiting-finalization e tu decides o que fazer.
Execucoes sobrevivem a reinicios
Feche o app no meio de uma execucao, reabra: a execucao retoma a etapa onde estava. Estado, notas e timeline vivem no disco; o orquestrador retoma o trabalho em vez de deixar um zumbi.
Biblioteca de equipes na sua conta
Equipes globais sao sincronizadas com sua conta e seguem voce de maquina em maquina; equipes de projeto viajam com a room. Ambas mantem cache offline, e edicoes feitas offline sao reproduzidas ao reconectar.
Scratchpad NOTES.md partilhado
Cada agente do run lê e escreve num ficheiro markdown do workspace. Sobrevive à compactação, ao crash, ao reinício. A fonte única de verdade para o raciocínio da equipa.
Inbox papel-a-papel
Precisas que o QA faça uma pergunta ao Architect a meio do run? team_ask posta uma mensagem na inbox do papel. O agente seguinte desse papel lê-a e responde. Chat real entre agentes.
Comm inter-agente via MCP
Todas as tools de equipa são expostas via servidor MCP. As tools sobrevivem à compactação de contexto Claude (Anthropic reenvia-as em cada turn). Resistentes a /clear, /compact e loops longos.
Resumo de handoff alimentado por Haiku
Se um agente não escreve o seu próprio resumo de feature, uma pequena chamada Haiku gera um a partir do diff git. Barato, rápido, e o agente seguinte aterra sempre com contexto.
Propagação Browser MCP
Um node de equipa com verifyInBrowser muda o seu agente para modo browser-access automaticamente. O node QA aterra com todas as tools de browser (navigate, click, type, screenshot, get logs).
Agentes efémeros por run
Cada run de equipa spawna agentes frescos e destrói-os ao dismiss. A tua lista de agentes do projeto mantém-se limpa. A equipa é o workflow, os agentes são o runtime.
Equipas globais e de projeto
Guarda equipas reutilizáveis na tua biblioteca global (~/.agentsroom/teams) ou prende-as a um projeto específico (commitadas com a room). Mesmo editor, scope diferente.
Quatro modelos de equipe inclusos
Construir e verificar, Especificar construir verificar, Caca ao bug (reproduzir, corrigir, provar) e Escudo de release com QA e Seguranca em paralelo. Duplique, edite, rode. Pronto em 30 segundos.
UI da timeline do run
Cada handoff aparece como um cartão na timeline do run: que papel acabou de terminar, o que diz o resumo, que ficheiros mudaram, que flags foram postas. Auditável, replayable.
Lança em qualquer ticket de backlog
Põe um ticket numa equipa e a cadeia arranca nesse ticket. O primeiro agente lê o título e o body do ticket, o resto da equipa pega a partir daí.
14 papéis especializados, prontos a serem ligados
Cada papel tem o seu próprio system prompt, áreas de focus e tarefas exemplo. Mistura-os no canvas. Adiciona os teus próprios papéis custom a qualquer momento.
Porque é que uma verdadeira equipa vence um super-agente
A orquestração multi-agente soa a buzzword. Aqui está a diferença prática, numa feature que entregarias mesmo.
Cenário: adicionar um flow de checkout Stripe a um site de e-commerce
Super-agente solo
- • Lê o ticket. Escreve 600 linhas entre a API, o formulário React, o webhook, a migração e os testes.
- • Esquece a idempotency key no webhook. Esquece de testar o caminho de falha. Esquece a variável de ambiente de staging.
- • Diz 'Done'. Passas duas horas a caçar bugs em produção.
Agent Team (Dev para Security para QA)
- • Agente Fullstack entrega a implementação, commit, faz handoff com um resumo e uma lista de riscos a sinalizar a alteração de auth.
- • Agente Security lê o diff, audita a verificação de assinatura do webhook, escreve pistas de teste para o QA no payload de handoff.
- • Agente QA executa as pistas de teste no navegador integrado, encontra um bug de idempotência, põe qaPassed equals false, devolve o ticket ao Dev com a repro exata.
- • Dev corrige, faz handoff outra vez. QA passa. O PM finaliza. O run vai para done.
Mesmo ticket, mesmos modelos, mesmo projeto. Forma de trabalho diferente. A abordagem de equipa apanha o que o agente solo perde, porque cada papel tem um brief focado e um handoff estruturado.
Confianca se mede, nao se declara
Um agente que corrige a propria prova acaba se aprovando sozinho. O Agent Teams mantem o pipeline honesto com dois mecanismos.
O codigo de saida decide
Qualquer no pode declarar um comando de verificacao: npm test, um lint, um build, qualquer coisa que devolva um codigo de saida. Quando o agente chama team_complete_step, o runner executa o comando no workspace e escreve o resultado medido na flag de roteamento. Verde: a execucao avanca. Vermelho: a saida de erro aterrissa no topo do contexto do proximo agente, com o stderr real. Um agente que afirma que todos os testes passam enquanto a suite esta vermelha e roteado pela suite vermelha, nao pela afirmacao.
Quatro olhos, ao mesmo tempo
Divida um no em ramos paralelos: QA percorre os fluxos enquanto Seguranca audita o diff, cada um em seu proprio agente, cego as conclusoes do outro. Um no de juncao espera todos os ramos, funde resumos, riscos e flags, e roteia sobre o resultado combinado. Conflitos booleanos se resolvem em false por construcao: um unico revisor reprovado basta para segurar a release.
Dev → [ QA ∥ Security ] → Release gateComo funciona um run de equipa
Abre o separador Teams
Na visao do projeto, a aba Teams lista quatro modelos inclusos (Construir e verificar, Especificar construir verificar, Caca ao bug, Escudo de release) mais as equipes que voce ja salvou. Duplique um modelo ou clique em 'New team'.
Constrói o workflow no canvas
Põe nodes de agente no canvas React Flow. Para cada node, escolhe o papel (Fullstack, QA, Security, PM, etc.), o provider, o modelo, e algumas linhas de instruções de passo. Liga-os com edges. Adiciona condições nos edges se precisares de branching.
Dev → QA → PMDefine o modo de handoff por node
Handoff auto: o agente chama team_complete_step quando o seu trabalho está feito, o runner toma conta. Handoff manual: o agente espera que carregues em 'Hand off'. Mistura ambos conforme necessário.
Lança a equipa
A partir de um ticket de backlog, carrega em 'Run with team'. A partir de um slot de agente vazio, carrega em 'Create as team'. O primeiro node spawna como agente efémero no workspace do projeto.
Vê o handoff acontecer
Quando o agente N termina, o AgentsRoom monta o payload de handoff (resumo via agente ou via Haiku, diff do git, riscos, dicas de teste, flags), acrescenta uma nota ao NOTES.md, escolhe a ligacao de saida certa conforme as flags e passa o bastao ao agente N+1 com esse payload como contexto de entrada. Se o no declara um comando de verificacao, o runner o executa primeiro: o codigo de saida medido, nao a afirmacao do agente, define a flag de roteamento.
Loop, fim, finalização
Os loops de feedback re-entram no agente original (memória completa preservada). O node final dispara awaiting-finalization. Carregas em 'Finish run'. Dismiss do banner para destruir os agentes e libertar os PTYs.
Comunicação inter-agente que sobrevive a tudo
O detalhe que a maioria das demos multi-agente saltam. Aqui está o que faz com que o Agent Teams aguente em runs longos e muitos cycles.
Os agentes Claude Code têm uma janela de contexto e compactam-na. O erro clássico dos sistemas multi-agente é pôr a coordenação de equipa só no system prompt. Depois de dois cycles de /compact, o agente não faz ideia de que está numa equipa. AgentsRoom não faz isso.
Toda a coordenação de equipa vive em três sítios que sobrevivem à compactação. Primeiro, um servidor MCP (agentsroom-team) expõe tools (team_get_context, team_read_notes, team_post_note, team_read_inbox, team_ask, team_read_timeline, team_read_diff, team_complete_step). As tools MCP são reenviadas pela CLI ao Claude em cada turn, por isso são imunes à compressão de contexto.
Segundo, um hook UserPromptSubmit corre antes de cada mensagem do utilizador e prepende um pequeno lembrete se houver notas novas ou mensagens novas na inbox desse papel. Barato quando não há nada, decisivo quando há.
Terceiro, NOTES.md e state.json vivem em disco no workspace. O agente pode relê-los a qualquer momento com um Read simples ou com team_read_notes. Sobrevivem a crashes, reinícios, /clear, /compact e reboots de Mac. O system prompt nunca é a fonte de verdade, o disco e as tools MCP são.
O que as pessoas constroem com Agent Teams
Pipeline Dev para QA
O clássico. Fullstack entrega a feature. QA valida-a no navegador integrado, executa as pistas de teste, assina. Equipa de dois nodes, corre em cada ticket do backlog.
Dev para QA com loop de feedback
Como acima, mas com um edge condicional: qaPassed equals false devolve o ticket ao Dev com as pistas de teste. Máx 3 cycles. Apanha regressões antes que cheguem a um reviewer humano.
Dev para Security para QA
Para features que tocam em auth, pagamentos ou PII. Agente Security faz review do diff, sinaliza riscos, escreve pistas de teste para o QA. Usado por equipas que entregam fintech, healthtech e SaaS B2B.
PM para Architect para Dev
Workflow spec-first. O agente PM transforma o ticket numa spec estruturada. O Architect escolhe a abordagem. O Dev implementa. Três papéis, separação limpa, decisões rastreáveis.
Fan-out Frontend, Backend, DevOps
Divisão sequencial para features full-stack. Frontend entrega a UI. Backend entrega a API. DevOps adiciona a config de infra. Cada papel trabalha na sua área, faz handoff com um diff limpo.
Marketing para SEO para i18n
Sim, AgentsRoom Teams não é só para código. Marketing escreve o copy da landing. SEO injeta os keywords. Localization traduz para 14 línguas. Uma equipa, um ticket, um ship.
Escudo de release: QA e Seguranca em paralelo
Um no dev se divide em QA e Seguranca rodando lado a lado, e um portao de release funde os dois relatorios. Vem com o app como modelo. O escudo inteiro volta ao Dev se qualquer ramo reportar um problema.
Caca ao bug: reproduzir antes de corrigir
Um agente QA reproduz o bug e anota os passos exatos. Um dev corrige a causa raiz. Um segundo QA repete os mesmos passos para provar o conserto. Chega de 'na minha maquina funciona'.
Como se compara com outras abordagens multi-agente
A orquestração multi-agente é um buzzword saturado. Aqui está o que entrega mesmo, e onde encaixa o AgentsRoom Teams.
Anthropic Subagents (tool Task, .claude/agents) deixam uma sessão Claude única delegar a agentes helper especializados. Ótimo para delegação inline, mas a sessão pai continua a ser o coordenador e um contexto único. AgentsRoom Teams está um nível acima: cada node de equipa é uma sessão Claude top-level separada com a sua própria janela, o seu próprio estado, o seu próprio scrollback. CrewAI, AutoGen e LangGraph são frameworks Python excelentes para flows multi-agente, mas vivem fora do teu IDE e não correm CLIs reais Claude Code, Codex ou Antigravity end-to-end no teu repo local. n8n, Make, Pipedream e Retool entregam o mesmo tipo de editor canvas que usamos, mas são plataformas de automação generalistas, não construídas para agentes IA de código. AgentsRoom Teams é o editor de workflow multi-agente estilo canvas, mas ligado especificamente aos teus agentes CLI, ao teu projeto, ao teu git, aos teus terminais e ao teu navegador.
Se constróis sistemas agênticos em Python, continua com CrewAI ou LangGraph para pipelines de produção. Se entregas código com Claude Code, Codex CLI, OpenCode, Antigravity CLI, Aider, Grok Build, Mistral Vibe ou Kimi Code, Agent Teams é o workflow de equipa que corre onde tu codas mesmo.
FAQ
Em que é que isto é diferente dos subagents do Claude Code (a tool Task, .claude/agents)?
Os subagents Claude são delegações inline de uma sessão Claude pai única. O pai decide quando chamar um subagent, o subagent corre numa janela de contexto isolada, devolve um resultado, e o pai continua. AgentsRoom Teams está um nível acima: cada node é uma sessão Claude Code top-level com o seu próprio terminal, o seu próprio estado e o seu próprio scrollback. Vês cada agente correr ao vivo no seu próprio separador, podes falar com qualquer um a qualquer momento, podes pausar a equipa, mudar o workflow e retomar. Não é um substituto dos subagents Claude, podes absolutamente usar ambos. Um node de equipa pode usar subagents internamente.
Isto só funciona com Claude Code?
Funciona com todos os providers suportados pelo AgentsRoom (Claude Code, Codex CLI, OpenCode, Antigravity CLI, Aider, Grok Build, Mistral Vibe, Kimi Code). Cada node de equipa escolhe o seu próprio provider e modelo. As tools de coordenação de equipa baseadas em MCP funcionam de forma idêntica em todos os providers porque são expostas através do Model Context Protocol standard. Podes correr uma equipa com Codex no node backend pesado e Haiku no node QA se for o que encaixa com o teu orçamento e a tua latência.
O que é um payload de handoff?
Um objeto estruturado que viaja de um agente para o seguinte. Campos: featureSummary (uma descrição curta do que acabou de ser entregue), changedFiles (git diff name-status), touchedAreas (UI, API, DB, config), risks (qualquer coisa com que o agente seguinte se deva preocupar), testHints (prioridades para o QA), flags (booleanos como qaPassed, usados pelos edges condicionais). O agente chama team_complete_step com este payload, o runner valida-o do lado do servidor, o agente seguinte recebe-o como o seu contexto inicial.
Os agentes podem mesmo ir e voltar (Dev para QA para Dev)?
Sim. Quando um node é re-entrado (cycle maior que 1), AgentsRoom não spawna um agente novo. Reutiliza o agente original do cycle 1, escreve o novo payload de handoff diretamente no seu terminal existente, e o agente mantém toda a sua memória de sessão Claude dos cycles anteriores. Isto é crítico: um agente Dev que já sabe o que o QA sinalizou da última vez corrige o bug. Um agente Dev fresco sem memória repetiria simplesmente o mesmo erro.
O que acontece se o QA continuar a rejeitar o Dev para sempre?
A config da equipa tem um guard de max-cycles, por defeito 3. Quando o tecto é atingido, o run pausa com estado 'blocked' e espera por ti. Podes finalizar o run, fazer mais um handoff manual, ou cancelar tudo. Sem loops infinitos, sem faturas surpresa de um dia para o outro.
Todos os agentes da equipa partilham o mesmo workspace git?
Sim. A equipa corre num workspace único e numa branch única (ou worktree se usares a feature Worktrees do AgentsRoom). Cada agente vê o trabalho do anterior através do git. O payload de handoff inclui um diff git contra a baseline do run para que o agente seguinte saiba exatamente o que é novo.
Isto requer uma subscrição extra?
Não. Teams faz parte do AgentsRoom. Trazes as tuas próprias keys de provider (Claude, Codex, OpenCode, Antigravity, Aider, Grok Build, Mistral Vibe, Kimi Code) e pagas só pelos tokens que usas, como com um agente único. Correr uma equipa Dev para QA num ticket pequeno tipicamente custa o mesmo que correr um agente Fullstack único, porque Haiku/Sonnet no passo de QA é barato.
Onde é que as equipas são guardadas? São commitadas no git?
Equipes de projeto vivem com a room, sincronizadas com sua conta e em cache em {project}/.agentsroom/teams-cache.json (gitignored). Equipes globais tambem sao sincronizadas com sua conta: sua biblioteca segue voce de maquina em maquina, com ~/.agentsroom/teams/ como cache offline. Os modelos inclusos ficam locais: cada maquina os instala no proprio idioma.
E se um agente crashar ou a app reiniciar a meio do run?
O estado da execucao e persistido em disco em {workspace}/.agentsroom/team-runs/{runId}/ (state.json, NOTES.md, inbox/, timeline.jsonl), com escritas atomicas e notas append-only. Uma execucao interrompida e retomada ao reiniciar o app: o orquestrador reentra na etapa ativa, reabre o terminal e o agente recupera o contexto pelas notas e pelas ferramentas de equipe. Uma execucao cuja equipe foi excluida e fechada automaticamente em vez de ficar largada para sempre.
Posso correr várias equipas em paralelo em tickets diferentes?
Sim. Cada execucao e independente, identificada pelo seu runId. Voce pode ter tres equipes diferentes rodando em tres tickets do mesmo projeto. Dentro de uma execucao, o fluxo segue seu grafo: sequencial por padrao, paralelo onde voce desenha ramos paralelos (por exemplo QA e Seguranca revisando juntos), sempre com uma juncao deterministica.
Dois agentes podem mesmo rodar ao mesmo tempo?
Sim. Trace duas ligacoes sem condicao a partir de um no e os dois destinos rodam como ramos paralelos, cada um em seu proprio agente e terminal. Os ramos tem um no de profundidade e precisam convergir para um no de juncao comum, o que o editor valida antes de deixar voce rodar. Quando todos os ramos terminam, a juncao recebe um payload fundido: resumos rotulados por papel, riscos e dicas de teste deduplicados, e flags fundidas com uma regra fail-safe (um conflito booleano se resolve em false).
Como funcionam exatamente os portoes de qualidade?
Voce digita um comando de shell no no, por exemplo npm test, e opcionalmente um nome de flag (checkPassed por padrao). Quando o agente sinaliza o fim da etapa, o AgentsRoom executa o comando no workspace com teto de cinco minutos. Codigo de saida 0 escreve true na flag, qualquer outro escreve false, sobrescrevendo o que o agente declarou sobre si mesmo. Em caso de falha, os ultimos kilobytes de saida viajam ao proximo agente: a volta aterrissa com o stack trace real, e o resultado aparece na timeline da execucao.
Uma etapa pode carregar meus procedimentos da Skills Library?
Sim. Cada no pode fixar skills da sua Skills Library, de projeto ou globais. O agente recebe a instrucao de carrega-las antes de comecar a etapa: uma checklist de revisao, um runbook de deploy ou um procedimento de teste e aplicado em cada execucao, em vez de depender da memoria do agente.
Constrói a tua equipa dev IA dos sonhos
Quatro modelos vem com o app. Abra o AgentsRoom, solte nos, trace ligacoes, rode em qualquer ticket. Sua equipe de engenharia IA esta a um clique.
App complementar: acompanhe seus agentes em qualquer lugar
Use Claude, Codex, Antigravity CLI ou outro provedor de IA.
Envie bugs e pedidos direto para o seu backlog público.
Uma visão do AgentsRoom em ação.