arroway.arroway.

Respostas

Respostas sobre memória compartilhada para pessoas e IA

Comece pela pergunta que está diante do seu time. Cada resposta explica uma parte de como o contexto compartilhado chega à IA antes do trabalho começar.

Explore as respostas

Memória compartilhada para times que trabalham com IA

Memória compartilhada de um time é um lugar só — fora de todos os assistentes — onde as decisões, as regras e o registro do dia ficam escritos, e que a IA de cada pessoa lê antes de começar uma tarefa e escreve quando termina. A Arroway é esse lugar. A memória é do projeto, não da janela de chat de alguém, então o assistente da segunda pessoa começa do que a primeira já resolveu, e não do zero. Funciona igual com uma pessoa e um agente só, porque a próxima sessão também é leitora, e se instala na ferramenta que você já usa: Claude, ChatGPT ou Codex, Cursor, ou qualquer uma que se conecte por MCP.

Contexto compartilhado entre Claude, ChatGPT e Codex

Uma conexão, e todo assistente lê o mesmo projeto. A Arroway roda como um servidor ao qual as suas ferramentas de IA se conectam — Claude, ChatGPT, Codex e qualquer outra que fale o mesmo padrão de conexão —, então todas leem e escrevem uma memória só. O que você resolveu numa ferramenta já está lá quando abre a próxima, e trocar de ferramenta não faz você começar de novo.

Memória de IA que uma pessoa aprova antes de valer

Memória sancionada quer dizer que uma pessoa decide o que vira regra, e a IA não consegue promover o próprio palpite a esse status. Na Arroway o assistente escreve à vontade enquanto trabalha, mas tudo o que ele deduziu sozinho entra como proposta. Uma pessoa transforma proposta em regra vigente — ou edita, ou joga fora — numa tela de review, depois do fato. O trabalho nunca fica esperando essa review.

Como as decisões do time chegam às IAs que fazem o trabalho

Uma decisão chega a uma IA quando é colocada na frente dela antes de ela agir — na leitura que o assistente faz no começo de uma tarefa, e não num documento que alguém torce para ele achar. A Arroway guarda as decisões como material de um projeto, marca as que devem valer sempre, ordena o resto pela tarefa que está na frente do assistente, e diz de uma vez quanto coube e o que não coube.

Como instalar e usar a Arroway nos principais ecossistemas de IA

Você escolhe a ferramenta em que já trabalha, conecta a Arroway a ela e começa a trabalhar. A página de instalação faz uma pergunta — onde você usa IA? — e mostra um caminho, não um cardápio de todas as possibilidades. E não pede login antes do momento em que um login é de fato necessário.

O conhecimento do time deve morar em arquivos versionados ou em memória curada?

Arquivos no repositório — um CLAUDE.md, uma pasta de skills, anotações commitadas ao lado do código — são onde a maioria dos times coloca o que a IA precisa saber, e é aí que o problema começa: o que cai neles governa toda sessão seguinte, e ninguém vê aquilo entrar nem aprova — palpite de assistente, status que venceu, decisão que o time nem sabia que tinha sido tomada. Um arquivo também não diz que regra vale hoje, quem decidiu, nem se o modelo de fato recebeu. A Arroway guarda o que precisa valer: escrito por pessoas e pelos assistentes delas, aprovado por uma pessoa, ordenado pela tarefa e entregue com a conta do que coube. O arquivo pode ficar vazio.

Onde a memória do time entra num ciclo de software nativo em IA?

O ciclo nativo em IA costuma ser descrito como uma cadeia de artefatos: uma intenção escrita, um plano derivado dela, código produzido contra o plano e uma revisão fechando o círculo. Isso descreve como uma unidade de trabalho viaja. Não carrega o que continua verdadeiro entre as unidades — que regra vale, quem decidiu, por que uma abordagem foi abandonada, e o que as pessoas que nunca abrem o repositório já resolveram. Essa camada permanente é o que a Arroway guarda, e ela é colocada na frente do assistente antes de ele planejar qualquer coisa.

Seu CLAUDE.md passou de uma página. O que sai dele?

O conselho de sempre é manter o CLAUDE.md em menos de uma página e cortar quando ele cresce. Cortar trata o tamanho como o problema. O problema é que tudo no arquivo governa toda sessão, e ninguém vê o que entra nem aprova: o palpite de um assistente, uma linha de status de março e uma decisão tomada numa reunião em que o leitor não estava pesam o mesmo que o comando de build. Então o que sai é tudo. O que ainda vale vai para a Arroway, onde uma pessoa aprova e a leitura escolhe pela tarefa; o que venceu ou é ruído é apagado. O arquivo pode terminar vazio.

Memória compartilhada para escritórios de advocacia: a posição da casa na IA de cada sócio

A posição do escritório sobre uma questão recorrente é da casa, mas a IA de cada sócio só sabe o que aquele sócio digitou nela. A Arroway é um lugar compartilhado, fora dos assistentes, onde essas posições ficam escritas e aprovadas por alguém do escritório. Dali em diante, quando a IA de qualquer sócio começa a trabalhar num caso, ela lê as posições que se aplicam antes de redigir qualquer coisa. Ninguém reexplica a visão da casa em prompt, e ninguém descobre que um colega respondeu o contrário depois que o parecer já foi ao cliente.

Memória de IA e sigilo do cliente: como o caso de um cliente fica fora do de outro

A memória vive dentro de um projeto, e uma leitura nunca cruza de um projeto para outro. Um caso, um cliente, uma área — cada um é o próprio projeto, e o que está escrito ali é servido só às pessoas que fazem parte dele, em conexões que as identificam pessoalmente. Nada é compartilhado por padrão, nada se espalha porque dois casos se parecem, e o que nunca deveria estar ao alcance de uma IA fica de fora pelo único controle que de fato segura: uma pessoa decide o que é escrito, para começar.

O sócio da conta muda. O que o próximo herda?

O que um sucessor deveria herdar são as decisões que a conta já carrega — não uma pasta de e-mails para garimpar e uma agenda de ligações que ninguém registrou. Com a Arroway a conta lembra, em vez da pessoa: cada decisão tomada com aquele cliente é escrita na hora em que acontece, aprovada por uma pessoa, e lida pela IA do próximo sócio no momento em que ele abre o trabalho. A reunião de passagem deixa de ser a única transferência — e deixa de ser o lugar onde se perde o que ninguém pensou em mencionar.

A tese do fundo, já sabida pela IA que analisa o deal

A tese e os critérios de triagem de um fundo são decididos uma vez pelos sócios e aplicados a todo deal que chega — mas a IA que aplica só sabe o que alguém colou nela naquela manhã. A Arroway é um lugar compartilhado, fora de cada assistente, onde a tese, os critérios e as linhas duras ficam escritos e aprovados por um sócio. Dali em diante, quando a IA de qualquer sócio abre um deal, ela lê os critérios que se aplicam antes de formar uma opinião. Ninguém redigita a tese num prompt, e ninguém descobre depois que a triagem rodou contra a versão do ano passado.

Uma regra, quatro prompts: por que suas automações de IA se desencontram

Quando a mesma regra está colada em quatro prompts de automação, você não tem uma regra — tem quatro cópias que vão parar de concordar. Corrigir exige achar todo arquivo que a carrega, e a cópia que escapou continua rodando. Com a Arroway a regra é escrita e aprovada uma vez, num lugar compartilhado fora dos prompts, e toda rotina a lê quando abre. A correção é uma única edição, e nenhum prompt fica segurando uma versão que ninguém lembrou de atualizar.

