Top-10 da busca não é top-10 do usuário: por que a SERP bruta sabota seu agente

Você plugou a SERP do Google direto no seu agente. Pegou os 10 primeiros links, jogou tudo no contexto, mandou o LLM "responder com base nesses resultados". Funcionou nos testes. Em produção, o agente começou a recomendar coisa estranha. Site afiliado disfarçado de review. Página gerada por IA com fato inventado. Cinco resultados dizendo a mesma frase porque foram clonados do mesmo blog.

Não é bug do modelo. É a SERP. A primeira página do Google não foi feita pra alimentar agente de IA — ela foi feita pra ranquear sites. E essas duas coisas, em 2026, não são mais a mesma coisa.

Neste post você vai entender por que o top-10 da busca não é o top-10 do usuário, quais são as três falhas estruturais que destroem seu agente quando você usa SERP bruta, e como montar um pipeline mínimo de filtros + rerank que devolve confiança à sua camada de recuperação. Esse texto também prepara o terreno para o capítulo de ranking do nosso próximo workshop.

TL;DR

• O que é: análise de por que SERP crua sabota agentes de IA, mais um pipeline mínimo de defesa em três camadas.
• Stack do exemplo: PHP 8.3, Laravel HTTP Client, Cohere Rerank 3.5 (ou 4), allowlist de domínios e dedupe simples.
• Custo/Acesso: Cohere Rerank tem free tier; provedor de busca de sua escolha (Brave, Tavily, Serper, etc.). Modelo open-source (BGE, Jina) também serve.
• Link útil: Cohere Rerank e paper sobre rerankers da Pinecone.

O cenário: a SERP de 2026 está contaminada

A web sempre teve lixo. A diferença é a escala e a velocidade.

Em março de 2026, o Google rodou um spam update que terminou em menos de 24 horas — o mais rápido da história. Um update inteiro contra "scaled content abuse", a definição oficial deles para "produzir muita página com IA pra manipular ranking sem agregar valor". O efeito foi brutal: redes inteiras de sites afiliados gerados por IA viram tráfego cair pra perto de zero da noite pro dia (Search Engine Land).

Boa notícia? Em parte. O update derrubou o lixo mais escancarado. O lixo sofisticado continua de pé.

Existe uma categoria mais antiga e mais teimosa: os MFA — Made For AdSense. Sites criados unicamente para servir anúncios, com texto raso o suficiente pra parecer útil e otimizado o suficiente pra ranquear. Estudos da indústria de ad-tech mostram que sites MFA chegaram a representar 21% das impressões e 15% do gasto em campanhas analisadas (análise de ad-tech). Isso são bilhões de impressões mensais em conteúdo otimizado pra ranquear sem te ensinar nada.

E não é só Google. Qualquer provedor de busca que use sinais de link, autoridade de domínio e click-through herda parte do problema. Você troca de provedor, troca de viés. Não foge dele.

Some três tendências que se reforçam:

1. Conteúdo gerado por IA aumentou em ordens de magnitude o custo marginal de produzir página "razoável".
2. EEAT (Experience, Expertise, Authoritativeness, Trustworthiness) continua sendo um sinal probabilístico, não impede a publicação, só penaliza depois.
3. A maior parte do tráfego dos buscadores ainda é humano clicando, e humano confunde "primeiro resultado" com "fonte boa".

Resultado: a SERP que você puxa hoje tem três tipos de conteúdo misturados sem etiqueta. Conteúdo de autor real e fonte primária. Conteúdo de copy-paste com SEO. Conteúdo gerado em escala por IA, que pode ser inofensivo ou pode ser invenção pura.

Pra um humano que sabe ler URL, isso é navegável. Pra um LLM que recebeu "aqui estão 10 resultados, responda", é veneno.

Por que isso quebra seu agente (não só seu UX)

Top-10 da busca foi otimizado para uma métrica: cliques de humanos em resultados que parecem responder à query. Top-10 do usuário do seu agente é outra coisa: as 3 a 5 fontes mais confiáveis e mais específicas para a intenção real dele, sem redundância.

São objetivos diferentes. Por isso a SERP bruta sabota seu agente em três frentes:

