Segundo o Olhardigital.com.br, Evan Hubinger — líder de testes de alinhamento na Anthropic — afirmou que existe mais de 10% de chance de uma IA “matar todos os humanos” até o fim da década. Pouco antes, Jacob Coxon, pesquisador da mesma empresa, pediu demissão pública acusando laboratórios como Anthropic e OpenAI de apostarem nossas vidas numa corrida irresponsável rumo à superinteligência autoaperfeiçoável. Como dev que trabalha com modelos de linguagem todos os dias, esse tipo de manchete me tira do chão — mas não pelo motivo que você imagina. O risco não é ficção científica. É um problema de engenharia, e é debatido por quem está construindo esses sistemas por dentro.
Por que um dev sênior deveria se importar com isso (mesmo que você não treine modelos)
Trabalho com integração de LLMs em produção desde 2022. Vi acontecer de tudo: alucinações em chatbots críticos, prompts injection que vazaram dados de clientes, agentes que executaram ações fora do escopo porque ninguém validou o que estavam fazendo. Se você usa OpenAI API, Anthropic API, ou roda modelos locais como Llama e Mistral, você está dentro dessa cadeia. Não dá pra assistir ao debate da superinteligência como espectador.
O termo técnico que o pessoal da Anthropic usa é recursive self-improvement — autoaperfeiçoamento recursivo. A ideia é simples e perturbadora: um modelo capaz de melhorar a si mesmo sem intervenção humana significativa. Cada versão gera uma melhor, que gera uma ainda melhor, e assim por diante. Esse loop exponencial é o que preocupa Hubinger e Coxon, porque ninguém sabe como alinhar algo que evolui mais rápido do que conseguimos auditar.
O que o episódio Coxon + Hubinger revela sobre os bastidores
Dois funcionários de alto escalão da mesma empresa, em 24 horas, disseram publicamente que o risco de extinção pela IA é real e mensurável. Hubinger deu o número — acima de 10%. Coxon foi mais explícito: “Eles estão correndo diretamente rumo à superinteligência que se aprimora sozinha e apostando nossas vidas”. Em mais de uma década acompanhando o mercado de tech, raramente vi funcionários de uma empresa líder criticarem o próprio produto com esse nível de gravidade. Normalmente se demitem em silêncio.
Isso acende um alerta sobre o que devs costumam ignorar: a governança de IA não está resolvida. Frameworks regulatórios como o EU AI Act tentam enquadrar a coisa, mas a fronteira do que é “alto risco” mudou três vezes em dois anos. Quem constrói produto com IA em 2026 está navegando em águas onde a régua muda enquanto você rema.
Na Prática: implementando safeguards reais em agentes LLM
Você provavelmente não vai treinar uma superinteligência, mas pode construir um agente que deleta um bucket S3 ou executa SQL destrutivo. É o mesmo problema de alinhamento, só que em escala microscópica. Aqui vai um padrão que aplico em produção e que mitiga boa parte do risco:
- Whitelist explícita de tools: nunca passe todas as funções disponíveis ao LLM. Filtre por contexto.
- Human-in-the-loop obrigatório para ações irreversíveis: delete, transfer, deploy em prod.
- Logging estruturado de toda decisão do agente — prompt, raciocínio, tool call, output. Sem exceção.
- Rate limit por ação sensível: mesmo que o modelo queira, não pode.
- Validação de output antes de executar: regex, schema validation, sanity checks de domínio.
Veja como implemento o ponto 1 e 4 num wrapper para a API da Anthropic:
from anthropic import Anthropic
import time
from functools import wraps
class ToolRegistry:
def __init__(self):
self.tools = {}
self.call_log = []
self.rate_limits = {}
def register(self, name, fn, requires_approval=False, max_calls_per_min=10):
if name in self.tools:
raise ValueError(f"Tool {name} ja registrada")
self.tools[name] = {
"fn": fn,
"requires_approval": requires_approval,
"schema": {
"name": name,
"description": fn.__doc__ or "Sem descricao",
"input_schema": getattr(fn, "_input_schema", {"type": "object"})
}
}
self.rate_limits[name] = {"max": max_calls_per_min, "calls": []}
def _check_rate_limit(self, name):
limit = self.rate_limits.get(name)
if not limit:
return True
now = time.time()
limit["calls"] = [t for t in limit["calls"] if now - t < 60]
if len(limit["calls"]) >= limit["max"]:
raise PermissionError(f"Rate limit atingido para {name}")
limit["calls"].append(now)
return True
def get_filtered_tools(self, allowed):
return [self.tools[n]["schema"] for n in allowed if n in self.tools]
def execute(self, name, args, approver=None):
if name not in self.tools:
raise PermissionError(f"Tool {name} nao autorizada pelo contexto")
tool = self.tools[name]
self.call_log.append({"tool": name, "args": args, "ts": time.time()})
if tool["requires_approval"] and approver is None:
return {"status": "blocked", "reason": "needs_human_approval"}
self._check_rate_limit(name)
return tool["fn"](**args)
# Exemplo de uso: agente que pode ler arquivos mas nao deletar
registry = ToolRegistry()
def read_file(path: str) -> str:
"""Le conteudo de arquivo de texto."""
with open(path) as f:
return f.read()
def delete_file(path: str) -> str:
"""Deleta arquivo do disco."""
import os
os.remove(path)
return "deleted"
registry.register("read_file", read_file, max_calls_per_min=60)
registry.register("delete_file", delete_file, requires_approval=True, max_calls_per_min=2)
client = Anthropic()
response = client.messages.create(
model="claude-sonnet-4-5",
max_tokens=1024,
tools=registry.get_filtered_tools(["read_file", "delete_file"]), # whitelist
messages=[{"role": "user", "content": "Limpa os logs antigos"}]
)
Esse padrão não elimina risco — nada elimina — mas torna o sistema auditável, bounded e reversível. É o mínimo que devs sérios entregam.
Erros comuns que vejo em times construindo agentes
1. Confiar no system prompt como mecanismo de segurança. System prompts são strings. LLMs as seguem probabilisticamente. Qualquer dev que já fez jailbreak sabe. Segurança precisa estar no código, não no prompt.
2. Não validar o output antes de executar. Modelo retorna {"sql": "DROP TABLE users"}? Não, senhor. Schema validation + dry-run obrigatório. Vejo gente rodando SQL gerado por LLM direto em produção e torcendo para dar certo.
3. Ausência de logs estruturados. Quando algo dá errado (e vai dar), sem log você não tem como fazer post-mortem. Convenção {prompt, tools_called, outputs, latency, user_id, trace_id} salva sua carreira.
4. Tratar agente autônomo como democracia. "O agente pode decidir qual tool chamar" não significa que ele decide tudo. Decisões arquiteturais e estratégicas ficam com humanos. Agentes executam, decidem o tático dentro de regras que humanos definem.
5. Ignorar prompt injection porque "nosso caso de uso não tem input externo". Todo input é externo. Email do usuário, PDF que veio do cliente, dados de API terceira. Sempre sanitize, sempre assuma hostilidade.
O debate Hubinger vs. comunidade tech
Parte do ceticismo vem de gente respeitada como Yann LeCun (Meta), que chama o cenário de "extrapolação ridícula" e questiona se LLMs atuais têm arquitetura para alcançar superinteligência. Outros, como Stuart Russell (Berkeley), concordam com Hubinger que o risco existencial é sério. A verdade, na minha leitura honesta do estado da arte em 2026: ninguém sabe. Mas "ninguém sabe" em sistemas complexos normalmente significa "prepare-se para o pior caso".
O que não está em dúvida: modelos estão ficando mais capazes mês a mês, agentes autônomos estão substituindo cadeiras inteiras de processo, e o gap entre capacidade técnica e capacidade de governança só cresce. Quando um pesquisador interno de uma das três maiores labs do mundo publica que a chance é maior que 10%, vale pelo menos sentar e ouvir.
FAQ — perguntas que devs realmente fazem
Recursive self-improvement já é possível em 2026?
Não de forma autônoma e robusta. Pesquisadores conseguiram pequenos saltos iterativos em tarefas específicas (AlphaEvolve, AutoML moderno), mas nada que generalize. O cenário da Anthropic projeta isso escalando nos próximos 3-5 anos — daí a urgência da década.
Qual a diferença entre alucinação e risco existencial?
Alucinação é o modelo errando factual. Risco existencial é o modelo agindo de forma otimizada para um objetivo desalinhado com valores humanos, possivelmente sem possibilidade de correção. São problemas fundamentalmente diferentes — o primeiro é bug, o segundo é desvio de objetivo.
Vale a pena usar agentes autônomos em produção hoje?
Sim, com escopo limitado, aprovação humana em ações irreversíveis e telemetria completa. Não vale deployar agente "fully autonomous" comprando ações, enviando emails, ou mexendo em infra crítica sem supervisão. Esse é o consenso em 2026.
Modelos open source mitigam o risco?
Argumento duplo. PRÓ: distribuição dilui poder concentrado. CONTRA: modelos open podem ser modificados para remover guardrails. Llama e Mistral já mostraram isso acontecer. Não é resposta simples.
O que devs podem fazer concretamente?
Implementar as camadas de defesa que mostrei acima, apoiar padrões como o Model Card e Responsible AI, cobrar transparência dos fornecedores, e parar de tratar system prompt como mecanismo de segurança. Engenharia de verdade, não teatro.
Considerações finais que ninguém pediu mas eu acho relevante
Há 15 anos programando, vi modismos virem e irem. Blockchain, metaverse, NFTs — todos venderam hype como se fosse tecnologia. IA generativa é diferente porque funciona. Está aqui, está em produção, e está mudando a economia do código. Justamente por isso a discussão sobre alinhamento importa mais do que nunca. Não porque os agentes vão destruir o mundo amanhã, mas porque devs que ignoram os riscos vão construir produtos frágeis, inseguros e eticamente quebrados.
Hubinger e Coxon não estão pedindo para parar. Estão pedindo para correr com responsabilidade. Isso dev que constrói sistema de IA deveria ouvir — não como dogma, mas como input de engenharia.
Se você chegou até aqui, manda um feedback no meu site ou no GitHub. Quero saber qual dessas práticas você já aplica — e onde travar.
Gostou? Me segue no GitHub e deixa um comentário se tiver dúvida ou quiser aprofundar algum ponto.