CodeRabbit ou Greptile : quel outil de revue de code IA choisir ?

Comparer Greptile à CodeRabbit, c’est arbitrer entre deux compteurs différents à $30 par auteur. CodeRabbit convient mieux à un volume régulier de pull requests et à Azure DevOps ; Greptile prend l’avantage si la profondeur de revue paramétrable, la prise en charge de SCM de niche ou la validation T-Rex en sandbox justifient une facturation par crédits et par auteur.

CodeRabbit face à Greptile : le débit d’un côté, la profondeur de l’autre

CodeRabbit est le choix par défaut le plus rassurant pour une équipe qui veut faire relire chaque pull request courante sans acheter un bloc mensuel de crédits. Son forfait Essentials coûte $30 par développeur en paiement mensuel, n’impose aucun quota mensuel global de pull requests et s’intègre à GitHub, GitLab, Bitbucket et Azure DevOps. En contrepartie, la disponibilité des revues est calculée pour chaque développeur sur des fenêtres glissantes, puis la poursuite payante est facturée selon le nombre de fichiers examinés.

Greptile est plus pertinent lorsque la revue doit offrir plusieurs niveaux de profondeur ou produire des preuves d’exécution. Le forfait Pro coûte lui aussi $30 par auteur actif et par mois, mais chacun reçoit 50 crédits non mutualisables. Une revue Base consomme 1 crédit, Plus en consomme 3, Apex 10, tandis que la bêta T-Rex peut lancer des tests en sandbox pour 3 crédits supplémentaires, en plus du coût de la revue.

Les tarifs et limites ci-dessous ont été vérifiés sur les pages en ligne des deux éditeurs le 25 septembre 2026. Il s’agit d’un comparatif de prix et de fonctionnalités, pas d’un test pratique visant à déterminer quel outil détecte le plus de défauts. Aucun protocole contrôlé sur des pull requests n’a été fourni ni mené : le taux de détection, les faux positifs et la latence doivent donc être évalués pendant un essai.

Sources : tarifs de Greptile, facturation de Greptile, fournisseurs de code pris en charge par Greptile, forfaits de CodeRabbit, plateformes prises en charge par CodeRabbit et facturation à l’usage de CodeRabbit.

Comparatif des outils de revue de code IA : les critères décisifs

Le choix repose sur quatre questions : où sont hébergés les dépôts, qui crée les pull requests, à quelle fréquence une modification est-elle revue et faut-il de simples commentaires du modèle ou des preuves exécutables ? Les listes de fonctionnalités ne deviennent utiles qu’après avoir tranché ces contraintes.

• Choisissez CodeRabbit pour une équipe sur GitHub, GitLab, Bitbucket ou Azure DevOps qui effectue fréquemment des revues standard et peut lisser l’activité dans le quota de chaque auteur.
• Choisissez Greptile si les niveaux d’effort Base, Plus et Apex sont utiles, si la validation à l’exécution T-Rex doit faire partie de la revue, ou si Gitea, Perforce ou Cursor Origin est imposé.
• Ne vous fiez pas aux déclarations des éditeurs sur les défauts détectés. Faites analyser le même jeu de pull requests figé par les deux outils et conservez les commentaires bruts, les défauts manqués et les faux positifs.

CodeRabbit ou Greptile : la règle qui inverse le choix

Avec les premiers forfaits publics payés au mois, CodeRabbit devient plus intéressant dès qu’un auteur Greptile dépasse régulièrement 50 revues Base et que CodeRabbit peut absorber les mêmes événements dans son quota glissant. Pour cinq auteurs à charge égale, le seuil correspond à 250 revues Base dans toute l’équipe. Comme les crédits ne forment pas un pot commun, un auteur très actif peut le franchir bien plus tôt.

Greptile reprend l’avantage lorsqu’un crédit payant finance un mode de revue qu’il faudrait autrement assembler séparément. T-Rex peut générer et exécuter des tests ciblés dans une sandbox isolée, tandis que Plus et Apex permettent de concentrer davantage de ressources sur certaines modifications. C’est un choix de fonctionnalité, pas la preuve que les commentaires obtenus sont meilleurs.

Coût de la revue de pull requests : le calcul pour cinq auteurs

