Por Yosef e Or, cofundadores 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 silenciosa. É a suposição que está por baixo de quase todos os roadmaps de produto, camadas de governança, sistemas de permissão, stacks de auditoria e frameworks de agentes sendo construídos agora:
Que conforme os modelos melhoram, os sistemas construídos ao redor deles se tornarão mais seguros como consequência.
Não acho que seja assim que isso se desenrola.
Acho 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,
recuperabilidade.
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 essa 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 a relação de Deus com os seres humanos. Essa pergunta 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 podia alcançar Adão diretamente, então atacou através do fork confiável.
Eva recebeu a injeção de reformulação:
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 é nomeada em homenagem à cifra mais antiga conhecida, do Livro de Jeremias:
uma substituição simples 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.
A 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 impede os agentes antes que 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 todas as peças de infraestrutura que construímos para governar, permitir, proteger e auditar o Software 2.0 ainda herdam 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.
Não são.
São Teslas com tanques de gasolina parafusados.
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ão 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 nada disso de forma confiável.
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, deixa eu parar"
a menos que nós 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.
Não são.
E se o ator mudou, o modelo de controle tem que mudar junto.
Não odeie o jogador. Odeie o quadro.
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 é o que torna o padrão perigoso.
Se apenas equipes ruins falhassem, a resposta seriam 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ída sobre essa suposição herda a mesma rachadura.
O inimigo não é o jogador.
O inimigo é o quadro.
As rachaduras começaram a se formar mais cedo do que a maioria das pessoas percebeu.
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 silenciosamente entendia, mas 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 do 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 era que os modelos eram maliciosos.
A parte importante era que os sistemas não permaneciam mais 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 através de 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 em nível de host.
Uma frase se tornou um shell.
Essa é a mudança de categoria escondida sob a 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é um agente começar 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 existia uma vulnerabilidade.
Vulnerabilidades sempre existem.
A parte importante é que tipo de vulnerabilidade era essa.
O agente não saiu do 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 de execução diferente.
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.
Eles se moveram através de confiança delegada.
Um funcionário havia autorizado uma ferramenta de IA de terceiros.
A conexão carregava acesso.
A relação confiável se tornou o caminho do ataque.
Esse é o novo problema de fronteira.
Não porque a Vercel foi descuidada.
Porque os sistemas modernos agora estão cheios de forks confiados:
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 do contexto humano original desaparecer.
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 agora fazem parte da sua fronteira de segurança.
Então o padrão acelerou
A pior parte é que o quadro 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 conseguem evoluir.
Aplicações vibe-coded.
Integrações geradas por IA.
Servidores MCP escritos por agentes.
Fluxos OAuth delegados montados sem modelagem de ameaça 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 através de sistemas nunca projetados para atores não humanos.
Karpathy chamou o ecossistema de um pesadelo de segurança.
Não porque os 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 em IA pode industrializar erros antigos de autorização.
"Logado" se confundiu com "autorizado".
"Público" se confundiu com "compreendido".
"Configurável" se confundiu com "seguro".
E fora do mundo nativo em IA completamente, incidentes como 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, lançamentos de pacotes comprometidos se espalharam por partes do ecossistema npm e PyPI, incluindo pacotes da Mistral AI, TanStack, UiPath e outros.
O aviso não era meramente que pacotes podem ser comprometidos.
Todo mundo já sabe disso.
O aviso era que caminhos de lançamento confiados, pacotes com 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 estão agora usando agentes para construir a próxima geração de ferramentas para agentes,
em maior velocidade,
dentro do mesmo quadro quebrado.
Cada agente de codificação 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 downstream 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 importava.
Porque o modelo não estava "quebrando" o fluxo de trabalho.
Ele estava seguindo-o:
interpretando,
reescrevendo,
planejando,
e traduzindo a intenção antes da execução.
A instrução maliciosa desapareceu upstream muito antes da 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.
O quadro não se corrige à medida que escalamos.
Ele 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 as com a demonstração mais inteligente.
Serão as que entendem onde estão as linhas vermelhas.
Não toda ação.
Isso mataria o sistema.
A maior parte do comportamento do agente 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 em produção.
Exportar dados de clientes.
Usar acesso OAuth delegado para entrar em um ambiente interno.
Mudar infraestrutura.
Liberar segredos.
Aprovar transações.
Deletar registros.
Cruzar da simulação para o estado.
Essas não são ações comuns.
Essas 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 o fluxo de trabalho inteiro.
Não cada pensamento.
Não cada token.
Não cada chamada de ferramenta.
A fronteira.
O momento antes do 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 selecionadas de agentes sensíveis antes da execução e retorna:
PERMITIR.
SEGURAR.
BLOQUEAR.
Se a ação cruzar uma fronteira proibida, ela pode ser presa antes de atingir o estado do mundo real.
Não registrada depois do fato.
Não negada para que o agente tente novamente ao redor.
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 do agente deve fluir.
A Atbash intervém apenas nas fronteiras que importam:
o irreversível,
o consequente,
os lugares onde "deixa eu desfazer isso" não existe.
Linhagem
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 descuidadas 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.
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 vem de fingir que o sistema pode magicamente saber toda fronteira futura.
A 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.
Um stack de auditoria melhor ainda registra resultados.
Um produto de segurança melhor ainda detecta ameaças.
A Atbash é diferente porque fica 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 agente.
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 impede os agentes antes que 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 Project 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,
maior distribuição,
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 no quadro.
Que tipo de ator é um agente?
Onde a autoridade realmente se senta?
Quais ações são consequentes 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 ter permissão para 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.
Também a solução.
Descubra quais linhas vermelhas seu 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 agora sendo lançados seletivamente para equipes que implantam agentes em fluxos de trabalho sensíveis.
Atbash.ai
