Trust layer no agente: como pontuar a confiabilidade de cada fonte antes do LLM ver

Seu agente de IA acabou de recomendar um hotel em Buenos Aires baseado em um blog que tem três anos de domínio, 18 links de afiliado por página e o mesmo texto reescrito por LLM em 40 outros sites. O LLM não sabia disso. O reranker mandou o documento pro topo porque a similaridade vetorial era alta. E a resposta foi pro usuário com a confiança de quem cita o New York Times.

Esse é o problema que ninguém quer encarar quando monta um agente que consome a web aberta. Reranker é ótimo pra relevância. Mas relevância não é confiança. Um documento pode ser exatamente o que o usuário pediu e ainda assim ser propaganda paga, alucinação reciclada ou — pior — uma instrução adversária plantada num texto que parece resposta.

Neste post você sai com um modelo concreto de trust layer: uma camada que pontua a confiabilidade de cada fonte antes de o LLM sequer enxergar o conteúdo. Sinais simples, código que roda, e como plugar isso no reranker sem reescrever seu pipeline.

TL;DR

• O que é: uma camada entre o retrieval e o LLM que atribui um score de confiança (0-1) por fonte, combinando sinais de domínio, conteúdo e comportamento.
• Stack/Modelos: Python, qualquer reranker (Cohere Rerank 4, Voyage, BGE), opcional Cleanlab TLM pra score de saída.
• Custo/Acesso: heurísticas são grátis; reranker comercial fica em centavos por consulta; LLM-as-judge é o mais caro e deve rodar só na cauda.
• Link útil: Citations API da Anthropic, Cohere Rerank, paper sobre RAG fact-checking.

Por que confiança virou camada explícita

A indústria já entendeu que retrieval sozinho não resolve. Por isso temos rerankers, citations, evals. Mas todo mundo está otimizando a pergunta errada: "esse documento é relevante?". A pergunta certa é "esse documento merece entrar no contexto do meu LLM?".

A diferença é gigante. Olha os números.

A Anthropic lançou a Citations API e relatou casos reais — Endex reduziu hallucinações de fonte de 10% para 0% e aumentou referências por resposta em 20%. Avaliações internas mostraram +15% de recall accuracy. Não é mágica de modelo maior. É arquitetura.

A Cleanlab foi mais longe: o TLM (Trustworthy Language Model) produz um score 0-1 combinando self-reflection, predição probabilística e consistência observada. Em um exemplo do blog deles, uma pergunta sobre RTX 4090 começa com score 0.635 sem retrieval, sobe pra 0.725 com busca semântica simples (ainda insuficiente) e só passa do threshold (0.988) quando o agente escala pra busca híbrida com rerank. O harness decide quando parar.

Agora o lado feio. Prompt injection é a vulnerabilidade número um da OWASP LLM em 2026, presente em 73% dos deployments em produção. E o vetor mais perigoso não é o usuário malicioso — é a indirect prompt injection: instruções plantadas em páginas web, documentos e respostas de API que o agente busca sozinho. Um único parágrafo num blog manjado pode sequestrar o workflow inteiro.

Reranker não te protege disso. Ele puxa pra cima o documento adversário se ele for relevante. Trust layer puxa pra baixo independente da relevância.

Os sinais que cabem em um harness real

Nada de modelo gigante de fraud detection treinado em 50M de exemplos. A pegada é diferente: sinais simples, baratos, calculáveis em milissegundos, que você compõe num score por fonte. A maioria sai de heurística pura.

1. Reputação do domínio

A primeira pergunta é sobre quem está falando, não o que está sendo dito.

• Idade do domínio. Não é ranking factor positivo do Google desde sempre, mas a patente US8521749B1 usa duração de registro como spam filter — domínios spam costumam ser registrados por um ano só. Use como filtro negativo, não como boost.
• Atividade recente. Em 2026 o consenso virou claro: domínio dormente de dez anos vale menos que ativo de dois. Conta a frequência de publicação dos últimos 90 dias.
• Allowlist e blocklist internas. Sua lista vale ouro. Curadoria humana de 200 domínios confiáveis no seu nicho bate qualquer ML.
• Presença em fontes-âncora. Domínio citado por Wikipedia, GitHub Trending, papers no arXiv ou Hacker News tem peso diferente.

2. Densidade de afiliado e disclosure

Sinal barato, sinal forte.

A própria Google explica em política pública que conteúdo afiliado sem valor agregado é "thin affiliation". O March 2026 spam update mirou em cheio sites de review gerados por IA com afiliado em todo parágrafo.

Conta no harness:

• Razão entre links de afiliado (?ref=, ?aff=, tag=, parâmetros conhecidos de Amazon, ShareASale, Awin, Hotmart) e total de links.
• Densidade de afiliado por mil palavras.
• Presença de disclosure (rel="sponsored", texto explícito).