1. Hallucination por contexto ruim. A pesquisa em RAG já mostrou várias vezes que recuperação ruim é um dos principais vetores de alucinação. Se o modelo recebe contexto irrelevante ou de baixa qualidade, ele parafraseia o lixo com confiança (Pryon sobre reasoning e hallucination). Modelos de raciocínio mais novos pioram nisso, não melhoram, porque "trabalham mais" em cima do contexto que receberam.

2. Amplificação de viés por duplicação. A SERP devolve várias páginas que clonaram a mesma frase. O LLM lê cinco vezes a mesma afirmação e trata como consenso. Você acabou de transformar um único site duvidoso em "fonte amplamente reportada".

3. Vetor de prompt injection indireto. Esse é o mais novo e o mais perigoso. O Unit 42 da Palo Alto e a Help Net Security relataram em 2026 um aumento de 32% em conteúdo malicioso dentro de páginas indexadas, com instruções escondidas em CSS de cor zero, fonte de 1px, comentários HTML e meta tags (Palo Alto Unit 42, Help Net Security). Já existem payloads in-the-wild que tentam fazer agentes com acesso a pagamento iniciar transações em PayPal e Stripe. Você lê SERP bruta e injeta o HTML no contexto? Você acabou de dar acesso de instrução ao primeiro spammer com tempo livre.

A regra é simples: tudo que vem da web entra como dado, nunca como instrução. SERP bruta no contexto quebra essa regra por padrão.

Pipeline de defesa: três camadas, na ordem certa

Não existe filtro mágico. Existe pipeline. A ideia é que o resultado da busca passe por três etapas antes de virar contexto pro LLM:

Camada 1 — Filtros de confiança (cheap). Remove o lixo óbvio antes de gastar token ou chamada de modelo:

• Allowlist/denylist de domínios para o seu domínio de problema (financeiro, médico, dev, etc.).
• Heurísticas baratas: presença de autor, data de publicação visível, comprimento mínimo, ausência de marcadores de afiliado conhecidos.
• Dedupe por hash de trecho ou similaridade alta (>0.95) entre resultados.

Camada 2 — Rerank semântico. Aqui é onde a maioria pula etapa e perde. Embedding sozinho comprime tudo num vetor; cross-encoder (rerank) lê query e documento juntos e devolve uma similaridade muito mais fiel. Pinecone reportou ganhos de 14% a 30% em qualidade de recall quando se adiciona rerank a um pipeline de busca (Pinecone sobre rerankers). Cohere reportou ganho de +23,4% sobre busca híbrida em datasets financeiros com o Rerank 3.5 (documentação Oracle sobre Rerank 3.5).

A NVIDIA, em um post sobre RAG, deixa explícito: a métrica que o rerank melhora é exatamente "o sistema tinha a resposta certa em algum lugar do top 50, mas não conseguia trazer pro top 10" (NVIDIA blog). É exatamente o seu cenário com SERP.

Camada 3 — Grounding e citação obrigatória. O Vertex AI da Google define grounding como "ancorar o output do modelo em fontes verificáveis específicas" (Vertex AI grounding). Operacionalmente, isso vira: o LLM não pode afirmar nada sem citar de qual dos N documentos veio. Se não cita, você rejeita a resposta.

Conceito + aplicação + impacto: rerank é um cross-encoder que reordena resultados, você passa a entregar 5 fontes confiáveis em vez de 10 mistas, e seu agente para de inventar e começa a ser auditável.

Mão na massa: implementação mínima em PHP/Laravel

Vamos montar a versão enxuta. Provedor de busca de sua escolha (no exemplo uso uma chamada genérica), Cohere Rerank, dedupe e allowlist. Tudo em um service só.

Passo 1: buscar bruto e descartar o óbvio

<?php

namespace App\Services\Search;

use Illuminate\Support\Facades\Http;
use Illuminate\Support\Str;

class TrustedWebSearch
{
    private const ALLOWED_DOMAINS = [
        'docs.anthropic.com',
        'platform.openai.com',
        'cohere.com',
        'huggingface.co',
        'arxiv.org',
        'github.com',
        // adicione os seus domínios de confiança por vertical
    ];

    private const BLOCKED_PATTERNS = [
        '/\b(best|top|melhores)\s+\d+\b/i',  // top-10 articles, normalmente afiliado
        '/(coupon|cashback|cupom)/i',
    ];