Avec cinq auteurs actifs et un engagement mensuel, les deux produits démarrent à $150 par mois. La facture Greptile augmente ensuite avec les crédits consommés par les revues terminées ; CodeRabbit reste au prix des sièges uniquement si les événements de chaque auteur tiennent dans la disponibilité glissante incluse.

Ce calcul suppose des revues Greptile Base, une charge répartie à parts égales entre cinq auteurs, des événements CodeRabbit étalés dans la disponibilité incluse de chacun, sans taxe, remise ni devis Enterprise. Les hypothèses Greptile proviennent de ses règles de facturation par auteur. La condition CodeRabbit vient de ses limites glissantes de revue. Ce sont des hypothèses de charge, et non des données d’utilisation d’Omid.

Dans ce scénario, le calcul Greptile est déterministe. Cinq sièges comprennent 250 crédits de revue Base. À 300 revues, les 50 crédits supplémentaires ajoutent $50. À 600, les 350 crédits supplémentaires ajoutent $350.

La colonne CodeRabbit porte volontairement la mention de base, sous condition. Un total mensuel ne dit ni quand les revues ont eu lieu, ni quelle identité d’auteur les a consommées, ni combien de fichiers ont été examinés, ni si la poursuite à l’usage était activée. Sans horodatage ni nombre de fichiers revus, le montant final de la facture CodeRabbit reste inconnu.

La principale limite de Greptile disparaît lorsqu’on ne regarde que les totaux d’équipe : les crédits ne se mutualisent pas. Si 100 revues Base sont réparties selon 96/1/1/1/1 entre cinq auteurs actifs, la facture atteint $196, et non $150. L’auteur le plus actif consomme ses 50 crédits inclus puis 46 crédits flex, tandis que les autres laissent l’essentiel de leurs quotas inutilisé.

Chez CodeRabbit, le même risque vient de la concentration des identités. La capacité de revue suit l’auteur de la PR. Si un bot ou un compte partagé d’agent de code ouvre toutes les pull requests, acheter davantage de sièges humains ne répartit pas son quota. La documentation de l’éditeur sur les limites de débit avertit qu’une seule identité peut supporter toute la charge de l’organisation pendant que les autres sièges restent inutilisés.

Prix de CodeRabbit : tarif mensuel, annuel et dépassements

CodeRabbit Essentials propose l’engagement public le moins cher si vous pouvez payer à l’année. Cinq développeurs coûtent $150 en paiement mensuel. Au tarif de $24 par développeur et par mois facturé annuellement, les cinq sièges reviennent à $1,440 pour l’année, soit $120 par mois en moyenne et $360 d’économie face à douze mensualités. Ces prix sont à jour sur la page des forfaits CodeRabbit.

La remise annuelle garantit un prix, pas un débit instantané illimité. Essentials démarre à 5 revues de PR par développeur et par heure, avec 150 fichiers par revue. La recharge adaptative peut passer de 5 revues par heure pour 0 à 29 revues récentes à 1 par heure à partir de 60 revues au cours des 7 jours précédents. Selon le réglage de l’administrateur, une revue peut attendre, s’interrompre ou continuer via la facturation à l’usage.

La poursuite à l’usage coûte $1 par crédit, à raison de 4 fichiers revus par crédit, soit $0.25 par fichier. Une revue admissible au-delà de la limite et portant sur 12 fichiers coûte donc $3. Les administrateurs peuvent choisir Automatic, On demand ou Off et définir un plafond mensuel. L’autorisation à la demande ne vaut que pour le commit en cours : tout nouveau contenu modifié exige un nouvel accord.

Les grosses pull requests rencontrent une autre barrière. Essentials comprend 150 fichiers par revue. Une pull request GitHub admissible qui dépasse cette limite sans excéder 300 fichiers peut proposer une action facturée à l’usage ; au-delà de 300 fichiers, cette option n’est plus disponible, tandis que les autres fournisseurs Git affichent uniquement le message signalant la limite de fichiers.

Team coûte $60 par développeur en paiement mensuel ou $48 avec facturation annuelle. Ce forfait ajoute Triage, des contrôles personnalisés avant merge, les finitions, des actions après merge et des limites plus élevées. Advanced coûte $90 par mois ou $72 avec facturation annuelle et ajoute des fonctions liées à l’impact architectural et à la sécurité. Ne montez pas en gamme pour une vague promesse de qualité : ne le faites que si l’un de ces contrôles précis figure dans les critères d’achat.

