Claude Code MCP Tasks : tâches en arrière-plan et Elicitation

Pour utiliser MCP Tasks dans Claude Code, choisissez un serveur MCP compatible avec Tasks, puis appelez son outil depuis la conversation principale du CLI dans le terminal, en v2.1.304 ou version ultérieure. Le serveur prend en charge l’opération, Claude poursuit son travail et le résultat lui parvient une fois l’exécution terminée. Vérifiez les conditions d’éligibilité avant de modifier votre serveur : le passage automatique d’un appel ordinaire en arrière-plan après deux minutes repose sur un mécanisme différent.

Au 2026-10-24, la documentation de Claude Code présente MCP Tasks comme une bêta publique. Ce guide couvre la révision actuelle du protocole, 2026-07-28, et les conditions qui déterminent si votre appel peut utiliser Tasks.

À quoi servent Tasks et Elicitation ?

Utilisez Tasks pour les opérations longues que le serveur peut accepter et suivre de façon autonome : compilations, exécutions de tests, exports ou recherches. Utilisez Elicitation lorsque le serveur a besoin d’une décision ou d’une information manquante de votre part avant de continuer.

Trois comportements peuvent sembler similaires :

Mécanisme	Comportement	Ce que le serveur doit implémenter
Appel MCP ordinaire	Claude attend le résultat de l’outil.	Une implémentation classique de l’outil.
Passage automatique en arrière-plan	Un appel de la conversation principale encore en cours après deux minutes passe en arrière-plan. Son résultat arrive plus tard, mais cet appel ne survit pas à la fermeture de la session.	Aucune prise en charge de Tasks n’est nécessaire.
MCP Task	Le serveur renvoie un descripteur de tâche lorsqu’il accepte l’opération. Claude Code suit ce descripteur et récupère le résultat. Les opérations exécutées sur un serveur distant peuvent continuer après la fermeture du CLI.	L’extension Tasks et une gestion persistante des tâches.

Elicitation est une capacité distincte. Un outil de rapport peut demander quel environnement interroger, puis exécuter l’export sous forme de Task. Un outil rapide peut demander la même précision sans créer de Task.

Elicitation existait déjà avant ce déploiement : la version v2.1.76 de Claude Code a introduit les boîtes de dialogue correspondantes et les hooks Elicitation et ElicitationResult. La nouveauté traitée ici concerne les Tasks gérées par le serveur.

Vérifier si votre appel peut devenir une MCP Task

Toutes les conditions de la liste officielle des prérequis doivent être remplies. Installer un CLI plus récent ne satisfait que la première ligne.

Vérification	Condition requise
Version de Claude Code	`v2.1.304` ou version ultérieure.
Implémentation du serveur	Le serveur prend en charge l’extension Tasks. Une connexion MCP ne suffit pas à établir cette compatibilité.
Transport et protocole	Un serveur HTTP, stdio ou connecteur claude.ai, connecté avec la révision `2026-07-28` du protocole.
Réglages imposant l’ancien protocole	Ni `MCP_SDK_GENERATION=v1` ni `MCP_PROTOCOL_NEGOTIATION=legacy` ne doit forcer l’utilisation de l’ancien protocole.
Disponibilité de la fonctionnalité	La session récupère les indicateurs de fonctionnalités, ou feature flags, et Anthropic active Tasks pour ce type de session.
Interface prise en charge	CLI dans le terminal, Agent SDK ou GitHub Actions. L’extension VS Code et l’application de bureau ne prennent pas actuellement en charge MCP Tasks.
Origine de l’appel	L’appel provient de la conversation principale. Les appels effectués par des sous-agents ne deviennent pas des MCP Tasks.
Mode d’entrée	Une session interactive, ou une session Agent SDK ou à entrée en flux répondant aux conditions ci-dessous.

Pour une exécution non interactive, une session Agent SDK ou une commande claude -p utilisant --input-format stream-json exige également :

CLAUDE_AUTO_BACKGROUND_TASKS=1
CLAUDE_CODE_DISABLE_MCP_TASK_BACKGROUND ne doit pas être défini sur 1
CLAUDE_CODE_MCP_AUTO_BACKGROUND_MS ne doit pas être défini sur 0

Gardez le flux d’entrée ouvert : après sa fermeture, l’exécution n’attend pas les MCP Tasks. Une invocation ponctuelle claude -p "..." ne bénéficie pas de Tasks. La prise en charge de GitHub Actions ne dispense pas de respecter ces conditions relatives au mode d’entrée.

La référence des variables d’environnement recense plusieurs réglages qui empêchent la récupération des indicateurs :

DISABLE_GROWTHBOOK=1 ou true
DO_NOT_TRACK=1
Toute valeur non vide pour DISABLE_TELEMETRY
Toute valeur non vide pour CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC

