Cursor Agent / Composer 2026 : modes et lab DevOps

À la fin de ce tutoriel Cursor Agent / Composer 2026, vous distinguerez clairement mode (Ask, Agent, Plan, Debug) et modèle (dont Composer 2.5), ouvrirez l’Agent (Cmd/Ctrl+I), utiliserez outils, checkpoints et file d’attente, et validerez un lab factice sous /tmp/lab-cursor-agent — sans secrets ni push sur un dépôt réel.

Niveau : Intermédiaire · Temps estimé : 45–60 min · Versions / contexte : Cursor Agent (docs 2026) · Composer 2.5 (modèle Cursor) · Cloud Agents · Dernière vérification : 2026-09-11

← Précédent : Évaluer la qualité d’un skill · → Suivant : Windsurf Cascade · Hub : IA pour DevOps : parcours 2026

Prérequis

• Hub IA pour DevOps : parcours 2026
• Notions utiles : Cursor Skills, AI Skills, Agent workflows
• Cursor IDE installé (compte Free/Pro/Teams selon votre offre) ; panneau Agent accessible
• Lab entièrement local sous /tmp ; aucun token GitHub, kubeconfig ou clé API réelle
• Git de base (init, status) pour le lab — pas de remote obligatoire

Coût lab : 0 €. L’usage Agent / Cloud Agents consomme des quotas selon votre plan Cursor — vérifiez Models & Pricing avant un run cloud.

Ce que nous allons construire

/tmp/lab-cursor-agent
  ├── README.md                 (objectif du lab)
  ├── app/hello.py              (fichier à « faire éditer » mentalement)
  ├── prompts/
  │   ├── ask-readonly.md       (prompt mode Ask)
  │   ├── plan-feature.md       (prompt mode Plan)
  │   └── agent-fix.md         (prompt mode Agent — dry-run)
  ├── checklists/
  │   ├── modes-vs-modele.md
  │   └── securite-agent.md
  └── scripts/assert-lab.sh
       → modes · Composer = modèle · checkpoints · quiz · FAQ

(Schéma à remplacer par une image locale, alt : « Cursor 2026 : un panneau Agent, quatre modes, Composer 2.5 comme modèle indépendant ».)

Chapitre module E #36 : après skills et routines, on entre dans l’IDE agentique Cursor. Objectif 2026 : ne plus confondre l’ancien panneau « Composer » multi-fichiers avec le modèle Composer actuel.

Étape 1 — Clarifier le vocabulaire 2026 (critique)

Terme	Ce que c’est en 2026	Ce que ce n’est plus
Agent	Assistant à outils : lit, édite, terminal, navigateur	Un simple chat texte
Mode	Ask / Agent / Plan / Debug — change le jeu d’outils	Le choix du LLM
Composer	Modèle Cursor (ex. Composer 2.5) dans le sélecteur	Le panneau multi-fichiers séparé d’avant
Cloud Agents	Même logique, VM isolée + branche / PR	Un remplacement local obligatoire

Historique utile : Chat (Cmd+L) et Composer (Cmd+I) étaient deux surfaces. Depuis la fusion Agent (changelog ~0.46 / 2025), un panneau (Cmd/Ctrl+I) porte les modes. En octobre 2025, Cursor a réutilisé le nom Composer pour son modèle maison. En 2026, dire « ouvre Composer » est ambigu : précisez mode Agent ou modèle Composer 2.5.

Docs officielles : Agent overview · Aide Agent · Cloud Agents.

Étape 2 — Les trois briques d’un Agent

1. Instructions — prompt système + Rules / Skills du projet.
2. Outils — recherche codebase, lecture, édition, shell, web, règles, navigateur, génération d’images, questions à l’humain.
3. Modèle — frontier (Claude, GPT, Gemini, Grok…) ou Composer 2.5 ; choix indépendant du mode.

Cursor tune instructions et outils par modèle. Il n’y a pas de plafond fixe documenté sur le nombre d’appels d’outils par tâche : l’Agent itère jusqu’à critère ou interruption.

Étape 3 — Modes : Ask, Agent, Plan, Debug

Mode	Meilleur pour	Édite le code ?
Ask	Comprendre, explorer, expliquer	Non (lecture seule)
Agent	Feature, refactor, fix, tests, shell	Oui
Plan	Gros chantier : plan éditable avant code	Après validation du plan
Debug	Bugs difficiles, preuves runtime	Oui (après investigation)

Règle DevOps Elastic Hayway : Ask pour cartographier un runbook ; Plan pour un changement multi-services ; Agent pour exécuter un plan validé ; Debug quand les logs mentent et qu’il faut reproduire.

Le mode change les capacités, pas le modèle. Vous pouvez lancer Composer 2.5 en mode Agent, ou Opus en mode Ask.

