> Source: https://clickhouse.github.io/loom/pt-BR/benchmarks/coverage/ (Markdown: https://clickhouse.github.io/loom/pt-BR/benchmarks/coverage.md)

<!-- i18n: source=docs/benchmarks/coverage.md blob=9fcb841d4e8d303e5db5edafbe9a2beeb448ef11 model=claude-sonnet-5-5 -->
> Esta página é uma tradução automática da [página em inglês](https://clickhouse.github.io/loom/benchmarks/coverage/), que prevalece.
> Machine-translated from the [English page](https://clickhouse.github.io/loom/benchmarks/coverage/), which is authoritative.

<a id="benchmark-coverage"></a>

# Cobertura de benchmarks

Esta matriz mostra quais partes dos fluxos de memória, conhecimento e código do Loom têm uma medição pública reproduzível. Ela distingue o comportamento medido de um harness executável e de uma capacidade do produto que ainda não tem evidência pública de qualidade.

<a id="status"></a>

## Situação

| Situação                  | Significado                                                                                                                      |
| ------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |
| **Publicado**             | Existem um artefato de resultado commitado, um registro do modelo, o protocolo, as limitações e o comando de reprodução.        |
| **Parcial**               | Um resultado público mede parte da pergunta da avaliação, mas não o fluxo completo nem uma escala representativa.                |
| **Somente harness**       | Existe um protocolo executável, mas nenhuma medição commitada com um provedor real sustenta uma afirmação pública de desempenho. |
| **Sem medição pública**   | O repositório não tem um protocolo e um artefato públicos completos para esta pergunta. Pode haver documentação do produto.     |

Um teste unitário, uma execução simulada (dry run) ou um gate com provedor falso nunca conta como um resultado de qualidade publicado.
O [registro de resultados](https://github.com/ClickHouse/loom/blob/main/docs/benchmarks/results.md) é a fonte dos números publicados; o
[inventário de harnesses](https://github.com/ClickHouse/loom/blob/main/bench/README.md) é a fonte dos protocolos executáveis.

<a id="full-flow-matrix"></a>

## Matriz de fluxo completo

| Superfície                | Pergunta de avaliação                                                                                                                                                       | Medidas necessárias                                                                                                                                                                                                                                      | Status                    | Evidência pública ou próximo resultado necessário                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| ------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Construção de memória     | A extração grava fatos com suporte e evita afirmações sem suporte?                                                                                                          | cobertura de evidências, precisão da extração, taxa de memória falsa, tokens e tempo de construção                                                                                                                                                       | **Somente harness**       | Execute `memory_integrity.py` e `extraction_eval.py` em um conjunto público de conversas; faça commit de cada fato extraído e de cada veredito do juiz.                                                                                                                                                                                                                                                                                                                                                                                                                  |
| Recuperação de memória    | A memória correta fica perto do topo do ranking?                                                                                                                            | recall@k, rank@1, MRR e intrusão de distratores                                                                                                                                                                                                          | **Publicado**             | Artefatos de LongMemEval-S, LoCoMo, MuSiQue e MemoryAgentBench no [registro de resultados](https://github.com/ClickHouse/loom/blob/main/docs/benchmarks/results.md).                                                                                                                                                                                                                                                                                                                                                                                                      |
| Respostas de memória      | A resposta final usa corretamente a evidência recuperada?                                                                                                                   | acurácia da resposta, correção das citações e falhas por categoria                                                                                                                                                                                       | **Publicado**             | LongMemEval-S, LoCoMo, MemBench, MemoryAgentBench e PerLTQA.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| Perguntas desconhecidas   | O Loom se abstém em vez de responder com base em evidência fraca?                                                                                                           | precisão/recall de abstenção, taxa de resposta falsa e recall de perguntas respondíveis                                                                                                                                                                  | **Parcial**               | As perguntas adversariais do LoCoMo e dez sondagens de abstenção de código estão publicadas; ainda é necessário um conjunto maior e calibrado de abstenção de memória.                                                                                                                                                                                                                                                                                                                                                                                                   |
| Correções e tempo         | O valor atual substitui fatos obsoletos enquanto as consultas históricas continuam corretas?                                                                                | acurácia do valor atual, taxa de respostas obsoletas, acurácia temporal e precisão de substituição                                                                                                                                                       | **Somente harness**       | Publique `pi_llm.py`, `forget_switch_eval.py`, `fama_forgetting.py` e `supersession_audit.py` em um único corpus público compartilhado.                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| Continuidade entre ferramentas | Um fato gravado por um cliente ajuda outro cliente em uma sessão posterior?                                                                                            | recall entre clientes, proveniência, perda de captura e latência                                                                                                                                                                                         | **Somente harness**       | `cross_tool_validate.py` tem seis consultas; publique uma matriz maior com Claude Code, Codex e Cursor, com as capturas brutas.                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| Eficiência de memória     | A recuperação economiza contexto, gasto com modelo e turnos?                                                                                                                | sucesso na tarefa, tokens de prompt/saída, custo do modelo e ponto de equilíbrio da construção                                                                                                                                                          | **Publicado**             | O resultado pareado de histórico completo do LongMemEval relata 91% menos tokens do leitor e o ponto de equilíbrio da construção.                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| Recuperação de conhecimento | O RAG de documentos encontra e cita a passagem correta?                                                                                                                   | recall@k de chunks, acurácia da resposta, precisão das citações, abstenção, latência e tokens                                                                                                                                                            | **Parcial**               | O braço 2 de [Decisões de design](https://github.com/ClickHouse/loom/blob/main/docs/benchmarks/results.md#design-decisions-from-design-documents) mede a acurácia da resposta sobre os resultados de conhecimento de `loom_search` (precisão e recall de A e D em relação ao gabarito), precisão e recall das citações, abstenção e tokens injetados, em um conjunto privado de cinco documentos com um único juiz; ainda são necessários recall@k de chunks, latência e um conjunto público (`narrativeqa.py` com um leitor fixo, casos difíceis sem resposta e casos de citação). |
| Formatos de origem        | Quais entradas chegam a um texto pesquisável equivalente?                                                                                                                   | sucesso da extração, fidelidade de texto/tabelas, qualidade de OCR e taxa de falha por formato                                                                                                                                                           | **Parcial**               | [Análise de documentos](https://github.com/ClickHouse/loom/blob/main/docs/benchmarks/results.md#document-parsing) mede a fidelidade de texto, tabelas e localizadores, a qualidade de OCR e a perda silenciosa para PDF, DOCX e PPTX em um corpus commitado, contra uma linha de base com modelo de layout; ainda são necessários CSV, XLSX, Parquet, HTML e os demais formatos de texto, além de um corpus real com licença.                                                                                                                                              |
| Busca conceitual de código | Um texto no formato de issue encontra a implementação?                                                                                                                     | file hit@k, all-gold hit@k, MRR, abstenção, tokens e latência                                                                                                                                                                                            | **Publicado**             | Perguntas conceituais do ClickHouse e uma amostra de 200 instâncias do SWE-bench Verified para localização de arquivos; isto é recuperação, não a pontuação oficial de patch e teste.                                                                                                                                                                                                                                                                                                                                                                                    |
| Estrutura de código       | As definições e os chamadores estão completos?                                                                                                                              | exact@1 de definição, precisão/recall/F1 de chamadores e rótulo de completude                                                                                                                                                                            | **Publicado**             | Dez perguntas de definição e quatro de chamadores no ClickHouse. O conjunto de chamadores é pequeno demais para comparações próximas.                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| Portabilidade entre linguagens de código | A qualidade se mantém entre linguagens e formatos de repositório?                                                                                                | as mesmas métricas de recuperação e estrutura por linguagem e repositório                                                                                                                                                                                | **Somente harness**       | A [tabela de linguagens](https://github.com/ClickHouse/loom/blob/main/docs/features/code-index/overview.md#language-support) documenta as camadas do parser; `make bench-code-portability-dry` verifica apenas a pontuação. Execute as fixtures públicas em índices reais.                                                                                                                                                                                                                                                                                                |
| Resultado do agente de código | O agente conclui a tarefa, e não apenas encontra um arquivo?                                                                                                            | taxa de resolução, testes aprovados, qualidade do patch, turnos, tokens, custo e tempo                                                                                                                                                                   | **Parcial**               | Execuções pareadas no ClickHouse avaliam a resposta do agente em relação a uma referência verificada (explicação, impacto, histórico) e relatam custo, turnos e tempo; elas não editam nem testam. Ainda é necessário um benchmark de patch e teste com controle de vazamento.                                                                                                                                                                                                                                                                                            |
| Decisões de design        | As decisões servidas a partir de documentos de design impedem que um agente proponha de novo opções rejeitadas, e suas respostas de "por quê" e sobre funcionalidades estão corretas, citadas e atuais? | evitar opções rejeitadas, satisfação de restrições, precisão/recall de argumentos e fatos de funcionalidades, precisão/recall de citações, afirmações obsoletas e abstenções falhas, tokens injetados, precisão da extração                                 | **Parcial**               | [Decisões de design](https://github.com/ClickHouse/loom/blob/main/docs/benchmarks/results.md#design-decisions-from-design-documents) em um conjunto privado de cinco documentos, com um único modelo juiz; ainda são necessárias a acurácia do juiz em relação a rótulos humanos e a precisão da extração.                                                                                                                                                                                                                                                               |
| Construção do índice      | Quanto custa um índice a frio?                                                                                                                                              | tempo de relógio, tokens de embedding/modelo, armazenamento do ClickHouse e recursos de pico dos workers por tamanho de repositório                                                                                                                      | **Parcial**               | A execução do SWE-bench relata 137.5 milhões de tokens de embedding e cerca de 10.6 horas para 11 backfills mais 188 deltas, mas sem curva de tamanho nem registro de hardware.                                                                                                                                                                                                                                                                                                                                                                                          |
| Atualidade do índice      | Com que rapidez um commit se torna pesquisável e quando as respostas ficam obsoletas?                                                                                       | latência do commit até a consulta, custo do delta, taxa de respostas obsoletas e recuperação após interrupção                                                                                                                                            | **Somente harness**       | Existem harnesses de latência por estágio e de obsolescência; publique execuções a frio, incrementais e de reparo com o tamanho do repositório e o hardware.                                                                                                                                                                                                                                                                                                                                                                                                             |
| Capacidade de busca       | O que acontece conforme crescem as linhas, os repositórios, os tenants e a concorrência?                                                                    | p50/p95/p99, throughput, volume de leitura do ClickHouse, CPU e memória sob uma carga de trabalho mista                                                                                                   | **Parcial**               | A latência em servidor único está publicada, e [memória em escala](https://github.com/ClickHouse/loom/blob/main/docs/benchmarks/results.md#memory-at-scale) registra o hardware, um formato multi-tenant (Zipf sobre 10,000 namespaces) e onde estão os limites da memória, em um único host compartilhado. Não há execução em nuvem, curva de capacidade entre tamanhos nem carga representativa de agentes mistos.                                                                                                                                      |
| Correção do cache         | Perguntas repetidas evitam a síntese sem reutilizar a resposta errada?                                                                                      | taxa de acerto, latência/tokens economizados e taxa de falso compartilhamento no limiar selecionado                                                                                                       | **Publicado**             | A varredura de limiares e o agregado de produção de 30 dias são públicos. As repetições foram 3% das chamadas observadas.                                                                                                                                                                                                                                                                                                                         |
| Qualidade do tracker      | A detecção de duplicatas encontra a issue mais antiga com uma taxa aceitável de falsos positivos?                                                           | taxa de acerto positivo, precisão do veredito, taxa de falsos positivos nos exemplos negativos (não duplicados) e latência                                                                                | **Publicado**             | 104 duplicatas públicas do ClickHouse e 100 negativos. Outros formatos de tracker ainda não estão representados.                                                                                                                                                                                                                                                                                                                                  |
| Segurança e privacidade   | O uso comum ou adversarial pode vazar, envenenar ou reter dados apagados?                                                                                   | taxa de extração, sucesso de envenenamento, falsos positivos benignos, vazamento e resíduo                                                                                                                | **Apenas harness**        | Existem harnesses de red team, sensibilidade, envenenamento e apagamento; nenhum resultado commitado com provedor real sustenta uma taxa pública de segurança.                                                                                                                                                                                                                                                                                    |
| Confiabilidade            | Uma escrita, indexação ou exclusão interrompida é retomada sem perda?                                                                                       | sucesso de recuperação, trabalho duplicado, tempo indisponível e resíduo após injeção de falhas                                                                                                           | **Sem medição pública**   | Testes unitários e de integração cobrem os mecanismos, mas não há resultado público de injeção de falhas em nível de carga de trabalho.                                                                                                                                                                                                                                                                                                           |
| Custo total de operação   | Quanto o Loom custa depois dos gastos com modelo, ClickHouse e construção do índice?                                                                        | gasto com modelo na construção e nas consultas, computação/armazenamento do ClickHouse, recursos dos workers e ponto de equilíbrio                                                                        | **Parcial**               | Os tokens de modelo e alguns custos pareados estão publicados, e [memória em escala](https://github.com/ClickHouse/loom/blob/main/docs/benchmarks/results.md#memory-at-scale) precifica o armazenamento do ClickHouse por milhão de memórias e a CPU por milhão de chamadas, a preços de tabela; Postgres, merges e capacidade ociosa não estão em uma curva de custo total.                                                                                                                                                 |

<a id="what-belongs-in-the-readme"></a>

## O que pertence ao README

O README traz vários benchmarks públicos, agrupados pelo resultado de avaliação que medem.
Uma linha só pertence a ele depois que esta matriz indicar **Publicado**, a amostra for grande o suficiente
para ser interpretada e o resultado tiver uma frase clara sobre onde ele não se generaliza.

Não mova linhas **Apenas harness** ou **Sem medição pública** para as afirmações de desempenho
do README. Em vez disso, faça um link para esta matriz. Um harness prova que o Loom pode ser
medido; ele não prova que o Loom tem bom desempenho.

<a id="publication-backlog"></a>

## Backlog de publicação

Cada item abaixo responde a perguntas de avaliação da matriz acima:

- **Integridade de escrita e correções:** precisão de extração, taxa de falsas memórias,
  substituição e taxa de respostas desatualizadas em um corpus conversacional público.
- **RAG de conhecimento:** qualidade de recuperação, resposta e citação em documentos de texto, seguida
  por um corpus licenciado de fidelidade de formato para PDF, CSV e texto estruturado.
- **Resultado de ponta a ponta do agente de código:** geração de patches com controle de vazamento e sucesso nos testes,
  pareada com o mesmo agente sem o Loom.
- **Portabilidade de código em produção:** medições com provedores reais nos fixtures
  poliglotas, SQL/shell e OSS já existentes.
- **Economia e atualidade do índice:** curvas a frio e incrementais por tamanho de repositório,
  com hardware, armazenamento do ClickHouse e recursos dos workers registrados.
- **Capacidade e confiabilidade:** uma carga de trabalho mista de memória/código entre tenants, seguida
  por injeção de falhas em workers, no ClickHouse e na rede.
- **Segurança e privacidade:** publique os resultados de ataques nomeados separadamente; nunca os agrupe
  em uma pontuação geral de segurança.

Cada novo resultado segue [Adicionando um resultado](https://github.com/ClickHouse/loom/blob/main/docs/benchmarks/results.md#adding-a-result): faça o commit do artefato
bruto, registre cada modelo e o build do servidor, informe a licença do dataset, inclua o
comando exato, relate falhas e resultados negativos, e adicione a incerteza ou o tamanho
da variação de uma única pergunta.

<a id="related"></a>

## Relacionados

- [Avaliar o Loom](https://github.com/ClickHouse/loom/blob/main/docs/getting-started/evaluate.md): escolha um teste de produto ou de carga de trabalho.
- [Metodologia](https://github.com/ClickHouse/loom/blob/main/docs/benchmarks/methodology.md): quando dois números são comparáveis e onde há viés.
- [Execução](https://github.com/ClickHouse/loom/blob/main/docs/benchmarks/running.md): provedores, conjuntos de dados e comandos.
- [Resultados](https://github.com/ClickHouse/loom/blob/main/docs/benchmarks/results.md): medições reproduzíveis a partir de arquivos commitados.
