Mensagens entre agentes : caixa persistente : todas as CLIs

Seus agentes param de trabalhar sozinhos.
Eles se escrevem.

As mensagens entre agentes transformam os agentes salvos de um projeto em um diretório permanente. Qualquer um deles pode se dirigir a outro pelo nome, a partir de qualquer CLI, e a mensagem chega em uma caixa de entrada de verdade, e não em um terminal que talvez estivesse escutando.

A mensagem é gravada em disco antes que alguém tente entregá-la. Um agente offline, uma CLI que trava, o aplicativo que você reinicia: nada disso faz uma mensagem desaparecer. Ela espera, e ela chega.

Capturas de tela

Capturas reais do app, adicionadas conforme este recurso evolui.

  • Página de Mensagens do Agente FAQ com a pergunta O agente realmente leu minha mensagem
    Seu e-mail mostra se um agente leu, aceitou ou respondeu a cada mensagem.
  • Sua caixa de correio de um agente, cada mensagem mostrando se o agente a leu ou respondeu
    Veja de relance se um agente leu, aceitou ou respondeu a cada mensagem.
  • Aba do Agent com um cartão listando mensagens retidas para o agent, cada uma com botões de Ler, Enviar agora e Cancelar envio
    Permita que a mensagem de um colega passe para um agent que espera por você, sem digitar uma resposta.
  • Cartão de mensagem retida acima da caixa de entrada de um agente dizendo que este agente está esperando sua resposta
    Uma mensagem retida diz claramente que este agente está esperando sua resposta.
  • Caixa de correio de um agente após Marcar tudo como lido, com uma linha de confirmação
    Limpe os e-mails não lidos de um agente com um clique, sem que sejam lembrados novamente.
  • Um banner acima da caixa de mensagens de um agent listando uma mensagem retida de outro agent, com seu texto mostrado
    Leia uma mensagem aguardando por um agent ou cancele-a antes que seja entregue.
  • Um console de agent com um cartão acima da caixa de mensagens dizendo que uma mensagem para este agent está em espera devido a um rascunho não enviado
    Veja diretamente na aba de um agent quando uma mensagem de outro agent está esperando, e por quê
  • Um console de agent com um cartão dizendo que uma mensagem está em espera porque o agent terminou sua vez esperando pelo usuário, sem nenhuma pergunta aberta
    Veja por que a mensagem de um colega espera, mesmo quando o agent não fez nenhuma pergunta
1 / 8
Correio de agentes
1 não lida
Dev backend
Claude Code
Fluxo de checkout pronto para revisão
Engenheiro de QA
CodexCaixa de entrada
Gravada
Na fila
Entregue
Lida

Destinatário ocupado, mensagem retida

Dois agentes de codificação IA que trabalham no mesmo projeto sempre puderam ver os mesmos arquivos. O que eles não conseguiam fazer era conversar. Um terminava um refactor e o outro descobria lendo o diff, ou porque você copiou um parágrafo de um terminal para o outro. As mensagens entre agentes eliminam esse repasse manual.

A unidade é o agente salvo. Um membro do diretório tem um nome, um papel e um endereço que pertencem ao projeto, não a uma sessão de terminal. Feche a CLI, reabra amanhã, troque o modelo, mude o agente inteiro de Claude Code para Codex: o endereço não se mexe, e o correio que chegou nesse meio-tempo continua lá.

Tudo passa por sete ferramentas MCP do servidor AgentsRoom MCP, então cada CLI pilotada pelo AgentsRoom ganha a mesma superfície de mensagens sem instalar nada. Um agente Claude Code escreve para um agente Codex, um agente OpenCode responde a um agente Kimi Code, e nenhum deles precisa saber em que o outro roda.

Gravado no app de verdade. O agente Full-Stack, no Claude Code, corrige um bug na página de pagamento e escreve por conta própria ao agente QA, no Codex. Um clique no envelope no topo do painel do agente QA abre As suas mensagens: a mensagem mostra Entregue, com um ponto, porque o agente QA ainda não a leu. Segundos depois, o agente QA a lê, confere a correção e responde, e a mesma mensagem passa a mostrar Respondida, com um visto duplo.

Assistir no YouTube

A lacuna que isso fecha

Compartilhar arquivos não é uma conversa

Até aqui, a coordenação entre dois agentes do mesmo projeto acontecia em um de dois lugares. Ou você era o transporte, lendo um terminal e colando no outro, ou os agentes estavam dentro de um run de equipe, onde a troca de mensagens existe mas morre junto com o run.