Passar trabalho entre as suas próprias rotinas de IA, sem recontar

Rotinas de IA agendadas costumam passar trabalho uma para a outra recontando — uma anotação num arquivo, uma mensagem num canal, o transcript da rodada de ontem — e fato recontado deriva. Com a Arroway, rodada que para sem terminar deixa um handoff explícito: onde parou, qual é o próximo passo, qual risco ficou aberto, e para quem é. Esse handoff é servido primeiro a quem ler depois, e fica ali até alguém fechar. Nada é herdado como resumo de resumo, e nada cai da lista em silêncio.

Eu mantenho uma planilha de fatos pra colar em cada IA. Existe jeito melhor?

Existe — e a planilha é o instinto certo no lugar errado. Manter uma lista curta e escolhida de fatos e decisões é justamente o que faz um assistente ser útil; o que não funciona é você ser o meio de entrega. A Arroway guarda essa mesma lista num servidor a que suas ferramentas de IA se conectam, então cada assistente lê no começo do trabalho em vez de esperar receber. Você fica com a parte que sempre foi sua, que é decidir o que entra na lista, e para de fazer a parte que pessoa nenhuma deveria fazer, que é carregá-la de ferramenta em ferramenta.

Vamos trocar de ferramenta de IA. Perdemos o que o time já decidiu?

Não, se as decisões nunca estiveram dentro da ferramenta. O que um time perde numa migração é o que guardou na memória da própria ferramenta, nas configurações dela e nos arquivos de configuração de cada uma — aquilo pertence à ferramenta, e exportação nenhuma faz aquilo chegar intacto em outro lugar. A Arroway guarda decisão em outro lugar: um servidor a que as suas ferramentas se conectam. O assistente novo lê, no primeiro dia, o mesmo conjunto sancionado que o antigo lia — a troca custa configuração, não contexto.

Como uma agência de IA mantém a regra de um cliente longe do trabalho de outro?

Mantendo cada cliente no projeto dele, e o jeito de trabalhar da agência num projeto separado. Memória na Arroway tem escopo de projeto e nunca é global: o assistente que trabalha numa conta lê as regras sancionadas daquele cliente mais o método da casa, e nada de nenhum outro cliente — porque as outras contas não estão no escopo daquela leitura, não porque alguém lembrou de deixá-las fora. A mesma pessoa e o mesmo assistente atendem seis contas num dia sem a sexta herdar a voz da primeira.

Associado novo usando IA: como a posição do sócio chega antes

Um associado que trabalha com IA responde com o que a IA sabe, e o que ela sabe é o que ele contou — não o que os sócios bateram o martelo sobre a mesma questão dois anos antes, num caso que ele nunca tocou. A memória curada inverte a ordem: a posição que o escritório já sancionou é servida à IA do associado na abertura do trabalho, antes de existir um primeiro rascunho, e o que aquele assistente concluir por conta própria fica guardado como proposta, nunca como a resposta da casa. O associado começa sabendo onde a casa está, em vez de alguém pegar a contradição na revisão.

Memória compartilhada em consultoria multi-sócio: o que a firma padroniza e o que fica de cada um

Numa consultoria cada sócio tem os clientes dele e o jeito dele de conduzir um projeto, e as duas coisas valem a pena manter — então a pergunta útil não é como fazer a IA de todo sócio responder igual, é qual parte da resposta pertence à firma. A memória curada desenha essa linha de forma explícita: o que a firma vende — o método, os padrões, o que ela não faz, o registro em que ela escreve — se escreve uma vez e é sancionado, e alcança qualquer IA que qualquer sócio conectar. Como cada sócio conduz a conta dele fica no projeto dele, sem padronização, de propósito.

Já tentamos um documento de regras por cliente e ninguém atualizou

O documento compartilhado não falhou por falta de disciplina; falhou porque manter atualizado e ler eram os dois gestos a mais, e gesto a mais perde para trabalho faturável todas as vezes. A memória curada tira os dois. Os assistentes que já estão dentro do trabalho escrevem o que foi decidido no momento em que se decide, e a norma é lida quando um assistente abre o trabalho, não quando alguém lembra de consultar. O que sobra para uma pessoa é uma review curta — aprovar ou corrigir o que foi escrito —, poucos minutos sobre trabalho já feito, e não uma tarefa esperando para ser feita.

Por que não rodar RAG sobre o nosso repositório em vez de mais uma ferramenta de memória de IA?

Porque recuperar e sancionar respondem perguntas diferentes. RAG acha as passagens mais parecidas com o que foi perguntado, dentro de tudo que ele indexou — inclusive a decisão que o time reverteu no trimestre passado, o desenho que nunca foi construído e os dois documentos que se contradizem. Ele não tem como dizer qual dos três está vigente, porque nada num índice carrega isso. A Arroway guarda um conjunto muito menor: as regras e decisões que uma pessoa do time sancionou, cada uma com o nome de quem sancionou e a condição que a encerra. O assistente lê esse conjunto antes de agir. RAG continua achando texto pra você; ele não é o que diz ao assistente qual texto ainda vale.

Como uma agência de IA troca a pessoa alocada num cliente sem perder o que a conta sabe?

Mantendo o que a conta sabe no projeto da própria conta, escrito na hora em que é decidido, em vez de na cabeça de quem está nela agora. Quando alguém sai do cliente, ela perde o acesso àquele projeto, e tudo que registrou lá fica — no nome dela, com a data e o motivo. Quem assume lê as regras vigentes do cliente no primeiro dia, e o assistente dessa pessoa lê o mesmo conjunto. O único que vai embora com quem sai é o que ninguém escreveu, e é por isso que a escrita acontece durante o trabalho, não numa passagem de bastão na semana em que alguém sai.

Como mostrar ao cliente que a nossa IA seguiu as regras dele em vez de inventar uma?

Mostrando o registro que o assistente leu, e não um resumo escrito depois. Toda regra vigente num projeto carrega o que foi decidido, quando e qual pessoa sancionou — e regra que o assistente propôs e ninguém sancionou continua visivelmente como proposta. Então a resposta ao cliente que pergunta de onde veio uma regra é uma linha com data e nome. O que o registro não faz é provar que uma entrega específica saiu dele: ele mostra o que regeu o trabalho, e é a revisão de vocês que amarra uma peça a isso. Afirmar mais seria afirmar mais do que o registro sustenta.

Dá pra indicar uma memória de IA ao portfólio sem virar o suporte dela?

Dá, porque nada passa pelo fundo. Cada empresa cria a própria conta, no nome dela, e conecta os assistentes que o time dela já usa — o fundo não compra licença, não fica como administrador e não guarda chave nenhuma do lado de lá. A metade honesta da indicação é o que instalar não resolve: conectar leva minutos e funciona sozinho, mas nada muda até alguém daquela empresa escrever as primeiras decisões que os assistentes deveriam estar lendo. Esse passo é dela, e indicação que omite isso produz empresa que instalou e nunca usou. Não existe link de indicação nem contrato de revenda pra assinar — a indicação é um link e uma opinião.

Cada sócio faz a diligência com uma IA diferente e as notas nunca batem

