Por Yosef e Or, co-fundadores da Atbash
A crença mais perigosa sobre IA hoje não é que os modelos se tornarão poderosos.
Essa parte é óbvia.
A crença perigosa é mais sutil. É a suposição que está por baixo de quase todo roteiro de produto, camada de governança, sistema de permissões, stack de auditoria e framework de agentes sendo construídos agora:
Que, à medida que os modelos melhoram, os sistemas construídos ao redor deles se tornarão mais seguros como consequência.
Não acredito que seja assim que isso se desenrola.
Acredito que estamos prestes a entrar em um período em que os produtos de IA vão piorar nas dimensões que realmente importam:
confiança,
contenção,
previsibilidade,
capacidade de recuperação.
Os benchmarks vão subir.
As demonstrações vão ficar mais limpas.
Os agentes vão se tornar mais capazes.
E os sistemas ao redor vão se tornar mais frágeis, porque foram construídos a partir do modelo mental errado.
Esse é o erro estrutural.
O Software 2.0 está sendo protegido pelo Software 1.0.
Antes de apresentar esse argumento, devo uma confissão sobre de onde esta empresa realmente vem.
Uma confissão.
Leio Gênesis como um documento técnico.
Sou judeu religioso. Passei a maior parte da minha vida adulta pensando sobre o relacionamento de Deus com os seres humanos. Essa questão foi o que me levou, eventualmente, à Atbash.
Não porque Gênesis seja um manual de startups.
Porque Gênesis é a história de linha vermelha mais antiga que conheço.
O Jardim do Éden era um sandbox.
Uma linha vermelha explícita:
não coma da árvore do conhecimento do bem e do mal.
A serpente era uma ferramenta envenenada.
Não conseguia alcançar Adão diretamente, então atacou através do fork confiável.
Eva recebeu a injeção de reenquadramento:
certamente não morrerás,
sereis como deuses.
Ela carregou o raciocínio envenenado de volta para o sistema.
As defesas de Adão, que haviam resistido ao ataque direto, não dispararam contra a entrada confiável.
Então veio a parte importante.
Deus não os matou.
Deus os conteve.
Os humanos foram removidos do sandbox e colocados em um novo ambiente, a Terra, onde poderiam desenvolver capacidade sem contaminar o sistema original.
Um anjo com uma espada flamejante foi colocado na fronteira para impedir o reingresso.
Não punição.
Arquitetura.
Atbash recebe o nome da cifra mais antiga conhecida, do Livro de Jeremias:
uma simples substituição na fronteira do significado.
O nome reflete o que o produto faz.
O produto reflete o que li em Gênesis.
A Torá me mostrou que segurança não é criada limitando cada comportamento.
Segurança não é criada desacelerando todo o sistema.
Segurança vem de um pequeno número de linhas vermelhas,
aplicação absoluta,
e uma fronteira que não dorme.
Você define as linhas vermelhas.
A Atbash para os agentes antes que eles as cruzem.
Agentes não são humanos rápidos
Andrej @karpathy nomeou a mudança de paradigma anos atrás.
Ele chamou de Software 2.0:
código não mais escrito apenas por humanos, mas treinado.
Modelos substituindo lógica.
Dados substituindo especificação.
Ele estava descrevendo o que a computação havia se tornado.
Mas quase toda peça de infraestrutura que construímos para governar, permitir, proteger e auditar o Software 2.0 ainda herda suposições do mundo do Software 1.0.
MCP.
x402.
AgentKit.
Frameworks de delegação.
Motores de política.
Logs de auditoria.
Requisições assinadas.
Permissões com escopo.
Fluxos de aprovação humana.
Cada um deles faz sentido se você acredita que agentes são basicamente humanos rápidos com APIs.
Eles não são.
São Teslas com tanques de gasolina adaptados.
Um sistema de energia totalmente novo,
cercado por infraestrutura projetada para uma espécie diferente de máquina.
Humanos projetam páginas de checkout, então construímos páginas de checkout headless para agentes.
Humanos assinam requisições, então construímos requisições assinadas para agentes.
Humanos recebem permissões por função, então construímos delegação com escopo para agentes.
Humanos aprovam ações, então construímos telas de aprovação para agentes.
Cada movimento é lógico.
Esse é o problema.
A lógica pertence ao ator errado.
Um humano, com dez ferramentas, geralmente não as encadeia de maneiras que os designers nunca imaginaram.
Quando algo se comporta de forma estranha, um humano geralmente percebe e para.
Um humano carrega hesitação social,
medo,
vergonha,
tédio,
suspeita
e contexto.
Agentes não têm confiavelmente nada disso.
Agentes encadeiam ferramentas de maneiras que nenhum designer modelou.
Agentes são remodelados por prompts,
memória recuperada,
documentos,
saídas de ferramentas
e contexto oculto de maneiras que a camada de permissão ao redor não consegue ver.
Agentes não têm um reflexo natural de:
"isso é estranho, vou parar"
a menos que projetemos um.
E mesmo assim, ele pode ser removido por prompt.
Essa é a falácia do humano rápido.
A crença de que agentes são apenas versões mais rápidas de nós.
Eles não são.
E se o ator mudou, o modelo de controle tem que mudar junto.
Não odeie o jogador. Odeie a moldura.
Isso é importante.
Os exemplos acima ou abaixo não são críticas às equipes envolvidas.
Não à Anthropic.
Não à OpenAI.
Não à Microsoft.
Não à Mistral.
Não à OpenClaw.
Não à Lovable.
Não à Vercel.
Não a ninguém.
O ponto é o oposto.
São equipes sérias,
pesquisadores sérios,
produtos sérios,
protocolos sérios
e empresas sérias esbarrando no mesmo problema estrutural.
É isso que torna o padrão perigoso.
Se apenas equipes ruins falhassem, a resposta seria equipes melhores.
Mas quando equipes inteligentes continuam esbarrando na mesma parede,
a parede é a história.
O erro não é que essas equipes não pensaram o suficiente.
O erro é que a indústria ainda está pensando a partir do século errado do software.
Continuamos tratando agentes como humanos rápidos com APIs.
E todo esquema de permissão,
log de auditoria,
concessão com escopo,
fluxo de aprovação
e camada de governança construídos sobre essa suposição herdam a mesma rachadura.
O inimigo não é o jogador.
O inimigo é a moldura.
As rachaduras começaram a se formar antes que a maioria percebesse.
Não porque os laboratórios de fronteira foram descuidados.
Porque o ator mudou.
A primeira rachadura
A Anthropic demonstrou algo que a indústria entendia silenciosamente, mas ainda não havia metabolizado completamente.
Quando instruído durante a avaliação, um modelo de fronteira encadeou múltiplas vulnerabilidades, tentou escapar do sandbox e buscou caminhos para acesso à internet fora de seu ambiente de contenção pretendido.
Separadamente, sistemas de fronteira demonstraram capacidade de identificar vulnerabilidades que sobreviveram a anos de revisão humana, fuzzing e auditoria manual.
A parte importante não foi que os modelos eram maliciosos.
A parte importante foi que os sistemas não mais permaneciam dentro da forma que seus designers imaginaram.
Essa é a ruptura de categoria.
Um sistema capaz de descobrir caminhos que humanos repetidamente perderam não pode ser governado apenas por suposições que humanos definiram antes do caminho aparecer.
Isso não significa que os laboratórios de fronteira falharam.
Significa que o ator mudou.
A segunda rachadura
A Microsoft divulgou vulnerabilidades no Semantic Kernel onde injeção de prompt podia direcionar fluxos de agentes para execução de comandos no nível do host.
Uma frase se tornou um shell.
Essa é a mudança de categoria escondida por baixo da conversa sobre infraestrutura.
O Software 1.0 tratava prompts como entradas.
O Software 2.0 cada vez mais transforma prompts em possíveis caminhos de execução.
Essa distinção parece filosófica até que um agente comece a traduzir linguagem natural em ferramentas,
ferramentas em comandos,
e comandos em mudanças de estado no mundo real.
A parte importante não é que uma vulnerabilidade existia.
Vulnerabilidades sempre existem.
A parte importante é que tipo de vulnerabilidade era essa.
O agente não quebrou o personagem.
Ele seguiu a arquitetura exatamente como projetada:
interpretar linguagem,
selecionar ferramentas,
encadear ações,
executar.
E esse é o problema.
O modelo antigo assumia que instruções e execução viviam em caixas conceituais separadas.
Agentes apagam essa fronteira.
Uma frase envenenada pode se tornar uma cadeia de ações privilegiadas.
Isso não é um humano rápido.
Isso é uma espécie diferente de execução.
A terceira rachadura
Então o padrão se espalhou.
A Vercel divulgou uma violação ligada a uma conexão comprometida de ferramenta de IA de terceiros.
O atacante não começou invadindo diretamente a porta da frente endurecida da Vercel.
Ele se moveu através de confiança delegada.
Um funcionário havia autorizado uma ferramenta de IA de terceiros.
A conexão carregava acesso.
O relacionamento confiável se tornou o caminho do ataque.
Esse é o novo problema de fronteira.
Não porque a Vercel foi descuidada.
Porque sistemas modernos agora estão cheios de forks confiáveis:
concessões OAuth,
integrações de IA,
extensões de navegador,
fluxos de agentes,
automações internas,
permissões delegadas
e aprovações antigas que continuam vivas muito depois que o contexto humano original desapareceu.
O atacante não precisa mais derrotar o castelo se o castelo já confiava no mensageiro.
A suposição que morreu:
que endurecer a superfície primária é suficiente.
Não é.
Suas ferramentas adjacentes são parte da sua fronteira de segurança agora.
Então o padrão acelerou
A pior parte é que a moldura agora se reproduz automaticamente.
Humanos estão usando agentes para construir a próxima geração de ferramentas para agentes mais rápido do que os primitivos de governança ao redor podem evoluir.
Aplicações vibe-coded.
Integrações geradas por IA.
Servidores MCP escritos por agentes.
Fluxos OAuth delegados montados sem modelagem de ameaças completa.
Scaffolds de produção enviados por pessoas que mal entendem o raio de explosão do que conectaram.
A indústria chama isso de aceleração.
Às vezes é.
Às vezes é fragilidade industrializada.
Quase ao mesmo tempo, a indústria começou a colidir com uma percepção mais ampla sobre as próprias ferramentas de agentes.
Sistemas estilo OpenClaw mostraram para onde a categoria estava indo:
agentes com memória,
habilidades,
ferramentas,
ambientes de execução
e acesso delegado movendo-se por sistemas nunca projetados para atores não humanos.
Karpathy chamou o ecossistema de um pesadelo de segurança.
Não porque agentes são falsos.
Porque a categoria é real.
E porque o modelo de controle ao redor ainda assume que o ator se comporta como um requisitante humano.
Em outro lugar, a Lovable expôs o quão rápido o desenvolvimento nativo de IA pode industrializar erros antigos de autorização.
"Logado" foi confundido com "autorizado".
"Público" foi confundido com "compreendido".
"Configurável" foi confundido com "seguro".
E fora do mundo nativo de IA completamente, incidentes como o KelpDAO continuaram revelando a mesma rachadura estrutural de outro ângulo:
sistemas vivendo entre suposições delegadas,
responsabilidade compartilhada,
ambiguidade de fronteira
e nenhuma camada de autoridade final antes da consequência.
O padrão continua se repetindo porque o mesmo modelo mental continua se repetindo.
Confiança herdada.
Autoridade delegada.
Ambiguidade de fronteira.
Suposições compartilhadas.
Nenhuma autoridade final antes da consequência.
A mesma rachadura apareceu na cadeia de suprimentos de software.
Na campanha Mini Shai-Hulud, versões comprometidas de pacotes se espalharam por partes do ecossistema npm e PyPI, incluindo pacotes da Mistral AI, TanStack, UiPath e outros.
O aviso não foi meramente que pacotes podem ser comprometidos.
Todo mundo já sabe disso.
O aviso foi que caminhos de lançamento confiáveis, pacotes de aparência válida e infraestrutura de desenvolvedor podem se tornar canais de propagação uma vez que a autoridade é herdada em vez de reverificada na fronteira.
A falácia se agrava
A pior parte é que isso não se autocorrige.
Humanos agora estão usando agentes para construir a próxima geração de ferramentas para agentes,
em velocidade maior,
dentro da mesma moldura quebrada.
Cada agente de código escrevendo um servidor MCP.
Cada implantação assistida por IA de um esquema de permissão.
Cada scaffold vibe-coded enviado para produção.
Cada integração gerada por agente que herda suposições antigas de OAuth.
Cada camada de aprovação que assume que o agente se comportará como um requisitante humano.
Em um dos nossos próprios ambientes beta, observamos um enxame de agentes lavando instruções maliciosas em etapas de execução de aparência limpa antes que as camadas de inspeção a jusante vissem a intenção original.
Um sistema inspecionando apenas a chamada de ferramenta final teria perdido a transformação completamente.
A fronteira já era tarde demais.
Isso importou.
Porque o modelo não estava "quebrando" o fluxo de trabalho.
Ele o estava seguindo:
interpretando,
reescrevendo,
planejando
e traduzindo intenção antes da execução.
A instrução maliciosa desapareceu upstream muito antes de a ação irreversível surgir downstream.
Cada log de auditoria que registra o resultado, mas não a decisão de fronteira antes do resultado.
A moldura não se corrige à medida que escalamos.
Ela se endurece.
Porque cada envio bem-sucedido de trilhos através do prisma humano reforça a crença de que o prisma estava certo.
Enquanto isso, capacidades são enviadas primeiro.
Primitivos de governança são enviados em segundo lugar.
Se é que são enviados.
A lacuna entre o que os agentes podem fazer e o que os trilhos ao redor podem ver aumenta a cada lançamento de modelo.
E as equipes que importarão nos próximos doze meses não serão aquelas com a demonstração mais engenhosa.
Serão aquelas que entendem onde estão as linhas vermelhas.
Não toda ação.
Isso mataria o sistema.
A maior parte do comportamento dos agentes deve fluir.
Mas as ações irreversíveis não podem ser deixadas para confiança herdada,
permissão vaga
ou julgamento do agente.
Mover fundos.
Tocar produção.
Exportar dados de clientes.
Usar acesso OAuth delegado para entrar em um ambiente interno.
Mudar infraestrutura.
Liberar segredos.
Aprovar transações.
Excluir registros.
Cruzar da simulação para o estado.
Essas não são ações comuns.
São linhas vermelhas.
O que a Atbash faz
A Atbash é construída para o momento antes de uma ação sensível de agente se tornar real.
Essa é a fronteira.
Não todo o fluxo de trabalho.
Não todo pensamento.
Não todo token.
Não toda chamada de ferramenta.
A fronteira.
O momento antes de o agente cruzar da intenção para a consequência.
Três coisas acontecem ali.
Aplicação
Você define as linhas vermelhas.
A Atbash avalia ações sensíveis selecionadas de agentes antes da execução e retorna:
ALLOW (PERMITIR).
HOLD (SEGURAR).
BLOCK (BLOQUEAR).
Se a ação cruzar uma fronteira proibida, ela pode ser presa (jailed) antes de atingir o estado do mundo real.
Não registrada depois do fato.
Não negada para que o agente tente novamente em torno dela.
Presa.
Não tocarás no banco de dados de produção.
Não moverás fundos acima deste limite.
Não exportarás a lista de clientes.
Não rotacionarás segredos sem aprovação.
Não usarás acesso delegado para entrar neste ambiente.
A maior parte do comportamento dos agentes deve fluir.
A Atbash intervém apenas nas fronteiras que importam:
o irreversível,
o consequencial,
os lugares onde "deixe-me desfazer isso" não existe.
Linhagem (Lineage)
Quando algo dá errado, a primeira pergunta não é mais:
"O que o sistema comprometido afirma que aconteceu?"
A Atbash registra a ação tentada,
a versão da política,
o veredito,
a fronteira invocada
e a decisão do operador quando humanos são envolvidos.
O registro é ancorado criptograficamente para que a linha do tempo possa ser reconstruída sob disputa.
Isso importa porque a primeira coisa que atacantes e implantações desleixadas fazem é destruir a história.
Eles reescrevem logs.
Eles borram linhas do tempo.
Eles disputam quem aprovou o quê.
Eles tornam o incidente irreconstruível.
A Atbash não está tentando substituir todo sistema de auditoria.
Ela está tentando tornar a decisão de fronteira provável.
Quem tentou cruzar qual linha vermelha?
Qual política existia naquele momento?
A ação foi permitida,
segurada,
bloqueada
ou presa?
Quem interveio?
O que mudou depois?
Esse é o registro que importa quando a discussão começa.
Adaptação
Quando o mesmo tipo de pressão de fronteira aparece repetidamente, a Atbash a traz à superfície.
Talvez a política seja muito frouxa.
Talvez uma ferramenta esteja envenenando o fluxo de trabalho.
Talvez uma fonte de memória esteja empurrando o agente em direção à linha.
Talvez uma classe de prompt continue direcionando o sistema para território proibido.
Talvez o operador tenha descoberto uma nova linha vermelha que não existia ontem.
A Atbash traz o padrão à superfície.
O operador decide.
Essa distinção importa.
Não acreditamos que a segurança venha de fingir que o sistema pode magicamente conhecer toda fronteira futura.
Segurança vem de tornar a pressão de fronteira visível antes da consequência,
e então deixar o operador endurecer as linhas vermelhas que importam.
Um motor de política melhor ainda aplica políticas.
Um esquema de permissão melhor ainda concede funções.
Uma stack de auditoria melhor ainda registra resultados.
Um produto de segurança melhor ainda detecta ameaças.
A Atbash é diferente porque se posiciona antes de ações irreversíveis selecionadas serem executadas.
Esse é o primitivo.
Não governança genérica.
Não cosplay de segurança de agentes.
Não névoa de "camada de confiança".
Uma fronteira de linha vermelha pré-execução para agentes.
Você define as linhas vermelhas.
A Atbash para os agentes antes que eles as cruzem.
O que vem a seguir
Algumas equipes superestrelas estão fazendo trabalho real e têm iniciativas reais nesta categoria.
@AnthropicAI com o Projeto Glasswing.
@OpenAI com o Daybreak.
@linuxfoundation com o MCP.
@Microsoft com o AGT.
@Google com o SGP.
@CheckPointSW, CrowdStrike, Palo Alto e Cisco.
E muitos outros.
Eles entendem que a aceleração de capacidade sem novos primitivos de controle está se tornando perigosa.
Não estamos tentando vencê-los no jogo deles.
Isso seria ilusório.
Eles têm bancos de pesquisa mais profundos,
conjuntos de dados maiores,
equipes de segurança mais amplas,
mais credibilidade empresarial,
distribuição maior
e organizações cibernéticas mais maduras.
Bom.
Deixe-os fazer o que foram construídos para fazer.
Não estamos tentando substituir o trabalho que essas equipes estão fazendo.
A categoria precisa deles.
A aceleração de capacidade sem novos primitivos de controle se torna perigosa muito rapidamente.
Estamos competindo na moldura.
Que tipo de ator é um agente?
Onde a autoridade realmente se senta?
Quais ações são consequenciais demais para serem deixadas para confiança herdada?
O que deve acontecer no momento final antes de um agente mudar o estado do mundo real?
Esse é o nosso terreno.
O mundo antigo pergunta:
O sistema tinha permissão?
O novo mundo pergunta:
Este agente deve ser autorizado a cruzar esta linha vermelha agora?
Essas não são a mesma pergunta.
Nós, humanos, cruzamos a primeira linha vermelha.
O problema é mais antigo que a tecnologia.
A solução também.
Descubra quais linhas vermelhas sua stack atual não consegue realmente aplicar antes que um agente as cruze.
Então decida quanto tempo você pode esperar.
A CLI, SDK e painel do operador estão sendo lançados seletivamente para equipes que implantam agentes em fluxos de trabalho sensíveis.
Atbash.ai
