# Jeu de données : « L'IA peut-elle préparer une note fiscale ? Ce que nous avons mesuré »

Ce jeu de données contient uniquement des chiffres. Les cas sont anonymisés (numérotés de 1 à 6, dans un ordre sans lien avec l'ordre interne), et il ne contient ni énoncé de cas, ni consigne, ni texte de notation. Vous pouvez recalculer avec le script fourni les chiffres de l'article, ainsi que les jetons et les coûts présentés dans « Près du niveau de Claude Sonnet 5 avec le même corpus, pour une fraction du coût : ce que nous avons mesuré » :

```
python recompute.py
```

Le script n'utilise que la bibliothèque standard de Python 3 et lit `scores.csv`, `scores_same_grader.csv`, `tokens_costs.csv`, `openrouter_activity_2026-10-01.json` et `openrouter_activity_2026-10-11.json` dans son propre dossier, quel que soit le dossier courant. Il affiche des lignes `identifiant,valeur`. Les clés `a3.*` sont les chiffres du tableau de l'article, toutes les notes étant notées par la même version du correcteur ; les clés de score `a1.*` viennent de notre premier correcteur, sans outils (voir les limites). Il affiche aussi quelques clés d'appoint que l'article ne cite pas : `a1.majors_rechecked.*` (défauts majeurs après la revérification automatique).

## Fichiers

- `scores.csv` : une ligne par note notée. Colonnes : `arm` (configuration), `cas` (1 à 6), `run` (essai), `score` (0 à 10), `verdict`, `conclusion`, `majors` (nombre de défauts majeurs), puis un compteur par classe de défaut : `wrong_rule`, `wrong_citation`, `wrong_entry`, `invented_fact`, `missing_element`, `internal_noise`, `digression`, puis `research_major` (1 si la note a au moins un défaut majeur de recherche : `wrong_rule`, `wrong_citation`, `missing_element` ou `invented_fact`, sinon 0).
- `scores_same_grader.csv` : mêmes colonnes que `scores.csv`, pour les notes du tableau de l'article, toutes notées par la même version du correcteur, qui vérifie dans le corpus les citations des notes sans paragraphes joints : les quatre passages de notre chaîne (`prod_run_1001`, `prod_run_1007`, `prod_run_1010`, `prod_run_1011`) et les quatre configurations de Claude Sonnet 5 (`sonnet_mcp`, `sonnet_web`, `sonnet_web_verified`, `sonnet_closedbook`).
- `tokens_costs.csv` : `arm`, `calls` (appels API), `prompt_tokens`, `completion_tokens`, `reasoning_tokens` (jetons de raisonnement, pour information : ils sont déjà compris dans `completion_tokens` ; renseignés pour la production), puis la ventilation `input_tokens`, `cache_creation_tokens`, `cache_read_tokens`, `output_tokens` (renseignée pour `sonnet_mcp` ; vide quand la source ne la donne pas), `cache_hit_rate` (taux mesuré sur la journée, non arrondi), `price_input_per_m`, `price_output_per_m`, `price_cache_read_per_m`, `price_cache_write_per_m` (USD par million de jetons), `cost_usd`, `cost_source`.
- `prices_snapshot.json` : capture des prix OpenRouter du 2 octobre 2026, et celle du point d'accès Novita du 16 octobre 2026 (`deepseek_novita_endpoint_2026-10-16`), dont les prix sont ceux facturés le 11 octobre, comme le montre le rapprochement de la facture de ce jour-là.
- `openrouter_activity_2026-10-01.json` : la ligne de l'API d'activité d'OpenRouter pour la journée du 1er octobre 2026, modèle DeepSeek v4.1-flash chez Novita : requêtes, jetons d'entrée, produits, de raisonnement et lus en cache, montant facturé. Uniquement des chiffres, avec la date de la capture.
- `openrouter_activity_2026-10-11.json` : la même ligne d'activité pour la journée du 11 octobre 2026.
- `recompute.py` : le script de recalcul. Il refait, à partir des CSV et de l'instantané d'activité : les scores moyens et les défauts majeurs de chaque configuration, les notes portant un défaut majeur de recherche (`a1.research_major_notes.*`), la moyenne revérifiée et le nombre de notes portant un défaut majeur de recherche après revérification (`a1.research_major_notes_rechecked.sonnet_web_verified`), le nombre de cas, le nombre d'appels de la production, ses jetons de raisonnement, ses jetons par note (entrée + sortie), son coût avec et sans cache et son coût par note, le taux de cache de la journée, le rapprochement de la facture de la journée, les jetons de Claude + MCP, ses jetons par note (`a1.sonnet_mcp.tokens_per_note`) et son coût (recalculé jetons × prix, dans les deux variantes de tarif d'écriture en cache), le rapport entre ce coût et celui de la production, les coûts des deux configurations Claude en un seul appel, et les clés `a3.*` : scores, défauts majeurs et notes portant un défaut majeur de recherche du tableau de l'article (`a3.prod.*` pour nos quatre passages ; `a3.mean.*`, `a3.majors.*`, `a3.research_major_notes.*` pour Claude), le coût du passage du 11 octobre (`a3.run_1011.*`), le rapprochement de la facture de cette journée (`a3.day_1011.*`), la fourchette de coût de notre chaîne (`a3.prod.cost_min`, `a3.prod.cost_max`) et celle du rapport avec Claude + MCP (`a3.cost_ratio_min`, `a3.cost_ratio_max`). Les coûts des deux configurations Claude en un seul appel sont ceux qu'Anthropic a renvoyés pour l'exécution (`total_cost_usd`) : le script les relit, il ne peut pas les refaire.