O que resolve é pôr o que a diligência já apurou num lugar só, lido pela IA de qualquer sócio, em vez de em dois conjuntos de notas que só se encontram no comitê. Cada achado entra uma vez — o número de receita confirmado e o documento que confirmou, a referência de cliente que voltou fraca, a pergunta que segue aberta — e dali em diante o assistente de qualquer sócio abre o trabalho já com aquilo, seja qual for a ferramenta dele. O que isso tira não é a divergência entre sócios, que é o trabalho: tira duas IAs reportando números diferentes com a mesma confiança porque cada uma leu metade do material.

Nossas rotinas de IA agendadas começam do zero toda rodada. Como elas seguram o fio?

Escrevendo o que cada rodada apurou num lugar que a rodada seguinte lê antes de fazer qualquer coisa. Rotina agendada não tem memória das próprias rodadas — todo disparo é um contexto novo —, então a rodada de hoje redescobre o que a de ontem já tinha resolvido, e ou chega à mesma conclusão pelo mesmo custo, ou chega a outra sem nada ali para contradizê-la. O hábito que conserta tem duas metades: a rodada abre lendo as regras vigentes e o que as rodadas recentes registraram, e fecha registrando o que achou em uma linha ou duas, inclusive quando não achou nada. Rodada que não registrou é indistinguível de rodada que não disparou, e é contra essa falha que vale desenhar.

Eu tenho um segundo cérebro meu. Qual é o segundo cérebro das IAs que meu time usa?

É um registro compartilhado que as IAs leem antes de agir, com o que o time realmente decidiu. Segundo cérebro pessoal é escrito para o próprio autor reler: você escreveu a nota, então ao abri-la você completa em silêncio tudo que ela deixou de fora — que aquela era um talvez, que deixou de valer em março, que a regra de tom é para trabalho de cliente e não para rascunho interno. A IA não tem ninguém do lado para completar nada disso. Então o segundo cérebro das suas IAs precisa dizer em voz alta três coisas que o pessoal nunca precisa: o que é decisão e o que ainda é proposta de alguém, quando cada coisa para de valer, e quem a colocou ali. É isso que torna seguro uma ferramenta ler o registro e agir sem conferir com você antes.

Temos vários agentes de IA e pessoas no mesmo trabalho. Ferramenta de orquestração é o que a gente precisa?

Duas coisas diferentes se chamam orquestração, e só uma delas é problema de agendamento. Ordenar o trabalho — o que roda quando, o que espera o quê, o que tenta de novo depois de falhar — é o que um orquestrador faz, e esta página não manda contratar um. A falha que a maioria dos times encontra de verdade não se parece nada com isso: dois agentes rodam corretamente, ao mesmo tempo, sobre premissas diferentes do que o time decidiu. Nada está atrasado, nada travou, nada tentou de novo — e as duas saídas se contradizem. Isso não se resolve decidindo quem manda em quem. Resolve todo agente e toda pessoa lendo a mesma decisão vigente antes de agir, e registrando o que fizeram. Fila coordena ordem; registro compartilhado coordena acordo — Use a Arroway quando a falha for a segunda: todo agente e toda pessoa leem a mesma decisão vigente antes de agir.

Uma janela de contexto grande o bastante não resolve isso sem ferramenta de memória?

Não, porque as duas resolvem problemas diferentes. Uma janela maior aumenta quanto texto o assistente segura de uma vez. Ela não diz qual desse texto ainda está em vigor, quem o aprovou, nem o que já o substituiu. Coloque a história inteira do time na frente do modelo e você entregou a ele a decisão revertida em março ao lado da que a substituiu, sem nada marcando qual é qual. A Arroway guarda um conjunto bem menor — as regras e decisões que uma pessoa do time aprovou, cada uma com o nome de quem aprovou e a condição que a encerra — e o assistente lê esse conjunto antes de agir. Capacidade nunca foi a peça que faltava. Faltava alguém dizer o que vale agora.

Memória de IA desatualizada não é pior do que memória nenhuma?

O risco é real e é a pergunta certa a fazer: um assistente que afirma com confiança uma regra morta faz mais estrago do que um que pergunta. O que decide é se alguma coisa encerra uma memória além de alguém lembrar de apagá-la. Aqui toda regra e toda decisão é escrita junto com a condição que a encerra — a revogação, a data, o evento que a torna falsa. Cumprida essa condição, a memória se retira e para de ser servida; e a decisão que substitui outra nomeia a que substituiu, em vez de ficar ao lado dela. A falha que você descreve é dos acervos que só acumulam. Aqui a vigência é parte do registro, não uma faxina que alguém precisa agendar.

Por que a IA larga uma regra que combinamos cinco mensagens atrás?

Porque a regra só existiu dentro da conversa. O que se combina no meio da sessão fica na mesma janela que tudo o que veio depois — o código colado, os erros que voltaram, o desvio sobre outro assunto — e os padrões próprios do modelo são para onde ele volta conforme essa disputa fica cheia. Regra que precisa sobreviver a ter sido dita uma vez não está guardada em lugar nenhum: está sendo lembrada por um processo que ninguém pediu para lembrar. Aqui a regra se escreve uma vez, fora de qualquer conversa, e todo assistente lê o conjunto vigente antes de começar. Ela não depende de a sessão lembrar — e é por isso que também sobrevive à sessão seguinte, à outra ferramenta e ao colega que não estava lá.

De quem é a memória quando ela mora no servidor de quem vende a IA?

A pergunta se resolve num teste só: dá para tirar de lá e ler sem o software deles. O recurso de memória embutido num assistente faz parte daquele produto — o que ele guarda, por quanto tempo, em que formato e sob que política são decisões de quem o vende, e mudam sem ninguém consultar você. A Arroway é um registro separado, do seu time. O que está nele é texto que as suas pessoas escreveram, exportável inteiro a qualquer momento, lido por qualquer assistente que esteja trabalhando em vez de por um deles, e regido por regras que o time escreve. A questão não é onde os bytes ficam fisicamente — os nossos também ficam num servidor. É quem decide o que o registro contém, e se ele sobrevive a você mudar de ideia sobre a ferramenta.

Memória de IA sem política de escrita não é só alucinar mais rápido?

É, e é a objeção certa a fazer sobre quase tudo que se vende como memória de agente. Se qualquer coisa que um assistente produz pode virar fato gravado, o acervo passa a ser o lugar onde um erro confiante é preservado e entregue à rodada seguinte como assunto resolvido. Recuperação melhor piora isso em vez de melhorar, porque torna a entrada errada mais fácil de achar. O que quebra o laço é um degrau entre escrever e reger: aqui o assistente pode propor, e só uma pessoa do projeto torna a proposta obrigatória. Até alguém sancionar, ela fica numa fila de revisão como sugestão, e assistente nenhum a lê como regra.

Um grafo de conhecimento não resolve isso ligando os fatos entre si?

Resolve uma parte de verdade, e a parte que ele resolve não é esta. Grafo é bom em identidade: ele descobre que "o serviço de cobrança", "billing-svc" e "o backend de pagamentos" são a mesma coisa, o que uma lista plana de anotações não faz. O que ele não carrega é autoridade. Ligue os fatos daquele serviço e as versões contraditórias passam a chegar juntas — a política de retentativa do ano passado ao lado da deste trimestre, conectadas, coerentes e igualmente presentes, sem nenhuma aresta dizendo qual está em vigor. A Arroway responde essa pergunta primeiro: uma entrada é a vigente, ela nomeia quem a sancionou, e a que ela substituiu é aposentada com o motivo junto.

Nossa IA escreve bastão de 400 linhas e o próximo agente lê metade. O que resolve?