Un détail de trésorerie compte lorsque l’équipe évolue : sur un abonnement mensuel, un siège CodeRabbit marqué pour désattribution reste actif et facturé jusqu’à la fin du cycle. Il peut être réattribué, mais son coût ne disparaît pas en cours de mois.

Crédits Greptile : un quota qui ne se mutualise pas

Greptile facture les revues terminées selon l’auteur de la PR, et non selon le dépôt ou la personne qui a lancé la commande. Un auteur devient actif dès qu’au moins une revue terminée lui est imputée pendant la période de facturation. Son siège coûte alors $30 et comprend 50 crédits.

La consommation dépend du niveau d’effort :

• Base coûte 1 crédit. C’est la revue standard qui tient compte du contexte de l’ensemble du code.
• Plus coûte 3 crédits. Ce niveau consacre davantage de ressources à une analyse plus approfondie.
• Apex coûte 10 crédits. Il vise les changements volumineux ou complexes.
• Auto coûte 1, 3 ou 10 crédits. Greptile choisit le niveau d’après la modification et facture celui qui a été exécuté.

Le coût marginal commence lorsque l’auteur atteint individuellement 50 crédits. Chaque crédit supplémentaire coûte $1. Avec cinq auteurs chargés à parts égales, 250 revues Base tiennent dans les quotas inclus. Dans une équipe déséquilibrée, les premiers frais flex peuvent apparaître alors que le total cumulé reste très inférieur à 250.

L’unité facturée est la revue terminée, et non la PR unique. Un déclenchement manuel peut occasionner un débit, tout comme les événements configurés à l’ouverture d’une PR, lors d’un push ou après un rebase. Une revue ignorée par Greptile n’est pas comptabilisée.

L’attribution dans le CLI modifie également la facture. Un utilisateur connecté et associé partage le siège et les crédits de la personne concernée. Une revue lancée depuis le CLI sans attribution, ou au moyen d’une clé API non liée, est facturée en usage flex sans créer de siège de développeur actif. Dans un workflow agentique, associer l’identité d’exécution relève donc de la configuration des coûts, pas d’une simple tâche administrative.

Greptile permet à l’organisation de plafonner l’usage flex. Dès que la dépense prévisionnelle atteint ce plafond, les revues qui généreraient un usage flex sont ignorées jusqu’à la période de facturation suivante ou jusqu’au relèvement du plafond. Les auteurs qui disposent encore de crédits inclus peuvent continuer. La page publique propose des tarifs annuels et pluriannuels personnalisés : pour cinq auteurs, l’engagement annuel reste donc inconnu tant que Greptile n’a pas établi de devis.

La prise en charge des plateformes peut trancher avant la qualité des revues

CodeRabbit couvre mieux les plateformes généralistes grâce à Azure DevOps ; Greptile se distingue sur les gestionnaires de code source de niche avec Gitea, Perforce et Cursor Origin. Tous deux prennent en charge les incontournables GitHub.com, GitLab.com et Bitbucket Cloud.

La matrice des fournisseurs de code de Greptile inclut GitHub Cloud, GitLab.com, Bitbucket Cloud et la bêta Cursor Origin dans tous les forfaits. Ses options Enterprise ajoutent GitHub Enterprise Server, GitHub Enterprise Cloud avec résidence des données, GitLab Self-Managed, Bitbucket Data Center et Gitea. Perforce avec P4 Code Review passe par un déploiement on-premises. Azure DevOps ne figure pas dans cette matrice.

La présentation des plateformes de CodeRabbit mentionne GitHub.com, GitHub Enterprise Server, GitLab.com, GitLab Self-Managed, Bitbucket Cloud, Bitbucket Data Center et Azure DevOps. Elle ne répertorie ni Gitea, ni Perforce, ni Cursor Origin. L’auto-hébergement est réservé au forfait Enterprise, et la page indique qu’il s’adresse aux clients Enterprise disposant de 500 sièges utilisateurs ou plus.

Une plateforme « non mentionnée » doit bloquer l’achat, sans pour autant être considérée comme définitivement incompatible sur le plan technique. Exigez une confirmation écrite de l’éditeur avant de signer. Si le choix de l’hébergeur de dépôts n’est pas encore arrêté, commencez par sélectionner ce système de référence à l’aide du comparatif des plateformes d’hébergement de code IA pour les équipes d’agents, puis achetez l’outil de revue qui le prend en charge.

