Utilisation de Jira pour l'ingénierie agentique

L'ingénierie agentique s'appuie sur Jira. À mesure que le métier d'ingénieur évolue, passant de l'écriture de code à la gestion d'agents IA, les tâches essentielles changent elles aussi. Les développeurs ne consacrent déjà qu'environ 16 % de leur temps à l'écriture de code, et à mesure que les agents prennent en charge une part croissante du développement, le plus gros du travail réside dans tout ce qui entoure cette activité : donner un contexte aux agents, les coordonner, vérifier leurs sorties et les encadrer.

C'est la tâche que Jira a toujours gérée, et qui est désormais étendue aux agents. Jira et le Teamwork Graph en sont le système de référence, le socle indispensable qui transforme l'activité de l'IA en véritables gains de productivité à mesure que les équipes évoluent.

Ce guide explique comment Jira prend en charge l'ingénierie agentique, comment il s'intègre à vos autres outils et comment vous lancer. En bref, Jira offre trois éléments qu'un agent de codage seul ne peut pas proposer :

• Fournit aux agents le bon contexte pour qu'ils agissent avec précision

• Délègue les tickets de routine à des flux automatisés respectant les autorisations

• Conserve un historique traçable dans le Teamwork Graph

Qu'est-ce que l'ingénierie agentique ?

L'ingénierie agentique consiste à développer des logiciels en pilotant des agents IA qui planifient et exécutent des tâches en plusieurs étapes, tandis que vous définissez l'objectif et évaluez le résultat, plutôt que d'écrire vous-même chaque ligne de code.

Cela modifie l'orientation de vos efforts : de l'écriture de code à la conception du système dans lequel les agents travaillent. Vous définissez ce qu'il faut réaliser, vous donnez du contexte aux agents, vous les guidez dans leur travail et vous déterminez si leur sortie est à la hauteur. Lorsque la fonction de saisie semi-automatique basée sur l'IA suggère la ligne suivante, un seul agent peut mener à bien l'ensemble du processus, depuis la description du résultat jusqu'à la création d'une pull request. L'ingénierie agentique constitue la couche supérieure : elle consiste à orchestrer un grand nombre d'agents à grande échelle, à coordonner leur travail et à contrôler ce qui est déployé.

Cela fait de l'ingénierie agentique une discipline de coordination et de jugement, et pas seulement de codage. Dès lors que les agents se chargent du codage ou de l'exécution de tâches, leurs droits d'accès, leurs actions et leurs sorties doivent rester dans les limites des contrôles auxquels votre équipe fait déjà confiance. Les questions que cela soulève relèvent davantage de la gestion des tâches que du codage, c'est pourquoi ce système s'appuie sur un système de suivi comme Jira.

Jira est-il conçu pour l'ingénierie agentique ?

Jira est conçu pour le développement logiciel natif pour l'IA, c'est-à-dire la pratique consistant à planifier, orchestrer et faire évoluer le travail entre différents agents IA. Lorsque l'on demande si Jira « prend en charge » l'ingénierie agentique, la véritable question est de savoir s'il peut constituer la couche sur laquelle le travail des agents s'ancre dans son contexte et où ce travail est coordonné, vérifié et piloté. C'est exactement ce que fait Jira, contrairement à un agent de codage utilisé seul.

Un agent de codage écrit la modification, mais il ne peut pas décider de ce qui doit être développé, déterminer si le résultat répond à vos exigences, ni évaluer comment ce travail s'intègre au reste du projet en cours. Ce sont là des décisions qui relèvent de la gestion des tâches et du fonctionnement de l'équipe : un agent de codage installé sur l'ordinateur d'une seule personne ne fonctionne que pour cette personne, tandis qu'une équipe composée de plusieurs membres et d'agents nécessite une coordination commune, une visibilité partagée et une seule source de référence. C'est Jira qui gère cette couche : il héberge le plan, attribue les tâches au bon agent, permet à un utilisateur de contrôler ce qui est livré et consigne ce qui s'est passé sous forme de contexte persistant qui sert de base aux travaux futurs. Cela se fait au fur et à mesure que le travail avance dans Jira, et ne constitue pas des étapes supplémentaires que le développeur doit effectuer.

Qu'apporte Jira de plus qu'un simple agent de codage ?

Même si l'on donne à un agent de codage un cahier des charges concret, celui-ci peut tout de même s'en écarter. Il oublie ses décisions, refait ce qu'il a déjà fait et se heurte à sa fenêtre contextuelle. Le fait de conserver le plan dans un fichier Markdown ne résout pas le problème, pas plus qu'un meilleur agent. La solution consiste en un système qui conserve les spécifications et l'état en dehors de la mémoire de l'agent. Cet effet s'amplifie à l'échelle d'une équipe, c'est pourquoi l'ingénierie agentique relève en réalité d'un choix de système de référence, et non d'un choix d'outil de codage. Les fonctionnalités ci-dessous découlent du fait que Jira est ce système lui-même.