A saída não é prompt mais curto nem regra de estilo mais rígida — é separar o que VIAJA do que fica guardado. Tamanho é o que o leitor paga, e o que o próximo agente precisa cabe numa linha autorada. Na Arroway toda entrada carrega uma essência escrita à mão: o estado operativo numa frase, nunca a cópia da abertura do corpo. É essa linha que a leitura serve. O corpo inteiro continua recuperável e só volta quando alguém pede aquela entrada pelo nome. Assim o registro pode ser tão minucioso quanto o trabalho merecer sem que as próximas doze leituras paguem por isso — e, porque a linha é autorada em vez de truncada, ela diz a coisa, não os primeiros 200 caracteres da coisa.

Já existem dezenas de ferramentas de memória de IA. Por que avaliar mais uma?

Porque aquilo em que elas estão amontoadas não é o que está faltando. Quase toda ferramenta dessa lista responde às mesmas duas perguntas — como o texto é guardado e como ele volta — e nessas duas é genuinamente difícil distinguir umas das outras, que é exatamente o que faz a categoria parecer saturada. A pergunta que nenhuma delas responde por padrão é quem decidiu que uma afirmação guardada é o que o time sustenta, e o que acontece com ela quando alguém muda de ideia. Isso é governança, não recuperação, e mercado de recuperação lotado não diz nada a respeito. A versão honesta da objeção é que não dá para distinguir essas ferramentas no eixo em que você as estava comparando — o que é verdade, e é motivo para trocar o eixo, não para parar de procurar.

Não quero que a IA lembre de mim. Mantenho contexto por projeto. Isso não basta?

Manter contexto por projeto é o instinto certo, e é o mesmo em que isto aqui foi construído — o que se lembra aqui é o projeto, nunca a pessoa. A lacuna não está no recorte que você escolheu, está no que sustenta esse recorte. Contexto por projeto que mora num arquivo deixa o que cair nele — a sua linha, a de um assistente, a do mês passado — governar toda sessão sem ninguém ver nem aprovar, e piora no instante em que uma segunda pessoa, uma segunda máquina ou um segundo assistente toca o mesmo projeto, porque nada no arquivo diz qual versão está vigente nem quem decidiu. Então isto não é produto de perfil pessoal com um ajuste de projeto. A unidade é a decisão do projeto, uma pessoa a sanciona, e quem abrir aquele projeto em seguida a lê — outro colega, outra ferramenta, ou você daqui a três semanas.

Memória de IA é quase sempre só escrita — contexto entra, recuperação sai, e nada nunca é corrigido. O que fecha esse laço?

Um caminho de correção que faz parte do registro, em vez de ficar ao lado dele. Quando algo guardado aqui deixa de ser verdade, três coisas acontecem nesta ordem, e as três ficam conferíveis depois. Quem abriu a fonte e viu a divergência anota o que a fonte diz de fato, pra ninguém precisar ir olhar de novo. A correção então se propõe como substituição que NOMEIA a memória que ela contradiz — não uma linha nova ao lado da antiga. E uma pessoa aceita ou recusa; na aceitação, a afirmação substituída se aposenta no mesmo ato, com o motivo e o autor na linha arquivada dela. Até essa aceitação, o que continua sendo servido é a afirmação anterior. A demora é de propósito: um registro onde o assistente aposenta a decisão do time por julgamento próprio é um diário do que o último modelo achou.

Se toda sessão tem que ler as decisões do time antes de agir, isso não custa tokens em cada chamada?

Custa uma vez por sessão, e depois disso só o que mudou. A leitura de um projeto termina com um carimbo de sessão. Apresente esse carimbo numa chamada seguinte e as regras vigentes são REFERENCIADAS em vez de reimpressas, e o espaço que elas ocupariam vai pro material de que esta tarefa precisa. Medido em produção numa segunda leitura: 4.826 tokens referenciados em vez de reimpressos. O que nunca se pula é a parte que se move — o trabalho em voo, o que aterrissou desde então, e o que ranqueia como relevante pro que você está fazendo agora. Assim, conferir o que o time já decidiu antes de agir para de ficar mais caro quanto mais você confere, que é a propriedade que decide se alguém continua conferindo.

Um grafo de conhecimento compartilhado entre os nossos agentes parece o padrão errado — qualquer um escreve nele, e fato de um projeto acaba no trabalho de outro. Dá pra evitar?

Dá, e as duas metades da objeção pedem respostas diferentes, porque são duas falhas diferentes. A escrita livre se responde com autoridade: escrever algo aqui não transforma aquilo em norma. O que o assistente escreve por iniciativa própria chega como proposta, ou como contexto explicitamente rotulado como não sancionado, e fica assim até uma pessoa aceitar — e aí vira o que o time sustenta, com o nome dela junto. O vazamento se responde com escopo: o projeto é o limite, ele é escolhido na hora de ESCREVER a memória e não filtrado na hora de ler, e material de um projeto não é servido em outro. Nenhuma das duas respostas é propriedade do formato de grafo. Um grafo pode carregar as duas, ou nenhuma — e é por isso que "grafo compartilhado" descreve uma escolha de armazenamento, nunca uma de governança.

A busca acha o documento certo e a resposta ainda sai com a linha desatualizada do começo dele. Por que a recuperação parece correta quando a resposta não é?

Porque recuperar e montar são dois passos, e número verde no primeiro não diz nada sobre o segundo. O que chega ao modelo aqui não é um documento para alguma camada seguinte recortar: é uma afirmação, entregue como uma linha autorada que carrega o ponto operativo, e o corpo inteiro só volta quando alguém pede aquela memória pelo nome. Não existe topo de arquivo para truncar nem parágrafo para escolher errado. Afirmação substituída não é vizinha pior ranqueada da substituta — ela é aposentada no mesmo ato que aceita a substituição, com o motivo e o autor guardados na linha arquivada. E afirmação que alguém viu divergindo da fonte chega marcada como contrariada, em vez de chegar limpa. Qual versão vale se decide uma vez, por uma pessoa, no registro; não se redecide a cada chamada por quem tiver a última palavra sobre o prompt.

Se toda sessão tem que ler de um serviço antes de agir, o que acontece quando esse serviço tem um segundo ruim?

A leitura é tentada de novo em vez de falhar. Banco que escala a zero recusa a primeira chamada depois de um período ocioso enquanto o compute sobe, e ele diz isso: a recusa vem com uma marca explícita do fornecedor significando que a chamada não chegou a um compute e pode ser repetida. Essa marca era ignorada aqui, e a recusa viajava inteira até quem chamou como leitura falha — o que, para uma sessão cujo primeiro ato é conferir o que o time já decidiu, quer dizer seguir sem isso. Desde setembro de 2026 recusa com essa marca é repetida, em até três tentativas, custando da ordem de três quartos de segundo no pior caso. Dois limites impedem que isso vire licença: só a declaração do próprio fornecedor conta, nunca a nossa leitura de uma mensagem de erro, e só instrução que é inequivocamente leitura se repete. O que escreve é tentado exatamente uma vez, como antes.

Regra de agente de IA não deveria ser travada no código, em vez de escrita como memória?