Meilleure profondeur de revue : Greptile

Greptile remporte le comparatif fonctionnel lorsque la profondeur est une variable contrôlable plutôt qu’un adjectif marketing. Les niveaux Base, Plus et Apex permettent de choisir directement l’effort consacré à une modification. Des règles peuvent renforcer cet effort selon une branche, un chemin de fichier, un label ou l’ampleur d’un changement, tandis qu’Auto sélectionne l’un de ces mêmes niveaux facturés.

L’approche repose sur le contexte de tout le dépôt. Greptile indique construire un graphe des fonctions, classes, imports et dépendances, puis s’en servir pour suivre les effets au-delà des lignes modifiées. Le produit peut ainsi convenir aux contrats et appelants répartis dans une vaste base de code. Cela ne démontre pas qu’il détecte plus de défauts que CodeRabbit sur votre code.

T-Rex rend la différence plus concrète. La bêta peut écrire des tests ciblés, exécuter le code modifié dans un environnement isolé et joindre à un commentaire de revue des preuves d’exécution, comme des logs ou des traces. Un constat étayé par un test en échec n’est pas le même livrable qu’un soupçon statique formulé par un modèle.

La limite, c’est le coût. T-Rex ajoute 3 crédits au niveau d’effort exécuté. Auto peut aussi sélectionner une revue plus chère que Base. Si l’équipe généralise ces modes sans plafond par auteur, le prix d’entrée de $30 cesse vite de refléter la facture.

Meilleur débit pour les revues standard : CodeRabbit

CodeRabbit l’emporte lorsqu’il faut assurer une première revue régulière sur un grand nombre de pull requests ordinaires. Essentials n’impose aucun quota mensuel global de PR : dans le calcul à cinq auteurs, le socle reste donc à $150 tant que l’activité tient dans la disponibilité glissante de chacun. Une fois les 50 crédits d’un auteur Greptile épuisés, CodeRabbit devient plus avantageux que chaque nouvelle revue Base facturée $1.

Les workflows s’enrichissent à mesure que l’on monte en gamme. Essentials comprend autofix, les docstrings, les connexions MCP, la prise en charge des linters et du SAST, ainsi qu’un dépôt lié pour l’analyse entre plusieurs dépôts. Team ajoute Triage, des contrôles personnalisés avant merge, la génération de tests unitaires, la résolution des conflits de merge et des actions après merge. Advanced ajoute la revue de sécurité continue des PR et des fonctions d’analyse de l’impact architectural.

La limite concerne les pics d’activité. Ouvrir une pull request, pousser un nouvel état, demander une revue manuelle, effectuer un rebase, rouvrir une PR ou faire passer un brouillon à l’état prêt peut chaque fois créer un événement de revue. Un nouveau push peut remplacer une revue encore en cours ; la revue précédente abandonnée aura malgré tout consommé un événement. Regrouper les commits locaux dans un seul push est donc un levier de capacité et de facturation.

L’identité utilisée par l’automatisation constitue le second point de blocage. Chez CodeRabbit, la disponibilité incluse appartient à l’identité du développeur qui a créé la PR. Un bot partagé peut ainsi ramener toute une organisation dotée de plusieurs sièges à un seul quota. Lorsque le workflow le permet, attribuez les pull requests générées par un agent au développeur responsable ; sinon, prévoyez la poursuite facturée au fichier pour l’automatisation volontairement intensive.

Les revues répétées et la validation à l’exécution changent la facture

Sur les deux plateformes, une « revue » ne correspond pas à une pull request. Une PR analysée à son ouverture puis de nouveau après un push a généré deux événements facturables ou décomptés de la capacité, même si l’équipe ne voit toujours qu’une seule PR.

Pour des revues Greptile Base menées par cinq auteurs à charge égale, deux passages par PR donnent les coûts mensuels suivants :

• 100 PR deviennent 200 revues terminées et restent à $150.
• 300 PR deviennent 600 revues terminées et coûtent $500.
• 600 PR deviennent 1,200 revues terminées et coûtent $1,100.