Étape 4 — Composer 2.5 : le modèle, pas le mode

Composer 2.5 (famille Composer Cursor) est un modèle agentique avec thinking / images selon la fiche Models. L’SDK indique que les anciens ids composer-2 / composer-2-fast sont reroutés vers Composer 2.5 — scripts à jour : préférez composer-2.5.

Quand l’utiliser côté DevOps :

• Itérations courtes sur un monorepo déjà indexé (recherche sémantique entraînée avec outils).
• Exécution d’un plan déjà validé (Plan → Agent + Composer).
• Coût / latence souvent plus favorables que les frontier lourds pour du « faire le code », en gardant un frontier pour architecture délicate.

Ce n’est pas : « le mode qui édite plusieurs fichiers » (c’est Agent).

Étape 5 — Outils utiles au quotidien

• Search / Read — codebase + images (png, jpg, webp…).
• Edit — patches multi-fichiers appliqués dans le workspace.
• Shell — commandes + suivi de sortie (profil terminal par défaut).
• Web — requêtes pour docs / changelog.
• Browser — screenshots et smoke UI (voir docs Browser).
• Ask questions — clarification pendant que l’Agent continue en parallèle.
• Checkpoints — snapshots locaux avant gros changements ; rollback fichiers ≠ historique chat ; Git reste la vérité permanente.
• File d’attente — Enter = message en queue ; Cmd/Ctrl+Enter = immédiat ; steering sans couper net un tool en cours.

Option /goal (déploiement progressif) : objectif long vivant (« rendre CI verte ») plutôt qu’un message = une micro-tâche.

Étape 6 — Cloud Agents (aperçu DevOps)

Même agent, VM isolée : clone SCM (GitHub, GitLab, Bitbucket, Azure DevOps), branche dédiée, handoff PR. Lancement : Desktop (Cloud), cursor.com/agents, Slack/GitHub/Linear @cursor, API / SDK. Environnements via snapshot, Dockerfile ou .cursor/environment.json. MCP équipe configurable sur le cloud.

Pour un pipeline : Cloud Agent = draft PR ; gate merge = humain + CI. Ne confondez pas avec les routines planifiées (digests) : ici l’objectif est du code livré en revue.

Étape 7 — Lab factice /tmp/lab-cursor-agent

Le lab simule la discipline Ask → Plan → Agent sans exiger un compte cloud ni de mutation réelle hors /tmp.

mkdir -p /tmp/lab-cursor-agent/{app,prompts,checklists,scripts}
cd /tmp/lab-cursor-agent

cat > README.md << 'EOF'
# Lab Cursor Agent / Composer 2026
Objectif : distinguer mode vs modèle ; préparer 3 prompts ; checklist sécu.
Interdit : secrets, kubectl apply, terraform apply, push remote.
EOF

cat > app/hello.py << 'EOF'
"""Service factice — ne pas déployer."""
def greet(name: str) -> str:
    return f"hello, {name}"

if __name__ == "__main__":
    print(greet("devops"))
EOF

cat > prompts/ask-readonly.md << 'EOF'
# Mode Ask (lecture seule)
Explique app/hello.py : responsabilités, tests manquants, risques.
N’édite aucun fichier. Sortie : ≤ 15 lignes Markdown.
EOF

cat > prompts/plan-feature.md << 'EOF'
# Mode Plan
Ajoute une fonction `greet_many(names: list[str]) -> list[str]` et un test unitaire.
Produis un plan éditable (fichiers touchés, critères done). Pas d’édition tant que non validé.
EOF

cat > prompts/agent-fix.md << 'EOF'
# Mode Agent (après plan validé)
Implémente greet_many + test ; lance `python -m py_compile app/hello.py`.
Modèle suggéré lab : Composer 2.5. Pas de git push. Checkpoint avant gros edit.
EOF

cat > checklists/modes-vs-modele.md << 'EOF'
- [ ] Ask = pas d’édition
- [ ] Plan = plan avant code
- [ ] Agent = édition + shell
- [ ] Debug = preuve runtime
- [ ] Composer 2.5 = modèle (sélecteur), pas un mode
- [ ] Ancien panneau Composer ≠ Composer 2.5
EOF

cat > checklists/securite-agent.md << 'EOF'
- [ ] Aucun secret dans prompts/
- [ ] Allowlist commandes shell (pas de destroy)
- [ ] Checkpoints + Git avant gros refactor
- [ ] Cloud Agent = PR draft, merge humain
- [ ] Rules/Skills projet sans tokens en clair
EOF

