AlphaProof Code: Verificação Formal Agêntica E O Limite Do 'Passou No Teste'

Sumário
- AlphaProof Code: Verificação Formal Agêntica E O Limite Do 'Passou No Teste'
- O Que A DeepMind Anunciou, E O Que O Paper Diz De Fato
- Teste, Propriedade E Prova: Três Níveis De Garantia
- Onde Está A Confiança: Gatekeeper, Hooks E A Base Confiável
- Onde O Humano Entra: A Spec É O Trabalho
- O Que Ficou De Fora
- O Que É Realista Para Um Time Comum Hoje
- Conclusão
AlphaProof Code: Verificação Formal Agêntica E O Limite Do 'Passou No Teste'
Tem uma frase que eu escrevo e leio em revisão de pull request quase todo dia: "passou no teste". Ela aparece no comentário do PR, na descrição do commit, na mensagem do agente que terminou a tarefa. E toda vez que leio, sei que ela diz menos do que parece. Diz que os casos que alguém imaginou se comportaram como esse alguém esperava. Não diz nada sobre o caso que ninguém imaginou, que costuma ser justamente o que vira incidente.
Foi com essa frase na cabeça que li, na semana passada, o anúncio do AlphaProof Code, publicado pela Google DeepMind em 10 de novembro. A manchete que circulou foi algo como "IA prova que o Signal é seguro". Fui atrás do paper técnico, do repositório e do site de artefatos, porque essa manchete, do jeito que estava, me pareceu grande demais. E de fato é: o que foi feito é impressionante, mas é bem mais específico e bem mais interessante do que "o Signal é seguro".
Preciso deixar claro o que este texto é. Não rodei o AlphaProof Code, não compilei as provas e não tenho experiência prática com Lean em produção. Tudo o que está aqui vem da leitura dos dois posts da DeepMind, do paper técnico, do README do repositório público e de algumas matérias de imprensa, todos de 10 a 12 de novembro. O post é de 18 de novembro. Quando um número for da DeepMind, digo que é da DeepMind, e quando o post de blog e o paper discordarem, e eles discordam em pelo menos um ponto, registro a divergência.
O caminho é este: o que foi anunciado e o que o paper diz; a diferença mecânica entre teste, propriedade e prova; onde fica a confiança quando agentes escrevem as provas, onde o humano entra e o que ficou de fora; e, por fim, o que um time comum pode levar disso hoje, e por que conversa com Spec-Driven Development.
O Que A DeepMind Anunciou, E O Que O Paper Diz De Fato
O AlphaProof Code é descrito pela DeepMind como um framework agêntico de verificação formal que combina especialistas humanos com agentes de IA. A demonstração foi o código criptográfico central do protocolo Signal, usado no app Signal e, segundo a DeepMind, no Google Messages. A empresa afirma que é a primeira vez que a implementação de um protocolo amplamente usado desse tipo é verificada formalmente por qualquer método. É afirmação da própria empresa, sem avaliação independente nas matérias que li.
Os números centrais vêm do paper, que é mais preciso que o post de blog. O alvo é o código Rust não modificado do libsignal-protocol na versão 0.105.4 e do spqr na versão 1.6.0, compilado com rustc 1.98.1 de prateleira, estaticamente ligado com musl, gerando um executável AArch64 para Linux. Esse executável é um pequeno harness de linha de comando, o libsignal-cli, com três operações verificadas: init, send e recv. O código verificado tem cerca de 560 KB, ou aproximadamente 140 mil instruções AArch64. O resumo do paper fala em "cerca de 6,5 milhões de linhas de prova Lean verificadas por máquina", das quais cerca de 5,3 milhões são sobre o binário.
Aqui está a primeira divergência que vale registrar. O corpo do post de blog fala em "mais de seis milhões de linhas de Lean", o que bate com o paper. Mas a descrição da mesma página, aquela que aparece em compartilhamentos, fala em "mais de três milhões". O paper e o site de artefatos não mencionam três milhões em lugar nenhum. Fico com os 6,5 milhões do paper, e anoto que quem leu só o card de compartilhamento ficou com um número que é metade do real.
O prazo também vem bem documentado. Segundo o paper, o trabalho de prova foi feito por um time de cinco pessoas ao longo de quatro semanas, cada uma rodando agentes na própria estação de trabalho, e nenhum dos autores escreveu código de prova. As provas foram produzidas por times de agentes rodando o Gemini 4 Carbon. Na etapa de especificação, o paper cita agentes rodando Gemini 4 Carbon e Claude Opus 5.5, com revisores de uma família de modelos diferente da do autor da spec. Uma campanha típica, segundo o texto, coloca de 40 a 80 agentes numa única máquina por 24 a 72 horas.
Os artefatos estão públicos. O repositório google-deepmind/code-verification no GitHub está sob Apache 2.0 (o libsignal mantém a AGPL-3.0 original), e o README diz que checar as provas leva várias horas e de 15 a 34 GiB de RAM de pico. O que não está público é o AlphaProof Code como ferramenta: foram abertas as specs e as provas, não o sistema de agentes. O custo computacional não foi divulgado, e, segundo a cobertura que cita a WIRED, o próprio Google disse que ainda não está claro o quanto isso é prático em escala.
A notícia também se distorceu no caminho. O 9to5Mac titulou que a análise "prova que a criptografia do Signal e do WhatsApp é segura" e escreveu que a verificação garante que "não há situação em que o protocolo vá falhar". Nenhuma das duas coisas está no paper: o WhatsApp não foi analisado, e a lista do que ficou fora do escopo é longa. A distância entre paper e manchete é, em si, um bom exemplo do tema deste post.
Teste, Propriedade E Prova: Três Níveis De Garantia
Para entender por que isso importa, vale separar três coisas que no dia a dia a gente costuma chamar de "testar". Um teste unitário é uma afirmação sobre um exemplo: para esta entrada, espero esta saída. Ele é concreto, barato e cobre exatamente o que foi escrito. Um teste baseado em propriedade, no estilo QuickCheck ou Hypothesis, é uma afirmação sobre todas as entradas, verificada por amostragem: para qualquer lista, ordenar duas vezes dá o mesmo que ordenar uma, e o framework gera algumas centenas de listas tentando quebrar isso. Ele cobre muito mais terreno, mas continua sendo amostra.
Uma prova formal é a mesma afirmação sobre todas as entradas, só que demonstrada em vez de amostrada. Não existe o caso que o gerador não sorteou, porque não há sorteio. Em Lean, isso funciona porque a afirmação é um tipo e a prova é um termo desse tipo, e um núcleo pequeno do sistema, o kernel, checa se o termo tem mesmo aquele tipo. Se o kernel aceita, a afirmação vale, dentro do modelo em que foi escrita. Essa última cláusula é a que manchetes costumam esquecer.
Um esboço ajuda a ver a diferença de forma. É ilustrativo, não compilei, e o exemplo é deliberadamente trivial:
def clamp (lo hi x : Nat) : Nat := max lo (min hi x)
-- Teste: um exemplo, checado por avaliação
example : clamp 0 10 42 = 10 := by decide
-- Propriedade provada: vale para todo lo, hi, x, desde que lo ≤ hi
theorem clamp_le_hi (lo hi x : Nat) (h : lo ≤ hi) :
clamp lo hi x ≤ hi := by
unfold clamp
omegaO example é o equivalente a um teste unitário. O teorema afirma que o resultado nunca passa de hi, para qualquer entrada, com a hipótese h explícita. Se alguém mudar clamp de um jeito que quebra a propriedade, a prova deixa de compilar: não é um teste vermelho num cenário, é o build quebrando porque a garantia deixou de valer. E a hipótese é parte da afirmação. Se lo > hi, o teorema não diz nada, e isso é escolha de quem escreveu a especificação.
O trabalho da DeepMind leva essa ideia a um extremo que, segundo a própria empresa, historicamente tomava anos de equipes especializadas. As propriedades são sigilo direto, segurança pós-comprometimento, autenticação, sigilo do handshake e confidencialidade e autenticidade de mensagens, provadas não sobre o código-fonte, mas sobre o binário. O paper tem dois cenários: um modelo simbólico, no estilo Dolev-Yao, com dez teoremas, e um modelo computacional, com um limite concreto para a vantagem de um atacante clássico.
O que mais me chamou atenção é o que a escolha do binário tira da base confiável. Segundo o paper, nem o código Rust nem o compilador são confiáveis no argumento. Se o rustc introduzir um comportamento estranho numa otimização, a prova sobre o binário pega, porque fala do que o processador executa, não do que o programador escreveu. É isso que separa este trabalho de uma análise de protocolo no papel.
Onde Está A Confiança: Gatekeeper, Hooks E A Base Confiável
Se agentes escrevem milhões de linhas de prova e nenhum humano escreveu código de prova, a pergunta óbvia é por que alguém deveria confiar no resultado. A resposta curta do paper é: você não confia nos agentes, confia no checador. O diagrama da DeepMind chama os agentes de "time de provadores não confiáveis" e coloca entre eles e o resultado um "gatekeeper confiável". Esse gatekeeper guarda uma cópia somente-leitura da especificação e usa a ferramenta comparator do Lean. Ele só aceita uma prova se o enunciado bater exatamente com a spec, se só axiomas padrão forem usados e se o kernel aceitar. O paper cita que sorry, o atalho do Lean para "confie em mim", e native_decide, que delega parte da checagem a código compilado, são rejeitados.
Essa arquitetura torna o volume irrelevante para a confiança. Seis milhões e meio de linhas de prova seriam ilegíveis para qualquer humano, mas não precisam ser lidas. O que precisa ser lido é o lado confiável da fronteira, e o paper é honesto sobre o tamanho dele: cerca de 18 mil linhas de enunciados e definições, cerca de 26 mil contando a semântica AArch64, que modela 467 instruções e 31 chamadas de sistema do Linux em modo usuário.
Uma parte dessa base merece atenção: os hooks. Algumas rotinas não são provadas contra o código real, são substituídas por contratos. O paper fala em 39 rotinas, o site de artefatos em 37, mas o perfil é o mesmo: primitivas criptográficas, funções de memória e string da libc, escrita em arquivo e saída padrão, algumas rotinas da biblioteca Rust. Ou seja, a implementação do X25519 ou do AES em si não é provada; assume-se que ela respeita um contrato. É uma escolha razoável e comum, mas significa que "verificado até o código de máquina" tem um asterisco do tamanho de uma biblioteca de criptografia.
Somam-se a isso as hipóteses criptográficas, que nenhuma prova de software elimina: Gap-DH, infalsificabilidade do XEdDSA, resistência a colisão do Kyber1024, segurança do HKDF e do HMAC, entre outras. No modelo simbólico, a criptografia é tratada como perfeita. Isso não é defeito, é o estado da arte de prova de protocolo. Mas é a diferença entre "o Signal é seguro" e "este binário satisfaz estas propriedades sob estas hipóteses", que é o que foi provado.
O que eu tiro dessa seção, como arquiteto, é uma pergunta que vale para qualquer sistema com agentes no meio: onde está a fronteira entre o que é gerado e o que é confiável, e quão pequeno é o lado confiável? No AlphaProof Code, a fronteira é um kernel de prova e algumas dezenas de milhares de linhas revisadas por humanos. Na maioria dos pipelines de código com agentes que vejo descritos hoje, a fronteira é uma suíte de testes que o próprio agente pode editar. Já escrevi sobre esse problema em o mecanismo pelo qual agentes apagam ou enfraquecem testes, e a resposta da DeepMind a ele é estrutural: o gatekeeper tem a spec em modo somente-leitura, e um agente crítico só aprova emendas à spec que sejam necessárias, pequenas e que não enfraqueçam a segurança.
Onde O Humano Entra: A Spec É O Trabalho
O número que mais circulou depois dos 6 milhões foi o de 1%. O post de blog da DeepMind diz que os agentes marcaram para uma segunda olhada humana "apenas um por cento da base de código", e chama isso de enorme economia de tempo. É um número da DeepMind, e eu não encontrei a mesma cifra no paper. Mais importante que a cifra, porém, é o que ela mede: a revisão humana dos trechos sinalizados pelos agentes, não o esforço humano total. E o paper é bem claro sobre onde esse esforço total foi parar.
A frase que mais me marcou no paper é esta: "a maior parte do nosso esforço não foi para as provas, mas para as especificações". Em outro trecho, os autores dizem que a maior parte do esforço humano em verificação de software agora está em engenharia de especificação. Os humanos escolhem o que provar, resolvem ambiguidades, avaliam trade-offs de segurança e tomam todas as decisões finais. O usuário revisa, corrige e aprova a especificação antes de qualquer prova ser escrita, e o commit git dessa aprovação vira a linha de base. O paper também admite que "monitorar o time tomou muito tempo humano". Ou seja, o 1% é real dentro do seu recorte, mas o recorte não é o projeto.
O processo de especificação é, para mim, a parte mais reaproveitável. Um agente rascunha os enunciados de topo, adaptados de modelos já publicados sobre o Signal, sob orientação humana. Revisores de outra família de modelos checam fidelidade, força e consistência. Há checagens de vacuidade, porque um teorema com hipóteses impossíveis é verdadeiro e inútil, e testes de mutação, como pular a verificação do MAC e conferir que a propriedade quebra. E os autores registraram todo ponto em que os enunciados em Lean se afastam das referências ou do próprio libsignal.
O teste mais convincente do trabalho, para mim, foi o de reintroduzir bugs. A equipe pegou duas falhas reais, já corrigidas no histórico do libsignal, e as recolocou numa cópia isolada. Uma envolvia o armazenamento de estado de uma nova sessão durante uma tentativa de decifração de mensagem de prekey, incluindo uma cópia do segredo do signed prekey. A outra era a ausência de checagem de que a chave base X25519 do iniciador está no subgrupo correto. Nos dois casos, o sistema produziu uma prova verificada por máquina de que a versão com bug viola o teorema simbólico. Isso responde a uma objeção importante: a spec não é tão fraca a ponto de aceitar qualquer código. O paper nota que o teorema computacional não pode ser refutado do mesmo jeito, porque isso exigiria quebrar as próprias hipóteses criptográficas.
Há um subproduto que considero quase tão relevante quanto o resultado principal. Ao formalizar especificações que partiam de análises anteriores publicadas, os autores registram cerca de 15 lacunas ou bugs na análise computacional existente do Double Ratchet e vários erros em consultas ProVerif simbólicas que precisaram ser corrigidos. Não são bugs no Signal. São bugs em especificações escritas por especialistas e revisadas por pares. Esse é o lembrete de que a spec é código, tem bug como código e precisa de revisão como código.
Isso conecta com o post sobre a Scion e a revisão por intenção em vez de por diff. Quando o volume gerado passa do que um humano consegue ler, a revisão precisa subir de nível: ler o que foi pedido, não o que foi feito. O AlphaProof Code é a versão mais radical disso que já vi documentada. Ninguém lê as 6,5 milhões de linhas; quem importa lê as 18 mil.
O Que Ficou De Fora
Uma leitura honesta do resultado precisa passar pela lista do que não foi provado, e o paper é generoso nessa lista. Só sessões um-para-um estão cobertas; mensagens em grupo ficam para trabalho futuro. Estado multi-dispositivo está fora. A cura pós-quântica do SPQR não está coberta, e nos teoremas do ratchet o atacante pode escolher as chaves do SPQR. O limite computacional vale apenas contra atacantes clássicos, sem garantia contra adversários quânticos. A geração de chaves, a operação keygen, não foi verificada. Canais laterais, como tempo e consumo de energia, estão fora do escopo.
O cenário simbólico é estreito de propósito: duas partes, um signed prekey, no máximo um prekey de uso único. No modelo computacional, os termos estatísticos ficam vazios a partir de cerca de 25 mil mensagens numa única sessão. O ambiente modelado tem relógio e aleatoriedade fixos, memória e pilha limitadas, e a semântica não modela threads, sinais, ligação dinâmica nem arquivos fora do diretório corrente.
E há a questão de plataforma. O resultado vale para o build Linux com musl. Os apps Android e iOS não foram verificados; o paper argumenta que o resultado se transfere se as diferenças de build e de sistema preservarem o comportamento do código do protocolo, o que é argumento, não prova. A imprensa que entrevistou a equipe registra mais dois pontos: a DeepMind partiu de trabalho prévio de verificação formal do Signal, então as quatro semanas não são um projeto do zero, e o custo não foi divulgado.
Nada disso diminui o feito; para quem conhece verificação formal, essa lista é sinal de seriedade. Mas ela mostra o limite da prova pelo mesmo ângulo que mostra o limite do teste. Um teste diz "funciona para estes casos". Uma prova diz "funciona para todos os casos dentro deste modelo, sob estas hipóteses". O "passou no teste" esconde quais casos; o "foi provado" pode esconder qual modelo. Swarat Chaudhuri, pesquisador da DeepMind, disse à imprensa que ainda há "um longo caminho" até escalar isso para todo o software do mundo, e acho que é a frase certa para guardar.
O Que É Realista Para Um Time Comum Hoje
Se você trabalha num time de produto comum, a pergunta prática não é se vai verificar o seu monólito em Lean na próxima sprint. Não vai, e o paper não sugere isso. A ferramenta de agentes não está disponível, o custo computacional não foi divulgado e o build das provas públicas pede dezenas de GiB de RAM e horas de máquina. O que dá para levar é a estrutura do raciocínio, que funciona em degraus bem mais baixos.
O primeiro degrau é escrever propriedades em vez de só exemplos. Toda base de código tem invariantes que, se quebrarem, viram incidente: um saldo que nunca fica negativo sem autorização, a idempotência de um webhook, uma transição de estado que nunca pula etapa. Testes baseados em propriedade, com Hypothesis, fast-check ou equivalentes, transformam isso em afirmações sobre todas as entradas, checadas por amostragem. Não é prova, mas muda a pergunta de "este caso funciona?" para "isto sempre vale?", e uma propriedade é bem mais difícil de satisfazer trapaceando do que um exemplo fixo.
O segundo degrau é tratar a especificação como artefato versionado e protegido. A lição mais transferível do AlphaProof Code nem é a prova, é a separação de papéis: quem escreve a spec não é quem escreve a implementação, a spec é aprovada antes do código, fica em modo somente-leitura para o agente implementador e qualquer mudança passa por um crítico que pergunta se ela enfraquece a garantia. Dá para fazer isso hoje com uma suíte de propriedades num diretório que o agente não pode editar, protegida por CODEOWNERS e por uma checagem de CI que falha se os arquivos de spec mudaram no mesmo PR da implementação.
O terceiro degrau é verificação formal de verdade, mas em núcleos pequenos e críticos. Ferramentas como Lean, Dafny e Verus existem, e o custo de escrever provas é exatamente o que agentes começam a baratear. Um cenário hipotético: um time de pagamentos com uma função de conciliação de 300 linhas que já causou dois incidentes. Especificar que a soma dos lançamentos fecha e que nenhuma transação é contada duas vezes, e deixar um agente tentar provar, é um experimento de escopo controlado. Se a prova não sai, a falha costuma apontar um caso de borda. Não tenho dado de que isso funcione bem fora do contexto da DeepMind; digo só que é o tamanho certo de aposta. Vale lembrar também o que discuti sobre o Harness 2 e agentes que reescrevem o próprio harness: quanto mais autonomia o agente tem sobre o ambiente, mais importa que o checador final fique fora do alcance dele.
É aqui que entra a ponte com Spec-Driven Development. No mapa de ferramentas de SDD e da spec como contrato executável, a ideia central era que a spec precisa ser algo que a máquina consegue checar, não só um documento que o agente lê. Spec como texto estruturado ajuda o agente a entender a intenção, mas não o impede de entregar algo que viola a intenção e passa no teste. O AlphaProof Code mostra a outra ponta: a spec é um enunciado formal, e "pronto" significa que um checador independente aceitou a prova. Entre texto livre e teorema em Lean há muitos pontos intermediários, e propriedades executáveis são o mais acessível.
Há um risco que vale nomear, e ele aparece no próprio paper. Se a especificação vira o lugar onde está todo o valor, ela vira também o lugar onde está todo o risco. Uma spec fraca provada é pior que uma spec fraca testada, porque gera uma confiança que não merece. É por isso que vacuidade, mutação e bugs reintroduzidos importam tanto no trabalho da DeepMind. E é por isso que a ideia de dívida cognitiva sobre código gerado por IA não some com a verificação formal; ela muda de lugar. Você pode não entender as provas, e tudo bem, mas precisa entender a spec muito bem, porque é a única parte que ninguém vai checar por você.
Conclusão
Saí da leitura do paper com a sensação de que o resultado mais importante não é o número de linhas, nem as quatro semanas, nem o 1%. É a frase de que a maior parte do esforço foi para as especificações. Ela descreve uma mudança de onde o trabalho difícil mora quando a geração fica barata. Escrever a prova deixou de ser o gargalo neste experimento; decidir o que vale a pena provar, e dizer isso de forma precisa o bastante para uma máquina checar, continua sendo trabalho humano, lento e caro.
Preciso repetir os limites do que li. Descrevo um anúncio, um paper e um repositório de 10 a 12 de novembro, sem ter reproduzido nada. Os números são da DeepMind, o 1% aparece no blog mas não o encontrei no paper, o blog tem uma divergência interna entre três e seis milhões de linhas, o custo não foi divulgado e a cobertura da imprensa que li não traz avaliação de especialistas independentes. O que foi provado é um conjunto específico de propriedades sobre um binário AArch64 de um harness de linha de comando, sob hipóteses explícitas. É muito, e é menos do que as manchetes disseram.
Para quem revisa PR todo dia, a lição que fica é mais modesta e mais imediata do que verificação formal. Da próxima vez que eu ler "passou no teste", quero conseguir perguntar qual propriedade o teste está afirmando e quem garante que ela não foi enfraquecida no mesmo PR. Não sei quanto tempo vai levar até provas como essas chegarem a código de produto comum. Sei que a pergunta sobre o que exatamente está sendo garantido já cabe em qualquer revisão hoje.
Fontes:
- Google DeepMind — Introducing AlphaProof Code
- Google DeepMind — Formal verification of the Signal protocol
- Google DeepMind — Formal Verification of Signal (paper técnico, PDF)
- GitHub — google-deepmind/code-verification
- Google DeepMind — Site de artefatos de verificação (specs e provas)
- Let's Data Science — Google DeepMind's AlphaProof Code Formally Verifies Key Signal Protocol Guarantees
- 9to5Mac — Google DeepMind analysis proves Signal and WhatsApp encryption is secure
Newsletter
Receba os artigos mais relevantes da semana, sem quebrar seu ritmo de leitura
Um resumo semanal com os melhores posts sobre IA, engenharia de software e tecnologia, enviado no melhor momento para continuar a conversa depois da leitura.

Escrito por
eltonjose
Engenheiro de software e estrategista de produtos digitais, focado em IA pragmática e em transformar experiências de trabalho remoto em aprendizados aplicáveis. Compartilho frameworks e decisões reais que uso em consultorias e projetos.
- Principais temasVerificação Formal, Lean
- Formato do conteúdoGuia prático + insights de carreira