Les connecteurs alimentent le Teamwork Graph avec les données de votre chaîne d'outils. MCP met cette mémoire organisationnelle à la disposition de toutes les IA que vos équipes utilisent déjà.

• Un système de référence unique pour les tâches effectuées par les humains et les agents. Au fur et à mesure qu'un agent travaille, il lit et écrit dans le Teamwork Graph, mettant à jour chaque décision et chaque enregistrement liés à la tâche, de sorte qu'aucun élément de contexte ne soit perdu dans une session locale.

• La gouvernance hérite de vos contrôles d'entreprise existants. L'accès des agents s'inscrit dans le modèle d'autorisation auquel les entreprises font déjà confiance ; ces contrôles s'appliquent donc automatiquement au travail des agents, sans constituer un nouvel élément à gérer.

• N'importe quel agent, n'importe quel modèle, une seule surface. Attribuez des tickets à Claude, Cursor, Codex, GitHub Copilot ou à l'agent de codage Jira natif, et orchestrez-les depuis un seul endroit. Comme les agents travaillent dans vos workflows existants, votre processus reste le même lorsque les agents changent. Un agent de codage unique vous lie à un seul fournisseur ; Jira est indépendant de tout agent.

• Une ingénierie du contexte couvrant l'ensemble du stack, et pas seulement le ticket. Le Teamwork Graph permet aux agents de s'ancrer dans les tickets, les décisions et l'historique à travers Jira, Confluence, le code et les outils où le travail est réellement discuté, comme Slack et Teams. Ils agissent ainsi en fonction d'une intention réelle, et non d'un prompt vide. C'est ce qui fait de Jira la couche contextuelle qui entoure l'agent.

• Vous disposez ainsi d'un plan de contrôle unique pour le travail des agents.Un agent de codage s'exécute dans sa propre session, déconnecté du plan et des autres tâches de l'équipe. Jira ajoute cette couche pour déterminer les tâches attribuées aux agents, leur fournir le contexte approprié et relier chaque session de codage au travail qu'elle produit, sans alourdir la journée du développeur. Alors que le système d'enregistrement capture ce qui s'est passé, le plan de contrôle vous permet de diriger et de coordonner le travail des agents en arrière-plan.

La place de Jira dans le cycle de vie du développement logiciel natif de l'IA

Jira prend en charge le travail des agents à travers quatre étapes : la planification, l'orchestration, la revue et l'évolutivité. Vous planifiez le travail sous forme de tickets prêts à être exécutés par les agents, vous orchestrez les agents pour qu'ils les réalisent, vous passez en revue et testez ce qu'ils produisent, puis vous déployez ces modèles à l'échelle de l'organisation en respectant la gouvernance et les autorisations nécessaires pour garantir leur sécurité. Voici ce que fait Jira à chaque étape.

Planifier : comment préparer une tâche pour qu'elle soit prête à être traitée par un agent ?

Transformez vos plans et votre documentation en suggestions de tickets en un clic, puis examinez-les et ajustez-les selon vos besoins avant de les valider.

La planification consiste à transformer une intention en tâche prête à être traitée par un agent : des spécifications concrètes avec des exigences et des critères d'acceptation clairs, ainsi que le contexte dont l'agent a besoin avant de commencer.

• Réceptionnez la tâche là où elle prend naissance : les demandes proviennent de partout : un fil de discussion Slack, une page Confluence, un enregistrement Loom, une réunion. Mentionnez @Jira ou utilisez Rovo pour les transformer directement en tickets. La réception ne se limite pas à éviter de retaper les informations : elle transforme une demande vague, même celle qui a commencé par une conversation, en un ticket accompagné du contexte issu du Teamwork Graph, qui indique comment il s'intègre au travail de l'équipe.

• Fournissez à l'agent des spécifications clairement définies, et pas seulement un prompt : dans le développement piloté par les spécifications, celles-ci constituent le point d'ancrage : l'agent travaille sur le ticket à partir des spécifications, et non à partir d'un prompt ponctuel qui disparaîtra après la session. Ces spécifications fonctionnent parallèlement à la base de code, aux normes de l'équipe et à l'historique du projet, de sorte que l'agent dispose du contexte nécessaire pour rédiger un code conforme aux normes de votre équipe. Jira Planner rédige un premier jet de spécifications à l'aide du Teamwork Graph, de votre base de code et de l'historique Confluence ; vous l'affinez ensuite et y ajoutez des critères d'acceptation, de sorte que ces spécifications deviennent la base sur laquelle l'agent s'appuie pour développer le code et la référence sur laquelle celui-ci est évalué.