## Les configurations

- `prod_stage10`, `prod_stage9e` : la chaîne de rédaction de Luca Paper en production (modèle DeepSeek, deux états successifs de la chaîne).
- `sonnet_mcp` : Claude Sonnet avec accès au corpus via MCP.
- `sonnet_web` : Claude Sonnet avec recherche web, sans corpus.
- `sonnet_web_verified` : Claude Sonnet avec recherche web et auto-vérification.
- `sonnet_web_verified_rechecked` : les mêmes notes que `sonnet_web_verified`, revérifiées automatiquement : des agents Claude ayant accès aux sources, pas une relecture humaine (voir les limites).
- `sonnet_closedbook` : Claude Sonnet sans outils.
- `prod_stage10_nocache` : ligne de coût de `prod_stage10` calculée sans cache.
- `prod_run_1001` à `prod_run_1011` (dans `scores_same_grader.csv`) : quatre passages de la même version de la chaîne, les 1er, 7, 10 et 11 octobre 2026 ; `prod_run_1001` est le passage `prod_stage10`, noté de nouveau. `prod_run_1011` dans `tokens_costs.csv` : coût du passage du 11 octobre.

## Limites

- n = 6 cas et un seul correcteur (Claude Opus). Un passage par configuration de Claude, quatre pour notre chaîne. Ces chiffres ne permettent aucune conclusion statistique fine.
- Les six cas sont nos cas de travail, ceux sur lesquels nous mesurons nos propres modifications de la chaîne de rédaction : la chaîne et ses consignes ont été mises au point au vu de leurs scores. La configuration `sonnet_mcp` suivait ces mêmes consignes et partage cet avantage ; les configurations Claude sans corpus, non.
- `scores.csv` vient de notre premier correcteur, qui travaillait SANS outils : pour les configurations Claude seules, il a donc jugé les citations de mémoire. Nous l'avons ensuite doté d'un outil qui vérifie une citation dans le corpus quand aucun texte n'est joint, et avons noté de nouveau toutes les notes du tableau : c'est `scores_same_grader.csv`, d'où viennent les chiffres de l'article. Une revérification automatique d'une seule configuration (web + auto-vérification), par des agents Claude ayant accès aux sources, a fait passer sa moyenne de 5,83 à 6,83 (`a1.mean_rechecked.sonnet_web_verified`). Elle a aussi relevé une omission réelle : les notes de cette configuration portant un défaut majeur de recherche passent de 0 à 1 sur 6. Cette revérification est une autre méthode : son 6,83 ne figure pas dans le tableau de l'article.
- La configuration sans outils ne permet pas d'exclure un usage d'internet.
- Le taux de cache de 86,39 % est mesuré par l'API d'activité d'OpenRouter sur toute la journée du 1er octobre 2026 (jetons lus en cache / jetons d'entrée). Il couvre tout notre trafic DeepSeek de ce jour-là, pas le banc d'essai seul : le banc d'essai a fait 322 des 542 requêtes de la journée. Le coût sans cache est donné en regard (`prod_stage10_nocache`).
- Rapprochement avec la facture : notre formule, appliquée aux jetons de toute la journée, donne 2,78 $ pour 2,77 $ facturés, soit un écart de 0,6 %. L'API d'activité compte les jetons de raisonnement à part des jetons produits, et les facture au prix de sortie ; dans nos journaux d'appels, ils font déjà partie des jetons produits, et ne sont donc pas ajoutés au coût du banc d'essai.
- Jetons de raisonnement de la production : 371 858 sur les six notes (`a1.prod.reasoning_tokens`). Ils sont déjà compris dans `completion_tokens` et ne sont donc pas ajoutés au coût.
- Les jetons de Claude + MCP ont été dédupliqués par `message.id` à partir des transcriptions de session : celles-ci écrivent une ligne par bloc de contenu, et chaque ligne répète l'usage de la réponse entière. Un premier décompte de 78,6 M comptait ainsi chaque réponse d'API environ deux fois ; le chiffre retenu est 38,8 M. Le coût (10,71 $) applique le tarif d'entrée aux jetons d'entrée et de création de cache ; au tarif d'écriture en cache de 2,50 $ par million, il serait de 11,49 $ (`a1.sonnet_mcp.cost_cachewrite`).
- Les jetons de sortie relevés dans les transcriptions de session paraissent incomplets ; le coût de cette configuration est donc une borne basse.
- Coût du passage du 11 octobre 2026 : 204 appels, au taux de cache de 85,31 % mesuré sur la journée (le banc d'essai a fait 204 des 479 requêtes) et aux prix facturés ce jour-là ; appliqués à toute la journée, ces prix retrouvent la facture (1,64 $). Ce jour-là, l'API d'activité compte déjà les jetons de raisonnement dans les jetons produits : ils ne sont pas ajoutés.
- Les prix du passage du 1er octobre sont une capture OpenRouter du 2 octobre 2026 ; ceux du passage du 11 octobre, ceux facturés ce jour-là. Ils ont pu changer depuis.

Les énoncés des cas et les consignes sont disponibles sur demande : hello@lucapaper.com

---

# Data pack: “Can AI draft a tax memo? What we measured”

This pack contains numbers only. Cases are anonymised (numbered 1 to 6, in an order unrelated to the internal one). It holds no case statements, no prompts and no grader text. Run `python recompute.py` (Python 3, standard library only) to reproduce the article’s figures, and the tokens and costs presented in “Close to Claude Sonnet 5 on the same corpus, at a fraction of the cost: what we measured”, from `scores.csv`, `scores_same_grader.csv`, `tokens_costs.csv`, `openrouter_activity_2026-10-01.json` and `openrouter_activity_2026-10-11.json`, read from the script’s own folder whatever the current directory; it prints `id,value` lines. The `a3.*` keys are the figures of the article’s table, every memo graded by the same version of the grader; the `a1.*` score keys come from our first grader, with no tools (see the limits). It also prints a few helper keys the article does not cite: `a1.majors_rechecked.*` (major defects after the automatic recheck).

## Files

- `scores.csv`: one row per graded memo. Columns: `arm`, `cas` (1–6), `run`, `score` (0–10), `verdict`, `conclusion`, `majors` (count of major defects), then one count per defect class (`wrong_rule`, `wrong_citation`, `wrong_entry`, `invented_fact`, `missing_element`, `internal_noise`, `digression`), then `research_major` (1 if the memo has at least one major research defect: `wrong_rule`, `wrong_citation`, `missing_element` or `invented_fact`, else 0).
- `scores_same_grader.csv`: same columns as `scores.csv`, for the memos of the article’s table, all graded by the same version of the grader, which checks in the corpus the citations of memos with no attached paragraphs: our pipeline’s four runs (`prod_run_1001`, `prod_run_1007`, `prod_run_1010`, `prod_run_1011`) and the four Claude Sonnet 5 configurations (`sonnet_mcp`, `sonnet_web`, `sonnet_web_verified`, `sonnet_closedbook`).
- `tokens_costs.csv`: `arm`, `calls`, `prompt_tokens`, `completion_tokens`, `reasoning_tokens` (informational: already included in `completion_tokens`; filled for production), then the split `input_tokens`, `cache_creation_tokens`, `cache_read_tokens`, `output_tokens` (filled for `sonnet_mcp`; empty where the source has no split), `cache_hit_rate` (day-level measured rate, unrounded), `price_input_per_m`, `price_output_per_m`, `price_cache_read_per_m`, `price_cache_write_per_m` (USD per million tokens), `cost_usd`, `cost_source`.
- `prices_snapshot.json`: OpenRouter price snapshot of 2 October 2026, plus the Novita endpoint captured on 16 October 2026 (`deepseek_novita_endpoint_2026-10-16`), whose prices are those billed on 11 October, as the reconciliation of that day’s bill shows.
- `openrouter_activity_2026-10-01.json`: the OpenRouter activity API row for the day of 1 October 2026, model DeepSeek v4.1-flash at Novita: requests, prompt, completion, reasoning and cached tokens, amount billed. Numbers only, with the capture date.
- `openrouter_activity_2026-10-11.json`: the same activity row for the day of 11 October 2026.
- `recompute.py`: the recompute script. From the CSVs and the activity snapshot it redoes: each configuration’s mean score, major defects and memos with a major research defect (`a1.research_major_notes.*`), the rechecked mean and the number of memos with a major research defect after the recheck (`a1.research_major_notes_rechecked.sonnet_web_verified`), the number of cases, production’s call count, reasoning tokens, tokens per memo (prompt + completion), cost with and without caching and cost per memo, the day’s cache-hit rate, the reconciliation with the day’s bill, the Claude + MCP tokens, tokens per memo (`a1.sonnet_mcp.tokens_per_note`) and cost (recomputed as tokens × prices, under both cache-write pricing variants), the ratio of that cost to production’s, the costs of the two single-call Claude configurations, and the `a3.*` keys: scores, major defects and memos with a major research defect of the article’s table (`a3.prod.*` for our four runs; `a3.mean.*`, `a3.majors.*`, `a3.research_major_notes.*` for Claude), the cost of the 11 October run (`a3.run_1011.*`), the reconciliation of that day’s bill (`a3.day_1011.*`), the range of our pipeline’s cost (`a3.prod.cost_min`, `a3.prod.cost_max`) and of its ratio to Claude + MCP (`a3.cost_ratio_min`, `a3.cost_ratio_max`). The costs of the two single-call Claude configurations are the costs Anthropic returned for the run (`total_cost_usd`): the script reads them back; it cannot redo them.

## Configurations

`prod_stage10` and `prod_stage9e` are Luca Paper’s production pipeline (DeepSeek model, two successive pipeline states); `sonnet_mcp` is Claude Sonnet with corpus access over MCP; `sonnet_web` is Claude Sonnet with web search and no corpus; `sonnet_web_verified` adds self-verification; `sonnet_web_verified_rechecked` is the same memos rechecked automatically (Claude agents with access to the sources, not a human review); `sonnet_closedbook` is Claude Sonnet with no tools; `prod_stage10_nocache` is the `prod_stage10` cost computed without any caching; `prod_run_1001` to `prod_run_1011` (in `scores_same_grader.csv`) are four runs of the same pipeline version, on 1, 7, 10 and 11 October 2026 (`prod_run_1001` is the `prod_stage10` run, regraded); `prod_run_1011` in `tokens_costs.csv` is the cost of the 11 October run.

## Limits

- n = 6 cases and a single grader (Claude Opus). One run per Claude configuration, four for our pipeline. Nothing here supports fine statistical conclusions.
- The six cases are our working cases, the ones on which we measure our own pipeline changes: the pipeline and its instructions were tuned with their scores in view. The `sonnet_mcp` configuration followed those same instructions and shares that advantage; the Claude configurations without the corpus do not.
- `scores.csv` comes from our first grader, which ran with NO tools, so for the Claude-only configurations it judged citations from memory. We then gave it a tool that checks a citation in the corpus when no text is attached, and graded every memo of the table again: that is `scores_same_grader.csv`, where the article’s figures come from. An automated recheck of one configuration only (web + self-verify), by Claude agents with access to the sources, raised its mean from 5.83 to 6.83 (`a1.mean_rechecked.sonnet_web_verified`). It also found a real omission: this configuration’s memos with a major research defect go from 0 to 1 out of 6. That recheck is a different method: its 6.83 is not in the article’s table.
- The no-tools configuration cannot rule out internet use.
- The 86.39% cache-hit rate is measured through the OpenRouter activity API for the whole day of 1 October 2026 (cached tokens / prompt tokens). It covers all our DeepSeek traffic that day, not the bench alone: the bench made 322 of that day’s 542 requests. The uncached cost is given alongside (`prod_stage10_nocache`).
- Reconciliation with the bill: our formula, applied to the whole day’s tokens, gives $2.78 against $2.77 billed, a 0.6% gap. The activity API counts reasoning tokens separately from completion tokens and bills them at the output price; in our per-call logs they are already part of the completion tokens, so they are not added to the bench cost.
- Production reasoning tokens: 371,858 over the six memos (`a1.prod.reasoning_tokens`). They are already included in `completion_tokens`, so they are not added to the cost.
- Claude + MCP tokens were deduped by `message.id` from session transcripts, which write one line per content block, each line repeating the whole response’s usage. A first count of 78.6M thus counted each API response about twice; the retained figure is 38.8M. The cost ($10.71) prices input and cache-creation tokens at the input rate; at the $2.50 per million cache-write rate it would be $11.49 (`a1.sonnet_mcp.cost_cachewrite`).
- The output tokens recorded in the session transcripts appear incomplete; the cost of this configuration is therefore a lower bound.
- Cost of the 11 October 2026 run: 204 calls, at the 85.31% cache-hit rate measured over the day (the bench made 204 of its 479 requests) and at the prices billed that day; applied to the whole day, those prices match the bill ($1.64). That day, the activity API already counts reasoning tokens within completion tokens: they are not added.
- The prices of the 1 October run are an OpenRouter snapshot of 2 October 2026; those of the 11 October run, the ones billed that day. They may have changed since.

Case statements and prompts are available on request: hello@lucapaper.com