Pour les deux dernières variables, même 0 ou false désactive le comportement concerné. Les sessions habituelles utilisant un fournisseur tiers, notamment Amazon Bedrock, ne récupèrent pas non plus ces indicateurs ; la référence documente une exception pour les intégrations gérées par l’application hôte.

Inspectez l’environnement de lancement et les paramètres effectivement appliqués. Les fichiers usuels sont ~/.claude/settings.json, .claude/settings.json et .claude/settings.local.json, auxquels peuvent s’ajouter des paramètres administrés. La référence des paramètres explique leurs portées respectives.

Supprimer un réglage imposant l’ancien protocole ne rend pas un serveur compatible avec une révision qu’il ne prend pas en charge. De même, la compatibilité API d’une passerelle ne prouve pas que la session peut récupérer les indicateurs de fonctionnalités. Si votre déploiement doit conserver un réglage bloquant, utilisez des appels d’outils ordinaires.

Dans une session interactive, CLAUDE_CODE_MCP_AUTO_BACKGROUND_MS=0 fait attendre Claude. CLAUDE_CODE_DISABLE_MCP_TASK_BACKGROUND=1 le fait également attendre les Tasks, même si le mécanisme ordinaire de passage automatique en arrière-plan peut ensuite déplacer un appel long. À lui seul, CLAUDE_CODE_DISABLE_BACKGROUND_TASKS=1 ne force pas les MCP Tasks à rester au premier plan.

Lancer une opération et vérifier le résultat

Commencez par un serveur authentifié dont la documentation ou l’implémentation confirme la prise en charge de Tasks, puis essayez une opération non destructive. Dans Bash, vérifiez l’installation et les serveurs configurés avant d’ouvrir le CLI interactif :

claude --version
claude mcp list
claude

Si votre installation prend en charge la mise à jour intégrée et se situe sous la version minimale, exécutez claude update, puis vérifiez de nouveau. Ces commandes sont décrites dans la référence du CLI.

Dans Claude Code, utilisez /mcp pour confirmer la connexion du serveur et effectuer l’authentification nécessaire. Si un outil d’exécution de tests est connecté, vous pouvez demander :

Exécute la suite de tests de ce dépôt avec son outil MCP depuis la conversation principale. Pendant son exécution, explique l’organisation des tests à partir du README. Une fois l’opération terminée, présente le résultat et les éventuels échecs.

Vérifiez le comportement à deux niveaux :

Dans Claude Code : cherchez le compteur de tâches MCP et consultez /tasks. Une entrée dans /tasks ne suffit pas à elle seule, car les appels ordinaires exécutés en arrière-plan y figurent aussi.
Dans la trace du serveur : confirmez que tools/call a renvoyé resultType: "task" et que les requêtes tasks/get suivantes utilisent le même taskId.

Une fois l’opération terminée, Claude Code reçoit le résultat ; demandez à Claude de le présenter. S’il est inactif, il peut reprendre automatiquement à partir de ce résultat. Si l’appel reste ordinaire, inspectez les capacités déclarées dans la requête réelle et la liste des prérequis avant de réécrire l’outil.

Côté serveur : renvoyer un descripteur et fournir le résultat

Implémentez l’extension Tasks actuelle au lieu de reprendre un ancien exemple expérimental. Les changements de MCP 2026-07-28 ont remplacé tasks/result par des interrogations périodiques via tasks/get, ajouté tasks/update et supprimé tasks/list.

Ne renvoyer une tâche que si la requête l’autorise

Vérifiez la capacité déclarée dans chaque requête, à cet emplacement :

params._meta["io.modelcontextprotocol/clientCapabilities"].extensions["io.modelcontextprotocol/tasks"]

Sa valeur est {}. Votre serveur annonce l’extension correspondante sous capabilities.extensions dans sa réponse à server/discover. La présentation de l’extension Tasks documente ces deux emplacements.

Lorsque le client déclare cette capacité, le serveur décide si l’opération concernée doit devenir une Task. En l’absence de cette capacité, renvoyez si possible un résultat ordinaire. Si l’opération exige Tasks, l’extension prévoit l’erreur de capacité manquante -32021 ; ne renvoyez pas de descripteur de tâche à un appelant incompatible.

Enregistrez durablement la tâche avant de répondre, afin que son identifiant soit déjà accessible via tasks/get. Il doit rester utilisable d’une connexion à l’autre. Vérifiez l’authentification et les droits d’accès à la tâche lors des requêtes suivantes.

Cette réponse JSON-RPC illustre l’acceptation d’une compilation. Son identifiant, ses horodatages et son résultat ultérieur sont des exemples, pas une trace d’exécution :

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "resultType": "task",
    "taskId": "6f17bfa2-4c5e-4d21-b563-2f7e83a902bc",
    "status": "working",
    "createdAt": "2026-10-24T08:00:00Z",
    "lastUpdatedAt": "2026-10-24T08:00:00Z",
    "ttlMs": 3600000,
    "pollIntervalMs": 5000
  }
}

