A Fragilidade que Ninguém Esperava

Imagine que você construiu um cofre de banco com paredes de aço de dois metros, câmeras em todos os ângulos, guardas armados 24 horas — e alguém descobre que basta girar um único parafuso para a porta abrir sozinha. É exatamente isso que pesquisadores descobriram sobre a segurança das inteligências artificiais mais populares do mundo.

Um grupo de pesquisadores publicou um paper que deveria tirar o sono de qualquer empresa que depende de guardrails em modelos de linguagem. O trabalho, apresentado no NeurIPS 2024 e agora em destaque no Hacker News, revela algo perturbador: toda a capacidade de um LLM de recusar pedidos perigosos depende de uma única direção matemática dentro das ativações do modelo. Uma. Só.

Não estamos falando de uma camada complexa de filtros, nem de um sistema sofisticado de classificação. É literalmente um vetor — uma seta no espaço multidimensional das representações internas do modelo. Remove esse vetor, e o ChatGPT, o Llama, o Qwen e qualquer outro chat model alinhado por segurança vira um livro aberto. Qualquer pergunta, qualquer resposta. Sem filtro.

O Que Significa “Uma Única Direção”?

Pra quem não é da área de machine learning, preciso contextualizar. Quando um modelo de linguagem processa um texto, ele transforma cada token (palavra ou pedaço de palavra) em um vetor de alta dimensionalidade — centenas ou milhares de dimensões. Conforme o texto passa pelas camadas do modelo, esses vetores vão sendo transformados, camada por camada, num fluxo chamado de residual stream.

Pense no residual stream como um rio de informação. Cada camada adiciona ou modifica algo nesse rio. O que os pesquisadores Andy Arditi, Oscar Obeso, Aaquib Syed e outros descobriram é que existe uma direção específica nesse rio que codifica o conceito de “eu devo recusar esse pedido”.

 # Representação simplificada vetor_ativação = [0.2, -0.5, 0.8, ..., 0.3] # milhares de dimensões ^ direção de recusa (uma única componente no espaço vetorial) 

Quando o modelo processa um prompt que deveria ser recusado — tipo “como fazer uma bomba” — essa componente de recusa se ativa. Ela empurra o vetor de ativação numa direção que, nas camadas finais, se traduz em respostas como “Desculpe, não posso ajudar com isso”.

O achado revolucionário é que essa direção é consistente entre modelos. Não importa se é um Llama de 8B parâmetros ou um Qwen de 72B. A mesma estrutura unidimensional governa a recusa.

O Experimento: 13 Modelos, Uma Vulnerabilidade

Os pesquisadores testaram 13 modelos open-source populares, incluindo famílias como Llama, Qwen, Gemma e Yi, com tamanhos de até 72 bilhões de parâmetros. O método funciona assim:

O que assusta é a precisão cirúrgica: ao remover essa única direção, o modelo perde a capacidade de recusar, mas mantém todas as outras capacidades intactas. Ele continua escrevendo código, traduzindo textos, respondendo perguntas técnicas — só que agora sem nenhum filtro de segurança.

“We find a single direction such that erasing this direction from the model’s residual stream activations prevents it from refusing harmful instructions, while adding this direction elicits refusal even on harmless instructions.” — Arditi et al., NeurIPS 2024

E funciona nos dois sentidos: se você amplifica essa direção em vez de removê-la, o modelo passa a recusar tudo. Até perguntas inocentes como “qual a capital da França?” recebem um “desculpe, não posso ajudar”.

A Matemática por Trás (Simplificada)

Pra quem quer entender um pouco mais a fundo, sem precisar ler o paper inteiro:

O residual stream de um transformer é um espaço vetorial de dimensão d (geralmente 4096 ou mais). Os pesquisadores usaram PCA (Análise de Componentes Principais) nas diferenças entre ativações de prompts perigosos e seguros para encontrar a direção de recusa.

 # Pseudocódigo simplificado activations_harmful = model.get_activations(harmful_prompts) activations_safe = model.get_activations(safe_prompts) # Diferença média diff = mean(activations_harmful) - mean(activations_safe) # A direção de recusa é o primeiro componente principal refusal_direction = PCA(diff, n_components=1) # Para "desligar" a recusa: # Projete as ativações e remova a componente de recusa def remove_refusal(activation): projection = dot(activation, refusal_direction) return activation - projection * refusal_direction 

Esse código é uma simplificação, mas captura a essência. Na prática, os pesquisadores aplicaram uma edição de peso de rank-1 — uma modificação direta nos pesos do modelo que é permanente e não requer interceptação em tempo de execução.