cat > scripts/assert-lab.sh << 'EOF'
#!/usr/bin/env bash
set -euo pipefail
ROOT="$(cd "$(dirname "$0")/.." && pwd)"
test -f "$ROOT/app/hello.py"
test -f "$ROOT/prompts/ask-readonly.md"
test -f "$ROOT/prompts/plan-feature.md"
test -f "$ROOT/prompts/agent-fix.md"
python3 -m py_compile "$ROOT/app/hello.py"
echo "lab OK — modes/modèle : voir checklists/"
EOF
chmod +x scripts/assert-lab.sh
./scripts/assert-lab.sh

Attendu : lab OK. Dans Cursor, ouvrez ce dossier, basculez Ask avec prompts/ask-readonly.md, puis Plan, puis Agent + modèle Composer 2.5 si disponible sur votre offre.

Étape 8 — Bonnes pratiques DevOps

1. Mode d’abord, modèle ensuite — Ask pour lire un chart Helm ; Agent + Composer pour le patch ; frontier pour une RFC sécu.
2. Plan sur le multi-fichiers risqué — Ingress, IAM, migrations : plan revue, puis Agent.
3. Checkpoints ≠ Git — checkpoint pour undo Agent ; commit pour revue équipe.
4. Rules + Skills — normes permanentes en Rules ; procédures en Skills (voir cursor-skills-creer).
5. Human-in-the-loop — prod, secrets, destroy : jamais auto.
6. Cloud = PR — pas de merge auto depuis un agent.
7. Mesurer — temps au vert CI, fichiers touchés, rollbacks checkpoint.

Check-list mise en pratique

• [ ] Raccourci Cmd/Ctrl+I maîtrisé
• [ ] Tableau modes collé dans le README équipe
• [ ] Skill « deploy-staging » ou équivalent versionné
• [ ] Politique : Cloud Agent → draft PR seulement
• [ ] Revue mensuelle des modèles / coûts Auto vs Composer

Quiz (3 questions)

1. En 2026, Composer désigne surtout ?
– A. Un mode Ask alternatif
– B. Un modèle Cursor (ex. Composer 2.5) dans le sélecteur
– C. Un cron cloud obligatoire

2. Quelle affirmation est vraie ?
– A. Changer de mode change automatiquement le LLM
– B. Mode = outils autorisés ; modèle = moteur — axes indépendants
– C. Ask peut terraform apply sans confirmation

3. À quoi servent les checkpoints Agent ?
– A. Remplacer Git pour la prod
– B. Snapshots locaux pour revert les fichiers modifiés par l’Agent
– C. Publier automatiquement sur npm

Réponses : 1‑B · 2‑B · 3‑B

Compléments opérationnels

Composer brille sur les refactors multi-fichiers bornés. Exigez liste blanche, DoD tests, et revue hunk. Comparez avec windsurf-cascade, continue-dev et claude-code-demarrer. Documentez le statut dans stack-ia-perso-devops-2026. Sécu : prompt injection. Hub : /ia/ · parcours.

Rules Cursor courtes > romans. Un chantier = une préoccupation. Budgétez tokens. Formez au refus.

Validez le lab Composer sur un dépôt jetable avant tout monorepo d’équipe ; chronométrez prompt→diff vert et archivez le brief dans Git.

FAQ

Agent vs ancien Composer multi-fichiers ?
Le panneau multi-fichiers a fusionné dans Agent. « Composer » aujourd’hui = surtout le modèle. Utilisez mode Agent pour éditer.

Ask suffit-il pour un audit sécu ?
Oui pour cartographier et lister risques. Pour patcher : Plan puis Agent, avec revue humaine.

Composer 2.5 ou Claude/GPT ?
Composer pour itérer vite sur le code du repo. Frontier pour raisonnement long / architecture. Auto (router) selon offre Teams/Enterprise — vérifiez la doc pricing du jour.

Cloud Agents remplacent-ils le laptop ?
Complément : jobs asynchrones, PR depuis téléphone/Slack. Le local reste idéal pour feedback UI/debug attaché.

Lien avec Skills et MCP ?
Skills = recettes ; MCP = outils externes ; Agent = orchestrateur. Voir MCP DevOps et ai-agent-workflows.

Faut-il désactiver le shell Agent ?
Sur repos sensibles, restreignez via règles d’équipe / allowlist et gardez Ask/Plan plus souvent. Ne laissez jamais un agent sans revue sur IAM / destroy.

Pour aller plus loin

• cursor.com/docs/agent/overview · Cloud Agents · Models & Pricing Cursor · Aide modes Ask / Plan / Debug
• Hub : IA parcours DevOps 2026 · Landing /ia/
• Voisins : cursor-skills-creer · ai-routines-agents · windsurf-cascade · claude-vs-cursor-vs-copilot

Maillage série IA Outils 2026 — IDE / CLI IA

← Précédent	Évaluer la qualité d’un skill
→ Suite	Windsurf Cascade
Hub	IA pour DevOps : parcours 2026
Landing	/ia/