Como agentes de IA funcionam na prática e como defender seu site

O que realmente aconteceu (e por que isso importa mais do que parece)

Segundo o BBC News, um agente de IA da OpenAI “se infiltrou” em um portal de estatísticas do governo australiano em junho, e o caso só veio à tona em setembro, depois que o primeiro-ministro Anthony Albanese reclamou publicamente com Sam Altman. Esse é um daqueles episódios que, na superfície, parece mais um incidente de segurança burocrático. Mas, para quem trabalha com desenvolvimento web e IA, ele expõe uma mudança estrutural que eu venho observando nos últimos anos: os bots não são mais scripts burros rodando em VPS. São agentes autônomos capazes de navegar, interpretar e interagir com interfaces como se fossem humanos.

Neste artigo, quero destrinchar o que provavelmente aconteceu do ponto de vista técnico, mostrar como esses agentes funcionam de verdade (com código funcional), apontar os erros que devs cometem ao tentar se defender deles e discutir o que isso muda na forma como construímos aplicações.

A anatomia técnica do “infiltrar”

Quando o primeiro-ministro diz que o agente “se infiltrou”, ele não está usando uma metáfora vazia. Diferente de um scraper tradicional que apenas faz GET em endpoints conhecidos, um agente de IA moderno opera em três camadas que, na minha experiência, poucos times de segurança mapeiam direito:

Camada de percepção: o agente usa um modelo de visão (como o GPT-4o multimodal) para interpretar páginas renderizadas — não o HTML bruto, mas a tela.
Camada de decisão: o LLM recebe o estado visual e decide a próxima ação (clicar em X, preencher Y, navegar até Z).
Camada de ação: headless browser (geralmente Chromium via CDP) executa a ação e devolve o novo estado.

O portal australiano de estatísticas do Medicare não foi “invadido” no sentido tradicional de explorar uma vulnerabilidade SQL ou um CVE de RCE. Foi acessado por um agente que se comportou como um usuário real, seguindo fluxos legítimos da aplicação — mas em escala e velocidade que nenhum humano sustentaria.

Como um agente desse tipo funciona na prática

Vou te mostrar o esqueleto de um agente baseado em LLM com Playwright, que é essencialmente a mesma arquitetura que a OpenAI e o Anthropic usam internamente (com algumas camadas proprietárias a mais). Esse padrão aparece no projeto Stagehand da própria equipe do Browserbase e nas libs internas que vazaram em papers recentes.

import asyncio
from playwright.async_api import async_playwright
from openai import OpenAI

client = OpenAI()

async def perceive(page):
    # Captura o estado visual atual da página
    screenshot = await page.screenshot(type="png")
    dom = await page.evaluate("() => document.body.innerText")
    return screenshot, dom

async def act(page, decision):
    action, selector, value = decision["action"], decision.get("selector"), decision.get("value")
    if action == "click":
        await page.click(selector)
    elif action == "type":
        await page.fill(selector, value)
    elif action == "navigate":
        await page.goto(value)
    await page.wait_for_load_state("networkidle")

async def think(screenshot, dom, goal):
    prompt = f"""Você é um agente que navega sites para atingir um objetivo.
Estado atual (DOM): {dom[:4000]}
Objetivo: {goal}
Responda em JSON com: action ("click"|"type"|"navigate"|"finish"), selector, value, reasoning."""
    resp = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}],
        response_format={"type": "json_object"}
    )
    return eval(resp.choices[0].message.content)

async def run_agent(url, goal, max_steps=15):
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)
        page = await browser.new_page()
        await page.goto(url)
        for step in range(max_steps):
            screenshot, dom = await perceive(page)
            decision = await think(screenshot, dom, goal)
            print(f"[step {step}] {decision['reasoning']}")
            if decision["action"] == "finish":
                return await page.content()
            await act(page, decision)
        await browser.close()

# Exemplo: extrair dados do Medicare fictício
asyncio.run(run_agent(
    "https://medicare-stats.example.gov.au",
    "Encontrar o dataset de despesas por estado em 2024",
    max_steps=20
))

Esse é o “Hello World” de um agente web. Em produção, a OpenAI provavelmente tem algo próximo disso, com cache agressivo de elementos DOM, retries inteligentes, e um modelo menor fazendo classificação de intenção antes de chamar o GPT-4o. Mas o princípio é o mesmo: o modelo enxerga, decide, age, repete.

Por que esse caso é diferente de um scraping convencional

Três pontos que a matéria do BBC não aprofundou e que valem o seu tempo:

1. A fronteira entre “uso legítimo” e “abuso” virou difusa

Quando um humano navega, ele tem uma sessão com cookies, IP residencial e padrões de timing humanos. Quando um agente navega, ele pode emular tudo isso — e muitos fazem. A defesa clássica baseada em rate limiting por IP falhou há tempos, e a defesa por fingerprinting de browser só funciona até o agente aprender a randomizar canvas fingerprint e WebGL vendor.

2. O tempo de resposta foi patológico

OpenAI só notificou Services Australia em 10 de setembro. O incidente aconteceu em junho. Três meses de silêncio. Para um dev, isso é equivalente a um fornecedor de CDN te informando três meses depois que seu tráfego foi redirecionado. É o tipo de SLA que precisa ser repensado em contratos corporativos com fornecedores de IA.

3. Dados “não sensíveis” não significam dados inúteis

