Jules Gratuit

-
Développeur Google
Site officiel https://jules.google/

Jules est un agent de codage indépendant asynchrone lancé par Google. Basé sur le modèle de la série Gemini, il effectue des tâches telles que la réparation du code, le supplément de test, la mise à niveau des dépendances et la reconstruction dans la machine virtuelle cloud, et crée enfin automatiquement un PR pour soumettre les modifications. Prend en charge trois méthodes d'accès : interface utilisateur Web, CLI et API REST, et fournit des solutions de quota de tâches Free/Pro/Ultra à trois niveaux.

Jules Interface du produit

Jules

Paramètres et statistiques de base

Jules est un agent de codage autonome asynchrone lancé par Google. Basé sur le modèle de la série Gemini, il automatise la planification, l'exécution et la soumission de tâches de code dans les machines virtuelles cloud. Il ne s'agit pas d'un "assistant de programmation IA de type chat", mais d'un agent de codage "sans intervention" - les développeurs peuvent partir après avoir soumis la description de la tâche, et Jules termine les modifications du code, les tests et la création des relations publiques en arrière-plan.

Projets Informations publiques
Positionnement officiel Un agent de codage autonome — des tâches de codage que vous ne voulez pas effectuer
Modèle sous-jacent Gemini 2.5 Pro → 3 Flash → 3 Pro → 3.1 Pro (mise à niveau continue)
Calcul contextuel Machine virtuelle cloud (disque de 20 Go, Node/Python/Rust/Bun et autres environnements d'exécution préinstallés)
Méthodes d'intégration Interface utilisateur Web, CLI (npm), API REST (Alpha), application GitHub
Niveaux de tarification Gratuit (15 tâches/jour 3 simultanées), Pro (100 tâches/jour 15 simultanées), Ultra (300 tâches/jour 60 simultanées)
Conditions d'accès Compte Google + autorisation d'entrepôt GitHub
Plateformes prises en charge Web, API, bureau (CLI)
Accueil États-Unis
Langage de développement Basé sur Google Cloud + Gemini, l'entrée frontale se trouve sur jules.google

Forme du produit : La principale différence entre Jules et les outils de « complétion en temps réel » tels que Cursor et GitHub Copilot est « l'exécution asynchrone ». Les développeurs n'ont qu'à décrire la tâche dans l'interface utilisateur Web ou la CLI, et Jules terminera indépendamment l'ensemble du processus de clonage de l'entrepôt → installation des dépendances → élaboration d'un plan → modification du code → exécution de tests → création d'un PR dans la VM cloud. Pendant cette période, le développeur peut partir pour effectuer d'autres travaux. Une fois terminé, les résultats seront informés via les notifications du navigateur ou GitHub PR.

Structure des quotas de tâches : la version gratuite comporte 15 tâches et 3 simultanéités par jour, ce qui convient à une évaluation personnelle ; la version Pro (s'appuyant sur l'abonnement Google AI Pro) est portée à 100 tâches/15 simultanéités ; la version Ultra (Google AI Ultra) peut contenir jusqu'à 300 tâches/60 simultanéités. Tous les niveaux sont calculés sur une fenêtre glissante de 24 heures, après quoi les nouvelles tâches sont bloquées jusqu'à ce que le quota soit réinitialisé.

Reconnaissance des utilisateurs et du marché

Jules est officiellement lancé par Google et s'appuie sur les modèles Google Cloud et Gemini. La confiance dans sa marque est naturellement supérieure à celle des projets entrepreneuriaux indépendants. Il n’a fallu que 3 mois entre la version bêta et la sortie officielle pour accumuler plus de 140 000 soumissions publiques (en août 2025), ce qui indique que les premiers utilisateurs sont très actifs.

Communauté et Écologie : Le public de Jules est principalement la communauté des développeurs GitHub. Le référentiel officiel Jules Awesome Prompts (github.com/google-labs-code/jules-awesome-list) est fourni à la communauté pour partager des cas d'utilisation. Le canal Discord est le principal canal de commentaires des utilisateurs. Étant donné que le produit ne fonctionne pas entièrement sur Google Cloud, il n'existe pas d'écosystème d'expansion auto-construit de la communauté open source. Son expansion écologique repose principalement sur l'intégration du serveur MCP et les capacités API officiellement lancées par Google.

Conditions d'atterrissage pour les entreprises : le forfait payant actuel ne prend en charge que les comptes Google personnels @gmail.com, et les comptes d'entreprise Google Workspace ne prennent pas encore en charge le chemin de mise à niveau. Cela signifie que les équipes d'entreprise ne peuvent actuellement pas unifier les achats et le règlement, et ne peuvent collaborer qu'une fois que les membres de l'équipe se sont abonnés à chacun. Google a ouvert le formulaire d'enregistrement de la demande d'entreprise, mais il n'y a pas de moment précis pour son lancement. Pour les équipes qui ont besoin de fonctionnalités d'entreprise telles que le SSO, les journaux d'audit, la résidence des données, etc., l'étape actuelle ne convient qu'aux pilotes individuels ou en petites équipes et ne convient pas en tant qu'infrastructure de codage standard à l'échelle de l'entreprise.

Avantage de coût

La structure de coûts de Jules est différente des plug-ins IDE traditionnels ou des abonnements SaaS et doit être évaluée sous trois angles : individuel, équipe et entreprise.

Développeur côté C/individuel

Planifier Quota de tâches quotidiennes Limite de concurrence Modèle Coût mensuel (estimation)
Gratuit 15 tâches/jour 3 Gémeaux 2.5 Pro 0 $
Pro (y compris Google AI Pro) 100 tâches/jour 15 Gemini 3.1 Pro (par défaut) Prix ​​de l'abonnement Google AI Pro
Ultra (y compris Google AI Ultra) 300 tâches/jour 60 Gemini 3.1 Pro (prioritaire) Prix ​​de l'abonnement Google AI Ultra
  • Développeur individuel : le plan gratuit comporte 15 tâches par jour, ce qui est suffisant pour couvrir les corrections de bogues personnelles, la refactorisation à petite échelle et les ajouts de tests. Calculé sur la base de 5 à 15 minutes de temps de travail manuel par tâche, cela équivaut à économiser 1 à 3 heures de travail de codage mécanique chaque jour. Le plan Pro/Ultra convient aux committers à haute fréquence ou aux développeurs qui gèrent plusieurs référentiels.
  • Coût caché : la consommation des tâches de Jules n'est pas équivalente à "chaque question" - une exigence complexe peut consommer plusieurs tâches (planifier → exécuter → corriger → réessayer), et le nombre réel de tâches disponibles peut être inférieur à celui prévu. Il est recommandé d'enregistrer la répartition réelle de la consommation des tâches dans le pilote.

API / Intégration Développeur

L'API Jules REST est actuellement en phase Alpha. Les clés API sont générées via la page des paramètres de l'interface utilisateur Web. Chaque compte peut avoir jusqu'à 3 clés. Les quotas de tâches pour les appels d'API sont partagés entre les plans d'abonnement, sans tarification d'API autonome. Cela signifie :

  • Les appels API ne coûtent pas plus cher, mais consomment des crédits de tâches quotidiennes Free/Pro/Ultra.
  • La session de création d'API approuve automatiquement le plan par défaut ; si une révision manuelle est requise, définissez « requirePlanApproval : true ».
  • L'API actuelle n'est pas adaptée aux scénarios d'intégration CI/CD à haut débit (les quotas de tâches limitent naturellement la fréquence des appels).

Déploiement en entreprise/en équipe

Actuellement l'activité de Jules en est à ses débuts :

  • Aucune prise en charge de Workspace : le paiement est uniquement disponible sur @gmail.com, et les comptes d'entreprise ne peuvent pas être achetés et gérés de manière uniforme.
  • Pas de SSO/Audit : aucune prise en charge SAML, SCIM ou journal d'audit n'est exposée.
  • Résidence des données : le code est traité dans Google Cloud VM, l'accord de traitement des données est soumis aux conditions d'utilisation de Google, aucune condition de traitement de données indépendante ni option de liaison régionale n'est divulguée.
  • Collaboration en équipe : collaborez indirectement via un référentiel GitHub partagé au lieu d'un espace de travail d'équipe. L'attribution de l'auteur de la soumission prend en charge les modes « Jules uniquement », « Co-écrit » et « Utilisateur uniquement ».

Suggestion d'achat : L'étape actuelle est plus adaptée aux développeurs individuels ou aux petites équipes pour essayer Pro/Ultra à leurs propres frais afin d'évaluer l'effet ; les achats au niveau de l'entreprise doivent attendre que la solution de support Workspace soit mise en ligne avant de procéder à une évaluation formelle.

Fonctions principales

Les capacités de Jules sont conçues autour du « codage autonome asynchrone », et les fonctions principales peuvent être résumées dans les six catégories suivantes :

  • Réparation de code et localisation des bogues : Jules peut lire les rapports de bogues dans les problèmes GitHub, les commentaires PR ou les descriptions en langage naturel, localiser les problèmes dans la VM cloud, rédiger des correctifs, ajouter des tests et soumettre des PR. Prise en charge du déclenchement automatique des tâches à partir des problèmes GitHub en ajoutant la balise « Jules ».
  • Mise à niveau des dépendances et migration de version : Pour les changements de version des gestionnaires de packages tels que npm, pip, cargo, etc., Jules peut effectuer automatiquement des opérations telles que l'adaptation de l'API de mise à jour de version et la migration des fichiers de configuration. Les scénarios typiques incluent la migration de la structure de répertoires depuis Next.js v10 → v15.
  • Supplément de test et correctif CI : Jules peut identifier les parties du code qui manquent de couverture de test et écrire automatiquement des cas de test. La fonction CI Fixer peut détecter automatiquement les builds échouées des actions GitHub, analyser les journaux, envoyer des correctifs et soumettre à nouveau les PR, ce qui entraîne un cycle « correction → soumission → réexécution ».
  • Refactoring du code et optimisation de l'architecture : prend en charge le nettoyage des dettes techniques avec des limites claires, telles que la refactorisation des classes en machines à états, le fractionnement des fonctions trop volumineuses et l'extraction de modules communs. Critic Agent agit comme un réviseur de code intégré, effectuant des examens contradictoires avant chaque modification, marquant les failles potentielles et les cas extrêmes manqués.
  • Tâches planifiées et actives : les tâches planifiées prennent en charge la maintenance répétitive définie sur une base hebdomadaire/quotidienne (telles que les contrôles de dépendance hebdomadaires, les réparations quotidiennes de charpie) et sont automatiquement exécutées après une configuration. Les tâches suggérées analysent de manière proactive le référentiel à la recherche de commentaires TODO et d'opportunités d'optimisation des performances, affichant des recommandations dans le tableau de bord.
  • Intégration du serveur MCP : En se connectant au serveur MCP (le premier lot prend en charge Linear, Stitch, Neon, Tinybird, Context7, Supabase), Jules peut automatiquement appeler les données et les outils de services externes pendant le processus de codage, comme extraire le contexte Issue de Linear et interroger le schéma de Supabase.

Avis d'expert : La vraie valeur de Jules ne réside pas dans la force d'une seule fonction, mais dans le lien complet "description du besoin → formulation du plan → modification du code → vérification des tests → soumission du PR". Comparé à l'achèvement en temps réel de Copilot ou à l'édition conversationnelle de Cursor, le mode asynchrone de Jules est plus adapté aux scénarios où « vous savez ce que vous voulez changer, mais vous ne voulez pas le faire vous-même ». L'effet synergique de CI Fixer et de Scheduled Tasks est particulièrement évident : ils font passer l'agent de codage de la « réponse passive » à la « maintenance active », un domaine que les outils de programmation d'IA traditionnels n'ont pas encore couvert.

Evolution du modèle et de la version

Jules a maintenu une fréquence d'itération très élevée depuis sa sortie bêta en mai 2025, avec des mises à jour de fonctionnalités importantes chaque mois. Ce qui suit est une chronologie des étapes clés.

Période de lancement et de version bêta (2025-05 ~ 2025-07)

  • 2025-05-19 : Jules Beta est publié, fournissant des fonctionnalités de base pour l'intégration de GitHub, les correctifs de code, les mises à jour de version et la création de relations publiques.
  • 2025-05-30 : limite de tâches mise à jour à 60 tâches/jour 5 simultanées ; taux de défaillance réduit de 2/3.
  • 2025-06-06 : améliorations de l'interface utilisateur (code de copie/téléchargement, panneau de code réglable, boîte modale de tâches).
  • 2025-06-18 : mise à niveau du contexte de base, préinstallée avec la dernière version de Rust/Node/Python et prenant en charge le runtime Bun.
  • 2025-06-20 : mise à niveau de l'agent - prend en charge le fichier de commande d'entrepôt AGENTS.md, réduisant considérablement le taux d'abandon.
  • 2025-06-26 : Intégration des problèmes GitHub - l'ajout de la balise jules déclenche automatiquement les tâches.

Sortie officielle et tarifs en ligne (2025-08)

  • 2025-08-04 : Prise en charge de la création de relations publiques directement à partir de l'interface utilisateur.
  • 2025-08-05 : Avec la fonction d'instantané de contexte, la vitesse de démarrage des projets complexes est grandement améliorée.
  • 06/08/2025 : Publié officiellement (hors version bêta), un total de plus de 140 000 soumissions publiques ; a lancé une tarification à trois niveaux Free/Pro/Ultra. Le modèle par défaut est mis à niveau vers Gemini 2.5 (mode réflexion).
  • 2025-08-07 : Vérification de capture d'écran de l'application Web - Jules peut restituer la page frontale et renvoyer des captures d'écran.
  • 2025-08-08 : Agent Critique (revue de résistance au code), Plan Interactif (formulation de plan interactif), Recherche Web (recherche active de réseau).

API et CLI ouvertes (2025-09 ~ 2025-10)

  • 2025-09-02 : exemple de mots d'invite sur la page d'accueil.
  • 2025-09-03 : Améliorations des critiques - affichage en temps réel du processus de réflexion des critiques.
  • 2025-09-04 : vue de comparaison verticale Stacked Diff.
  • 2025-09-09 : Prise en charge du téléchargement d'images (JPEG/PNG, <5 Mo, uniquement lors de la création d'une tâche).
  • 2025-09-23 : Réponse automatique aux commentaires PR - Jules lit les commentaires et pousse les modifications.
  • 2025-09-29 : Sélecteur de fichiers - identifiez la plage de fichiers de tâches.
  • 2025-09-30 : Fonctionnalité de mémoire - préférences d'entrepôt de mémoire inter-tâches.
  • 2025-10-01 : Prise en charge des variables limitées.
  • 02/10/2025 : Jules Tools CLI est publié - npm install -g @google/jules.
  • 03/10/2025 : Version alpha de l'API REST Jules.