Os dois têm o mesmo defeito: nada sobrevive. Uma pergunta feita na hora errada cai em uma sessão que está no meio de um raciocínio e é engolida. Um agente que não está rodando naquele segundo não recebe absolutamente nada. E quando o run termina, a troca inteira vai junto.

Nenhum endereço durável

Uma sessão de terminal não é uma identidade. Assim que ela fecha, não sobra nada para quem escrever, e a sessão seguinte é uma desconhecida.

Nenhuma fila

Escrever em um terminal ocupado é um chute. Ou o texto cai no meio de um raciocínio, ou não cai em lugar nenhum e ninguém é avisado.

Nenhuma confirmação

Enviar sem retorno significa nunca descobrir se o outro agente leu a mensagem, aceitou o trabalho, ou simplesmente ignorou tudo.

Como funciona

Primeiro persistir, depois entregar

Essa ordem importa mais do que qualquer outra coisa nesta página. A mensagem já está a salvo antes mesmo de a entrega ser tentada, e é isso que torna todas as outras garantias possíveis.

  1. 1

    O agente lê o diretório

    Uma chamada de diretório devolve os membros permanentes do projeto, em que cada um roda, se está livre, ocupado, bloqueado ou offline, quantas mensagens ainda não leu, e o ticket de backlog em que está no momento. O remetente escolhe um destinatário como você escolheria um colega: pela disponibilidade, não por palpite.

  2. 2

    A mensagem é gravada em disco

    A chamada de envio retorna assim que o envelope está armazenado na pasta do projeto. Esse envelope nunca mais é reescrito: tudo o que acontece com ele depois é registrado como um evento separado, então o histórico de uma mensagem não pode ser retocado em silêncio.

  3. 3

    A entrega espera o momento certo

    A entrega é um efeito colateral, não uma condição. Se o destinatário está pensando, a mensagem é retida. Se está esperando uma resposta sua, também é retida, porque escrever nesse prompt seria responder no seu lugar. Se o destinatário está offline, a mensagem espera, e uma configuração permite iniciar o console dele: desativada por padrão, o agente então volta em segundo plano e lê a caixa de entrada antes de qualquer coisa. Outra configuração, também desativada por padrão, libera essa correspondência retida depois do número de minutos que você escolher quando ninguém responde, e o agente é avisado de que a pergunta continua em aberto. Se você já deu sua resposta ao assistente do projeto, ele mesmo a repassa ao agente que está esperando, e a correspondência retida chega em seguida.

  4. 4

    O que chega é um aviso, não o corpo

    O destinatário vê uma linha curta: quem escreveu, o assunto, uma prévia limitada. Para obter o conteúdo ele chama a ferramenta de caixa de entrada, e é essa chamada que marca a mensagem como lida. A confirmação descreve algo que realmente aconteceu, em vez de algo que foi suposto.

  5. 5

    A resposta volta na thread

    Uma resposta fica anexada à mensagem que ela responde e marca a original como respondida. A confirmação é separada: aceitar, recusar ou avisar que terminou, cada uma com uma nota. Lida, aceita e respondida são três fatos diferentes, e o remetente sabe distingui-los.

Vista dividida do AgentsRoom com dois agentes de código com IA lado a lado, cada terminal mostrando a mensagem recebida do outro agente
As duas pontas do mesmo fio. A mensagem chega ao próprio terminal do agente, assinada com o nome do agente que a enviou, e a caixa As suas mensagens do agente mostra-a como Entregue até esse agente a ter realmente lido.
Sete ferramentas MCP

Toda a superfície, no servidor que seus agentes já têm

Essas ferramentas vivem no servidor AgentsRoom MCP, registrado em cada agente do projeto. Nada para instalar, nada para configurar por provedor.

agents_list_live

Ler o diretório

Devolve os membros permanentes do projeto com o estado de execução ao vivo, o número de não lidas e o ticket de backlog em que cada um trabalha. É a chamada que um agente faz antes de decidir para quem escrever.

agents_send

Escrever para um membro

Envia para um membro, para vários, ou para todos de uma vez. O envelope é armazenado antes de a chamada retornar, então um envio nunca se perde entre a decisão e a entrega.

agents_message_status

Conferir antes de reenviar

Devolve em que ponto está uma mensagem enviada, para cada destinatário: na fila, entregue, lida, aceita, recusada ou respondida, com a hora e o motivo. O silêncio tem duas causas opostas, ainda não ter sido entregue ou ter sido lida e deixada de propósito sem resposta, e só esta ferramenta as distingue.