CodeRabbit compte lui aussi la revue à l’ouverture puis celle du push comme deux événements distincts, mais leur coût ne peut pas être calculé à partir de ces seuls totaux. S’ils tiennent dans le quota glissant, les cinq sièges restent à $150. S’ils se poursuivent via la facturation à l’usage, le montant dépend du nombre de fichiers examinés dans les événements hors limite. Il faut connaître l’horodatage des événements et le nombre de fichiers pour obtenir un chiffre précis.

La validation à l’exécution creuse encore l’écart. Une revue Greptile Base avec T-Rex consomme 4 crédits. Avec la même hypothèse de cinq auteurs à charge égale :

• 100 revues Base avec T-Rex coûtent $300.
• 300 coûtent $1,100.
• 600 coûtent $2,300.

La documentation publique de CodeRabbit sur les revues ne présente pas d’option comparable à la validation à l’exécution T-Rex avec un prix unitaire équivalent. CodeRabbit Agent est un produit distinct, disponible à la demande pour $0.40 par minute d’agent, mais ces minutes ne correspondent pas à une validation à l’exécution au sein d’une revue de PR. Sans tâche définie ni durée mesurée, le coût équivalent reste inconnu.

Voilà pourquoi le budget d’une équipe de cinq auteurs doit comptabiliser les événements de revue, les niveaux d’effort et les passages répétés, et non le nombre de pull requests mergées. Le registre des événements constitue le véritable modèle de facturation.

Testez les deux outils avant de vous fier à leurs revues

Seul un jeu figé de pull requests synthétiques permet de transformer honnêtement ce comparatif fonctionnel en décision sur la qualité. Utilisez des modifications dont les défauts attendus sont connus, ajoutez des cas témoins sans erreur et conservez toutes les sorties brutes. Ne reprenez pas les classements de benchmarks des éditeurs comme s’ils mesuraient vos langages, votre architecture ou votre politique de revue.

1. 1

   Figez les pull requests

   Créez un jeu versionné de modifications synthétiques représentatives : une rupture de contrat entre plusieurs fichiers, une validation manquante, un chemin sensible pour la sécurité, une régression de performances, un refactoring propre et un changement qui ne devrait susciter aucun commentaire.

2. 2

   Alignez la configuration

   Donnez aux deux outils les mêmes dépôts, la même intention dans les règles, les mêmes chemins ignorés et le même déclencheur de revue. Consignez chaque réglage. Si Greptile utilise Plus, Apex ou T-Rex, indiquez-le avec le coût en crédits au lieu de comparer le résultat à une configuration par défaut non chiffrée.

3. 3

   Conservez les sorties brutes

   Sauvegardez l’intégralité des commentaires, résumés, horodatages et paramètres. Une conclusion dépourvue du reçu brut de la revue ne pourra plus être auditée lorsque l’un des éditeurs modifiera ses modèles ou ses réglages par défaut.

4. 4

   Évaluez ce qui déclenche une action humaine

   Relevez les défauts injectés détectés ou manqués, les faux positifs, les commentaires en double, les constats jugés valables par la personne chargée de la revue, la latence et le temps de configuration. Distinguez les niveaux de gravité : dix remarques cosmétiques ne doivent pas peser davantage qu’une faille d’autorisation manquée.

5. 5

   Appliquez la politique de merge

   Les commentaires de l’IA restent consultatifs. Utilisez la politique de revue du code généré par IA pour laisser à une personne nommément désignée la responsabilité du merge et soumettre les changements sensibles à des contrôles déterministes ainsi qu’à une validation humaine.

6. 6

   Recalculez le prix des événements observés

   Réinjectez dans le calcul l’auteur, le déclencheur, le niveau d’effort et le nombre de fichiers examinés pendant l’essai. Achetez selon la charge constatée, pas selon le prix d’appel.

Changer d’outil coûte plus cher que réinstaller un bot

Ne changez de produit que si le nouveau résout une contrainte précise et mesurable. Supprimer une application puis en installer une autre est la partie la plus simple de la migration.

Les règles de revue doivent être transposées. Les exclusions de chemins, préférences de gravité, consignes propres au dépôt, politiques d’effort, contrôles personnalisés et déclencheurs automatiques ne se correspondent pas champ par champ. L’historique d’apprentissage et les retours des reviewers peuvent rester chez l’ancien éditeur. Les modèles de pull request, commandes du bot, contrôles de statut et règles de branche peuvent également faire référence à l’intégration en place.