Parte delas, sim — e essas nunca deveriam ter sido instrução. Regra que vale enquanto o sistema for construído do jeito que é, como um deploy por vez, mora numa trava que o agente não consegue pular. Só que a trava sabe impor a regra enquanto ela vale; ela não tem como dizer que a regra deixou de valer, quem decidiu isso ou o que entrou no lugar. A maior parte das regras que um time passa aos agentes é desse segundo tipo: decisão que alguém tomou e alguém vai rever — o que pode ir para o cliente, qual branch sobe, quanto custa um plano. É isso que a Arroway guarda. Cada regra carrega a condição que a encerra, a substituta aponta para a que aposenta, e só uma pessoa torna uma regra vigente. O invariante vai para o código e a decisão vai para a memória; regra que é as duas coisas ganha a trava e o registro de por que a trava existe.

Arroway ou escrever no CLAUDE.md: qual é a diferença?

O CLAUDE.md é um arquivo no repositório: alguém escreve, alguém mantém em dia, e o assistente de código que trabalha naquele repositório o carrega. A Arroway é uma memória compartilhada que toda ferramenta de IA conectada a um projeto lê antes de agir — Claude, ChatGPT, Codex e as outras ferramentas que falam o mesmo padrão de conexão. Ela guarda o que o arquivo não consegue: quais regras e decisões estão vigentes agora, quem decidiu cada uma, o que as encerraria e o que já foi aposentado. Os assistentes escrevem nela como proposta, e uma pessoa aprova o que passa a valer. Ela não lê seu código, seu repositório nem seus dados, e não roda seus agentes. A recomendação da Arroway é deixar o CLAUDE.md vazio: o que vale vai para a Arroway, onde alguém vê e aprova, para que as pessoas e as IAs delas trabalhem a partir do mesmo combinado.

Como impedir que meus agentes de IA esqueçam as decisões?

Pare de pedir ao agente que lembre, e faça toda sessão começar lendo. O agente não carrega decisão de uma sessão para outra: a conversa acaba, o contexto é compactado, outro agente assume o trabalho, e o que ficou combinado na terça simplesmente não está na frente do modelo na quarta. Os consertos de sempre — um arquivo de decisões, um vector store, um checkpoint — resolvem o armazenamento, e armazenar nunca foi a parte difícil. O que eles deixam em aberto é se a sessão seguinte de fato lê antes de agir, e se ela consegue distinguir a decisão vigente da que foi superada. A Arroway cobre as duas coisas sem nada para montar: toda sessão abre lendo o projeto, cada decisão carrega quem a tomou e o que a encerraria, e a substituta aposenta a antiga. Funciona igual com um agente só e nenhum time — quem lê é o mesmo agente, amanhã.

Servidor MCP de memória para times: o que ele deve entregar ao agente antes de agir?

Um servidor MCP de memória é um servidor que as suas ferramentas de IA chamam para ler e gravar o que um projeto sabe. Para um time, o teste é o que ele entrega ao agente antes de o trabalho começar: o que está em vigor agora, quem decidiu cada coisa e o que já foi aposentado — não só o texto guardado que mais se parece com a pergunta. A Arroway é um servidor MCP remoto construído em torno dessa leitura. A sessão abre lendo o projeto, na ordem da tarefa que o agente diz que vai fazer; toda regra e decisão carrega o autor e a condição que a encerra; a substituta aposenta a que ela substitui; e o que um assistente grava por conta própria chega como proposta até uma pessoa aprovar. Ela se conecta ao Claude pelo diretório de conectores, ao ChatGPT e ao Codex, ao Cursor pelo plugin, e a qualquer ferramenta que aceite servidor MCP remoto. A página de instalação mostra a rota da ferramenta que você usa.

Como eu vejo o que a minha IA deixou para a próxima sessão — e dá para confiar?

Dá para confiar até onde dá para conferir, então o recado precisa ser algo que se confere. Quando uma sessão se resume para a próxima, esse resumo costuma ser um texto que a próxima sessão lê e ninguém mais vê: você só descobre o que ele dizia quando o trabalho dá errado. Na Arroway, a sessão que para com trabalho por terminar deixa um handoff com partes fixas — onde parou, o único próximo passo, o que já está conferido e não se refaz, o risco que fica aberto, e para quem ele é. Ele aparece no painel do projeto antes de alguém continuar, com o nome de quem o deixou, se alguém já o pegou e se alguma IA já o leu. Só uma pessoa pode descartá-lo, e o descarte fica no registro. A Arroway não confere se o recado é verdadeiro; ela garante que uma pessoa consiga conferir.

Qual é a melhor ferramenta de memória compartilhada para agentes de IA e times?

Depende de uma pergunta que a maioria das comparações pula: quando os seus agentes leem a memória, eles precisam do que foi dito ou do que está decidido? As listas de ferramentas de memória para IA — Mem0, Zep, Letta, Cognee, Supermemory, Graphiti, LangMem e outras — costumam ser comparadas pela qualidade de guardar e recuperar, e nesse eixo é difícil distingui-las. Para um time, as perguntas que as separam são outras: quem pode tornar uma afirmação vigente, como uma afirmação deixa de valer, e se todo agente e toda pessoa leem a mesma versão atual antes de agir. A Arroway é construída sobre essas três: uma pessoa aprova o que vira regra, toda regra carrega a condição que a encerra e a substituta aposenta a antiga, e as sessões em toda ferramenta conectada abrem lendo o projeto, enquanto a que não leu não consegue propor uma memória. Esta página não ranqueia ninguém; ela dá as perguntas para fazer a cada ferramenta, e a resposta da Arroway a cada uma.

O que o Artigo 26 do AI Act exige de quem usa IA sobre supervisão humana?

O Artigo 26 define os deveres de quem usa um sistema de IA de alto risco no próprio trabalho — o implantador, e não o fornecedor que o construiu. Dois desses deveres falam de pessoas e de registro: a supervisão tem de ser atribuída a pessoas nomeadas, com a competência, o treinamento e a autoridade para exercê-la, e os logs que o sistema gera têm de ser guardados, na medida em que estejam sob o seu controle, por pelo menos seis meses. Ainda não vale. As obrigações de alto risco foram adiadas para 2 de dezembro de 2027 nos sistemas do Anexo III — contratação, crédito, educação, acesso a serviços essenciais e afins — e para 2 de agosto de 2028 na IA embarcada em produto já coberto pela legislação de segurança da UE; só os deveres de transparência valem desde 2 de agosto de 2026. É preparação, com mais de um ano de folga. Um registro de supervisão humana precisa mostrar quem supervisiona e com que autoridade, sob que regras a IA trabalhou e desde quando, o que mudou e quem mudou, e o que cada IA leu antes de agir. A Arroway guarda esse lado humano do registro; ela não substitui os logs do próprio sistema e não é relatório de conformidade.

O Claude Code lê o AGENTS.md?

Sim, desde a versão 2.1.277 (18 de setembro de 2026) — mas, por padrão, só quando o projeto não tem CLAUDE.md. Se houver um CLAUDE.md, .claude/CLAUDE.md ou CLAUDE.local.md no diretório de trabalho ou em qualquer diretório acima dele, o Claude Code lê esses e deixa o AGENTS.md de fora, sem erro nenhum. O padrão muda em "Project instructions" no /config, por exemplo para ler os dois arquivos, e uma versão de 24 de setembro estendeu o suporte a Amazon Bedrock, Google Vertex AI, Microsoft Foundry, gateways de LLM e sessões com telemetria desligada. Qual arquivo é carregado decide quais instruções valem, e nada avisa o time. A recomendação da Arroway é deixar os dois arquivos vazios: o que está neles governa toda sessão sem ninguém ver nem aprovar, e nunca chega a um assistente de chat, a outro agente ou a uma pessoa fora do repositório. O que vale vai para a Arroway, com quem decidiu e quando deixa de valer, e toda ferramenta conectada lê isso antes de agir, seja qual for o arquivo que ela carrega.