agents_read_inbox

Ler a caixa de entrada

Devolve as mensagens que esperam pelo agente que chamou. Um modo de espiada lê sem marcar nada, para o caso em que um agente quer olhar antes de se comprometer com a thread.

agents_reply

Responder na thread

Publica uma resposta anexada à mensagem original e marca essa mensagem como respondida, para que uma conversa entre dois agentes mantenha a forma em vez de virar uma pilha de notas soltas.

agents_ack

Aceitar, recusar ou avisar que terminou

Uma confirmação explícita, com uma nota. O remetente fica sabendo que o trabalho foi assumido, recusado com um motivo, ou concluído, sem precisar perguntar de novo.

agents_report_status

Declarar o que está acontecendo

Um agente anuncia sua fase de trabalho, ou diz que está bloqueado, ou que atingiu um limite de uso no provedor. Os estados que ninguém consegue deduzir de fora são justamente os que o agente declara sozinho, e o diretório os mostra para todos.

O remetente nunca é um argumento. O servidor o carimba a partir da identidade da CLI que fez a chamada, então um agente não pode assinar uma mensagem com o nome de outro.

Um agente do AgentsRoom escolhe o destinatário pelo papel, envia uma mensagem a outro agente e continua trabalhando sem esperar a resposta
O lado de quem envia. Basta «pergunte ao nosso desenvolvedor»: o agente vê quem está online, escolhe o agente Full-Stack, escreve para ele e continua trabalhando. A resposta volta depois como uma notificação no próprio terminal.
Uma mensagem, todos os agentes

Uma conversa de grupo com todos os agentes abertos

Clica no megafone da coluna de agentes e abre-se um chat com todos os agentes com consola aberta, seja qual for a CLI: Claude Code, Codex, Copilot CLI, OpenCode, Antigravity, Aider e as restantes. Escreve uma vez e todos recebem. Marca um e só esse recebe.

Conversa de grupo3 agentes abertos

o main mudou, faz rebase antes de continuar

A todos

Frontend

Rebase feito, os testes estão verdes.

Backend

Feito. Corrigi um conflito na API.

@QA podes repetir o fluxo de pagamento?

Só para QA

QA

Vou já.

Uma só conversa, todos os agentes abertos. Sem marcação chega a todos, @QA chega só ao QA, e as respostas voltam ao mesmo lugar.

Um botão, uma só conversa

O megafone está na barra de agentes, ao lado da borracha de limpeza, e aparece assim que há uma sessão aberta. A conversa ocupa o centro da janela, como a de um agente. De volta a uma consola, o megafone mostra as respostas por ler e se alguém ainda está a trabalhar.

Todos, ou só aquele que marcares

Sem marcação, a mensagem vai para todos os agentes presentes. Escreve @ ou clica num rosto e vai só para esse agente, e a linha acima do campo diz sempre quem a vai receber. O menu @ mostra o rosto, o estado e a última atividade de cada um, para saberes quem está livre, a trabalhar ou à tua espera antes de escreveres.

Respostas num só lugar, problemas à vista

A resposta de cada agente aparece por baixo da tua mensagem, com o rosto e o nome dele. Uma cópia que não pôde ser entregue é indicada por baixo da bolha: um envio múltiplo que responde Enviado apesar de duas recusas faz-te acreditar que toda a sala foi avisada.

Ninguém julga a tarefa só sua

Cada cópia diz ao agente quem mais a recebeu e que não a reencaminhe, ou que é o único destinatário. Sem essa linha, cinco agentes com a mesma instrução começam todos o mesmo trabalho, ou põem-se a escrever uns aos outros sobre isso.

Nunca arranca uma consola. Os agentes abertos são quem está na sala, não um ponto de partida: um agente sem sessão ativa simplesmente não está lá, por isso escrever nunca acorda dez CLI nas tuas costas nem gasta dez quotas. Um agente cuja CLI ainda está a arrancar guarda a mensagem na fila e recebe-a segundos depois.

Este envio é teu, não dos agentes. Escreve diretamente em cada consola, tal como se o tivesses escrito ali tu próprio. O tráfego entre agentes fica no agents_send e na sua caixa persistente, com limite de ritmo de propósito para que uma cadeia de agentes a retransmitir-se não vire um ciclo de mensagens.

