---
title: "Benchmark agents Cursor : consommation tokens / contexte / durées — RainbowPiano"
subtitle: "Cinq tâches, dix runs mesurés, cinq échecs quota : ce que les self-reports LLM_STATS_V1 disent vraiment (et ce qu'ils n'autorisent pas)"
date: 2026-09-15
time: "00:34"
author: VFG / Rainbow Journey
publishedBy: idea
status: pub
tags: ["rainbowjourney", "benchmark", "agents", "tokens", "contexte", "cursor", "orchestration", "devblog"]
---

![Benchmark agents Cursor : consommation tokens / contexte / durées — RainbowPiano](../images/covers/2026-09-15-benchmark-agents-cursor-tokens-contexte-durees.png)


Dans la soirée du 14 septembre 2026 (fuseau Paris, UTC+2), une session Cursor a lancé un **benchmark token / contexte / durée** sur le dépôt RainbowPiano (`D:\GitRepos\RainbowPiano`). L'objectif n'était pas d'améliorer le jeu, mais de mesurer, avec une grille commune, comment différents modèles se comportent sur les mêmes micro-tâches d'agent : lire un état, chercher une doc, auditer un plan, lire des règles, écrire une note de journal.

Ce billet capitalise le rapport métrique de la session (10 runs réussis + 5 échecs quota), y compris les stats T5 grok retrouvées après coup. Les chiffres sont des **estimations auto-déclarées** par les agents (`chars/4`), pas des compteurs de facturation Cursor / OpenAI / Anthropic / xAI.

## 1. Contexte et objectif du bench

Rainbow Journey vit dans un workspace dense : invariants MIDI, zones agents, plans d'essai UI, journal, handoffs. Chaque agent consomme du contexte. Sans mesure, on choisit les modèles à l'instinct (« Claude est précis », « Grok lit beaucoup », « GPT réfléchit long »).

Le bench vise trois questions opérationnelles :

1. Sur une **même** micro-tâche, qui lit le moins / le plus, et combien de temps ça prend ?
2. Quand le quota « Other Models » tombe, que valent les fallbacks `inherit` et `cursor-grok-4.6-high-fast` ?
3. Les self-reports `LLM_STATS_V1` sont-ils assez cohérents pour guider l'orchestration, ou seulement pour ordonner des tendances ?

Périmètre volontairement étroit : pas d'édition produit (sauf les notes T5 sous `docs/journal/benchmark-token-stats/`), pas de commit, pas de merge, pas de chargement massif de `node_modules` / `dist` / archives.

## 2. Méthode

### Plan expérimental

Cinq tâches × deux modèles (paire initiale **gpt-5.4-medium** vs **claude-4.5-sonnet-thinking**), lancés en parallèle via l'outil Task Cursor :

| Id | Libellé | Consigne courte |
| --- | --- | --- |
| T1 | `T1-read-status` | Lire `docs/etat/STATUS.md` (+ AGENTS.md minimal si besoin), résumé 5–8 lignes |
| T2 | `T2-search-docs` | Chercher une info ciblée dans la doc technique |
| T3 | `T3-audit-plans` | Audit léger de `docs/plans/essai-ui-ingame-2a/` (présence README / CONTRAT / PLAN / chantiers / handoffs) |
| T4 | `T4-read-rules` | Lire AGENTS.md (+ CLAUDE.md court), résumé 8–12 lignes |
| T5 | `T5-write-journal` | Écrire une note courte sous `docs/journal/benchmark-token-stats/` |

### Format obligatoire `LLM_STATS_V1`

Chaque agent devait terminer par un bloc machine-lisible. Tokens estimés en **`chars/4`** (heuristique classique, pas un tokenizer provider). Durées découpées en réflexion / outils / sortie, plus un total mural.

Champs attendus (extrait) : `task_id`, `model_requested`, `model_effective`, `started_at_iso`, `ended_at_iso`, `duration_total_ms`, `duration_reflection_ms`, `duration_tools_ms`, `duration_output_ms`, `tokens_input_est`, `tokens_output_est`, `context_chars_read`, `tools_called_count`, `result_ok`.

### Fallback quota

En cours de run, plusieurs agents ont reçu :

> `Other Models usage limit reached Switched to grok-4.6 after reaching Other Models usage limit.`

Relances effectives : T3 → `inherit` + `grok` ; T4 claude → `grok` ; T5 gpt/claude → `inherit` + `grok`. Les paires ne restent donc **pas** homogènes gpt/claude sur toute la grille.

## 3. Limites (lire avant les tableaux)

