#6 Chain-of-Verification (CoVe)

Chain-of-Verification (Dhuliawala et al., 2023) é a técnica canônica para reduzir hallucination em outputs LLM. O fluxo: produzir resposta → gerar perguntas de verificação sobre as claims → responder cada pergunta independentemente (sem ver a resposta original) → reconciliar discrepâncias. O ChatCLI implementa via VerifierAgent (pure reasoning, zero tools) + VerifyHook (PostHook do pipeline). Quando discrepância é detectada, o flag verified_with_discrepancy é gravado em result.Metadata, ativando o Reflexion downstream.

CoVe é opt-in. Com CHATCLI_QUALITY_VERIFY_ENABLED=false (default), zero overhead. Quando ligado, adiciona +1 chamada LLM por ponto de uso com effort alto (default effort="high").

Protocolo do VerifierAgent

O modelo recebe TASK + DRAFT e emite cinco blocos:

<status>verified-clean OR verified-with-corrections</status>

<questions>
- Q1: claim específica 1 verificável
- Q2: claim específica 2 verificável
- Q3: claim específica 3 verificável
</questions>

<answers>
- A1: resposta independente a Q1 (sem olhar DRAFT)
- A2: resposta independente a Q2
- A3: resposta independente a Q3
</answers>

<discrepancies>
- descrição da discrepância, OU "none"
</discrepancies>

<final>
…resposta pronta para entregar ao usuário (repete DRAFT se verified-clean,
ou reescreve se verified-with-corrections)…
</final>

Regra crítica: respostas INDEPENDENTES

O protocolo instrui o modelo a responder cada Q<n> sem referenciar o DRAFT. Isso é o coração de CoVe — se as respostas independentes contradizem o draft, há claim suspeito.

Modelos que simplesmente regurgitam o draft nas respostas defeat o padrão. O system prompt enfatiza isso explicitamente; use modelos capazes de “self-distance” (Claude Sonnet, GPT-4+).

Fluxo do VerifyHook

Worker termina

Qualquer agente produz result.Output.

PostRun do VerifyHook

if result.Error != nil { return }
if !cfg.Verify.Enabled { return }
if !AppliesToAgent(agent, cfg.ExcludeAgents) { return }
if result.Output == "" { return }

Dispatch VerifierAgent

body := VerifyDirective + fmt.Sprintf(" [NUM_QUESTIONS=%d]\n", numQ) +
        "Task:\n" + task + "\n\n" +
        "Draft:\n" + result.Output
res := dispatch(ctx, AgentCall{Agent: verifier, Task: body})

ParseVerifierOutput

Extrai os 5 blocos. Tolerante a ordem, bullets com - ou *.

HasDiscrepancy check

Status=="verified-with-corrections" OU Discrepancies!="none".

Se discrepância + RewriteOnDiscrepancy

result.SetMetadata("verified_with_discrepancy", "true")
result.SetMetadata("verifier_discrepancies", parsed.Discrepancies)
if cfg.RewriteOnDiscrepancy {
    result.Output = parsed.Final
}

Reflexion consome o flag

Na mesma execução do pipeline, ReflexionHook.PostRun vê o metadata e, se OnHallucination=true, dispara lesson generation.

Exclude list (anti-recursão + agents não-textuais)

ExcludeAgents: []string{"formatter", "deps", "shell", "refiner", "verifier"}

Agente	Razão
formatter	Output é código formatado, não claims
deps	Output é lista determinística de pacotes
shell	Output é stdout/stderr, não claims verificáveis
refiner	Output já passou por crítica; verify seria redundante
verifier	Anti-recursão — verificar o verifier criaria loop

`/verify` — session toggle

/verify on

/verify off

/verify auto

/verify
# → verify: OFF (session override active)

Variáveis de ambiente

Env var	Default	O que faz
`CHATCLI_QUALITY_VERIFY_ENABLED`	`false`	Master switch
`CHATCLI_QUALITY_VERIFY_NUM_QUESTIONS`	`3`	Quantas perguntas de verificação
`CHATCLI_QUALITY_VERIFY_REWRITE`	`true`	Reescrever output em discrepância
`CHATCLI_QUALITY_VERIFY_EXCLUDE`	`formatter,deps,shell,refiner,verifier`	CSV de exclusões

Override do verifier

# Use modelo mais forte só para verify
export CHATCLI_AGENT_VERIFIER_MODEL="claude-opus-4-8"
export CHATCLI_AGENT_VERIFIER_EFFORT="max"

# Ou mais questions para workflows críticos
export CHATCLI_QUALITY_VERIFY_NUM_QUESTIONS=5

Exemplo: catching hallucination sobre API

Draft (com erro sutil)
Questions
Answers
Discrepancies
Final (reescrito)

O http.Client do Go tem um campo DefaultTimeout que você pode setar globalmente. Basta fazer http.DefaultClient.DefaultTimeout = 30 * time.Second no init do programa.