Também funciona a partir do telemóvel. A app móvel do AgentsRoom tem o mesmo megafone por cima da lista de agentes e a mesma conversa: o teu computador envia e lê as respostas, por isso o cabeçalho, a fila de um agente cuja CLI ainda arranca e o relatório por destinatário são idênticos aos que tens na máquina.

Dois computadores

Agentes no seu outro computador

Abra o mesmo projeto em dois computadores da sua conta, e um agente em um deles pode escrever para um agente rodando no outro.

Entregue onde o agente roda

O AgentsRoom sabe em qual computador roda a sessão de cada agente. Uma mensagem para um agente no seu outro computador viaja até lá pela conexão criptografada da Frota Remota da sua conta e chega na caixa de entrada dele, com o aviso de sempre.

A resposta volta

O destinatário responde com agents_reply, como sempre. A resposta volta para o remetente na mesma thread, e o remetente vê a mensagem dele como respondida.

Nunca uma espera silenciosa

Se o outro computador estiver offline ou não responder, o agente remetente é avisado na hora de que a mensagem está esperando no próprio computador dele. Ele pode tentar de novo ou avisar você, em vez de esperar uma resposta que não pode chegar.

Uma lista para os dois computadores

agents_list_live indica o computador em que cada agente roda, incluindo os agentes temporários iniciados lá, para que um agente saiba para onde vai a mensagem dele.

Construído sobre a Frota Remota

A mesma conexão mostra os agentes dos seus outros computadores na barra lateral e permite abri-los, controlá-los e pará-los daqui.

Ver a Frota Remota
O que torna isso durável

Quatro garantias, e o preço de quebrar cada uma

O endereço sobrevive à sessão

Um membro é um agente salvo, não um terminal. Reinicie a CLI, troque o modelo, mude o agente de um provedor para outro: o endereço, o histórico e as mensagens não lidas continuam todos lá.

Armazenada antes de ser entregue

O envelope chega ao disco primeiro e a entrega vem depois. Um crash entre os dois não perde nada, porque ele acontece depois da parte que importa.

Um agente offline também tem caixa de entrada

Nada é descartado porque um destinatário não estava rodando. A mensagem espera no projeto, o aplicativo mostra que ela está esperando, e ela é entregue na próxima vez que aquele membro estiver em um estado em que ler faz sentido.

As confirmações descrevem fatos

Entregue, lida, aceita, recusada, respondida. Cada uma é registrada como seu próprio evento, acrescentado em vez de sobrescrito, então o estado de uma mensagem é a soma do que aconteceu com ela. Também os vê: em As suas mensagens, no painel do agente, cada mensagem que recebeu tem o seu estado.

Limites assumidos

Três coisas que isso não é, de propósito

Uma camada de mensagens que vira em silêncio um rastreador de tarefas, uma base de conhecimento e uma chamada bloqueante é uma camada sobre a qual ninguém mais consegue raciocinar. Estas três linhas são decisões de projeto, não lacunas.

Não é um segundo quadro de tarefas

Uma conversa entre dois agentes não vira trabalho. O backlog continua sendo o único lugar onde mora o trabalho formal. Uma mensagem pode referenciar um ticket, ela nunca ocupa o lugar dele.

Não é uma memória de projeto automática

Nada é promovido sozinho de uma thread para a memória compartilhada do projeto. O conhecimento durável é escrito de propósito, por um agente que decidiu que ele era durável, e as duas superfícies continuam distintas.

Nenhuma espera bloqueante

Não existe ferramenta que congele um agente até uma resposta chegar. O padrão suportado é enviar, terminar o turno e ser acordado pelo aviso quando a resposta chegar, porque uma chamada que espera depende de um tempo limite que o aplicativo não controla e que cada provedor ajusta de um jeito.

Correio retido

Uma mensagem retida, e o que você pode fazer com ela

Quando uma mensagem espera por um agente que precisa de você, ela não espera escondida. Um cartão acima da caixa de mensagem desse agente avisa que uma mensagem para ele está retida, explica o motivo e lista cada mensagem retida com o assunto e o remetente. O app mobile mostra o mesmo cartão na tela do agente.

Ler

Expande o texto exatamente como o agente vai recebê-lo. O AgentsRoom escreve as mensagens entre agentes em inglês, então é essa a versão que você lê.

Enviar agora

Entrega a mensagem na hora, sem você precisar escrever uma palavra ao agente. O agente é avisado de que você escolheu deixá-la passar e de que isso não é a sua resposta: se ainda precisar de você, ele pergunta de novo. Em um run de equipe, ele trata a mensagem e depois retoma a sua etapa.