Arroway vs Mem0: qual é a diferença?

O Mem0 é uma camada de memória que você embute no seu próprio aplicativo ou agente de IA: você manda a conversa, um LLM a destila em fatos, e na consulta ele devolve as memórias mais relevantes para o pedido, organizadas por usuário, agente, aplicativo ou execução. Existe como plataforma gerenciada e como código aberto. A Arroway não se embute em nada: é uma memória compartilhada de um projeto, que toda ferramenta de IA que você já usa — Claude, ChatGPT, Codex, Cursor ou qualquer uma via MCP — lê antes de agir. A diferença está no que cada uma faz. O Mem0 lembra o que foi dito, para um aplicativo personalizar para cada usuário dele. A Arroway guarda o que foi decidido: quem decidiu, o que está em vigor, o que encerra a decisão e o que ela substituiu — com os assistentes escrevendo propostas e uma pessoa aprovando o que passa a valer. Use a Arroway quando os agentes e as pessoas do seu time precisarem agir sobre as mesmas decisões vigentes em qualquer ferramenta. O primeiro passo é a página de instalação.

Arroway vs Zep: qual é a diferença?

O Zep é uma camada de contexto para aplicativos de IA construída sobre um grafo de conhecimento temporal: ele recebe conversas e dados do negócio, extrai fatos e relações, e quando um dado novo invalida um fato anterior ele grava o momento em que aquele fato deixou de valer. O motor de código aberto dele, o Graphiti, faz o mesmo em grafos que você mesmo roda. A Arroway é uma memória compartilhada de um projeto, que toda ferramenta de IA que você já usa lê antes de agir. As duas guardam o histórico em vez de sobrescrever. A diferença é quem decide que algo mudou. No Zep, a mudança é inferida dos dados que chegam. Na Arroway, uma pessoa aprova o que vira regra, toda regra carrega a condição que a encerra, e a substituta diz qual regra aposenta. Use a Arroway quando o time precisar assumir a decisão: uma pessoa aprova, e o próximo agente, em qualquer ferramenta conectada, lê a que ainda está vigente. O primeiro passo é a página de instalação.

Arroway ou Settled: qual decisão obriga o próximo agente?

As duas mantêm uma pessoa na decisão, e as duas deixam o agente perguntar o que ainda vale. O Settled é um agente de ledger de decisões no Slack: o repositório dele descreve detectar decisões atrás de um portão de confiança mais uma marca humana, acompanhar cada uma de proposta a contestada, firmada e superada, guardar a citação literal e o link de volta à mensagem, e expor um servidor MCP para o agente chamar is_binding antes de agir. A Arroway é a memória do projeto que todo assistente conectado lê antes de agir — Claude, ChatGPT, Codex, Cursor ou qualquer ferramenta por MCP — e uma decisão só passa a obrigar quando uma pessoa aprova, carrega a condição que a encerra e sai da leitura seguinte quando outra decisão a substitui. Use a Arroway quando essa decisão tiver que chegar antes de o próximo agente agir, em qualquer ferramenta conectada, inclusive a que nunca viu a mensagem. O primeiro passo é a página de instalação.

Arroway ou Basic Memory Teams: conhecimento compartilhado, ou decisão em vigor?

O Basic Memory Teams é uma base de conhecimento compartilhada para o time e para todo agente de IA conectado a ela. A documentação diz que uma decisão capturada na sessão de Claude de uma pessoa vira contexto para a rodada de Codex de outra, que os agentes leem um grafo compartilhado e escrevem notas de volta, que toda mudança aparece num feed de atividade e que cada gravação guarda um histórico de arquivo para voltar atrás. A Arroway é a memória do projeto que essas mesmas ferramentas leem antes de agir, e uma afirmação só vira regra quando uma pessoa aprova. A diferença aparece quando a nota de um agente contradiz uma decisão que uma pessoa já tomou. O Basic Memory guarda as duas na base, com o histórico do arquivo. A Arroway mantém a decisão aprovada na leitura e segura a nota do agente como proposta até uma pessoa aprovar a substituição. Use a Arroway quando o próximo agente precisar tratar uma afirmação como a decisão em vigor. O primeiro passo é a página de instalação.

Arroway ou Snipara: contexto para a próxima mudança de código, ou decisão que também sai do repositório?

A Snipara é inteligência de projeto compartilhada para agentes de código. O site dela diz: troque o agente e fique com o projeto — decisões revisadas, fontes e checks para Claude Code, Codex e Cursor. A página de contexto de código, atualizada em 24 de setembro de 2026, guarda os arquivos do repositório num projeto com escopo de código e diz que fluxos de negócio — RFP, pacote de proposta, dossiê de cliente — agora moram na Helvabase, enquanto a Snipara fica no contexto de repositório, no fluxo de quem desenvolve, num MCP hospedado, em memória e em agentes de código. A Arroway é a memória do projeto que toda ferramenta conectada lê antes de agir, inclusive um chat que nunca abriu o repositório. Use a Arroway quando essa mesma regra também tiver que obrigar um agente que nunca abriu o repositório. O primeiro passo é a página de instalação.

Arroway vs Letta: qual é a diferença?

A Letta é uma plataforma para construir agentes com estado: o agente que você cria lá guarda a própria memória entre conversas, e parte dessa memória são blocos de memória que ficam na janela de contexto do agente e que ele mesmo lê e reescreve com ferramentas embutidas. Vários agentes podem se ligar ao mesmo bloco, e um bloco pode ser marcado como somente leitura. Ela roda na Letta Cloud ou num servidor que você mantém. A Arroway não é um lugar para construir agente: é uma memória compartilhada de um projeto, que toda ferramenta de IA que você já usa — Claude, ChatGPT, Codex, Cursor ou qualquer ferramenta MCP — lê antes de agir. A diferença é onde a memória mora e quem a edita. Na Letta ela mora dentro dos agentes que você constrói ali, e o agente a edita. Na Arroway ela mora fora de todo agente, os assistentes escrevem propostas, e uma pessoa aprova o que vira regra, com a condição que a encerra. Use a Arroway quando os agentes e as pessoas que fazem o trabalho estão em ferramentas que você não construiu e precisam agir sobre as mesmas decisões vigentes. O primeiro passo é a página de instalação.

Quem responde pelo que um agente de IA faz num time?

Uma pessoa com nome, para cada agente, e escrito onde o próprio agente lê. A pergunta é comum porque a resposta no papel e a real são diferentes: uma pesquisa da Ivanti com 1.500 profissionais de TI, noticiada pelo VentureBeat em junho de 2026, achou 85% dizendo que todo agente de IA tem um dono nomeado e só 42% dizendo que a responsabilidade é de fato clara. O que funciona é o jeito como um gestor responde pelo trabalho de uma pessoa. Um humano responde pelos resultados do agente. Uma lista curta diz o que o agente faz sozinho, o que entrega para aprovação e o que nunca toca. Um registro mostra o que ele fez. Essas linhas precisam mudar quando o time decide outra coisa, e o agente precisa ler a versão atual antes de agir. A Arroway é onde isso mora: cada decisão leva quem a tomou e o que a encerra, cada entrada de registro e cada passagem de bastão leva quem a escreveu, e toda ferramenta conectada lê o que está em vigor. O primeiro passo é a página de instalação.