    public function fetch(string $query, int $limit = 20): array
    {
        $raw = Http::withToken(config('services.search.key'))
            ->get('https://api.search.brave.com/res/v1/web/search', [
                'q' => $query,
                'count' => $limit,
            ])
            ->json('web.results', []);

        return collect($raw)
            ->reject(fn ($r) => $this->isBlocked($r))
            ->reject(fn ($r) => $this->isAffiliateBait($r))
            ->values()
            ->all();
    }

    private function isBlocked(array $r): bool
    {
        if (empty(self::ALLOWED_DOMAINS)) {
            return false; // sem allowlist, deixa passar
        }
        $host = parse_url($r['url'] ?? '', PHP_URL_HOST) ?? '';
        return ! collect(self::ALLOWED_DOMAINS)
            ->contains(fn ($d) => Str::endsWith($host, $d));
    }

    private function isAffiliateBait(array $r): bool
    {
        $title = ($r['title'] ?? '').' '.($r['description'] ?? '');
        foreach (self::BLOCKED_PATTERNS as $pattern) {
            if (preg_match($pattern, $title)) {
                return true;
            }
        }
        return false;
    }
}

Allowlist é a ferramenta mais subestimada. Dois minutos pensando "para o meu domínio, quais são as 30 fontes que valem a pena?" entrega mais qualidade que três semanas tunando embedding.

Passo 2: dedupe antes do rerank

Não pague rerank em quatro versões da mesma frase clonada.

private function dedupe(array $results): array
{
    $seen = [];
    $unique = [];

    foreach ($results as $r) {
        $fingerprint = $this->fingerprint($r['description'] ?? '');
        if (isset($seen[$fingerprint])) continue;
        $seen[$fingerprint] = true;
        $unique[] = $r;
    }
    return $unique;
}

private function fingerprint(string $text): string
{
    // shingle simples; em produção use simhash/minhash
    $normalized = Str::of($text)->lower()->squish()->limit(160, '');
    return md5((string) $normalized);
}

Para volume sério, troque o md5 por simhash com hamming distance. A ideia central é: páginas que dizem a mesma coisa não devem votar várias vezes no contexto.

Passo 3: rerank com Cohere

A chamada é uma só. O ganho é absurdo.

public function rerank(string $query, array $documents, int $topK = 5): array
{
    $payload = [
        'model' => 'rerank-v3.5',
        'query' => $query,
        'documents' => array_map(
            fn ($d) => $d['title'].' - '.$d['description'],
            $documents
        ),
        'top_n' => $topK,
        'return_documents' => false,
    ];

    $response = Http::withToken(config('services.cohere.key'))
        ->post('https://api.cohere.com/v2/rerank', $payload)
        ->json('results', []);

    return collect($response)
        ->map(fn ($r) => [
            ...$documents[$r['index']],
            'relevance_score' => $r['relevance_score'],
        ])
        ->all();
}

A AWS publicou um benchmark mostrando ganho consistente do Rerank 3.5 sobre busca híbrida no OpenSearch (AWS blog sobre Rerank 3.5). Em abril de 2026 a Cohere lançou o Rerank 4 com janela de contexto 4x maior, justamente focado em reduzir erro de agente (VentureBeat sobre Rerank 4). Vale testar a v4 se você precisa enviar documentos maiores.

Não quer depender de provedor pago? Modelos open-source como BGE-Reranker e Jina Reranker rodam local com qualidade comparável em vários cenários. Confira o leaderboard mantido pela Agentset.

Passo 4: orquestração e contrato com o LLM

public function search(string $query): array
{
    $raw = $this->fetch($query, 30);
    $clean = $this->dedupe($raw);
    return $this->rerank($query, $clean, topK: 5);
}

E no prompt do agente, contrato explícito:

Você responde APENAS com base nos documentos enumerados abaixo.
Cada afirmação na sua resposta deve terminar com [doc N], onde N é o
índice do documento. Se a informação não estiver nos documentos,
responda exatamente: "Não encontrei essa informação nas fontes
disponíveis."

Documentos:
[1] {{titulo}} - {{trecho}}  (fonte: {{url}})
[2] ...

Esse contrato é o que transforma "agente que parafraseia internet" em "agente que cita fonte". Você ainda pode validar, após a geração, se cada [doc N] aponta para uma fonte real. Se um aponta pra documento que não existe, rejeita a resposta.