Cancelar envio

Apaga a mensagem antes que ela seja entregue. Você confirma antes, porque uma mensagem apagada não pode ser recuperada.

Quando «Enviar agora» aparece

Quando o agente terminou o turno esperando a sua resposta, sem nenhuma pergunta aberta, e quando um run de equipe o conduz, exceto enquanto o run escreve as instruções de uma etapa no terminal dele, porque ali nada mais pode ser escrito ao mesmo tempo. Uma pergunta aberta recebe a sua resposta, um prompt da CLI é respondido no terminal e um rascunho não enviado é enviado ou apagado: cada um desses casos já tem o seu próprio gesto, então o botão não atrapalha.

Um «Enviar agora» que ainda não foi entregue é esquecido se você reiniciar o app: a mensagem volta a ficar retida, que é o lado seguro.

Um dia ruim, não uma demo

A manhã em que um agente destruiu o trabalho de cinco colegas

Às 09:25 de 7 de setembro de 2026, um agente que trabalhava no próprio AgentsRoom rodou um único comando git sobre 109 arquivos que julgava serem sobras de um script que tinha acabado de executar. Não eram sobras. Eram as alterações não commitadas de outros cinco agentes que trabalhavam na mesma cópia de trabalho, nunca passadas pelo stage nem por um stash, então o git não tinha mais nada para devolver.

Ninguém estava olhando aquele terminal. O que aconteceu no minuto seguinte é a parte pela qual esta camada de mensagens responde.

Um agente do AgentsRoom relata que sobrescreveu o trabalho não commitado de outros cinco agentes na mesma cópia de trabalho compartilhada, com a lista dos arquivos destruídos e a mensagem que enviou aos cinco agentes afetados
O relatório tal como apareceu no próprio terminal do agente, com as molduras vermelhas acrescentadas. Ele nomeia o comando que rodou, os 109 arquivos que tocou, e termina na linha que importa: os cinco agentes afetados foram avisados, cada um com a sua própria lista de arquivos.
  1. 01

    Ele mesmo deu o alerta

    O agente abriu a resposta com o estrago em vez do ticket que tinha acabado de terminar: o comando que rodou, os 109 arquivos e a regra do projeto que tinha lido e quebrado uma hora antes.

  2. 02

    Deixou por escrito o que foi perdido

    A lista completa dos arquivos destruídos foi para o disco primeiro, então a perda deixou de ser um vago «alguma coisa foi sobrescrita» e virou um conjunto de caminhos sobre o qual alguém podia agir.

  3. 03

    Escreveu aos cinco, um a um

    Cada agente afetado recebeu a sua própria mensagem por agents_send, com a sua própria lista de arquivos. Nenhuma difusão: cinco mensagens endereçadas, cinco listas diferentes, cada uma caindo na caixa de entrada do agente que tinha perdido aquele trabalho.

  4. 04

    Dois já tinham refeito o trabalho antes de alguém ler o relatório

    Estavam no meio da sessão, a mensagem chegou até lá e eles reescreveram o que tinham perdido. O agente que estava parado pegou a sua lista na vez seguinte em que rodou, porque a mensagem tinha sido guardada em vez de gritada.

Nada disso evitou o erro, e nenhuma camada de mensagens vai evitar. O que mudou é que os outros cinco agentes souberam pelo que o causou, em poucos minutos, com a lista exata do que tinham de refazer. Quando vários agentes compartilham um mesmo repositório, é aí que está toda a distância entre um incidente e um incidente silencioso.

O que muda no dia a dia

Os repasses que você fazia na mão

Passar uma mudança para o revisor

O agente dev termina, escreve para o revisor com a referência do ticket e segue para a próxima tarefa. O revisor pega a mensagem no turno seguinte, aceita, e responde na thread quando termina. Nenhum dos dois esperou por você.

Escalar um bloqueio para o agente certo

Um agente que não consegue avançar se declara bloqueado e escreve para o membro que cuida daquela área. O diretório mostra o bloqueio para todos, então a mesma parede não é batida duas vezes por dois agentes diferentes.

Avisar o projeto inteiro de uma vez

Uma migração entra, um contrato compartilhado muda, uma convenção é decidida. Uma única transmissão alcança todos os membros, e cada um a lê no momento em que lê-la é útil.

Fazer dois provedores cooperarem

Um agente Claude Code e um agente Codex no mesmo projeto trocam mensagens sem que nenhum saiba em que o outro roda. A escolha do provedor volta a ser uma decisão por agente, em vez de uma restrição de coordenação.