Acima de 10 links de afiliado por mil palavras sem disclosure, o documento entra em quarentena.

3. Coerência entre reviews

Aqui mora o sinal mais elegante da literatura. Pesquisa do Cambridge mostra que reviews fraudulentas têm coerência semântica menor que reviews autênticas. Frases dentro do mesmo texto não casam — elogiam o atendimento e depois reclamam dele, descrevem cores que não combinam, citam features que não existem.

Operacionalmente, dois testes:

• Coerência intra-fonte. Embed de cada parágrafo, similaridade média entre eles. Texto coerente fica entre 0.45-0.75; texto incoerente cai pra <0.30 ou estoura pra >0.85 (sinal de repetição massiva).
• Coerência cross-source. Pra mesma entidade (hotel X, produto Y), pega 5+ fontes diferentes e mede a variância de claims numéricos (preço, nota, ano de fundação). Variância alta sinaliza fonte mentindo ou dado obsoleto.

4. Sinais comportamentais (quando você tem)

Se a fonte é uma plataforma com perfis (TripAdvisor, Amazon, Google Maps), aplique o que a literatura de fake review já mapeou: rating entropy, review gap, review count, rating deviation, time of review, user tenure (referência). Não é o foco aqui — você raramente vai recalcular isso em runtime —, mas se a plataforma já expõe um "verified" flag, use.

5. Sinais textuais

Os mais baratos. Densidade lexical baixa, repetição de N-gramas, alta proporção de adjetivos superlativos, ausência de números concretos. Tudo isso pode ser calculado com regex e contagem. Não acertam sozinhos. Compostos com os outros, sim.

Trust score em código

Esqueleto Python. Roda em CPU, sem dependência absurda. Adapta pro seu pipeline.

from dataclasses import dataclass
from datetime import datetime, timedelta
from urllib.parse import urlparse
import re

AFFILIATE_PARAMS = {"ref", "aff", "tag", "affid", "utm_source"}
AFFILIATE_HOSTS = {"amzn.to", "shareasale.com", "awin1.com", "hotmart.com"}

@dataclass
class SourceSignals:
    domain: str
    domain_age_days: int
    last_publish_days: int
    in_allowlist: bool
    in_blocklist: bool
    word_count: int
    affiliate_link_count: int
    has_disclosure: bool
    intra_coherence: float        # 0-1, sim media entre paragrafos
    cross_source_variance: float  # baixo = bate com outras fontes


def score_domain(s: SourceSignals) -> float:
    if s.in_blocklist:
        return 0.0
    if s.in_allowlist:
        return 1.0
    age = min(s.domain_age_days / 365, 5) / 5            # 0-1, satura em 5 anos
    activity = max(0, 1 - s.last_publish_days / 180)     # cai em 6 meses
    return 0.6 * age + 0.4 * activity


def score_affiliate(s: SourceSignals) -> float:
    if s.word_count < 100:
        return 0.5
    density = s.affiliate_link_count / (s.word_count / 1000)
    if density == 0:
        return 1.0
    if density > 10 and not s.has_disclosure:
        return 0.1
    if density > 5:
        return 0.4 if s.has_disclosure else 0.25
    return 0.7 if s.has_disclosure else 0.5


def score_coherence(s: SourceSignals) -> float:
    intra = s.intra_coherence
    if intra < 0.30 or intra > 0.85:
        return 0.2
    intra_norm = 1 - abs(intra - 0.60) / 0.30
    cross = max(0, 1 - s.cross_source_variance)
    return 0.5 * intra_norm + 0.5 * cross


def trust_score(s: SourceSignals) -> float:
    weights = {"domain": 0.35, "affiliate": 0.30, "coherence": 0.35}
    score = (
        weights["domain"] * score_domain(s)
        + weights["affiliate"] * score_affiliate(s)
        + weights["coherence"] * score_coherence(s)
    )
    return round(score, 3)

Dois detalhes que importam mais que o algoritmo:

1. Threshold é decisão de produto, não de engenharia. Recomendação de hotel pode tolerar 0.55. Resposta médica não passa de 0.85. Use eval pra calibrar com adversariais reais do seu domínio.
2. Fonte abaixo do threshold não é deletada — é marcada. Você precisa do dado pra evals e pra explicar ao usuário por que aquela fonte não foi usada.

Integrando com o reranker

O ponto de conexão é onde mais gente erra. Reranker e trust são funções diferentes que ranqueiam o mesmo conjunto. O jeito mais simples e robusto de combinar é uma soma ponderada após normalizar:

def final_rank(docs, alpha=0.7, beta=0.3):
    """
    docs: lista de dicts com 'rerank_score' (0-1) e 'trust_score' (0-1)
    alpha: peso da relevancia
    beta: peso da confianca
    """
    for d in docs:
        d["final_score"] = alpha * d["rerank_score"] + beta * d["trust_score"]
    return sorted(docs, key=lambda d: d["final_score"], reverse=True)