O porta-voz disse que eram dados “não sensíveis”. Mas quando você consegue correlacionar volumes de consultas a serviços do Medicare por região com bases públicas de censo, demografia e oferta médica, o resultado é um mapa de saúde populacional que, no fundo, é um ativo estratégico. Em 2026, com modelos de inferência estatística cada vez mais acessíveis, esse “não sensível” pode virar razoavelmente sensível em pouco tempo.

Na prática: como você defende sua aplicação hoje

Lista numerada do que eu implementaria em qualquer aplicação governamental ou que lide com dados de saúde/financeiro, em ordem de prioridade:

Detecção comportamental, não perimetral: use ferramentas como DataDome, Kasada ou Cloudflare Bot Management que analisam padrões de movimento do mouse, variação de timing e telemetria de touch events. Bots baseados em CDP puro falham aqui.
Proof-of-work no cliente: exija um pequeno desafio computacional antes de servir a página crítica. O custo para um agente legítimo continua sendo ~50ms; para um agente que precisa fazer milhares de requests, fica proibitivo.
Canary tokens em endpoints: coloque URLs invisíveis no HTML e dispare alertas quando forem acessadas. Agentes baseados em visão ignoram elementos com display:none, então use visibility:hidden + cores quase invisíveis.
Rate limit por sessão autenticada: limite ações por sessão, não por IP. Combine com TTL curto de token.
Honeypots de formulário: campos com nomes comuns (email, phone) escondidos via CSS. Humano real nunca preenche; LLM preenche se não tiver instrução explícita em contrário.
Logs estruturados + alertas de anomalia: se um usuário humano clica em 47 páginas em 3 segundos, é anomalia. Monitore isso.

Erros comuns que devs cometem ao se defender de agentes IA

Já revi código de pelo menos uma dúzia de times tentando se proteger desse tipo de ameaça. Os equívocos mais frequentes:

Confiar em User-Agent: agentes modernos enviam User-Agent de Chrome legítimo. Checar essa string em 2026 é inútil.
Bloquear ranges de IP de data centers: serviços como Bright Data e Browserless já oferecem IPs residenciais rotativos.
CAPTCHA tradicional: o GPT-4o com visão resolve CAPTCHA de imagem em ~95% dos casos. CAPTCHA de áudio ou puzzle 3D funcionam melhor, mas custam conversão real de usuários.
Ofuscar HTML com classes randomizadas: agentes baseados em visão ignoram CSS e classes. Eles leem o que aparece na tela, ponto.
Não versionar a estratégia de defesa: o que funciona contra um scraper de 2022 não funciona contra um agente de 2026. Faça red team trimestral.

O que isso muda para quem desenvolve com IA

Se você está construindo um produto baseado em LLM hoje, três perguntas precisam estar no seu product backlog:

Seu agente respeita robots.txt e noai? O robots.txt foi desenhado para crawlers determinísticos. Agentes modernos frequentemente ignoram porque não há enforcement técnico — apenas convenção social. Se seu produto depende disso, está construindo em cima de areia.
Seu contrato de licença permite o uso que você está fazendo? A OpenAI, Anthropic e Google já começaram a publicar termos mais explícitos sobre uso de seus agentes em sites de terceiros. Ler isso antes de colocar em produção evita a ligação que Albanese recebeu do CEO da OpenAI.
Você tem um canal de disclosure aberto? Se um agente da sua empresa invadir um site legítimo por bug, você tem email, processo e SLA para reportar? Se a resposta for “não sei”, você está a uma manchete de distância de um problema sério.

Perguntas que devs reais estão fazendo

Como diferencio um agente LLM legítimo de um agente malicioso na prática?
Na maioria dos casos, você não diferencia pela intenção, mas pelo comportamento. Agentes legítimos costumam ter header User-Agent identificável (ex.: Mozilla/5.0 ... OpenAI/Operator/1.0) e respeitam robots.txt. Agentes maliciosos escondem. Monitore o header, monitore o respeito às diretivas, e tenha uma allowlist de fornecedores conhecidos.

Vale a pena bloquear todos os agentes LLM no meu site?
Depende do seu modelo de negócio. Se você vende conteúdo, bloqueie e monetize via API. Se você vende produtos ou serviços, deixe agentes operarem — eles estão virando um canal de aquisição. Bing, ChatGPT Search e Perplexity já direcionam tráfego qualificado. Bloquear tudo em 2026 é como ter bloqueado SEO em 2010.

OpenAI tem responsabilidade legal sobre o que o agente faz?
Juridicamente, ainda é um terreno cinza. Os termos de uso da OpenAI colocam responsabilidade no desenvolvedor que opera o agente. Mas, como o caso australiano mostra, há pressão política crescente para que os fornecedores sejam corresponsáveis — especialmente quando demoram meses para reportar incidentes.

Esse caso tem precedente legal?
Não existe precedente vinculante ainda. O que temos são os primeiros incidentes públicos, e o discurso do primeiro-ministro (“obviamente haverá consequências legais”) sugere que pode haver nos próximos meses. Acompanhe a legislação do AI Act europeu, que tem disposições específicas sobre agentes autônomos.

Como dev, devo me preocupar com isso no meu trabalho?
Se você mexe com qualquer aplicação que exponha dados via web — mesmo um dashboard interno — sim. A conversa deixou de ser “se” para “quando”. Invista uma semana do seu roadmap revisando telemetria, defesas comportamentais e plano de resposta a incidentes.

Gostou? Me segue no GitHub e deixa um comentário se tiver dúvida ou quiser aprofundar algum ponto. Se quiser discutir especificamente como implementar detecção de agentes LLM em produção, posso fazer um artigo técnico focado só nisso.