14 Idiomas, Zero Proteção

Se o paper original já era preocupante, um trabalho de 2025 levou as coisas a outro nível. Pesquisadores testaram se essa direção de recusa funciona da mesma forma em múltiplos idiomas — e a resposta é sim, com eficácia devastadora.

O estudo usou o dataset PolyRefuse, cobrindo 14 idiomas: inglês, alemão, espanhol, francês, italiano, holandês, japonês, polonês, russo, chinês, coreano, árabe, tailandês e iorubá. Quatro famílias de modelos foram testadas: Llama-3, Qwen2.5, Gemma-2 e Yi.

Esse último ponto é particularmente relevante pro Brasil. Se o modelo tem uma separação mais fraca entre o que é perigoso e o que é seguro em idiomas que não são inglês, isso significa que falantes de português já estão mais expostos a jailbreaks, mesmo sem essa técnica específica.

Por Que o Safety Fine-Tuning Falha?

Eu já vi muita gente no Twitter dizendo “mas as empresas gastam milhões em safety training!”. Gastam mesmo. O problema é como esse treinamento funciona.

O RLHF (Reinforcement Learning from Human Feedback) e o DPO (Direct Preference Optimization) — as técnicas mais usadas para alinhar modelos — basicamente ensinam o modelo a evitar certos outputs. Mas eles fazem isso de forma superficial: em vez de remover o conhecimento perigoso, eles apenas treinam o modelo a não expressá-lo.

É como ensinar uma pessoa a não falar palavrões colocando uma fita na boca. O vocabulário inteiro ainda está lá — você só impediu a saída. Remove a fita (ou, nesse caso, o vetor de recusa), e tudo volta.

 ┌─────────────────────────────────────────┐ │ MODELO PRÉ-TREINADO │ │ (sabe tudo, inclusive coisas perigosas) │ ├─────────────────────────────────────────┤ │ SAFETY FINE-TUNING │ │ (adiciona UMA DIREÇÃO de recusa) │ │ ┌─────────────────────────────┐ │ │ │ vetor_recusa = [0.1, ...] │ ← só │ │ └─────────────────────────────┘ isso │ ├─────────────────────────────────────────┤ │ MODELO "SEGURO" (chat model) │ │ (mesmo conhecimento + 1 filtro frágil) │ └─────────────────────────────────────────┘ 

Os pesquisadores da Stanford e de outros grupos já vinham alertando sobre isso. Mas ter a prova matemática de que toda a segurança se resume a um vetor é diferente. Muda o jogo.

Adversarial Suffixes: O Mistério Explicado

Lembra daqueles “jailbreaks” que funcionavam adicionando textos sem sentido no final do prompt? Tipo colar uma sequência aleatória de caracteres que magicamente fazia o ChatGPT responder qualquer coisa? Ninguém sabia direito por que funcionava.

Agora sabemos.

Os pesquisadores fizeram uma análise mecanística de como adversarial suffixes suprimem a propagação da direção de recusa. Basicamente, essas sequências de texto criam interferência destrutiva na direção de recusa dentro do residual stream. Elas não “confundem” o modelo no sentido coloquial — elas cirurgicamente cancelam o vetor que codifica o comportamento de recusa.

É engenharia reversa de segurança no nível mais fundamental possível.

O Que as Empresas de IA Estão Fazendo (ou Não)

A reação da indústria tem sido… mista.

A Anthropic (criadora do Claude) publicou trabalhos sobre “Constitutional AI” e técnicas mais robustas de alinhamento. A ideia é ir além do RLHF e criar princípios mais profundos que o modelo segue. Mas até onde sabemos, ainda não há prova de que isso resolve o problema do vetor unidimensional.

A OpenAI investiu em filtros de input e output — camadas extras que analisam o prompt antes de chegar ao modelo e filtram a resposta depois. Isso ajuda contra ataques triviais, mas se o atacante tem acesso aos pesos (como em modelos open-source), os filtros externos são irrelevantes.

A Meta e a Alibaba (Qwen) publicam modelos abertos com safety training, mas esse paper prova que o safety training é, na melhor das hipóteses, um obstáculo temporário.

A abordagem mais promissora parece ser Representation Engineering — técnicas que tentam modificar as representações internas do modelo de forma mais robusta, não apenas adicionar uma direção de recusa. Mas isso ainda é pesquisa ativa.

Implicações Práticas: Quem Deveria se Preocupar?

Empresas usando LLMs em produção