Mise à niveau intergénérationnelle de Gemini 3 (2025-11 ~ 2026-01)

  • 2025-11-10 : mise à jour CLI - correctif d'installation de la tâche parallèle PyPI, vue Diff de comparaison latérale.
  • 2025-11-19 : Gemini 3 Pro est en ligne - Mémoires agentiques de raisonnement plus clair et vérification visuelle.
  • 2025-11-20 : mode Repoless - pas besoin de sélectionner un référentiel pour commencer le codage.
  • 2025-12-10 : tâches planifiées, tâches suggérées, intégration de rendu.
  • 2026-01-26 : Critique de planification (deuxième examen prévu de l'agent, taux d'échec réduit de 9,5 %), suggestions d'optimisation des performances Modification/pause/reprise des tâches planifiées.
  • 30/01/2026 : Gemini 3 Flash devient le modèle de base (remplaçant le 2.5 Pro), considérablement amélioré en termes de vitesse et de capacités.

MCP et intégration profonde (2026-02 ~ présent)

  • 02/02/2026 : Prise en charge du serveur MCP - le premier lot de Linear, Stitch, Neon, Tinybird, Context7, Supabase intégrés.
  • 2026-02-19 : CI Fixer (répare automatiquement les pannes de CI) + Commit Authoring (trois modes de signature).
  • 09/03/2026 : Gemini 3.1 Pro devient le modèle par défaut du package Pro, améliorant encore la capacité à résoudre des problèmes complexes.