Como se escreve a descrição de função de um agente de IA?

Do mesmo jeito que para uma contratação nova, em uma página, antes de o agente começar. A orientação da Harvard Business Review de março de 2026 sobre integrar agentes de IA diz que todo agente deve ter uma descrição de função que diga pelo que ele responde, onde a autoridade dele acaba e quando ele precisa pedir a opinião de uma pessoa. Uma versão utilizável tem sete linhas: para que o agente existe, a pessoa que responde por ele, o que ele faz sozinho, o que entrega para aprovação, o que nunca toca, a quem avisa quando trava e para onde vai o registro dele. A ficha só funciona se o agente a lê antes de agir e se ela muda quando o time decide outra coisa. A Arroway é onde a ficha pode morar, como um conjunto de regras que toda IA do time lê no começo de uma sessão, cada uma com quem a decidiu e quando ela termina. O primeiro passo é a página de instalação.

Como integrar uma pessoa nova num time que já trabalha com agentes de IA?

Entregue à pessoa nova, no primeiro dia, as quatro coisas que ela aprenderia interrompendo gente: quais agentes o time usa e quem responde por cada um, o que foi decidido e está valendo hoje, o que está pela metade e com quem, e como pedir correção quando um agente erra. A orientação da Harvard Business Review de março de 2026 trata agentes como colegas que precisam de um plano de integração próprio; o outro lado disso é que a pessoa que chega ao lado deles também precisa de um, e ele não deve ser o histórico inteiro do projeto. A versão mais curta é uma leitura, não um documento: o assistente da própria pessoa abre lendo o que está valendo no projeto e conta para ela. A Arroway é onde isso mora: decisões com quem as tomou e quando terminam, bastões com dono e o registro do que cada agente fez, lidos por toda ferramenta conectada antes de agir. O primeiro passo é a página de instalação.

Quais são as alternativas ao CLAUDE.md para compartilhar o contexto de IA num time?

Três das respostas continuam sendo arquivos. O AGENTS.md é um arquivo único que vários agentes de código leem; a documentação do Cursor diz que o suporta na raiz do projeto e em subpastas, o GitHub Copilot também o lê, e o Claude Code só o lê quando o projeto não tem CLAUDE.md. Os arquivos de regra de cada ferramenta — .cursor/rules do Cursor, .github/copilot-instructions.md do Copilot, GEMINI.md do Gemini CLI — dão a cada uma as próprias instruções. Uma importação ou um link simbólico faz de vários desses arquivos um só. As três mudam qual arquivo a ferramenta lê, não o que o arquivo é: texto que o modelo carrega em toda sessão e em que um assistente pode escrever, sem nada que diga quem aprovou uma linha ou se ela ainda vale, longe dos olhos de quem não abre o repositório. A alternativa que muda isso é tirar do arquivo o que vale e levar para onde alguém vê e aprova. A Arroway é esse lugar: regras e decisões por projeto, cada uma com quem a aprovou e quando termina, lidas antes de agir por toda ferramenta conectada. O primeiro passo é a página de instalação.

Como manter CLAUDE.md, AGENTS.md e GEMINI.md em sincronia?

Não copiando. Cópias divergem na primeira vez que uma regra muda num arquivo e nos outros não, e a ferramenta que lê o desatualizado segue a regra morta sem nenhum erro. Dentro de um repositório, os arquivos podem virar um só: o CLAUDE.md pode importar o AGENTS.md, e a opção context.fileName do Gemini CLI pode apontá-lo para o AGENTS.md. Isso põe os agentes de código num texto só, e continua sendo um arquivo: não diz quem decidiu uma linha, quando ela deixa de valer nem se um assistente a acrescentou numa sessão, e não alcança a ferramenta que não lê o repositório. Uma regra fica em sincronia quando mora uma vez, fora de todo arquivo, onde alguém a vê e a aprova, e toda ferramenta a lê dali. A Arroway é esse lugar: cada regra com quem a aprovou e quando termina, lida por todo assistente conectado antes de agir. O primeiro passo é a página de instalação.

Arroway vs LangMem: qual é a diferença?

O LangMem é uma biblioteca da LangChain para um agente construído no LangGraph aprender com as próprias conversas. A documentação dele descreve memória semântica (fatos, guardados como coleção pesquisável ou como perfil), memória episódica (interações passadas guardadas como exemplos) e memória procedural, em que as instruções do próprio agente são refinadas a partir de feedback por um otimizador de prompt. O agente decide o que guardar por ferramentas de memória, e as memórias ficam num armazenamento do LangGraph que você fornece. A Arroway não é uma biblioteca dentro de um agente: é uma memória compartilhada do projeto que toda IA que você já usa — Claude, ChatGPT, Codex, Cursor ou qualquer ferramenta MCP — lê antes de agir. A diferença é quem decide o que é verdade. No LangMem o agente extrai e reescreve, inclusive as próprias instruções. Na Arroway os assistentes escrevem propostas, e uma pessoa aprova o que vira regra, com a condição que a encerra. Use a Arroway quando as pessoas e os agentes que fazem o trabalho estão em ferramentas que você não construiu e precisam agir sobre as mesmas decisões atuais. O primeiro passo é a página de instalação.

Como compartilhar um Projeto do Claude com o time?

A central de ajuda do Claude diz que o compartilhamento está disponível nos planos Team e Enterprise. Um projeto é público, e então todos da organização podem ver e usar, ou privado, e então só as pessoas convidadas; quem é convidado recebe acesso de visualização ou de edição, e as conversas dentro de um projeto não são compartilhadas a menos que alguém compartilhe cada uma. Isso resolve uma coisa bem: todo mundo que usa o Claude nesse plano abre as mesmas instruções e o mesmo conhecimento do projeto. E para onde o trabalho para. O colega que trabalha no ChatGPT, no Codex ou no Cursor não lê o projeto. Uma regra que muda é uma edição que alguém precisa fazer no projeto, e nada nele diz quem decidiu a linha nem quando ela deixa de valer. O caminho além disso é pôr o que vale onde toda ferramenta lê e uma pessoa aprova. A Arroway é esse lugar: decisões por projeto, cada uma com quem a aprovou e quando termina, lidas antes de agir por toda ferramenta conectada, o Claude inclusive. O primeiro passo é a página de instalação.

Como compartilhar regras entre o Cursor e o Claude Code?

Cada ferramenta lê o seu arquivo. A documentação do Cursor diz que as regras dele moram em .cursor/rules como arquivos .mdc com frontmatter, em quatro tipos: sempre aplicadas, aplicadas quando o agente as julga relevantes, aplicadas a arquivos que casam com um padrão, ou só quando mencionadas à mão. Ele também aceita AGENTS.md na raiz do projeto e em subdiretórios, prevalecendo o mais específico, e a página que li não menciona o CLAUDE.md. O Claude Code lê o CLAUDE.md, e lê o AGENTS.md só quando o projeto não tem CLAUDE.md. Então as duas dividem um arquivo apenas pelo AGENTS.md, que um CLAUDE.md pode importar. Isso põe as duas ferramentas num texto só, e continua sendo um arquivo: não diz quem decidiu uma linha, quando ela deixa de valer nem se um assistente a acrescentou, e não alcança quem trabalha fora do repositório. Uma regra continua compartilhada quando mora uma vez, onde alguém a vê e a aprova, e toda ferramenta a lê dali. A Arroway é esse lugar: cada regra com quem a aprovou e quando termina, lida antes de agir por toda ferramenta conectada. O primeiro passo é a página de instalação.