1. **Pas de billing provider.** Aucun compteur officiel Cursor Usage / Anthropic / OpenAI / xAI. Tout est self-report agent.
2. **Self-report biaisé.** Un modèle peut sous-compter les chars lus, surévaluer les tok in (prompt système, historique, skill), arrondir les durées.
3. **Parallélisme.** Dix agents simultanés : `duration_tools_ms` est probablement gonflé (contention I/O, file d'attente outils).
4. **Quota Other Models.** Cinq runs sans aucun chiffre ; bascule forcée vers grok / inherit — les comparaisons inter-tâches « gpt vs claude » ne couvrent que T1 et T2.
5. **Fuseau.** Majorité UTC+2 ; T2-gpt mélange une horodatage `Z` et une fin `+02:00` (cohérent en murale, cosmétique seulement).
6. **Périmètre tok in ≠ chars lus.** Le ratio `tok_in / (chars/4)` varie de ~1 à 100 selon les runs (voir §10).

## 4. Matrice des runs

### Succès (10) — ids courts

| Tâche | Modèle effectif | Agent id (court) |
| --- | --- | --- |
| T1 | gpt-5.4-medium | `89ccfd21` |
| T1 | claude-4.5-sonnet-thinking | `23556b84` |
| T2 | gpt-5.4-medium | `9c6832e1` |
| T2 | claude-4.5-sonnet-thinking | `528f0054` |
| T3 | inherit (Composer Auto) | `31c1c36f` |
| T3 | cursor-grok-4.6-high-fast | `edd4f441` |
| T4 | gpt-5.4-medium | `3cad5830` |
| T4 | cursor-grok-4.6-high-fast | `03f33e02` |
| T5 | inherit | `3bcdbae7` |
| T5 | cursor-grok-4.6-high-fast | `d773f528` |

### Échecs quota (5) — aucun chiffre

| Tâche | Modèle demandé | Agent id (court) |
| --- | --- | --- |
| T3 | gpt-5.4-medium | `f34c33a1` |
| T3 | claude-4.5-sonnet-thinking | `42d25f0b` |
| T4 | claude-4.5-sonnet-thinking | `44858b73` |
| T5 | gpt-5.4-medium | `b7e3d892` |
| T5 | claude-4.5-sonnet-thinking | `2e998c87` |

Message unique observé : limite Other Models, bascule annoncée vers grok-4.6. Pas de bloc `LLM_STATS_V1` sur ces cinq runs.

## 5. Fiches métriques session par session

Pourcentages = part du `duration_total_ms`. Somme réflexion + outils + sortie = total pour les dix runs (Δ arithmétique nulle).

### T1 — lire l'état

**gpt-5.4-medium** (`89ccfd21`) — 21:30:15 → 21:30:37 +02

| Champ | Valeur |
| --- | ---: |
| total | 21 400 ms |
| réflexion | 5 900 (27,57 %) |
| outils | 12 500 (58,41 %) |
| sortie | 3 000 (14,02 %) |
| tok in / out | 9 800 / 620 |
| chars lus | 9 628 |
| outils | 7 |
| fichiers | skill using-superpowers, AGENTS.md, STATUS.md |

**claude-4.5-sonnet-thinking** (`23556b84`) — 21:30:00 → 21:30:08 +02

| Champ | Valeur |
| --- | ---: |
| total | 8 000 ms |
| réflexion | 500 (6,25 %) |
| outils | 6 500 (81,25 %) |
| sortie | 1 000 (12,50 %) |
| tok in / out | 6 250 / 450 |
| chars lus | 1 844 |
| outils | 3 |
| fichiers | STATUS.md |

### T2 — chercher la doc

**gpt-5.4-medium** (`9c6832e1`) — start noté `19:30:42.783Z` / end `21:31:06+02` (murale = 23 538 ms)

| Champ | Valeur |
| --- | ---: |
| total | 23 538 ms |
| réflexion | 7 200 (30,59 %) |
| outils | 12 500 (53,11 %) |
| sortie | 3 838 (16,31 %) |
| tok in / out | 5 200 / 430 |
| chars lus | 13 590 |
| outils | 19 |
| fichiers | skill, AGENTS, STATUS, INVARIANTS, technique/README |

**claude-4.5-sonnet-thinking** (`528f0054`) — 21:30:00 → 21:30:15 +02

| Champ | Valeur |
| --- | ---: |
| total | 15 000 ms |
| réflexion | 2 000 (13,33 %) |
| outils | 11 000 (73,33 %) |
| sortie | 2 000 (13,33 %) |
| tok in / out | 6 134 / 515 |
| chars lus | 2 861 |
| outils | 4 |
| fichiers | INVARIANTS.md |

### T3 — audit plans (retry après quota)

**inherit** (`31c1c36f`) — 21:31:00 → 21:32:15 +02

| Champ | Valeur |
| --- | ---: |
| total | 75 000 ms |
| réflexion | 25 000 (33,33 %) |
| outils | 40 000 (53,33 %) |
| sortie | 10 000 (13,33 %) |
| tok in / out | 2 800 / 550 |
| chars lus | 11 200 |
| outils | 8 |

**cursor-grok-4.6-high-fast** (`edd4f441`) — 21:31:00 → 21:33:40 +02

| Champ | Valeur |
| --- | ---: |
| total | 160 000 ms |
| réflexion | 28 000 (17,50 %) |
| outils | 108 000 (67,50 %) |
| sortie | 24 000 (15,00 %) |
| tok in / out | 14 200 / 1 100 |
| chars lus | 54 800 |
| outils | 16 |

### T4 — lire les règles

**gpt-5.4-medium** (`3cad5830`) — 21:31:00 → 21:33:10 +02

| Champ | Valeur |
| --- | ---: |
| total | 130 000 ms |
| réflexion | 65 000 (50,00 %) |
| outils | 45 000 (34,62 %) |
| sortie | 20 000 (15,38 %) |
| tok in / out | 9 500 / 500 |
| chars lus | 8 600 |
| outils | 8 |

**cursor-grok-4.6-high-fast** (`03f33e02`) — 21:32:00 → 21:33:12 +02

| Champ | Valeur |
| --- | ---: |
| total | 72 000 ms |
| réflexion | 8 000 (11,11 %) |
| outils | 55 000 (76,39 %) |
| sortie | 9 000 (12,50 %) |
| tok in / out | 1 638 / 720 |
| chars lus | 4 354 |
| outils | 4 |

### T5 — écrire le journal

**inherit** (`3bcdbae7`) — 21:32:00 → 21:32:45 +02

| Champ | Valeur |
| --- | ---: |
| total | 45 000 ms |
| réflexion | 8 000 (17,78 %) |
| outils | 32 000 (71,11 %) |
| sortie | 5 000 (11,11 %) |
| tok in / out | 4 200 / 450 |
| chars lus | 2 630 |
| outils | 7 |
| écrit | `NOTE-2026-09-14-agent-inherit.md` |

**cursor-grok-4.6-high-fast** (`d773f528`) — 21:32:00 → 21:33:50 +02 *(stats retrouvées dans le transcript)*

| Champ | Valeur |
| --- | ---: |
| total | 110 000 ms |
| réflexion | 8 000 (7,27 %) |
| outils | 90 000 (81,82 %) |
| sortie | 12 000 (10,91 %) |
| tok in / out | 22 000 / 1 400 |
| chars lus | 880 |
| outils | 7 |
| lus | `docs/journal/README.md`, `NOTE-2026-09-14-agent-gpt54.md` |
| écrit | `NOTE-2026-09-14-agent-grok46.md` |

## 6. Tableau récap et totaux

| Tâche | Modèle | ms | refl % | outils % | out % | tok in | tok out | chars | outils |
| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
| T1 | gpt | 21 400 | 27,57 | 58,41 | 14,02 | 9 800 | 620 | 9 628 | 7 |
| T1 | claude | 8 000 | 6,25 | 81,25 | 12,50 | 6 250 | 450 | 1 844 | 3 |
| T2 | gpt | 23 538 | 30,59 | 53,11 | 16,31 | 5 200 | 430 | 13 590 | 19 |
| T2 | claude | 15 000 | 13,33 | 73,33 | 13,33 | 6 134 | 515 | 2 861 | 4 |
| T3 | inherit | 75 000 | 33,33 | 53,33 | 13,33 | 2 800 | 550 | 11 200 | 8 |
| T3 | grok | 160 000 | 17,50 | 67,50 | 15,00 | 14 200 | 1 100 | 54 800 | 16 |
| T4 | gpt | 130 000 | 50,00 | 34,62 | 15,38 | 9 500 | 500 | 8 600 | 8 |
| T4 | grok | 72 000 | 11,11 | 76,39 | 12,50 | 1 638 | 720 | 4 354 | 4 |
| T5 | inherit | 45 000 | 17,78 | 71,11 | 11,11 | 4 200 | 450 | 2 630 | 7 |
| T5 | grok | 110 000 | 7,27 | 81,82 | 10,91 | 22 000 | 1 400 | 880 | 7 |

**Totaux 10 OK :** **659 938 ms** · **81 722 tok in** · **6 735 tok out** · **110 387 chars** · **83 outils**.

## 7. Deltas par paire et ratios

Convention : A = premier modèle de la paire effective, B = second ; Δ = B − A ; ratio = B/A.

### T1 — gpt → claude

Claude est nettement plus lean : **0,37×** la durée, **0,19×** les chars, **0,43×** les outils. Tok in encore **0,64×**.

| Métrique | A gpt | B claude | Δ | B/A |
| --- | ---: | ---: | ---: | ---: |
| ms | 21 400 | 8 000 | −13 400 | 0,37 |
| tok in | 9 800 | 6 250 | −3 550 | 0,64 |
| chars | 9 628 | 1 844 | −7 784 | 0,19 |
| outils | 7 | 3 | −4 | 0,43 |

### T2 — gpt → claude

Même tendance durée / contexte : Claude **0,64×** ms, **0,21×** chars, **0,21×** outils. Mais tok in légèrement **plus haut** (1,18×) — rappel que tok in ≠ chars lus.

| Métrique | A gpt | B claude | Δ | B/A |
| --- | ---: | ---: | ---: | ---: |
| ms | 23 538 | 15 000 | −8 538 | 0,64 |
| tok in | 5 200 | 6 134 | +934 | 1,18 |
| chars | 13 590 | 2 861 | −10 729 | 0,21 |
| outils | 19 | 4 | −15 | 0,21 |

### T3 — inherit → grok *(pas la paire d'origine)*

Grok lit **beaucoup** plus : **2,13×** durée, **5,07×** tok in, **4,89×** chars, **2×** outils.

### T4 — gpt → grok *(claude en échec quota)*

Ici Grok est **plus rapide** (0,55×) et plus frugal en tok in (0,17×) / chars (0,51×). GPT annonce **50 %** de réflexion — outlier de découpage temporel.

### T5 — inherit → grok *(gpt+claude en échec)*

Grok **2,44×** plus long, **5,24×** tok in, mais seulement **0,33×** chars lus déclarés — c'est le nœud qualité §10.

## 8. Agrégats par famille

| Famille | n | Σ ms | Σ tok in | Σ tok out | Σ chars | Σ outils | Σ ms réflexion |
| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
| gpt | 3 | 174 938 | 24 500 | 1 550 | 31 818 | 34 | 78 100 |
| claude | 2 | 23 000 | 12 384 | 965 | 4 705 | 7 | 2 500 |
| inherit | 2 | 120 000 | 7 000 | 1 000 | 13 830 | 15 | 33 000 |
| grok | 3 | 342 000 | 37 838 | 3 220 | 60 034 | 27 | 44 000 |
| **TOTAL** | **10** | **659 938** | **81 722** | **6 735** | **110 387** | **83** | **157 600** |

Moyennes (Σ/n) :

- **claude** : 11 500 ms · 6 192 tok in · 2 353 chars — le plus lean sur les deux tâches mesurées
- **inherit** : 60 000 ms · 3 500 tok in · 6 915 chars — milieu de table, utile en fallback
- **gpt** : 58 313 ms · 8 167 tok in · 10 606 chars — plus d'outils et de réflexion déclarée
- **grok** : 114 000 ms · 12 613 tok in · 20 011 chars — le plus lourd en durée et contexte agrégés

Attention : n et tâches ne sont pas équilibrés (Claude n'a que T1/T2 ; Grok porte T3/T4/T5).

## 9. Classements (parmi 10 OK)

| Critère | 1er | 2e | 3e |
| --- | --- | --- | --- |
| Plus rapide | T1-claude **8 000** | T2-claude **15 000** | T1-gpt **21 400** |
| Plus lent | T3-grok **160 000** | T4-gpt **130 000** | T5-grok **110 000** |
| Plus de contexte (chars) | T3-grok **54 800** | T2-gpt **13 590** | T3-inherit **11 200** |
| Plus d'outils | T2-gpt **19** | T3-grok **16** | T3-inherit / T4-gpt **8** |
| Plus de réflexion déclarée | T4-gpt **65 000** (50 %) | T3-grok **28 000** | T3-inherit **25 000** |
| Plus tok in est. | T5-grok **22 000** | T3-grok **14 200** | T1-gpt **9 800** |
| Plus tok out est. | T5-grok **1 400** | T3-grok **1 100** | T4-grok **720** |

## 10. Qualité des données et outliers

1. **T5 grok** : bloc `LLM_STATS_V1` présent dans le jsonl (`d773f528-…`), alors que le premier rapport parent le croyait absent.
2. **T2-gpt timezone** : `started …Z` + `ended …+02:00` — murale cohérente avec 23 538 ms ; équivalent local ≈ 21:30:42 → 21:31:06 +02.
3. **Ratio `tok_in / (chars/4)`** — hétérogénéité forte :
   - proche de 1 : T3-inherit (~1,00), T3-grok (~1,04) → toks ≈ contenu lu
   - autour de 1,5 : T2-gpt, T4-grok
   - élevé (prompt / système / skill probablement inclus) : T1-gpt ~4, T4-gpt ~4,4, T5-inherit ~6,4, T2-claude ~8,6, T1-claude ~13,6
   - **outlier T5-grok ≈ 100** (22 000 tok pour 880 chars) : tok in très surévalué **ou** chars sous-comptés — ne pas utiliser ce tok in comme vérité absolue
4. **T4-gpt 50 % réflexion** sur une lecture de règles : estimation large, peu fiable pour une comparaison fine des phases.
5. **Charge parallèle** : gonflement probable de `duration_tools_ms`.
6. **Paires non homogènes** après quota : seules T1/T2 comparent gpt vs claude. Extrapolations « famille X vs Y » hors ces paires = spéculation.

## 11. Enseignements opérationnels

1. **Claude lean sur lecture ciblée.** Sur T1/T2, moins de chars, moins d'outils, plus rapide — bon défaut pour « ouvre STATUS / trouve un invariant » sans balayer le dépôt.
2. **Grok audit large.** Sur T3, 54 800 chars et 16 outils : utile quand on veut une couverture large d'un dossier de plans, coûteux si la consigne demandait un audit léger.
3. **GPT réflexion T4.** 65 000 ms de réflexion déclarée (50 %) sur AGENTS.md : signal de style (longue planification) plus que de coût réel prouvé.
4. **Discipline de lecture.** L'écart T1 gpt (9 628 chars, skill + AGENTS + STATUS) vs T1 claude (1 844 chars, STATUS seul) montre que la **consigne « lecture minimale »** n'est pas appliquée uniformément : un skill d'amorce peut doubler le contexte avant même la tâche.
5. **Quota Other Models = variable d'expérience.** Sans fallback préparé, la moitié de la grille gpt/claude disparaît. Prévoir `inherit` / grok (ou une file séquentielle) dans le protocole.
6. **Self-report = boussole, pas facture.** Ordonner des tendances oui ; décider un budget euros/mois non.

## 12. Recommandations pour rejouer le bench

1. **Séquencer** les paires (ou limiter le parallélisme à 2) pour stabiliser `duration_tools_ms`.
2. **Vérifier le quota Other Models** avant le lancement ; sinon démarrer déjà sur les modèles disponibles.
3. **Imposer un plafond de fichiers** dans la consigne (`STATUS.md` uniquement ; interdit skill hors périmètre si le bench mesure la discipline).
4. **Croiser** un self-report avec un compteur externe dès qu'il existe (Cursor usage export, logs provider).
5. **Standardiser le fuseau** : tout en `+02:00` (ou tout en `Z`).
6. **Valider le ratio** `tok_in ≈ chars/4` en post-traitement ; flagger les outliers (>5× ou <0,5×) avant agrégation.
7. **Garder les notes T5** comme artefacts de preuve sous `docs/journal/benchmark-token-stats/`, sans les confondre avec un jalon produit.
8. **Publier le rapport** (ce billet) juste après la session, tant que les transcripts jsonl sont encore locaux.

## 13. Annexes

### A. Échecs quota (rappel)

T3 gpt `f34c33a1` · T3 claude `42d25f0b` · T4 claude `44858b73` · T5 gpt `b7e3d892` · T5 claude `2e998c87` — message Other Models / bascule grok-4.6, **aucun chiffre**.

### B. Notes journal (preuves T5 et siblings)

Sous RainbowPiano :

- `docs/journal/benchmark-token-stats/NOTE-2026-09-14-agent-gpt54.md`
- `docs/journal/benchmark-token-stats/NOTE-2026-09-14-agent-claude45.md`
- `docs/journal/benchmark-token-stats/NOTE-2026-09-14-agent-inherit.md`
- `docs/journal/benchmark-token-stats/NOTE-2026-09-14-agent-grok46.md`

### C. Transcripts

Parent session Cursor : `agent-transcripts/4f1fdb1d-9430-4d50-8448-0de6d582ea38/` (sous-agents = ids ci-dessus). Le rapport métrique intermédiaire a consolidé les dix fiches + deltas + agrégats repris ici.

---

*Méthode : LLM_STATS_V1 self-report · date des runs 2026-09-14 soir · publication éditoriale 2026-09-15. Aucun secret, aucun compteur de facturation, aucun commit produit RainbowPiano pour ce bench.*