• Donnez aux agents un contexte qui s'enrichit au fil du temps : le contexte est la véritable contrainte qui influe sur la qualité du travail des agents. Jira s'appuie sur le Teamwork Graph pour ancrer les agents dans les objectifs, les décisions et l'historique de l'ensemble de vos outils, et pas seulement dans le ticket. Ce système fonctionne avec n'importe quel agent MCP, et ce contexte s'enrichit : plus le volume de travail traité par le système est important, plus les agents disposent de ressources sur lesquelles s'appuyer, et plus les résultats gagnent en pertinence.

Orchestrer : comment assigner et diriger le travail des agents ?

Assignez des tâches à vos agents, y compris l'agent de codage natif de Jira, depuis un seul endroit.

Assignez les tâches à l'agent le plus à même de les réaliser, puis dirigez et supervisez ce que font ces agents, le tout depuis l'endroit où votre équipe suit déjà son travail.

• Assignez des tâches à n'importe quel agent, depuis un seul et même endroit : assignez un ticket à Claude, Cursor, Codex, GitHub Copilot ou à l'agent de codage natif de Jira, puis consultez les actions qu'il a effectuées et les décisions qu'il a prises lors des sessions Web, IDE et terminal, afin de détecter rapidement tout écart et de le corriger sans interrompre le flux de travail.

• Utilisez les agents là où vous travaillez déjà : orchestrez les opérations via les interfaces utilisées par votre équipe : mentionnez @Jira dans Slack pour créer un ticket et lancer une boucle de correction, connectez Cursor, Claude Desktop ou n'importe quel client MCP au contexte Jira, ou accordez aux agents un accès CLI/terminal pour passer du contexte à l'action.

• Automatisez les tâches routinières : déclenchez un agent à partir d'une règle d'automatisation ou d'une transition de workflow (ou ajoutez un agent à une colonne de tableau) afin qu'il prenne automatiquement en charge le travail lorsque l'état change, et qu'il renvoie la sortie via le même workflow. Les tâches routinières et répétitives constituent le meilleur point de départ.

• L'activité de l'agent reste visible, liée au travail : au fur et à mesure que l'agent travaille, son activité et la pull request qu'il ouvre restent associées au ticket ; ainsi, la progression est visible là où se trouve le travail, au lieu d'être enfouie dans un outil distinct. Vous voyez ce que chaque agent a pris en charge, ce qu'il a produit et ce qui est en attente de revue, le tout au même endroit.

Passer en revue : comment valider la sortie d'un agent ?

La vérification des résultats produits par les agents doit inclure une étape de validation humaine.

La sortie d'un agent peut sembler aboutie tout en étant erronée ; elle ne doit donc pas être livrée tant qu'elle n'a pas été passée en revue, testée et validée par une personne.

• Tests et validation : la sortie d'un agent doit tout de même passer les contrôles habituels. Ces contrôles s'exécutent dans votre pipeline de CI, et leur état s'affiche sur le ticket afin qu'une étape de revue puisse bloquer la transition à l'état terminé jusqu'à ce que le travail soit vérifié. Vous pouvez automatiser une partie de ce processus : un agent effectue des contrôles sur sa propre sortie et continue à itérer jusqu'à ce qu'ils soient validés, avant de passer le relais à un humain.

• Revue avec intervention humaine, intégrée à votre workflow : exigez une revue menée par un humain : la sortie s'affiche sur le ticket et ne peut passer à l'état Terminé tant qu'elle n'a pas été approuvée par quelqu'un. La pull request et son état de revue s'affichent dans le panneau de développement du ticket, ce qui permet d'effectuer la revue là où elle est suivie.

• Fusionnez et consignez ce qui a été livré : Une fois la revue validée, le changement est fusionné et le ticket passe à l'état Terminé. La fusion et le déploiement s'effectuent dans vos outils connectés ; Jira en conserve la trace.

Évolutivité : comment gérer les agents en toute sécurité au sein des différentes équipes au fil du temps ?

Un system of work unique favorise la réussite de la mise à l'échelle dans toute l'organisation.

L'évolutivité du travail des agents constitue un changement au niveau de l'organisation. Le défi ne réside pas tant dans le fait qu'un développeur donné exécute davantage d'agents, mais plutôt dans le maintien d'un niveau constant de qualité, de confiance et de visibilité à mesure que le travail des agents se répartit entre les équipes.

• Déléguez les tâches routinières : les agents traitent les tâches récurrentes et avec un périmètre bien défini en arrière-plan ; les pull requests apparaissent lorsqu'elles sont prêtes, et vous gardez le contrôle grâce à des autorisations partagées et des normes de sécurité.

• Itérez : l'ingénierie agentique est une boucle, pas un processus linéaire : les résultats alimentent les spécifications suivantes, et le travail réintègre le cycle de vie. C'est dans Jira que ce feedback est collecté afin d'affiner les travaux futurs.