Avantages techniques

Les avantages techniques de Jules proviennent de l’accumulation de Google à trois niveaux : inférence de grand modèle, infrastructure cloud et chaîne d’outils de développement, plutôt que d’une simple encapsulation des performances d’un modèle unique.

Génération de modèle leader : le modèle sous-jacent de Jules a été mis à niveau de Gemini 2.5 Pro en phase bêta vers Gemini 3 Flash (modèle de base) en janvier 2026, puis Gemini 3.1 Pro sera disponible pour les utilisateurs Pro en mars 2026, en maintenant un rythme de mise à niveau du modèle de version majeure d'environ 3 à 4 mois. Chaque mise à niveau du modèle se reflète directement dans le taux de réussite des tâches, la qualité de l'inférence et la vitesse d'exécution, et les utilisateurs peuvent en bénéficier sans commutation manuelle.

Exécution isolée dans le cloud : contrairement aux plug-ins IDE traditionnels qui s'exécutent localement, chaque tâche de Jules est exécutée dans une VM Google Cloud indépendante, avec Node.js, Python, Rust, Bun et d'autres environnements d'exécution et outils de test du navigateur Playwright préinstallés. Cette conception apporte trois avantages clés :

  • Isolement de sécurité : la portée des opérations de l'agent est limitée à la VM, et même si du code malveillant est généré, il n'affectera pas l'hôte.
  • Cohérence contextuelle : le contexte d'exécution des tâches est maintenu uniformément par Google pour éviter le problème de compatibilité de "peut s'exécuter sur ma machine".
  • Observabilité : Chaque étape de la tâche (plan → modification → test → résultat) est enregistrée sous forme d'activité et peut être interrogée via API, formant une piste d'audit infalsifiable.