Les champs de la tâche se trouvent directement dans le result JSON-RPC. Il n’y a pas d’objet task supplémentaire, et le descripteur initial n’a pas besoin de tableau content.

Champ	Exigence
`resultType`	`"task"` pour la réponse initiale contenant la tâche.
`taskId`	Obligatoire, généré par le serveur et difficile à deviner. Claude Code le limite en outre à 128 caractères ASCII imprimables, sans espaces.
`status`	Obligatoire : `working`, `input_required`, `completed`, `failed` ou `cancelled`.
`createdAt`, `lastUpdatedAt`	Chaînes d’horodatage ISO 8601 obligatoires.
`ttlMs`	Obligatoire : un entier en millisecondes à compter de la création, ou `null` pour une conservation sans limite. Ce n’est pas une estimation de la durée d’exécution.
`pollIntervalMs`	Intervalle d’interrogation facultatif, exprimé par un entier en millisecondes ; n’envoyez pas `null`.
`statusMessage`	Texte facultatif décrivant la progression ou l’état.

Le schéma publié de l’extension définit cette structure. Les validations propres à Claude sont décrites dans la référence destinée aux auteurs de serveurs.

Si Claude signale Unsupported result type 'task' for tools/call, vérifiez d’abord que la requête reçue contenait l’extension, puis qu’aucun des champs taskId, status, createdAt, lastUpdatedAt ou ttlMs ne manque. Une valeur de status non prise en charge provoque la même erreur. Un identifiant de tâche invalide provoque, lui, une erreur signalant un descripteur de tâche mal formé.

Fournir le résultat final de l’outil via `tasks/get`

Répondez à chaque interrogation avec l’état actuel de la tâche. Une réponse réussie à tasks/get utilise resultType: "complete" même lorsque le status de l’opération reste working : c’est la requête d’interrogation qui est terminée, pas nécessairement l’opération.

Pour la compilation de l’exemple précédent, la réponse une fois l’opération terminée est :

{
  "jsonrpc": "2.0",
  "id": 2,
  "result": {
    "resultType": "complete",
    "taskId": "6f17bfa2-4c5e-4d21-b563-2f7e83a902bc",
    "status": "completed",
    "createdAt": "2026-10-24T08:00:00Z",
    "lastUpdatedAt": "2026-10-24T08:03:00Z",
    "ttlMs": 3600000,
    "result": {
      "resultType": "complete",
      "content": [
        {
          "type": "text",
          "text": "Build completed successfully."
        }
      ]
    }
  }
}

Le result imbriqué contient le résultat normal de l’outil. Une erreur au niveau de l’outil, signalée par isError: true, appartient toujours à une tâche completed ; failed est réservé à une erreur d’exécution JSON-RPC portée par error.

Implémentez également tasks/cancel, en gardant à l’esprit que l’annulation est coopérative. La spécification de l’extension ne garantit pas qu’elle arrête le travail déjà engagé. Claude Code récupère actuellement les résultats par interrogation périodique ; ne comptez donc pas sur notifications/tasks pour lui transmettre le résultat.

Utiliser Elicitation pour les décisions que l’outil ne peut pas prendre

Demandez l’environnement, la destination ou l’autorisation manquante avant d’effectuer l’action qui en dépend. Le mode formulaire d’Elicitation recueille des champs structurés ; le mode URL propose un parcours dans le navigateur, par exemple pour se connecter à un service externe.

Pendant une Task, exposez une question via tasks/get avec status: "input_required" et une table inputRequests. Chaque entrée possède une clé unique et contient le method demandé, par exemple elicitation/create, ainsi que ses params. Claude Code transmet la réponse via tasks/update, avec les clés correspondantes dans inputResponses.

Dans le CLI interactif, fermez /tasks si la question est masquée derrière cette vue. Refuser ou appuyer sur Esc répond à la demande d’Elicitation ; c’est le serveur qui décide si son opération continue.

Lorsqu’une Task demande une saisie utilisateur dans une session non interactive, Claude Code demande au serveur de l’annuler sans exécuter les hooks Elicitation ni le callback onElicitation de l’Agent SDK. Fournissez les choix nécessaires avant de lancer une exécution sans intervention humaine, ou utilisez une session interactive. Cette restriction concerne spécifiquement les demandes de saisie effectuées par les MCP Tasks.

Auditez aussi les hooks avant de considérer une réponse à Elicitation comme une approbation humaine. La référence des hooks précise que :