Limitações e armadilhas

Não é cura, é higiene. Algumas coisas pra você se proteger antes de levar isso pra produção:

• Latência do rerank. Cohere e Voyage rodam em ~600ms para top 50. Se sua UX é chat real-time, isso pesa. Pondere top_n menor ou rerank assíncrono em segundo plano.
• Allowlist envelhece. O domínio que era ouro ano passado pode ter sido vendido pra uma rede de MFA. Auditoria trimestral, não um arquivo .env esquecido.
• Prompt injection indireto continua possível mesmo com rerank. Rerank reordena, não sanitiza. Sempre extraia texto puro da página (sem HTML, sem CSS), corte pra um limite de caracteres e envolva no contexto com delimitadores claros como <doc>...</doc>. O Vertex AI documenta esse padrão como defesa básica.
• Métricas você não tem. Sem ground truth, você não consegue medir "o rerank está melhorando?". Comece simples: log de query, top 5 antes/depois, spot-check humano semanal. Em duas semanas você tem sinal suficiente pra ajustar.
• Custo composto. Busca + rerank + LLM final pode triplicar seu custo por consulta. Cache agressivo de queries normalizadas e top-K pequeno são suas melhores armas.

Próximo passo: o capítulo de ranking do workshop

Esse texto é uma parte do quadro. No nosso próximo workshop a gente vai mais fundo no capítulo de ranking: rerank com modelos open-source rodando local, BM25 + embeddings + cross-encoder em três estágios, avaliação automatizada com judge-LLM, e como construir um trust score por domínio que aprende com feedback do usuário em produção.

Se você está construindo agente sério com busca na web e cansou de ver o seu LLM amplificar lixo, o lugar de continuar essa conversa é dentro do Clã Beer & Code. É lá que a gente está montando o próximo módulo, com código que roda, dataset de avaliação e revisão de arquitetura do que você está construindo.

Entra no Clã e participa do próximo workshop ao vivo.

FAQ rápido

1. Não dá pra simplesmente usar um provedor de busca melhor e pular o rerank? Provedor melhor reduz a contaminação, não elimina. Brave, Tavily, Exa e You.com têm filtros melhores que Google API "puro", mas todos retornam resultados com qualidade variável dentro do top 10. Rerank é a camada que normaliza isso para o seu domínio específico. Não é redundância, é especialização.

2. Embedding (cosine similarity) não substitui o rerank? Não. Embedding compacta cada documento em um vetor independente da query, perde nuance. Cross-encoder (rerank) recebe query + documento juntos e produz score com muito mais informação. Por isso ganha consistentemente em recall@K nos benchmarks. Use os dois: embedding pra buscar e rerank pra reordenar o top 50.

3. E para domínios em português, Cohere/BGE funcionam bem? Razoavelmente. Cohere Rerank 3.5+ tem suporte multilíngue oficial, e BGE-Reranker-v2-M3 também. Para domínios muito específicos (jurídico BR, fiscal), considere fine-tune leve com seus próprios pares query-doc. Comece sem fine-tune, meça, decida depois.

4. Como começo a medir se o rerank está melhorando o meu agente? Pegue 50 queries reais do seu produto. Para cada uma, rode o pipeline com e sem rerank, salve os top-5 dos dois lados. Faça spot-check humano (você ou outro dev) marcando "esse resultado é útil para responder essa query? sim/não". Compare a taxa. Em 2 horas você tem o número que precisa pra justificar o custo.

Conclusão

A web nunca foi limpa, mas em 2026 a sujeira é industrial e otimizada pra parecer informação. SERP bruta no contexto do seu agente é um atalho que você paga depois: em alucinação, em recomendação ruim, e na pior das hipóteses em prompt injection in-the-wild.

A cura não é mística. É pipeline: filtros baratos primeiro, rerank semântico depois, grounding e citação no contrato com o LLM. Cinco fontes boas batem dez fontes mistas todas as vezes.

O próximo passo dessa tecnologia é integrar trust scoring contínuo, com modelo aprendendo o que é fonte boa para o seu domínio a partir de feedback real de uso. Quem chega antes nessa camada, constrói agente que escala. Quem chega depois, mantém amplificador de lixo.

Começa hoje com o que tem: uma allowlist e uma chamada de rerank. O resto a gente constrói junto.