Mécanisme d'examen à double couche Critic Agent + Planning Critic : Jules a intégré deux nœuds d'examen dans le processus de génération de code : Planning Critic mène des questions contradictoires au cours de la phase de planification (réduisant le taux d'échec de 9,5 %) et Critic Agent examine la sécurité, l'efficacité et les cas extrêmes ligne par ligne pendant la phase de modification du code. Ce mécanisme à deux niveaux consistant à « examiner d'abord le plan, puis à examiner le code » est une conception de pointe parmi les outils de codage d'IA, qui réduit directement le fardeau de l'examen manuel.

Boîte à outils de gestion de contexte : Jules contrôle l'intégrité et l'exactitude du contexte du code via plusieurs mécanismes : le fichier de directives d'entrepôt AGENTS.md permet aux développeurs de prédéfinir les conventions de projet, le sélecteur de fichiers identifie la portée de la tâche, le script de variable contextuelle fournit la configuration d'exécution et la fonction Mémoire maintient la cohérence des préférences entre les tâches. Ensemble, ces fonctionnalités réduisent le risque que les agents se perdent dans leur contexte lorsqu'ils travaillent sur des projets de grande envergure.

Liste ouverte des outils (surface de l'outil)

En tant qu'agent de codage, Jules n'expose pas directement l'ensemble des outils d'automatisation du navigateur, mais fournit aux développeurs une surface de contrôle programmable via les interfaces suivantes :

Outils/Interfaces Fonctions Méthodes d'appel
API sources Liste des référentiels GitHub connectés REST GET /v1alpha/sources
API sessions Créer/interroger/gérer des tâches de codage REST POST/GET /v1alpha/sessions
API approvePlan Approuver le plan d'exécution formulé par l'Agent REST POST /v1alpha/sessions/{id}:approvePlan
API sendMessage Envoyer des commandes à une session en cours d'exécution REST POST /v1alpha/sessions/{id}:sendMessage
API activités Interroger les enregistrements d'audit au niveau des étapes d'une tâche REST GET /v1alpha/sessions/{id}/activities
CLI à distance nouveau Créer une nouvelle tâche depuis le terminal jules distant nouveau --repo <dépôt> --session "<invite>"
CLI extraction à distance Extrayez les résultats des tâches terminées Jules Remote Pull --session <id>
CLI liste distante Afficher le référentiel ou la liste des sessions jules liste distante --repo / --session
Étiquette GitHub Déclenchez des tâches via des étiquettes de problème Ajouter l'étiquette « Jules » aux problèmes GitHub
Serveurs MCP Appeler des services externes pendant l'encodage Déclenché automatiquement après la configuration de la clé API sur la page des paramètres

Lien architectural

Développeur ──→ Web UI / CLI / REST API ──→ Jules Orchestration layer ──→ Gemini LLM
                                                           │
                                                           ▼
                                          Cloud VM (clone Git → installer les dépendances → modifier le code → exécuter le test → soumettre)
                                                           │
                                              ┌────────────┼─────────────┐
                                              ▼ ▼ ▼
                                          Recherche sur le Web des serveurs MCP GitHub Repo
                                                       (Linéaire, (Documentation/extrait de code
                                                        Supabase, recherche)
                                                        Néon, etc.)

Le flux de contrôle s'effectue de haut en bas : les développeurs soumettent des descriptions de tâches via n'importe quelle interface → La couche d'orchestration Jules appelle le plan de génération de modèle Gemini → exécute les modifications de code dans Cloud VM → les résultats sont renvoyés vers GitHub PR.

Guide des pièges d'ingénierie

  1. Gestion du quota de tâches : Le quota quotidien de la version gratuite n'est que de 15 tâches, et les exigences complexes peuvent consommer 3 à 5 tâches (Planifier → Exécuter → Réparer → Réessayer). Il est recommandé d'utiliser le paramètre --parallel pour estimer la consommation moyenne d'une seule tâche avant de décider de mettre à niveau le package. Une fois le quota dépassé, les nouvelles tâches sont bloquées mais les tâches existantes ne sont pas affectées.

  2. Contrôle contextuel du grand référentiel : pour les référentiels contenant des milliers de fichiers, Jules peut manquer des fichiers critiques en raison des limitations de la fenêtre contextuelle. Les solutions incluent la définition claire de la structure du projet et des emplacements de fichiers clés via le fichier AGENTS.md, l'utilisation de sélecteurs de fichiers pour limiter la portée des tâches (plutôt que de laisser l'agent explorer librement) et le préchargement des données de test via des scripts de variables contextuelles pour éviter les échecs d'exécution.

  3. Gestion de la sécurité et des opérations irréversibles : Jules dispose des autorisations complètes de lecture et d'écriture sur l'entrepôt de la VM. Les sessions créées par l'API en mode par défaut approuveront automatiquement le plan et l'exécuteront. Pour les entrepôts de grande valeur, « requirePlanApproval : true » doit être défini pour forcer la révision manuelle de chaque étape du plan ; pour les opérations irréversibles telles que les autorisations d'écriture CI et le déploiement limité à la production, il est recommandé de maintenir le flux de travail de « confirmation manuelle PR → fusion manuelle » au lieu d'activer la PR automatisée.

3 minutes pour démarrer rapidement (méthode CLI)

#Installer l'outil de ligne de commande Jules
npm install -g @google/jules

# Connectez-vous à votre compte Google (le navigateur sera ouvert pour terminer l'authentification OAuth)
Jules se connecte

#Créer une nouvelle tâche (déduire automatiquement l'entrepôt du répertoire courant)
jules remote new --session "Tests unitaires supplémentaires pour la fonction parseQueryString dans utils.js"

# Afficher toutes les sessions actives
liste distante Jules --session

# Extrayez les modifications de code pour les sessions terminées
Jules Remote Pull --session <session-id>

Méthode de l'interface utilisateur Web : visitez https://jules.google.com → Connectez-vous avec un compte Google → Connectez-vous au référentiel GitHub → Sélectionnez le référentiel et entrez la description de la tâche → Cliquez sur "Donnez-moi un plan" → Commencez l'exécution après avoir examiné le plan → Affichez le Diff et créez un PR une fois terminé.

Comment utiliser

Les informations pertinentes n'ont pas été rendues publiques, veuillez vous référer à la page officielle en temps réel.

Prix des produits

La structure tarifaire de Jules est basée sur l'abonnement Google AI Pro/Ultra, adoptant une structure à deux niveaux « essai gratuit → mise à niveau de l'abonnement » :

Planifier Quota de tâches quotidiennes Limite supérieure de concurrence Modèle par défaut Comment obtenir
Gratuit 15 tâches/jour 3 Gémeaux 2.5 Pro Gratuit, inscrivez-vous directement
Pro 100 tâches/jour 15 Gémeaux 3.1 Pro Abonnement Google AI Pro (@gmail.com requis)
Ultra 300 tâches/jour 60 Gemini 3.1 Pro (prioritaire) Abonnement Google AI Ultra (@gmail.com requis)

Points clés du modèle de recharge :

  • Le forfait payant ne prend actuellement en charge que les comptes Google personnels (@gmail.com) et les comptes Workspace ne prennent actuellement pas en charge les mises à niveau.
  • Les différents membres d'un même groupe de partage familial ont des quotas de tâches indépendants et ne sont ni partagés ni regroupés.
  • Une fois le quota quotidien dépassé, le bouton de nouvelle tâche est désactivé, les tâches existantes ne sont pas affectées et le quota est réinitialisé après 24 heures glissantes.
  • Les appels REST API et CLI consomment également des quotas de tâches quotidiens et ne sont pas facturés indépendamment.
  • La page publique n'affiche pas de prix spécifiques pour les forfaits par répartition ou personnalisés par l'entreprise. Les entreprises doivent contacter l'équipe commerciale de Google pour les achats.

Coûts cachés :

  • Les quotas de tâches sont facturés par "fois" plutôt que par "complexité" - une refactorisation importante peut consommer plusieurs tâches (planification/exécution/réparation/nouvelle tentative). Il est recommandé de surveiller la consommation des tâches d'une seule exigence en utilisation réelle.
  • Pour les utilisateurs [email protected], il n'existe actuellement aucun chemin de mise à niveau payant, uniquement le plan gratuit.
  • Les abonnements Google AI Pro/Ultra incluent des avantages Google AI supplémentaires au-delà de Jules (tels que Gemini Advanced), et certains coûts peuvent être partagés avec d'autres services Google.

Scénarios d'application

Le mode autonome asynchrone de Jules détermine qu'il est le plus approprié pour les tâches de codage avec « des limites claires, des résultats acceptables et aucune interaction en temps réel » :

  • Correction quotidienne de bogues : extrayez les descriptions de bogues des problèmes GitHub ou des commentaires PR, et Jules localise automatiquement le problème, écrit des correctifs et complète les tests de régression. Particulièrement adapté aux bugs triviaux pour lesquels « vous savez ce qui n’a pas fonctionné, mais le corriger manuellement prend du temps ». Avantages typiques : le temps d'examen d'une seule correction de bug est réduit de 20 à 30 minutes à moins de 5 minutes.
  • Mises à niveau des dépendances et refactorisation à grande échelle : les mises à niveau des versions du framework (telles que Next.js, React, Angular) impliquent généralement de nombreux remplacements mécaniques d'API et migrations de configuration. Jules peut effectuer une migration qui prendrait des jours manuellement en une heure, et les Diffs générés sont clairement structurés et consultables fichier par fichier.
  • Supplément de tests automatisés : pour le code existant qui manque de couverture de test, Jules peut analyser les entrées et sorties de fonctions, les conditions aux limites et générer automatiquement des suites de tests Jest/PyTest. CI Fixer va encore plus loin et analyse automatiquement les journaux et les correctifs en cas de défaillance du pipeline CI, réduisant ainsi les coûts de changement de contexte pour les développeurs.
  • Maintenance programmée du code : les tâches planifiées permettent aux équipes de prédéfinir des tâches récurrentes telles que les contrôles hebdomadaires des dépendances, les réparations quotidiennes des peluches et le nettoyage mensuel des dettes techniques sans déclenchement manuel. Convient aux équipes disposant de processus de gestion de code standardisés.
  • Vérification rapide des prototypes techniques : le mode Repoless permet aux développeurs d'écrire rapidement des scripts ou de vérifier des idées sans avoir besoin de s'associer à un entrepôt, et convient au codage exploratoire et aux scénarios « d'outils jetables ».

Ne convient pas aux scénarios : Jules n'est pas adapté à la programmation en binôme qui nécessite une interaction en temps réel, aux changements impliquant des opérations irréversibles liées à la production, au développement d'algorithmes hautement personnalisés qui nécessitent une connaissance approfondie du domaine et aux scénarios qui ont des exigences de conformité strictes pour les résultats de génération de code (tels que les codes de réglementation médicale et financière).

Personnes concernées

Le modèle d'agent de codage asynchrone de Jules sera très utile pour :

  • Développeur personnel : convient aux développeurs qui ont un grand nombre de tâches de codage (mise à niveau des dépendances, correction de bugs et tests supplémentaires) qu'ils « savent faire mais ne veulent pas faire manuellement » au quotidien. Le forfait Free peut couvrir la plupart des besoins personnels. Nécessite une expérience de base dans l’utilisation de GitHub et une capacité claire de décomposition des tâches.
  • Responsable technique et architecte : Idéal pour déléguer le travail de codage répétitif à Jules et se concentrer sur la conception architecturale, les révisions de code et les décisions d'ingénierie de niveau supérieur. Nécessite la capacité d'écrire des fichiers AGENTS.md de haute qualité pour contraindre le comportement de l'agent, ainsi que la capacité de réviser le code généré par Jules.
  • Équipes DevOps et d'ingénierie de plate-forme : idéal pour intégrer Jules dans des pipelines automatisés à l'aide de tâches planifiées, de CI Fixer et d'API REST. Vous devez faire attention à la gestion des quotas et à la stabilité des API. L'API actuelle est encore au stade Alpha.
  • Mainteneur de projet Open Source : convient pour confier les corrections de bogues dans les problèmes à Jules et les déclencher automatiquement via la balise jules, réduisant ainsi le travail manuel du responsable. Il est nécessaire de prêter attention à la configuration des autorisations de l'entrepôt et au processus d'examen des relations publiques.

Ne s'applique pas à la foule :

  • Les développeurs qui ont besoin d'une expérience de programmation conversationnelle en temps réel (comme le curseur, le mode Copilot).
  • Votre organisation utilise Google Workspace et ne peut pas souscrire à un forfait payant via @gmail.com.
  • Les équipes qui doivent gérer des entrepôts uniques de très grande taille (des centaines de milliers de fichiers) ou qui ont des exigences strictes de personnalisation du contexte d'exécution.
  • Scénarios dans lesquels les exigences de conformité au code sont extrêmement élevées (comme DO-178C, processus de développement HIPAA) et où le code généré par l'IA n'est pas autorisé à entrer directement dans la base de code.

Résumé et Outlook

Jules est le produit phare de Google dans le domaine des agents de codage d'IA, formant une concurrence différenciée avec GitHub Copilot (achèvement en temps réel), Cursor (édition conversationnelle) et Devin (agent entièrement automatisé). Son principal avantage réside dans la combinaison « exécution asynchrone + isolation cloud + modèle de génération Gemini » - les développeurs peuvent partir après avoir soumis les tâches, et Jules termine indépendamment l'ensemble du processus, de la planification aux relations publiques, dans un environnement cloud sécurisé.

Limites et incertitudes actuelles :

  • Manque sévère de fonctionnalités au niveau de l'entreprise : pas de prise en charge des comptes Workspace, pas de SSO/audit, pas d'options de résidence des données et manque d'infrastructure pour les achats d'entreprise.
  • L'API est en phase Alpha : les points de terminaison, les méthodes d'authentification et les formats d'entrée et de sortie des modèles sont encore susceptibles de changer et ne sont pas adaptés à la construction d'intégrations de production de dépendances à long terme.
  • Système de quota de tâches au lieu d'une facturation au fur et à mesure : pour les tâches à haute fréquence et peu complexes (telles que la réparation des peluches fichier par fichier), le quota peut être consommé beaucoup plus rapidement que prévu.
  • Interface uniquement en anglais et invite en anglais : le seuil pour les développeurs non anglais est plus élevé.

Positionnement compétitif : Par rapport au positionnement « ingénieur logiciel entièrement autonome » de Devin (produit par Cognition), Jules se concentre davantage sur la « délégation asynchrone des tâches de codage » plutôt que sur la gestion de projet du cycle de vie complet ; par rapport au mode temps réel de Copilot/Cursor, Jules sacrifie l'interactivité en échange d'un plus grand espace d'exécution autonome. Les trois ne sont pas des remplacements directs, mais des choix pour différentes préférences de flux de travail.

Évaluation des risques d'approvisionnement/d'adoption : pour les développeurs individuels et les petites équipes, le plan gratuit peut vérifier l'effet réel de Jules dans leur pile technologique à un coût nul et avec un risque extrêmement faible. Pour les décideurs envisageant une adoption à grande échelle de Teams, le plus grand risque à ce stade vient du manque de prise en charge de Google Workspace et des lacunes dans les fonctionnalités au niveau de l'entreprise : jusqu'à ce que Google ait une feuille de route d'entreprise claire, il n'est pas recommandé d'intégrer Jules dans l'infrastructure de développement formelle de Teams. Le chemin d'adoption recommandé est le suivant : Essai personnel gratuit → Abonnement Pro pour accélérer l'efficacité personnelle → Attendre que l'équipe d'évaluation s'agrandisse après le lancement de la solution d'entreprise. Continuez à prêter attention à la stabilité de l'API de la liste d'extensions du serveur MCP et à la progression de la prise en charge de Workspace dans le journal des modifications officiel.

Outils associés : Copilote GitHub, Curseur

Chemin d'utilisation de Jules

Jules propose trois méthodes d'accès, adaptées aux développeurs dans différents scénarios :

Méthode d'accès Installation/démarrage Scénarios appropriés Restrictions clés
Interface utilisateur Web Accès par navigateur jules.google.com Expérience rapide, examen visuel des différences Contexte du navigateur requis
CLI (Outils Jules) npm install -g @google/jules Intégré au workflow du terminal, automatisation des scripts Nécessite le contexte Node.js
API REST Authentification par clé API Intégration CI/CD, flux de travail personnalisé Version alpha, les spécifications peuvent changer

Processus d'utilisation typique (en prenant l'interface utilisateur Web comme exemple) :

  1. Visitez jules.google.com et connectez-vous avec votre compte Google.
  2. Connectez-vous à votre compte GitHub et autorisez Jules à accéder à l'entrepôt spécifié (vous pouvez choisir tous les entrepôts ou des entrepôts limités).
  3. Sélectionnez l'entrepôt et la succursale cibles dans le sélecteur d'entrepôt et saisissez une description de tâche claire et spécifique (par exemple, « Mettre à niveau next.js vers la v15 et migrer vers le répertoire des applications »).
  4. (Facultatif) Ajoutez des variables limitées ou des scripts de configuration limités pour aider Jules à exécuter correctement le projet.
  5. Cliquez sur "Donnez-moi un plan" → Jules clone le référentiel dans la VM cloud, analyse le code et génère un plan d'exécution.
  6. Examinez le contenu du plan et confirmez que la portée et la stratégie de modification sont correctes avant d'approuver l'exécution.
  7. Jules automatise la modification du code, l'exécution des tests et la vérification des résultats.
  8. Examinez les modifications fichier par fichier dans le visualiseur Diff et cliquez sur « Publier la branche » ou « Ouvrir PR » après avoir confirmé qu'elles sont correctes.
  9. (Facultatif) Fusionnez après avoir examiné le PR sur GitHub.