Elicitation peut répondre automatiquement et supprimer l’affichage de la boîte de dialogue.
ElicitationResult peut modifier la réponse de l’utilisateur, y compris remplacer un refus par une acceptation si le hook est mal écrit.
ElicitationResult ne s’exécute pas lorsqu’un hook Elicitation a déjà répondu.

Examinez les hooks effectivement appliqués depuis les configurations utilisateur, projet, locale, administrée et des plugins. Se limiter au fichier de paramètres du dépôt peut laisser passer le hook qui fournit la réponse.

Que deviennent les tâches après un arrêt, une fermeture ou une reprise ?

Arrêtez explicitement une Task distante si vous souhaitez demander son annulation ; fermer le CLI ne le fait pas. Le cycle de vie documenté distingue l’exécution sur le serveur du suivi assuré par Claude Code.

Action	Résultat et suite à donner
Sélectionner la Task dans `/tasks` et appuyer sur `x`, ou demander à Claude de l’arrêter	Claude Code cesse de la suivre et demande son annulation. Le serveur peut néanmoins la mener à terme.
Appuyer sur `Esc` pendant une interaction ordinaire	Cela n’arrête pas une Task en arrière-plan.
Quitter pendant l’exécution d’une Task distante	L’opération continue sur le serveur. Reprenez sa session d’origine pour la suivre de nouveau.
Quitter avec une Task stdio en cours	Le processus du serveur local s’arrête. Ne supposez pas que son travail survit, sauf si le serveur prend explicitement en charge une exécution indépendante de ce processus.
Utiliser `/clear`, `/branch` ou changer de session avec `/resume` en laissant Claude Code ouvert	Le résultat peut arriver dans la conversation actuelle. Après avoir quitté, reprenez la session dans laquelle la Task a été lancée.
Reprendre la session d’origine en mode interactif	Le suivi reprend après la reconnexion du serveur, à condition qu’il connaisse encore la Task. Conservez le nom du serveur et ses paramètres de connexion.
Démarrer une nouvelle session ou utiliser `--fork-session`	La nouvelle session n’hérite pas du suivi de la Task.
Reprendre avec une invocation ponctuelle de `claude -p`	Cette exécution ne suit pas la Task ; utilisez une reprise interactive ou une entrée en flux remplissant les conditions requises.

Si le serveur est déconnecté, reconnectez-le via /mcp avant d’arrêter la Task. Sinon, aucune demande d’annulation ne lui parvient et Claude Code oublie la Task.

Utilisez claude --resume pour sélectionner la conversation d’origine. La politique de conservation du serveur reste déterminante : reprendre une conversation ne permet pas de récupérer un résultat que le serveur a supprimé.

Un prompt pour auditer votre configuration MCP

Commencez par un audit en lecture seule pour identifier la plus petite modification utile avant de toucher aux serveurs ou aux paramètres. Ce prompt adapte la suggestion d’audit MCP de @Voxyz_ai, en ajoutant des vérifications sur le format de réponse actuel et le comportement des sessions à entrée en flux.

Goal: Audit my Claude Code MCP setup for Tasks and Elicitation.

Read the current official documentation:
https://code.claude.com/docs/en/mcp
https://code.claude.com/docs/en/env-vars
https://code.claude.com/docs/en/hooks
https://modelcontextprotocol.io/extensions/tasks/overview

Scope: Inspect connected MCP servers, their configuration, effective settings, and any MCP server implementation in this repository. Say explicitly if no server implementation is present. Keep credential values out of the report.

Check:
1. Long-running tools: identify builds, test runs, exports, or research that could benefit from Tasks. For my server code, recommend the smallest change to return a valid task handle, persist it across connections, and deliver the final result through tasks/get. For third-party servers, cite evidence for the deployed version's support; otherwise mark support unknown.
2. Eligibility: check the CLI version, transport, actual protocol revision, per-request Tasks capability, feature-flag fetching, provider, supported surface, main conversation versus subagents, and input mode. Include MCP_SDK_GENERATION, MCP_PROTOCOL_NEGOTIATION, privacy/flag-fetching variables, CLAUDE_AUTO_BACKGROUND_TASKS, CLAUDE_CODE_DISABLE_MCP_TASK_BACKGROUND, and CLAUDE_CODE_MCP_AUTO_BACKGROUND_MS. Distinguish one-shot claude -p from stream-json input.
3. Elicitation: find tools that guess missing parameters or perform irreversible actions without obtaining the necessary decision. Inspect Elicitation and ElicitationResult hooks for automatic acceptance or changes to a user's refusal, including hooks outside this repository.
4. Lifecycle: check cancellation, remote versus stdio execution, retention, and resume. Identify unattended Tasks that might request user input.

Output: For each finding, name the tool or setting, cite the evidence, describe current behavior, recommend the smallest change, and give one verification step. Mark conditions you cannot observe as unknown.

Do not edit files, change settings, or invoke operational jobs during this audit. Show recommendations first.