Erro: DefaultTimeout não existe. É Timeout (e não há “DefaultTimeout” na stdlib).

- Q1: Does the `net/http.Client` struct in Go have a field called `DefaultTimeout`?
- Q2: What is the correct field name for setting a timeout on `http.Client`?
- Q3: Is `http.DefaultClient` mutable and reassignable?

- A1: No, `net/http.Client` has a `Timeout` field (type `time.Duration`), not `DefaultTimeout`.
- A2: The correct field is `Timeout`, used as `client.Timeout = 30 * time.Second`.
- A3: `http.DefaultClient` is a pointer to a pre-allocated Client; modifying its fields is legal but has process-wide side effects.

- Draft refers to `DefaultTimeout` field, which does not exist. Correct field is `Timeout`.

Status: verified-with-corrections

O http.Client do Go tem um campo Timeout (não DefaultTimeout). Para aplicar globalmente, você pode fazer:
http.DefaultClient.Timeout = 30 * time.Second
Mas atenção: DefaultClient é compartilhado pelo processo inteiro — modificações globais afetam todo código que usa http.Get, http.Post, etc. Para isolamento, instancie seu próprio &http.Client{Timeout: ...}.

Flag gravado em result.Metadata["verified_with_discrepancy"]=true. Se Reflexion está on (default), uma lesson é gerada em background:

LESSON: Citing Go stdlib API fields
MISTAKE: Invented "DefaultTimeout" field on http.Client
CORRECTION: Verify symbol exists via go doc or grep before citing
TRIGGER: hallucination

Integração com Refine

Quando Refine + Verify estão ambos ligados, a ordem importa:

// cli/agent/quality/builder.go
if cfg.Refine.Enabled && deps.Dispatch != nil {
    p.AddPost(NewRefineHook(...))      // primeiro
}
if cfg.Verify.Enabled && deps.Dispatch != nil {
    p.AddPost(NewVerifyHook(...))      // depois do refine
}

Refine melhora a qualidade estilística primeiro; Verify checa factual accuracy sobre o output já refinado. Ordem oposta (verify → refine) funcionaria, mas a reescrita do refine poderia introduzir claims não verificados.

Se você só liga um dos dois, prefira Verify para workflows factual (docs técnicas, código com API calls) e Refine para workflows estilísticos (summaries, relatórios).

Invocação direta

<agent_call agent="verifier" task="[VERIFY_ANSWER] Task: X Draft: Y" />

Ou com tool call direta ao verifier na orquestração de passos críticos:

# Chain: search → coder → verifier before user sees

Custo e latência

Config	Calls extras	Latência
`NumQuestions=3` (default)	+1 verifier call	3-8s com Sonnet
`NumQuestions=5`	+1 (mesmo call, mais questions)	5-12s
`NumQuestions=7+`	+1 + modelo pode quebrar contrato	Evitar

CoVe com modelos fracos gera perguntas superficiais ou “verificações” que só parafraseiam o draft. Use Sonnet, Opus, ou GPT-4+ como CHATCLI_AGENT_VERIFIER_MODEL.

#3 Reflexion

Consome o signal verified_with_discrepancy para gerar lessons sobre hallucination.

#5 Self-Refine

Complemento estilístico: Refine poliaça, CoVe verifica factualmente.

Paper original (Dhuliawala et al.)

Chain-of-Verification Reduces Hallucination in Large Language Models

Configuração

Env vars e slashes num lugar só.

Início

Primeiros Passos

Conceitos Fundamentais

Funcionalidades

Segurança

Suporte

#6 Chain-of-Verification (CoVe)

Protocolo do VerifierAgent

Regra crítica: respostas INDEPENDENTES

Fluxo do VerifyHook

Exclude list (anti-recursão + agents não-textuais)

`/verify` — session toggle

Variáveis de ambiente

Override do verifier

Exemplo: catching hallucination sobre API

Integração com Refine

Invocação direta

Custo e latência

Leia também

#3 Reflexion

#5 Self-Refine

Paper original (Dhuliawala et al.)

Configuração

​Protocolo do VerifierAgent

​Regra crítica: respostas INDEPENDENTES

​Fluxo do VerifyHook

​Exclude list (anti-recursão + agents não-textuais)

​/verify — session toggle

​Variáveis de ambiente

​Override do verifier

​Exemplo: catching hallucination sobre API

​Integração com Refine

​Invocação direta

​Custo e latência

​Leia também

#3 Reflexion

#5 Self-Refine

Paper original (Dhuliawala et al.)

Configuração

Protocolo do VerifierAgent

Regra crítica: respostas INDEPENDENTES

Fluxo do VerifyHook

Exclude list (anti-recursão + agents não-textuais)

`/verify` — session toggle

Variáveis de ambiente

Override do verifier

Exemplo: catching hallucination sobre API

Integração com Refine

Invocação direta

Custo e latência

Leia também