Três coisas a fazer depois do ranking final:

1. Quarentena de baixa confiança. Documentos com trust_score < 0.4 saem do contexto, mesmo se o final_score for alto. Esses são os candidatos a injection ou desinformação.
2. Tag explícita pro LLM. Documentos no meio (0.4-0.7) entram com prefixo [FONTE DE CONFIANÇA MÉDIA — verificar antes de afirmar]. O LLM aprende a hedgear.
3. Fallback iterativo no estilo Cleanlab. Se a média de trust_score do top-k for menor que 0.6, dispara re-busca com query reformulada ou estratégia mais cara (busca híbrida + rerank de modelo maior). Custa mais, mas só quando precisa.

E como esse fluxo conversa com a Citations API ou com o search_results content block do Claude? Você passa o trust_score como metadado da citação. O LLM cita a fonte e o usuário enxerga o badge de confiança no front. Isso fecha o loop — confiança vira parte da UX, não fica enterrada no log.

Limitações e onde você vai se queimar

Sinais simples não pegam adversário sofisticado. Texto gerado por LLM moderno tem coerência intra alta, densidade lexical normal e estrutura impecável. A literatura recente já mostra que detectores de review gerados por IA precisam de modelos próprios. Se o seu inimigo é um affiliate marketer caprichado usando GPT-5, o trust score vai precisar de um LLM-as-judge na cauda.

Domain age tem casos negativos óbvios. Lançamento de produto novo, blog técnico recém-aberto, paper acabado de subir no arXiv — todos teriam score baixo de domínio e merecem entrar. Por isso a allowlist existe. Curadoria humana é cara mas é o ground truth do seu negócio.

Calibração precisa de eval. Sem dataset adversarial — fontes maliciosas reais que você marcou na mão — você está chutando threshold no escuro. Comece pequeno: 50 fontes confiáveis e 50 ruins, mede precisão e recall por threshold, escolhe o ponto onde a perda de recall é aceitável pro seu produto.

E o elefante na sala: trust layer não substitui defesa em profundidade contra prompt injection. A pesquisa atual é unânime — não existe solução única. Você ainda precisa de privilege separation por tool, human-in-the-loop pra ações sensíveis e validação de saída. Trust score reduz a superfície de ataque em uma ordem de magnitude. Não fecha a porta.

Quer aplicar isso em produto de verdade?

Trust layer não é blogpost de framework, é decisão de arquitetura que a maioria dos times só descobre depois do primeiro incidente em produção. No Clã Beer & Code a gente está montando agentes que rodam com trust scoring desde o dia um — porque o cliente não quer saber se a fonte era relevante, quer saber se a resposta está certa.

Se você está construindo agente sério com retrieval da web aberta, vem pro Clã. Tem dev encarando esses problemas todo dia, código real circulando, e a galera que entende a diferença entre "demo bonita" e "produto que não te coloca no jornal".

FAQ rápido

Trust score substitui o reranker?

Não. Reranker responde "esse documento é relevante pra essa query?". Trust responde "essa fonte merece confiança?". São funções ortogonais. O ganho real vem de combinar as duas no score final.

Posso começar só com heurísticas, sem LLM-as-judge?

Pode e deve. As heurísticas do post — domain age, densidade de afiliado, coerência intra — pegam 70% dos casos por centavos. LLM-as-judge entra na cauda, em fontes que ficaram no meio do score, ou em domínios novos que precisam de avaliação caso a caso.

Como meço se o trust layer está funcionando?

Eval end-to-end com adversariais. Monta um set de 100+ queries com fontes plantadas (afiliado óbvio, blog recém-criado, review LLM-gerado, página com prompt injection conhecida) e mede quantas o agente cita versus filtra. Sem esse set, threshold é chute.

Trust score e Citations API se conflitam?

Combinam. Anthropic reduziu hallucination de fonte de 10% para 0% com Citations. Trust layer reduz outro vetor — fonte real porém não confiável. Você ganha as duas coisas: o LLM cita o que usou e você sabe que o que ele usou passou no filtro.

Conclusão

Reranker resolveu o problema de relevância. Trust layer resolve o problema de confiança. Os dois rodam juntos, baratos, e você não precisa de modelo proprietário pra começar — heurística boa cobre a maior parte do trabalho.

O próximo passo dessa stack é tornar trust score um cidadão de primeira classe no protocolo do agente: não um campo escondido nos logs, mas um sinal que o LLM enxerga, hedga em cima e devolve pro usuário como parte da resposta. É isso que separa agente de demo de agente que aguenta produção.

Agora que você tem a base, vai aprofundar como montar reranker de verdade no pipeline RAG e como usar evals pra calibrar threshold sem chutar.