• Gouvernez et auditez : les garde-fous sont intégrés au workflow, et non dans un document de politique, et chaque action laisse une trace auditable sur le ticket, régulée par les autorisations propres à Jira.

• Mesurez l'impact : suivez la manière dont l'IA transforme le mode de livraison de votre équipe, à l'aide de données de livraison, telles que la durée de cycle et le débit de pull requests, afin de mesurer les résultats plutôt que l'activité et d'investir là où c'est important.

Comment Jira s'intègre-t-il au reste de votre stack d'IA ?

Jira ne remplace pas vos agents de codage, votre IDE, ni les modèles que vous exécutez. Il s'agit d'une couche de coordination et d'enregistrement qui les relie entre eux, afin que le travail reste visible et contrôlé, quels que soient les outils utilisés pour le développement. Cette couche est indispensable à grande échelle ; sans système d'enregistrement partagé, le travail des agents se disperse entre les différents outils et la productivité ne peut pas s'exprimer pleinement.

Comment se lancer dans l'ingénierie agentique dans Jira

Consultez les actions que vos agents ont effectuées et les décisions qu'ils ont prises. Passez en revue l'historique complet de la session, détectez les dérives au plus tôt et corrigez-les si nécessaire.

Vous n'avez pas besoin d'un déploiement complet pour vous lancer. Le moyen le plus rapide d'obtenir un premier résultat concret consiste à connecter un agent de codage, à lui assigner une petite tâche et à passer en revue la pull request qu'il ouvre, le tout à partir d'un seul ticket.

1. Choisissez une tâche routinière au périmètre bien délimité. Un test instable, une mise à jour de dépendance ou une petite correction de bug constituent le point de départ le plus sûr.

2. Enregistrez-la sous forme de ticket. Transformez une page Confluence, un fil de discussion Slack ou un prompt court en un ticket accompagné d'un résumé et d'une description.

3. Assignez le ticket à un agent. Connectez votre dépôt Git, puis assignez le ticket à l'agent de codage Jira à partir du panneau Agents.

4. Passez en revue la pull request.L'agent ouvre une pull request associée au ticket, ce qui vous permet de la passer en revue au même endroit où vous l'avez planifiée.

5. Automatisez vos tâches. Après votre première exécution, identifiez les tâches que vous effectuez de façon répétitive et transformez-les en règles d'automatisation. Ces travaux récurrents constituent le point de départ le plus rentable et le moins risqué.

Envie de prendre de l'avance ? Effectuez une seule configuration, et le modèle d'ingénierie agentique met en place un espace prêt à l'emploi pour les agents, avec les workflows, les états et les étapes que ces derniers doivent suivre, afin que vous puissiez partir d'un cycle opérationnel plutôt que d'un projet vierge. Vous exécutez déjà des workflows agentiques dans un espace qui fonctionne bien ? Les clients disposant d'une offre payante peuvent l'enregistrer en tant que modèle personnalisé afin que votre équipe puisse créer de nouveaux espaces intégrant les mêmes agents et le même workflow.

Questions fréquentes sur l'ingénierie agentique

Que fait un ingénieur spécialisé dans le domaine agentique ?

Un ingénieur agentique définit les objectifs, le contexte et les garde-fous qui guident les agents IA tout au long d'une tâche comportant plusieurs étapes, puis examine et approuve les résultats. Un système d'enregistrement comme Jira en assure la coordination et la traçabilité.

Quelle est la différence entre l'ingénierie de prompt et l'ingénierie agentique ?

L'ingénierie de prompt élabore une instruction unique pour obtenir une bonne réponse du modèle, tandis que l'ingénierie agentique coordonne les agents qui planifient, agissent et itèrent sur l'ensemble d'une tâche. L'unité de travail passe du prompt à l'objectif.

Qu'apporte Jira de plus qu'un simple agent de codage ?

Un agent de codage écrit du code, mais Jira est l'endroit où le ticket est défini, priorisé, orchestré, vérifié et gouverné en tant que système d'enregistrement unique. Il coordonne n'importe quel agent tout en conservant une piste d'audit liée à chaque ticket.

Comment les agents IA récupèrent-ils le contexte depuis Jira ?

Les agents extraient le contexte du ticket lui-même (exigences et critères d'acceptation) et du Teamwork Graph, qui relie les tâches, les documents et le code connexes. Ils peuvent ainsi réfléchir avant d'agir, et pas seulement en fonction du prompt.

Avez-vous toujours besoin de Jira si l'IA écrit le code ?

Oui, et on pourrait même dire sans doute encore plus : à mesure que les agents produisent davantage de code plus rapidement, la difficulté se déplace vers la coordination, la révision et la gouvernance de ce travail. Jira est la plateforme de gestion qui permet de garantir la visibilité et la traçabilité des résultats fournis par les agents, tout en les reliant aux tickets qui leur ont été confiés.