Fichier AGENTS.md : placer AGENTS.md dans le répertoire racine de l'entrepôt permet à Jules de lire automatiquement la description de l'agent convenue du projet et les spécifications d'interaction, améliorant ainsi la qualité de l'exécution des tâches. Il est recommandé aux équipes de rédiger ce document avant le pilotage.

Informations de version

  • Gemini 3.1 Pro + CI Fixateur ：Gemini 3.1 Pro devient le modèle par défaut pour le package Pro ; CI Fixer détecte et répare automatiquement les pannes de CI ; Commit Authoring prend en charge trois modes de signature d'auteur. Les fonctions spécifiques et les zones disponibles sont soumises à la page officielle en temps réel.
  • Intégration du serveur MCP ：Accès à la prise en charge du serveur MCP, d'abord intégré à Linear, Stitch, Neon, Tinybird, Context7 et Supabase.
  • Critique de planification + Gemini 3 Flash ：Gemini 3 Flash devient le modèle de base (en remplacement du 2.5 Pro) ; l'agent de révision secondaire Planning Critic est introduit (le taux d'échec est réduit de 9,5 %) ; l'API REST ajoute la prise en charge de Repoless et de la sortie de fichiers ; Les tâches planifiées prennent en charge l'édition/pause/reprise.
  • Tâches planifiées et suggérées ：Tâches planifiées lancées (tâches planifiées) et tâches suggérées (analyse active des suggestions TODO/optimisation des performances) ; correctifs automatisés de déploiement de rendu intégrés.
  • Gemini 3 Pro + Repoless + CLI ：Gemini 3 Pro est en ligne ; Le mode Repoless permet un codage direct sans référentiel ; Jules Tools CLI est publié (npm install -g @google/jules).
  • API REST Jules ：La version Alpha de l'API Jules REST est publiée, prenant en charge la création/gestion de sessions via curl ; La fonction mémoire est en ligne ; Prise en charge des variables d'environnement.
  • Sortie officielle (hors bêta) ：Fin de la phase bêta, avec un total de plus de 140 000 soumissions publiques réussies ; lancement officiel de la tarification à trois niveaux Free/Pro/Ultra ; ajout de fonctionnalités de base telles que l'agent critique, la recherche sur le Web, le plan interactif et la vérification de capture d'écran de l'application Web.
  • Version bêta ：Jules est rendu public pour la première fois, fournissant des fonctionnalités d'agent de codage de base telles que l'intégration de GitHub, la réparation de code et la création de PR de mise à niveau des dépendances. Il n’y a pas encore de date officielle précise.

Avis des utilisateurs

  • Chargement des avis...