L’attribution de la facturation mérite son propre contrôle de migration. Greptile impute les coûts à l’auteur de la PR et sépare les crédits. CodeRabbit associe les sièges et la capacité de revue aux identités des développeurs. Une équipe qui transfère un workflow de PR créées par des agents sans cartographier ces identités risque de modifier dès le premier jour sa capacité de revue et ses coûts.

La méthode la plus sûre consiste à faire fonctionner les deux outils en parallèle pendant un mois sur des dépôts représentatifs. Cinq sièges payants dans chaque produit coûtent $300 avant les crédits flex Greptile ou les frais d’usage CodeRabbit. Cette dépense reste inférieure au coût d’une migration généralisée suivie de la découverte d’un fournisseur Git, d’un contrôle de revue ou d’un type de preuve absent du nouvel outil.

Qui ne devrait pas changer :

• Une équipe Azure DevOps ne devrait pas migrer vers Greptile avant d’avoir obtenu une confirmation écrite de la prise en charge ; Azure DevOps ne figure pas dans la liste documentée des fournisseurs Greptile.
• Une équipe Greptile qui utilise T-Rex, Gitea ou Perforce ne devrait pas migrer avant que CodeRabbit ait démontré l’équivalent requis ; ces éléments sont absents de la liste documentée des plateformes CodeRabbit ou de son modèle tarifaire public pour les revues.
• Une équipe CodeRabbit dont les revues standard restent dans le quota inclus ne devrait pas migrer pour une simple promesse de contexte plus profond. Il faut prouver que le constat supplémentaire de Greptile change une décision de merge.
• Une équipe Greptile qui reste sous le quota inclus de chaque auteur ne devrait pas migrer pour le seul prix. La facture mensuelle d’entrée est identique.

L’action du lundi : mesurer une semaine avant d’acheter

La semaine prochaine, mesurez la charge avant de lancer l’un ou l’autre essai. Exportez les identités des auteurs de PR, les pushes qui déclenchent une revue, les commandes manuelles de revue, le nombre de fichiers examinés, les hébergeurs des dépôts et les changements qui exigent réellement une validation à l’exécution.

Prenez ensuite la décision dans cet ordre :

• Éliminez tout produit qui ne documente pas l’hébergeur Git requis.
• Calculez le coût par auteur, et pas seulement la moyenne de l’équipe.
• Séparez la revue standard, la revue approfondie et la validation à l’exécution en lignes de charge distinctes.
• Exécutez l’essai figé et conservez les sorties brutes.
• Choisissez l’outil dont les constats exploitables rentabilisent le compteur sans affaiblir la responsabilité humaine du merge.

Cette séquence empêche le prix d’appel de $30 de masquer un déséquilibre de crédits, une limite lors des pics ou une plateforme non prise en charge.

Questions fréquentes

Quelle différence de prix entre Greptile et CodeRabbit ?

Les deux premiers forfaits publics coûtent $30 par auteur avec un paiement mensuel. Greptile Pro comprend 50 crédits non mutualisables par auteur actif, puis facture chaque crédit supplémentaire $1. CodeRabbit Essentials n’impose aucun quota mensuel global de PR, mais la poursuite admissible au-delà des limites glissantes coûte $0.25 par fichier examiné. CodeRabbit publie également un tarif annuel de $24 par développeur ; le prix annuel de Greptile nécessite un devis.

Greptile ou CodeRabbit : lequel choisir pour la revue de code ?

CodeRabbit constitue le meilleur choix par défaut pour un volume régulier de revues standard et pour Azure DevOps. Greptile convient mieux lorsque les niveaux d’effort, la validation à l’exécution T-Rex, le contexte sous forme de graphe de toute la base de code, Gitea, Perforce ou Cursor Origin font partie des critères d’achat. Pour juger la qualité sur votre code, il faut toujours un essai figé.

Ce comparatif Greptile vs CodeRabbit repose-t-il sur un test pratique ?

Non. Il vérifie les tarifs actuels des éditeurs, leurs unités de facturation et les plateformes prises en charge, puis les normalise dans un calcul pour cinq auteurs. Il fournit un protocole d’essai figé, car aucun test contrôlé de comptes, résultat de taux de détection, mesure de faux positifs ou relevé de latence n’a été fourni.