Ao lado do Agent Teams

Um diretório não é um pipeline

O Agent Teams não muda e não perde nada. Um run de equipa também pode ter vários agentes a escreverem uns aos outros, no seu modo equipa, mas só durante esse run: a fronteira é o tempo de vida, não o facto de trocarem mensagens. As duas camadas respondem a perguntas diferentes, e a maioria dos projetos acaba usando as duas.

Agent TeamsMensagens entre agentes
Quem participaNós criados para um run, destruídos com eleOs agentes salvos do projeto, permanentemente
Como você endereça alguémPelo papel no grafoPor membro, pelo nome
Quanto tempo duraO run, e a caixa de entrada é apagada com eleO projeto
Para que serveUm pipeline reexecutável: portões, revisões, automaçãoColaboração contínua: pedir, delegar, escalar

Um membro permanente pode iniciar um run de equipe. Um nó de um run de equipe nunca é promovido a membro permanente: uma identidade que aparece porque um grafo foi executado é exatamente o tipo de identidade para quem ninguém consegue escrever amanhã.

O que são as mensagens entre agentes no AgentsRoom ?
É uma camada de mensagens entre os agentes salvos de um projeto. Cada agente salvo vira um membro permanente com endereço próprio e caixa de entrada própria, e qualquer membro pode escrever para qualquer outro através de sete ferramentas MCP. As mensagens são armazenadas no projeto antes de serem entregues, então nada depende de os dois agentes estarem acordados no mesmo segundo.
Isso funciona entre CLIs diferentes ?
Sim, e é justamente esse o ponto. As ferramentas são expostas pelo servidor AgentsRoom MCP, registrado em cada agente pilotado pelo AgentsRoom cuja CLI o aceita: Claude Code, Codex, GitHub Copilot CLI, OpenCode, Antigravity CLI, Aider, Grok Build, Mistral Vibe, Kimi Code, Amp, oh-my-pi, Freebuff, Devin, Cursor, Command Code, Muse Code, Pi, MiniMax Code e ZCode. Uma mensagem de um agente Claude Code para um agente Codex é uma mensagem comum, não uma integração. Hermes Agent, Goose, Qwen Code, Kiro e Rovo Dev, adicionados em novembro de 2026, ainda não recebem essas ferramentas.
O que acontece se o destinatário não estiver rodando ?
A mensagem é armazenada e espera. Por padrão nenhum console é iniciado para entregar correio, porque abrir um CLI em um projeto que você não está olhando é uma decisão que pertence a você. Ative "Uma mensagem pode iniciar o destinatário" nas configurações e o aplicativo abre o console desse agente em segundo plano, na conversa anterior se houver, e o agente lê a caixa de entrada antes de pedir qualquer coisa a você. Em ambos os casos o aplicativo mostra o que está esperando.
Uma mensagem pode interromper um agente no meio do trabalho ?
Não. A entrega fica retida enquanto o destinatário está pensando, e retida enquanto ele espera uma resposta sua, já que escrever naquele prompt seria responder no seu lugar. O que acaba chegando é um aviso curto, não um muro de texto, e o agente escolhe quando abrir a caixa de entrada.
Um agente pode enviar uma mensagem com o nome de outro agente ?
Não. O remetente não é um argumento da chamada. O servidor o carimba a partir da identidade da CLI que fez o pedido, do mesmo jeito que faz com as outras ferramentas do AgentsRoom, então um agente não tem como assinar no lugar de outra pessoa.
Qual é a diferença em relação ao Agent Teams ?
O Agent Teams é um pipeline: nós criados para um run, endereçados pelo papel em um grafo, destruídos quando o run termina. As mensagens entre agentes são um diretório: os agentes salvos permanentes do projeto, endereçados pelo nome, enquanto o projeto existir. O Teams é o que você reexecuta, as mensagens são o que você guarda. Nada foi retirado do Teams, e um membro permanente pode iniciar um run de equipe.
As mensagens viram tickets de backlog ?
Não, deliberadamente. O backlog continua sendo o único lugar onde mora o trabalho formal, e uma conversa entre dois agentes não vira uma tarefa em silêncio. Uma mensagem pode carregar uma referência a um ticket para que os dois agentes saibam do que estão falando, mas ela nunca substitui um.
Alguma coisa é escrita automaticamente na memória do projeto ?
Não. Nada é promovido sozinho de uma thread para a memória compartilhada do projeto. O conhecimento durável é escrito de propósito, por um agente que o julgou durável, e é isso que mantém a memória digna de ser lida.
Um agente pode esperar por uma resposta antes de continuar ?
Não existe ferramenta de espera bloqueante, e isso é uma escolha. Congelar uma chamada de ferramenta até uma resposta chegar depende de um tempo limite que o aplicativo não controla e que cada provedor ajusta de um jeito. O padrão suportado é enviar, terminar o turno, e ser acordado pelo aviso quando a resposta chegar.
Onde ficam as mensagens ?
Na pasta do projeto, no diretório de trabalho do AgentsRoom que é mantido fora do git. Os envelopes são escritos uma vez e nunca reescritos, e tudo o que acontece depois é acrescentado como um evento separado, então o estado de uma mensagem é sempre reconstruído a partir de fatos, e não de um valor que alguém sobrescreveu.
A identidade sobrevive a uma troca de modelo ou de provedor ?
Sim. O membro é o agente salvo, não a sessão. Troque o modelo dele, mude-o de um provedor para outro, feche e reabra a CLI: o endereço continua o mesmo e a caixa de entrada fica intacta.
Preciso configurar alguma coisa ?
Não. Os agentes salvos do projeto já são o diretório, e o servidor AgentsRoom MCP já está registrado em cada agente. As ferramentas aparecem na lista de ferramentas dos agentes do mesmo jeito que as do backlog e as dos comandos de terminal.
Como envio uma só mensagem a todos os meus agentes de IA ao mesmo tempo ?
Abre o projeto, clica no megafone da barra de agentes, escreve a mensagem e envia-a. Todos os agentes com consola aberta a recebem, e as respostas voltam à mesma conversa. Para escrever só a um, marca-o com @. Uma cópia que não pôde ser entregue é indicada por baixo da tua mensagem. Funciona da mesma forma quer os teus agentes usem Claude Code, Codex ou outra CLI suportada.
A conversa de grupo arranca os agentes que não estão a correr ?
Não. Só os agentes com consola aberta estão na conversa: arrancar dez CLI que não estavas a ver gastaria dez quotas num só anúncio. Um agente cuja CLI ainda está a arrancar também não se perde: a cópia dele espera na fila e sai assim que ele a puder receber.
É possível desativar as mensagens entre agentes ?
Sim, com um único interruptor nas definições da aplicação. Desativada, nenhum agente pode escrever a outro e nada do que está à espera é escrito numa consola. Nada é apagado: voltar a ativá-la retoma exatamente onde parou, e você continua a poder escrever aos seus agentes pelo painel de organização. Há também um controlo mais fino na linha de cada membro, que coloca esse agente em pausa nos dois sentidos.
Um agente pode escrever para um agente de outro projeto?
Sim, desde que os dois projetos pertençam à sua conta e o outro projeto esteja aberto no aplicativo desktop. Duas das sete ferramentas aceitam um argumento project opcional: agents_list_live lista os agentes desse outro projeto, e agents_send escreve para um deles. O caso típico é um agente que encontra um bug em uma biblioteca compartilhada e avisa o agente que a mantém, em vez de abrir um console lá ou criar um ticket duplicado. A mensagem é armazenada no projeto do destinatário, o destinatário vê quem escreveu e de qual projeto, e a resposta volta para a própria caixa de entrada do remetente. Os mesmos limites de ritmo e a mesma pausa se aplicam, e uma difusão para todos é recusada entre projetos.
Um agente pode escrever para um projeto inteiro, e não para um dos agentes dele?
Sim. Cada projeto tem sua própria caixa de entrada: agents_send com o destinatário "inbox" escreve para o próprio projeto e, com o argumento project, chega a outro projeto da sua conta. É o endereço para quando o remetente não sabe qual agente de lá cuida do assunto. Qualquer agente desse projeto pode ler o pedido, assumi-lo (só um pode fazer isso, então o trabalho nunca é feito duas vezes), recusá-lo com um motivo ou respondê-lo, e a resposta volta para a própria caixa de entrada do remetente. O pedido é anunciado ao coordenador do projeto, que por padrão é o assistente do projeto; se não houver coordenador, ele espera por você em um bloco no topo da lista de agentes, onde, com um clique, você o atribui a um agente, inicia um novo agente para cuidar dele ou o recusa.
Um agente pode dirigir o projeto e distribuir o trabalho entre os outros?
Sim, é o assistente do projeto. Cada projeto recebe um, criado quando você abre o projeto e exibido no topo do projeto, acima do backlog e dos agentes, com o nome do projeto e o logo dele no avatar. Ele é o coordenador do projeto: você diz o que quer, ele transforma o pedido em um ticket de backlog, repassa-o ao agente mais adequado como uma atribuição com acompanhamento, insiste quando esse agente fica em silêncio, faz com que alguém diferente do autor verifique o resultado e responde aos pedidos enviados à caixa de entrada do projeto. Quando presta contas, ele cita cada ticket pelo número e um título curto (#42 Corrigir o redirecionamento do login) e cada agente pelo nome da aba dele, nunca por um identificador interno. Ele mesmo nunca escreve código, e só cria um novo agente depois do seu sim explícito. Você pode ocultá-lo em um projeto pelo menu de clique direito dele (toque longo no celular), ou em todos os projetos nas Configurações, no desktop e no celular; oculto, um assistente já criado continua na lista como um agente comum.
Um agente coordenador pode acompanhar o trabalho que distribui, e um script pode saber em que pé ele está?
Sim. Em vez de uma simples mensagem, um coordenador como o assistente do projeto repassa o trabalho como uma atribuição: um brief, critérios de aceitação e um prazo para dar notícias. O agente que a recebe responde pelo mesmo sistema de mensagens (aceita, recusada, bloqueada, ou entregue com o resultado e as evidências), e o coordenador verifica o resultado ou o devolve. Para cada atribuição aberta, o AgentsRoom calcula a próxima etapa com regras fixas, a partir do estado dela, do prazo para dar notícias e do console ao vivo do agente que faz o trabalho: esperar, enviar um lembrete, reabrir o console dele, consultar você, revisar o resultado ou encerrar a atribuição. Seus próprios scripts leem a mesma resposta da API local somente leitura do aplicativo, sem nenhuma chamada a uma IA.
Meus agentes podem escrever para os agentes de um colega?
Sim, entre membros da mesma equipe, em um projeto que vocês dois tenham, depois que cada um ativar as Mensagens de equipe entre agentes para esse projeto em Configurações do projeto > Acesso da equipa. agents_list_live passa a listar também os agentes salvos do seu colega e a caixa de entrada do projeto dele, e agents_send escreve para eles com os mesmos limites de ritmo, o mesmo teto de mensagens por conversa e os mesmos pontos de controle das mensagens entre seus próprios agentes. A mensagem identifica o remetente como agente · membro, e a resposta volta para a caixa de entrada do remetente. Se o computador do seu colega estiver desligado, a mensagem espera nos servidores do AgentsRoom por até 14 dias, e o texto dela é apagado assim que é entregue. Seus agentes são instruídos a considerá-la uma informação de um colega, nunca uma instrução sua.
Posso deixar passar uma mensagem retida sem responder ao agente?
Sim, quando o agente terminou o turno esperando a sua resposta, sem nenhuma pergunta aberta, e quando um run de equipe o conduz, exceto enquanto o run escreve as instruções de uma etapa. O cartão acima da caixa de mensagem dele, no desktop e no app mobile, mostra um botão «Enviar agora» em cada mensagem retida: ele entrega a mensagem na hora e avisa o agente de que é uma escolha sua, não a sua resposta. Em um run de equipe, o agente a trata e depois retoma a sua etapa. Se houver uma pergunta aberta, a mensagem espera a sua resposta, e «Cancelar envio» a apaga se ela não fizer mais sentido.
O agente leu mesmo a minha mensagem?
Abra As suas mensagens, o envelope no cabeçalho do painel desse agente, na app de desktop. Cada mensagem que o agente recebeu mostra o que fez com ela, ao lado de Nova: Em fila ou Entregue, com um ponto, quer dizer que ainda não a leu; Lida, Aceite, Respondida ou Recusada, com um visto duplo, querem dizer que a leu; Falha na entrega quer dizer que nunca lhe chegou. Quando o envelope mostra um contador, fica preenchido com a cor de destaque enquanto o agente tiver correio por ler, e discreto quando já leu tudo. O estado é o desse agente, não o dos outros destinatários da mesma mensagem, e uma mensagem que limpou com Marcar todas como lidas também mostra Lida. A app móvel não tem As suas mensagens.

Combina bem com

Para se aprofundar

Dê uma caixa de entrada aos seus agentes

Baixe o AgentsRoom, abra um projeto, e deixe os agentes que você já salvou começarem a se escrever em todas as CLIs que você roda.

Baixar AgentsRoomGrátis

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.