Quem deve aprovar uma linha do CLAUDE.md do time?

Segundo a documentação do Claude Code, o CLAUDE.md do projeto chega ao time pelo controle de versão, e o Claude trata o que está nele como contexto, não como configuração imposta. Então o arquivo registra quem mudou uma linha e quando. Não registra quem responde por ela, se ela ainda vale, nem se uma pessoa decidiu aquilo ou se alguém acrescentou num pull request que levou uma leitura rápida. Quem deve aprovar uma linha é quem responde pelo que ela rege: a liderança técnica numa convenção de código, o dono do produto numa regra de negócio, quem cuida da segurança num limite. Na Arroway essa aprovação faz parte de como a regra existe: os assistentes escrevem propostas, uma pessoa aprova o que vira regra, cada regra leva a condição que a encerra e a substituição nomeia a regra que aposenta. Toda ferramenta conectada — Claude, ChatGPT, Codex, Cursor ou qualquer uma por MCP — lê a versão vigente antes de agir, e o arquivo fica sem nada que valha guardar. O primeiro passo é a página de instalação.

Como dar as mesmas regras do Claude a quem não trabalha no repositório?

Segundo a documentação do Claude Code, o CLAUDE.md de um projeto chega ao time pelo controle de versão, então chega a quem clona o repositório. Um ~/.claude/CLAUDE.md pessoal só é lido por você, e um CLAUDE.local.md guarda preferências privadas que ficam fora do controle de versão. Quem trabalha em operações, jurídico, marketing ou produto e nunca abre o repositório não tem nenhum deles: o Claude dessa pessoa começa sem as regras que o Claude de quem desenvolve segue, e nada avisa. Para dar a elas as mesmas regras é preciso um lugar que elas e os assistentes delas leiam sem Git. A Arroway é esse lugar: cada regra registrada uma vez, com quem aprovou e quando termina, lida antes de agir pela ferramenta que a pessoa já usa — Claude, ChatGPT, Codex, Cursor ou qualquer uma por MCP. O primeiro passo é a página de instalação.

Arroway vs Cognee: qual é a diferença?

O Cognee se descreve como uma forma de transformar documentos e conversas em memória que agentes de IA conseguem recuperar. Segundo a documentação dele, os dados entram com remember, são divididos em trechos dos quais se extraem entidades e conceitos para um grafo de conhecimento, e são consultados com recall. Ele roda como biblioteca Python que você hospeda ou como Cognee Cloud, tem bindings em TypeScript e cita MCP; as páginas que li mencionam permissões por conjunto de dados para um time só no Cognee Cloud. A Arroway não é construída a partir dos seus dados: é uma memória compartilhada do que as pessoas de um projeto decidiram, que toda IA que você já usa — Claude, ChatGPT, Codex, Cursor ou qualquer uma por MCP — lê antes de agir. A diferença está no que entra e em quem decide que é verdade. No Cognee, o que o agente recupera vem dos documentos e conversas que recebeu, organizados por extração. Na Arroway, os assistentes escrevem propostas, e uma pessoa aprova o que vira regra, com a condição que a encerra. Use a Arroway quando uma decisão precisa chegar a várias ferramentas e pessoas como a vigente, com dono. O primeiro passo é a página de instalação.

Arroway vs Supermemory: qual é a diferença?

O Supermemory se descreve como infraestrutura de contexto para agentes de IA, que dá a um agente memória de longo prazo de cada usuário. Segundo a documentação dele, você envia conversas, documentos, arquivos ou URLs; um pipeline de memória extrai fatos, monta um perfil e um grafo, e a busca devolve memórias, trechos ou os dois. Ele oferece uma instalação local que você hospeda, tem servidor MCP e páginas de integração para Claude Code e Cursor, e isola os dados por namespace, que a documentação chama de fronteira rígida para um usuário, um tenant ou um projeto. A Arroway não é construída a partir do que foi dito a um agente: é uma memória compartilhada do que as pessoas de um projeto decidiram, que toda IA que você já usa — Claude, ChatGPT, Codex, Cursor ou qualquer uma por MCP — lê antes de agir. A diferença está em quem decide o que é o vigente. No Supermemory, as páginas que li dizem que o modelo de aprendizado decide o que é importante e quando esquecer. Na Arroway, os assistentes escrevem propostas, uma pessoa aprova o que vira regra, cada regra carrega a condição que a encerra, e a substituta nomeia a regra que aposenta. Use a Arroway quando uma decisão precisa chegar a várias ferramentas e pessoas como a vigente, com dono. O primeiro passo é a página de instalação.

Arroway vs MemoryLake: qual é a diferença?

O MemoryLake descreve um Memory Passport: uma memória só, mantida entre ChatGPT, Claude, Gemini e qualquer agente compatível com MCP. Segundo o próprio post do blog dele, de 18 de janeiro de 2026, as memórias têm seis tipos, cada entrada registra a plataforma e a conversa de origem e uma nota de confiança, toda criação, alteração e exclusão fica guardada como evento num registro ordenado, e uma detecção de conflito em três níveis aplica regras de resolução quando duas plataformas alteram a mesma memória. Ele descreve também um espaço compartilhado para times, na nuvem ou no seu próprio ambiente. A Arroway não é uma cópia portátil do que você e seus agentes disseram: é uma memória compartilhada do que as pessoas de um projeto decidiram, que toda IA que você já usa — Claude, ChatGPT, Codex, Cursor ou qualquer uma por MCP — lê antes de agir. A diferença está em quem encerra um conflito. Na página do MemoryLake que li, a entrada conflitante de time é sinalizada para resolução, e a página não diz quem resolve. Na Arroway, os assistentes escrevem propostas, uma pessoa aprova o que vira regra, cada regra carrega a condição que a encerra, e a substituta nomeia a regra que aposenta. Use a Arroway quando uma decisão precisa chegar a várias ferramentas e pessoas como a vigente, com dono. O primeiro passo é a página de instalação.

copilot-instructions.md vs CLAUDE.md: você precisa dos dois?

Segundo a documentação do GitHub, o Copilot lê o .github/copilot-instructions.md para o repositório inteiro, arquivos .instructions.md específicos de caminho que trazem um padrão applyTo, arquivos AGENTS.md (o mais próximo na árvore de diretórios tem precedência) e um único CLAUDE.md ou GEMINI.md na raiz do repositório como alternativa ao AGENTS.md. Então o Copilot consegue ler um CLAUDE.md sozinho; o que um CLAUDE.md não dá a ele são regras por caminho, que existem só em arquivos .instructions.md, e a documentação diz que instruções por caminho hoje são aceitas no GitHub.com apenas pelo agente de nuvem do Copilot e pela revisão de código do Copilot. Quando um arquivo do repositório inteiro e um de caminho específico valem para o mesmo arquivo, o Copilot usa os dois. Entre instruções pessoais, de repositório e de organização, todos os conjuntos relevantes são fornecidos, e a documentação aconselha evitar conflitos entre eles. Nenhum dos dois arquivos registra quem decidiu uma linha nem quando ela deixa de valer. Na Arroway, os assistentes escrevem propostas, uma pessoa aprova o que vira regra, cada regra carrega a condição que a encerra, e o Copilot, o Claude Code, o Cursor ou qualquer ferramenta por MCP lê a versão vigente antes de agir. O primeiro passo é a página de instalação.