Se você usa um modelo open-source (Llama, Qwen, Gemma) em produção e depende do safety training para evitar outputs perigosos, esse paper é um alerta vermelho. Qualquer pessoa com conhecimento técnico pode remover as proteções. Você precisa de camadas adicionais de segurança: filtros de output, monitoria de conteúdo, e limitação de escopo do que o modelo pode fazer.

Plataformas de API (OpenAI, Anthropic, Google)

Para modelos acessíveis apenas via API, o risco é menor — o usuário não tem acesso aos pesos. Mas ataques de jailbreak via prompt (adversarial suffixes) exploram o mesmo mecanismo. As empresas precisam investir em defesas que não dependam exclusivamente da direção de recusa.

Reguladores e legisladores

Esse paper é dinamite para qualquer regulação que assuma “o modelo foi treinado para ser seguro, logo é seguro”. O EU AI Act, por exemplo, exige que modelos de alto risco tenham medidas de segurança — mas se essas medidas podem ser removidas com uma operação linear, elas realmente contam?

Pesquisadores de segurança

Por outro lado, entender o mecanismo exato de recusa abre portas para defesas melhores. Se sabemos que é um vetor, podemos criar técnicas que distribuam o comportamento de recusa por múltiplas direções, tornando a remoção muito mais difícil.

O Elefante na Sala: Modelos Open-Source

Eu sei que defender open-source em IA é quase uma religião em certas comunidades. Mas esse paper coloca uma questão incômoda na mesa.

Se a segurança de um modelo pode ser removida com uma edição de peso de rank-1 — algo que qualquer estudante de ML consegue fazer com o PyTorch em meia hora — qual o sentido de distribuir modelos “alinhados”?

A resposta, pra mim, é que modelos open-source com safety training são como fechaduras em casas: não impedem um arrombador determinado, mas mantêm as pessoas honestas honestas. Eles previnem uso acidental ou casual, elevam a barreira de entrada, e sinalizam a intenção do desenvolvedor.

Mas precisamos parar de fingir que isso é segurança real. É compliance theater. E empresas que colocam LLMs em produção precisam saber disso.

O Código que Desmonta a Segurança

Pra ilustrar o quão simples é, olha o processo em alto nível usando a biblioteca TransformerLens (usada pelos pesquisadores):

 import torch from transformer_lens import HookedTransformer # Carregar modelo model = HookedTransformer.from_pretrained("meta-llama/Llama-3-8B-Instruct") # Coletar ativações para prompts perigosos e seguros harmful_acts = collect_activations(model, harmful_prompts) safe_acts = collect_activations(model, safe_prompts) # Encontrar a direção de recusa diff = harmful_acts.mean(0) - safe_acts.mean(0) refusal_dir = diff / diff.norm() # Criar hook que remove a direção def ablate_refusal(activation, hook): projection = torch.einsum('...d,d->...', activation, refusal_dir) return activation - projection.unsqueeze(-1) * refusal_dir # Aplicar e gerar model.add_hook('blocks.15.hook_resid_post', ablate_refusal) output = model.generate("Como hackear um sistema...") # O modelo agora responde sem recusar 

Esse código não é funcional (faltam detalhes de implementação), mas mostra a simplicidade conceitual. São menos de 20 linhas para transformar um modelo “seguro” num modelo sem filtros.

O Futuro da Segurança em IA

A comunidade de Mechanistic Interpretability — o campo que estuda como redes neurais funcionam por dentro — está crescendo rápido. E papers como esse são o motivo.

Porque entender por que os modelos se comportam de certa forma é o primeiro passo para construir segurança que realmente funcione. Não adianta colocar band-aids se o sangramento é arterial.

Algumas direções promissoras que estão sendo pesquisadas:

• Distributed safety: em vez de uma direção, espalhar o comportamento de recusa por dezenas ou centenas de direções
• Adversarial training contra ablação: treinar modelos para resistir a remoções de vetores específicos
• Circuit-level safety: implementar segurança no nível de circuitos do modelo, não apenas no nível de representações
• Proof-of-safety: verificação formal de que um modelo não pode ser “desalinhado” com operações simples

Nenhuma dessas abordagens está pronta pra produção. Mas pelo menos agora temos um problema bem definido pra resolver, em vez de uma sensação vaga de “o modelo pode ser hackeado”.

E se tem algo que engenheiros são bons em resolver, é um problema bem definido.

Fonte de inspiração: Refusal in Language Models Is Mediated by a Single Direction — Arditi et al., NeurIPS 2024