PathrulePathrule vs Letta
O Letta é uma plataforma para construir agentes com estado: você define blocos de memória que vivem na janela de contexto do agente, e o próprio agente os edita com ferramentas embutidas. O Pathrule não lhe dá um agente. Ele alimenta os que você já usa (Claude Code, Codex, Cursor, GitHub Copilot ou Windsurf) com o conhecimento que rege o caminho em que eles estão trabalhando.
O que o Letta acerta, e um mérito que vale reconhecer direito
O Letta descende do artigo do MemGPT e tirou dele a lição certa: um agente deve gerenciar a própria memória. Os blocos de memória são seções estruturadas da janela de contexto que persistem entre interações e ficam sempre visíveis, sem recuperação, e o agente os lê e atualiza com ferramentas embutidas. Por trás disso fica a memória de arquivo (archival memory), um armazenamento com busca semântica consultado sob demanda, então o agente move o conhecimento entre o que ele sempre vê e o que ele pode consultar.
O mérito que vale reconhecer explicitamente: a memória central (core memory) não espera ser consultada. Ela está na janela de contexto por construção. Então o argumento que este site usa contra APIs de memória, de que elas só respondem quando perguntadas, não se aplica aos blocos centrais do Letta, e fingir o contrário seria desonesto.
O harness é de código aberto, com uma nuvem gerenciada ou um servidor auto-hospedado, e o Letta cita agentes de programação entre as coisas que você pode construir com ele.
Lado a lado
| Letta | Pathrule | |
|---|---|---|
| O que você recebe | Uma plataforma para construir um agente com estado | Uma camada de inteligência para os agentes de programação que você já usa: CLI, servidor MCP, extensão para VS Code e Pathrule Cloud |
| Quem edita o conhecimento | O agente, com ferramentas de memória embutidas | Sua equipe e os agentes dela; as constatações aprendidas continuam consultivas, e os padrões da equipe precisam da aprovação de uma pessoa |
| Sempre no contexto | Blocos de memória, por construção | O recorte vinculado ao caminho, injetado antes da primeira chamada de ferramenta |
| Como escala além da janela | Memória de arquivo, consultada sob demanda | Escopo por caminho: só o recorte deste diretório é enviado |
| Organizado por | Blocos como human, persona, task | Caminhos do repositório |
| Restrições que podem bloquear uma alteração | Não é o propósito dele | As regras levam escopo, prioridade e nível de aplicação |
| Como os agentes se conectam | Em vez disso, você constrói o agente | O `pathrule setup` conecta Claude Code, Codex, Cursor, GitHub Copilot e Windsurf; qualquer cliente MCP pode usar o servidor |
As afirmações sobre o Letta vêm da documentação e do blog dele, consultados em agosto de 2026. Se alguma linha estiver errada, avise e nós corrigimos.
Onde os dois realmente divergem
Construir um agente ou equipar os que você tem. O Letta é a ferramenta certa se o produto que você está entregando É um agente e você quer que a memória dele seja de primeira classe. O Pathrule parte do princípio de que você já usa Claude Code, Codex, Cursor, GitHub Copilot ou Windsurf e prefere não reconstruir o agente.
Blocos são curados. Caminhos já vêm prontos.. Os blocos de memória são seções que alguém projeta: um bloco human, um bloco persona, um bloco task. É um bom modelo para um assistente com um papel. Para código, a estrutura já existe: o repositório. O Pathrule usa isso como chave, então o que um agente recebe enquanto edita
/services/billingnão exige nenhum design de blocos.Autoedição versus conhecimento revisado. Um agente editando a própria memória é poderoso e também não é revisado: nada o impede de escrever algo errado e depois ler aquilo como fato. No Pathrule, o que um agente salva fica em um espaço de trabalho compartilhado onde a equipe pode ver, editar e remover, as constatações que ele registra continuam consultivas e nunca são promovidas a regras automaticamente, e os padrões da equipe só chegam aos agentes depois que uma pessoa os verifica. Isso é mais lento por item, e é justamente esse o ponto quando o conhecimento é compartilhado com uma equipe.
Qual escolher
Escolha o Letta quando você está construindo um produto que é um agente e a memória dele faz parte do que você entrega, ou quando quer que o próprio agente seja dono do que lembra.
Escolha o Pathrule quando os agentes já estão escolhidos e o problema é que eles agem dentro do seu repositório sem saber o que sua equipe decidiu. Se as duas coisas forem verdade, eles não colidem: o Letta dentro do seu produto, o Pathrule sob os agentes de programação que o constroem.
Fontes e verificação
Documentação oficial verificada em 1º de outubro de 2026. A versão do produto Letta não estava disponível na documentação analisada, e ele não foi testado localmente. As afirmações sobre o Pathrule foram revisadas com base na versão lançada da CLI do Pathrule 0.6.1, em 9 de outubro de 2026.
- Letta: visão geral da plataforma
Posicionamento oficial da plataforma de agentes com estado e do harness de código aberto.
- Letta: como anexar e desanexar blocos de memória
Comportamento oficial dos blocos persistentes que continuam visíveis no contexto do agente.
Perguntas frequentes
O Pathrule é um framework de agentes como o Letta?
Não, e essa é a principal diferença. O Letta é uma plataforma para construir um agente com estado. O Pathrule se conecta aos agentes de programação que você já usa (Claude Code, Codex, Cursor, GitHub Copilot e Windsurf) e dá a eles conhecimento compartilhado e vinculado a caminhos, que sobrevive à troca entre eles.
Os blocos de memória do Letta estão sempre no contexto. Isso não é melhor do que injeção?
Para um conjunto fixo de blocos, é um design limpo, e nós reconhecemos isso. O trade-off está na escala: tudo sempre no contexto disputa a janela, então funciona melhor quando o conhecimento cabe em alguns blocos curados. O Pathrule parte de centenas de memórias e regras espalhadas por um repositório e envia só o recorte que rege o caminho atual.
Um agente consegue escrever conhecimento no Pathrule do jeito que um agente do Letta edita a própria memória?
Ele consegue salvar, e a equipe continua no controle. As ferramentas MCP permitem que um agente escreva uma memória, regra ou skill, que então fica no espaço de trabalho, onde sua equipe pode ver, editar ou remover. O que o Pathrule aprende por conta própria é tratado com mais cuidado: as constatações continuam consultivas e nunca são transformadas em regras automaticamente, e os padrões da equipe só chegam aos agentes depois que uma pessoa os verifica. Para conhecimento compartilhado pela equipe, essa etapa de revisão é o recurso, não um atrito.
Os dois são de código aberto. É a mesma coisa?
São peças diferentes. O Letta abre o código do harness de agentes, com implantação na nuvem ou auto-hospedada. O Pathrule abre o código do núcleo de contexto: o motor vinculado a caminhos, a superfície MCP e um backend SQLite embutido que roda o ciclo sem conta e sem rede.