---
title: "Guide pratique : quel modèle Cursor pour quelle tâche agentique ?"
subtitle: "Tutoriel décisionnel + comparatif chiffré — benchmark RainbowPiano 14–15 sept. 2026 (tokens estimés chars/4)"
date: 2026-09-15
time: "00:42"
author: VFG / Rainbow Journey
publishedBy: idea
status: pub
tags: ["rainbowjourney", "cursor", "agents", "modeles", "tutoriel", "orchestration", "benchmark", "devblog"]
---

![Guide pratique : quel modèle Cursor pour quelle tâche agentique ?](../images/covers/2026-09-15-guide-modeles-cursor-taches-agentiques.png)


Ce guide transforme le [benchmark tokens / contexte / durées](https://blog.vfg.lol/devblog/posts/rainbowjourney/2026-09-15-benchmark-agents-cursor-tokens-contexte-durees.md.html) en **recette actionnable** : quand choisir quel modèle Cursor, comment orchestrer une vague d’agents, et quels pièges le bench a déjà payés pour vous.

Chiffres : self-reports `LLM_STATS_V1`, tokens estimés en **chars/4** — pas une facture provider. Paires gpt/claude seulement sur T1–T2 ; ensuite bascule quota « Other Models » vers **inherit** et **grok**.

## 1. Pour qui / prérequis

**Pour qui.** Orchestrateurs Cursor qui lancent des agents (outil Task), du multitask, ou des subagents avec un `model` slug explicite. Utile aussi si vous mesurez la consommation pour caler une file de travail.

**Prérequis.**

1. Cursor avec agents / Task subagents.
2. Un dépôt avec règles claires (chez RainbowPiano : `AGENTS.md` + fiches de zone).
3. Si vous mesurez : imposer le bloc `LLM_STATS_V1` en fin de réponse (mêmes champs que le bench).
4. Conscience du quota **Other Models** : gpt / claude peuvent basculer forcé vers grok sans stats exploitables.

**Slugs réellement utilisés dans le bench.**

| Slug demandé | Rôle observé |
| --- | --- |
| `gpt-5.4-medium` | Paire A initiale ; réflexion large ; exploration parfois coûteuse |
| `claude-4.5-sonnet-thinking` | Paire B initiale ; lecture ciblée lean |
| `inherit` | Composer / Auto — fallback fiable hors Other Models |
| `cursor-grok-4.6-high-fast` | Fallback + audits larges ; contexte / durée élevés |

## 2. Cartographie modèles × profil

### Claude 4.5 Sonnet thinking — quand le quota le permet

**Profil.** Lecture ciblée, doc technique, état projet, faible exploration.

**Quand l’utiliser.** « Ouvre STATUS », « trouve l’invariant MIDI », « résume AGENTS en 10 lignes » — toute tâche où **moins de fichiers = mieux**.

**Preuve bench.** T1 : **8 s** / 1 844 chars / 3 outils vs GPT **21,4 s** / 9 628 chars / 7 outils. T2 : **15 s** / 2 861 chars / 4 outils vs GPT **23,5 s** / 13 590 chars / **19** outils. Agrégat Claude (2 runs) : **23 000 ms**, **4 705 chars** — le plus lean.

**Piège.** Quota Other Models : 3 des 5 fails claude/gpt sont tombés sur T3–T5. Ne pas compter sur Claude pour une vague longue sans vérifier le quota.

### GPT-5.4 medium — réflexion large, attention latence

**Profil.** Règles / repo, tâches où une réflexion plus large aide ; sur-exploration fréquente.

**Quand l’utiliser.** Synthèse de règles complexes, décisions multi-fichiers **si** vous imposez un budget fichiers. Moins bon défaut pour une lecture minimale.

**Preuve bench.** T4 : **130 s** dont **50 %** « réflexion » déclarée (65 000 ms) — outlier de découpage temporel, pas une preuve de coût euros. T2 : 19 appels outils pour une recherche doc ciblée.

**Piège.** Sans plafond de fichiers, GPT charge skill + AGENTS + STATUS + technique avant de répondre. Latence murale élevée en parallèle.

### Inherit / Composer (Auto) — fallback fiable

**Profil.** Audits « suffisants », écriture journal, file de secours quand Other Models est saturé.

**Quand l’utiliser.** Après message « Other Models usage limit… » ; notes de journal ; audit rapide d’un dossier de plans sans exhaustivité.

**Preuve bench.** T3 inherit : **75 s** / 11 200 chars / 8 outils. T5 inherit : **45 s** / 2 630 chars, note écrite correctement. Agrégat : 2 runs, **120 000 ms**, **13 830 chars**.

**Piège.** Ce n’est pas le plus lean en chars sur audit (Grok lit plus, Inherit reste « assez »). Ne pas le comparer à Claude sur T1/T2 : tâches différentes.

### Grok 4.6 high-fast — audits exhaustifs, second avis large

**Profil.** Couverture large d’un dossier ; second avis ; parfois tok in auto-estimé incohérent.

**Quand l’utiliser.** Audit de plans / handoffs où manquer un fichier coûte cher ; second passage après un Inherit rapide.

**Preuve bench.** T3 grok : **160 s** / **54 800 chars** / 16 outils vs Inherit 75 s / 11 200. Agrégat grok (3 runs) : **342 000 ms**, **60 034 chars** — le plus lourd. T5 grok : 22 000 tok in pour 880 chars lus → ratio ~100× (outlier).

**Piège.** Coût contexte/durée élevé. Tok in self-report parfois inutilisable (T5). Sur T4, Grok était *plus rapide* que GPT (72 s vs 130 s) — le profil « lourd » n’est pas universel.

## 3. Matrice décisionnelle tâche → modèle

| Tâche type | 1er choix | Alternative | À éviter / piège |
| --- | --- | --- | --- |
| Lire STATUS / état | Claude | Inherit | GPT si tu veux le minimum de fichiers |
| Chercher 1 élément doc | Claude (Grep→Read) | Grok | GPT sans budget fichiers (19 tools observés) |
| Audit dossier plans | Grok (exhaustif) ou Inherit (rapide) | — | Lancer les deux si couverture vs vitesse |
| Lire AGENTS / règles | Grok lean ou Claude | GPT | GPT T4 = 50 % « réflexion » / 130 s |
| Écrire note journal | Inherit | Grok | Other Models si quota saturé |

**Règle courte.** Quota OK → Claude pour lire/chercher. Quota saturé → Inherit par défaut, Grok pour exhaustif. GPT seulement avec budget fichiers explicite.

## 4. Recette d’orchestration (pas à pas)

### Étape 1 — Une tâche = un agent

Ne pas fusionner « lis STATUS + audite les plans + écris le journal » dans un seul prompt. Le bench a mesuré des micro-tâches isolées : c’est ce qui rend les deltas lisibles.

### Étape 2 — Paire A/B de modèles équivalents

Exemple : T1–T2 en `gpt-5.4-medium` × `claude-4.5-sonnet-thinking`. Même consigne, même format de sortie. Dès qu’un côté bascule (quota → grok), **noter** que la paire n’est plus comparable.

### Étape 3 — Séquencer pour mesurer

Dix agents en parallèle gonflent probablement `duration_tools_ms` (contention I/O). Pour un bench ou une mesure de file : **2 agents max**, ou une paire après l’autre.

### Étape 4 — Imposer un budget fichiers max

Exemple de contrainte dans le prompt :

> Lis uniquement `docs/etat/STATUS.md`. Interdit : journal, devblog, node_modules, skill hors périmètre. Max 3 appels outils.

Sans ça, l’écart T1 gpt (9 628 chars) vs claude (1 844) se rejoue à chaque vague.

### Étape 5 — Bloc `LLM_STATS_V1`

Exiger en fin de réponse : `task_id`, `model_requested`, `model_effective`, horodatages ISO, `duration_*_ms`, `tokens_*_est` (chars/4), `context_chars_read`, `tools_called_count`, `result_ok`. Post-traiter le ratio `tok_in / (chars/4)` ; flagger si >5× ou <0,5×.

### Étape 6 — Gérer le quota Other Models

Stratégie validée par le bench :

1. Avant la vague : tenter un ping mental (« Claude a-t-il encore du quota ? »). Sinon démarrer déjà en inherit/grok.
2. Sur message *Other Models usage limit… Switched to grok-4.6…* : **ne pas** attendre de `LLM_STATS` — relancer explicitement en `inherit` (rapide) et/ou `cursor-grok-4.6-high-fast` (exhaustif).
3. Cinq fails sans chiffre dans le bench : T3 gpt/claude, T4 claude, T5 gpt/claude. Prévoir ces relances dans le protocole, pas en improvisation.

## 5. Outils Cursor à coupler (pratique)

| Besoin | Faire | Éviter |
| --- | --- | --- |
| Lire un fichier connu | `Read` direct | `Shell` `Get-Content` large |
| Trouver un symbole / invariant | `Grep` ciblé → `Read` | Glob récursif puis tout ouvrir |
| Lister une famille de fichiers | `Glob` avec pattern étroit | `dir /s` sur tout le dépôt |
| Déléguer | Task subagent + `model` slug listé | 10 Task en parallèle « pour aller plus vite » si vous mesurez |
| Contexte RainbowPiano | STATUS + fiche de zone | journal, devblog, `node_modules`, `dist`, archives (cf. `AGENTS.md`) |

**Subagents.** Passer un slug de la liste autorisée (`gpt-5.4-medium`, `claude-4.5-sonnet-thinking`, `inherit`, `cursor-grok-4.6-high-fast`, …). Si le slug n’est pas dans la liste du harness, ne pas inventer un substitut.

**Quand ne pas charger.** Sur RainbowPiano, ne pas importer par défaut journal, devblog, pièces HTML/images, `package-lock.json`, `node_modules`, `dist`, coverage, artifacts. Ces contenus restent accessibles pour une tâche historique / visuelle / diagnostic — pas pour un STATUS.

## 6. Tableau comparatif dynamique (chiffres réels)

### Totaux session (10 OK + 5 fails quota)

| Indicateur | Valeur |
| --- | ---: |
| Runs OK | 10 |
| Fails quota (sans chiffre) | 5 |
| Σ durée | **659 938 ms** (~11 min murales agrégées) |
| Σ tok in (est.) | **81 722** |
| Σ tok out (est.) | **6 735** |
| Σ chars lus | **110 387** |
| Σ outils | **83** |

### Agrégats par famille

| Famille | n | Σ ms | Σ tok in | Σ tok out | Σ chars | Σ outils |
| --- | ---: | ---: | ---: | ---: | ---: | ---: |
| gpt | 3 | 174 938 | 24 500 | 1 550 | 31 818 | 34 |
| claude | 2 | **23 000** | 12 384 | 965 | **4 705** | **7** |
| inherit | 2 | 120 000 | 7 000 | 1 000 | 13 830 | 15 |
| grok | 3 | **342 000** | 37 838 | 3 220 | **60 034** | 27 |

Claude = plus lean (sur T1/T2 seulement). Grok = plus lourd (porte T3/T4/T5). n et tâches **non équilibrés** — lire les deltas pairés avant de conclure « famille X > Y ».

### Deltas qui guident le choix

| Comparaison | Signal |
| --- | --- |
| T1 Claude **8 s** vs GPT **21,4 s** | Claude pour STATUS |
| T3 Grok **160 s / 54 800 chars** vs Inherit **75 s / 11 200** | Grok exhaustif, Inherit rapide |
| T2 GPT **19** outils vs Claude **4** | Budget fichiers obligatoire pour GPT |
| T4 GPT **50 %** réflexion / 130 s | Ne pas prendre le découpage temporel au pied de la lettre |
| T5 Grok **22 000** tok in / **880** chars | Outlier — ignorer ce tok in pour les agrégats sensibles |

### Callouts outliers

1. **T5 grok** — tok in ~100× chars/4 : surestimation tok **ou** sous-comptage chars. Boussole cassée sur cette métrique seule.
2. **T4 gpt** — moitié du temps en « réflexion » déclarée sur une lecture de règles : style de self-report, pas une preuve de thinking provider.
3. **Parallélisme** — 10 agents simultanés : durées outils probablement gonflées.
4. **Paires non homogènes** après quota — seules T1/T2 comparent gpt vs claude à armes égales.

## 7. Checklist avant de lancer une vague d’agents

- [ ] Une micro-tâche claire par agent (pas un fourre-tout).
- [ ] Slug modèle explicite + alternative si quota Other Models.
- [ ] Budget fichiers / outils max dans le prompt.
- [ ] Interdits de chargement rappelés (journal, node_modules, …).
- [ ] Format `LLM_STATS_V1` exigé si vous mesurez.
- [ ] Parallélisme limité (≤2) si les durées comptent.
- [ ] Fuseau ISO homogène (`+02:00` ou `Z`, pas les deux mélangés).
- [ ] Plan de relance inherit + grok prêt.
- [ ] Post-traitement : flagger ratios tok/chars aberrants avant agrégation.
- [ ] Lien / archive vers le [rapport métrique exhaustif](https://blog.vfg.lol/devblog/posts/rainbowjourney/2026-09-15-benchmark-agents-cursor-tokens-contexte-durees.md.html).

## 8. Lien vers l’article métrique

Tout le détail run-par-run, deltas, classements et annexes ids agents :

**[Benchmark agents Cursor : consommation tokens / contexte / durées — RainbowPiano](https://blog.vfg.lol/devblog/posts/rainbowjourney/2026-09-15-benchmark-agents-cursor-tokens-contexte-durees.md.html)**

Ce guide en est le mode d’emploi. L’autre est la preuve chiffrée.

## 9. Limites du guide

1. **Paires non homogènes** après saturation Other Models — ne pas extrapoler « Claude > GPT » hors T1/T2.
2. **Self-report** — chars/4, découpage réflexion/outils/sortie, tok in incluant parfois prompt système / skills.
3. **n déséquilibré** — Claude 2 runs (légers), Grok 3 runs (lourds) : les agrégats famille ne sont pas un classement équitable.
4. **Pas de billing** — aucune décision budget euros ne doit reposer sur ces tok seuls.
5. **Harness Cursor évolue** — slugs et quotas peuvent changer ; revalider avant une campagne longue.

---

*Tutoriel basé sur les runs du 14 septembre 2026 (soir, UTC+2) · publication éditoriale 2026-09-15. Aucun secret, aucun compteur de facturation provider.*