Jules Free

-
Developer Google
Official Website https://jules.google/

Jules is an asynchronous independent coding agent launched by Google. Based on the Gemini series model, it completes tasks such as code repair, test supplement, dependency upgrade, and reconstruction in the cloud virtual machine, and finally automatically creates a PR to submit changes. Supports three access methods: Web UI, CLI and REST API, and provides Free/Pro/Ultra three-level task quota solutions.

Jules Product Interface

Jules

Core parameters and statistics

Jules is an asynchronous autonomous coding agent launched by Google. Based on the Gemini series model, it automates the planning, execution and submission of code tasks in cloud virtual machines. It is not a "chat-style AI programming assistant", but a "hands-off" coding agent - developers can leave after submitting the task description, and Jules completes code modifications, test runs and PR creation in the background.

Projects Public Information
Official positioning An autonomous coding agent — coding tasks you don't want to do
Underlying model Gemini 2.5 Pro → 3 Flash → 3 Pro → 3.1 Pro (continuous upgrade)
Computing with context Cloud virtual machine (20GB disk, pre-installed Node/Python/Rust/Bun and other runtimes)
Integration methods Web UI, CLI (npm), REST API (Alpha), GitHub App
Pricing Tiers Free (15 tasks/day 3 concurrency), Pro (100 tasks/day 15 concurrency), Ultra (300 tasks/day 60 concurrency)
Access prerequisites Google account + GitHub warehouse authorization
Supported Platforms Web, API, Desktop (CLI)
Home US
Development language Based on Google Cloud + Gemini, the front-end entrance is at jules.google

Product form: The core difference between Jules and "real-time completion" tools such as Cursor and GitHub Copilot is "asynchronous execution". Developers only need to describe the task in the Web UI or CLI, and Jules will independently complete the entire process of cloning the warehouse → installing dependencies → making a plan → modifying the code → running tests → creating a PR in the cloud VM. During this period, the developer can leave to do other work. After completion, the results will be informed through browser notifications or GitHub PR.

Task quota structure: The free version has 15 tasks and 3 concurrencies per day, which is suitable for personal evaluation; the Pro version (relying on Google AI Pro subscription) is increased to 100 tasks/15 concurrencies; the Ultra version (Google AI Ultra) is up to 300 tasks/60 concurrencies. All tiers are calculated using a rolling 24-hour window, after which new tasks are blocked until the quota is reset.

User and market recognition

Jules is officially launched by Google and is based on the Google Cloud and Gemini models. Its brand trust is naturally higher than that of independent entrepreneurial projects. It only took 3 months from beta to official release to accumulate 140,000+ public submissions (as of August 2025), indicating that early adopters are highly active.

Community and Ecology: The audience of Jules is mainly the GitHub developer community. The official Jules Awesome Prompts repository (github.com/google-labs-code/jules-awesome-list) is provided for the community to share use cases. The Discord channel is the primary channel for user feedback. Since the product does not run entirely on Google Cloud, there is no self-built expansion ecosystem of the open source community. Its ecological expansion mainly relies on the MCP Server integration and API capabilities officially launched by Google.

Enterprise landing conditions: The current paid package only supports @gmail.com personal Google accounts, and Google Workspace enterprise accounts do not yet support the upgrade path. This means that enterprise teams currently cannot unify procurement and settlement, and can only collaborate after team members subscribe to each one. Google has opened the enterprise demand registration form, but there is no clear time for it to be launched. For teams that require enterprise features such as SSO, audit logs, data residency, etc., the current stage is only suitable for individual or small team pilots and is not suitable as a company-wide standard coding infrastructure.

Cost advantage

The cost structure of Jules is different from traditional IDE plug-ins or SaaS subscriptions and needs to be evaluated from three perspectives: individual, team and enterprise.

C-side/individual developer

Plan Daily task quota Concurrency limit Model Monthly cost (estimate)
Free 15 tasks/day 3 Gemini 2.5 Pro $0
Pro (including Google AI Pro) 100 tasks/day 15 Gemini 3.1 Pro (default) Google AI Pro subscription price
Ultra (including Google AI Ultra) 300 tasks/day 60 Gemini 3.1 Pro (priority) Google AI Ultra subscription price
  • Individual Developer: The Free plan has 15 tasks per day, which is enough to cover personal bug fixes, small-scale refactoring and test additions. Calculated based on 5-15 minutes of manual labor time per task, it is equivalent to saving 1-3 hours of mechanical coding work every day. The Pro/Ultra plan is suitable for high-frequency committers or developers who manage multiple repositories.
  • Hidden Cost: Jules' task consumption is not equivalent to "every question" - a complex requirement may consume multiple tasks (plan → execute → fix → retry), and the actual number of available tasks may be less than expected. It is recommended to record the real task consumption distribution in the pilot.

API / Developer Integration

The Jules REST API is currently in the Alpha stage. API Keys are generated through the Web UI settings page. Each account can have up to 3 Keys. Task quotas for API calls are shared across subscription plans, with no standalone API pricing. This means:

  • API calls do not cost extra, but consume Free/Pro/Ultra daily task credits.
  • API creation Session automatically approves the plan by default; if manual review is required, set requirePlanApproval: true.
  • The current API is not suitable for high-throughput CI/CD integration scenarios (task quotas naturally limit call frequency).

Enterprise/Team Deployment

Currently Jules' business is in its early stages:

  • No Workspace support: Payment is only available at @gmail.com, and enterprise accounts cannot be purchased and managed uniformly.
  • No SSO/Audit: No SAML, SCIM or audit log support is exposed.
  • Data Residency: Code is processed in Google Cloud VM, the data processing agreement is subject to Google ToS, no independent data processing terms or region binding options are disclosed.
  • Team Collaboration: Collaborate indirectly through a shared GitHub repository instead of a team workspace. Submission author attribution supports "Jules only", "Co-authored" and "User only" modes.

Purchase Suggestion: The current stage is more suitable for individual developers or small teams to try Pro/Ultra at their own expense to evaluate the effect; enterprise-level purchases need to wait for the Workspace support solution to go online before making a formal evaluation.

Main functions

Jules' capabilities are designed around "asynchronous autonomous coding", and the core functions can be summarized into the following six categories:

  • Code Repair and Bug Location: Jules can read bug reports in GitHub Issues, PR comments, or natural language descriptions, locate issues in the cloud VM, write fixes, add tests, and submit PRs. Support automatically triggering tasks from GitHub Issues by adding the jules tag.
  • Dependency upgrade and version migration: For version changes of package managers such as npm, pip, cargo, etc., Jules can automatically perform operations such as version update API adaptation and configuration file migration. Typical scenarios include directory structure migration from Next.js v10 → v15.
  • Test Supplement and CI Fix: Jules can identify parts of the code that lack test coverage and automatically write test cases. The CI Fixer function can automatically detect failed builds of GitHub Actions, analyze logs, push fixes, and resubmit PRs, resulting in a "fix → submit → rerun" cycle.
  • Code Refactoring and Architecture Optimization: Supports technical debt cleanup with clear boundaries, such as refactoring classes into state machines, splitting overly large functions, and extracting common modules. Critic Agent acts as a built-in code reviewer, conducting adversarial reviews before each change, marking potential flaws and missed edge cases.
  • Scheduled and active tasks: Scheduled Tasks support repetitive maintenance defined on a weekly/daily basis (such as weekly dependency checks, daily lint repairs), and are automatically executed after one configuration. Suggested Tasks proactively scans the repository for TODO comments and performance optimization opportunities, displaying recommendations in the dashboard.
  • MCP Server integration: By connecting to the MCP server (the first batch supports Linear, Stitch, Neon, Tinybird, Context7, Supabase), Jules can automatically call the data and tools of external services during the coding process, such as pulling the Issue context from Linear and querying the schema from Supabase.

Expert view: The real value of Jules does not lie in the strength of a single function, but in the full link of "requirement description → plan formulation → code modification → test verification → PR submission". Compared with Copilot's real-time completion or Cursor's conversational editing, Jules' asynchronous mode is more suitable for those scenarios where "you know what you want to change, but you don't want to do it yourself". The synergistic effect of CI Fixer and Scheduled Tasks is particularly obvious - they upgrade the coding agent from "passive response" to "active maintenance", which is an area that traditional AI programming tools have not yet covered.

Model and version evolution

Jules has maintained a very high iteration frequency since its beta release in May 2025, with significant feature updates every month. The following is a timeline of key milestones.

Launch and Beta period (2025-05 ~ 2025-07)

  • 2025-05-19: Jules Beta released, providing basic capabilities for GitHub integration, code fixes, version updates, and PR creation.
  • 2025-05-30: Task limit updated to 60 tasks/day 5 concurrency; failure rate reduced by 2/3.
  • 2025-06-06: UI enhancements (copy/download code, adjustable code panel, task modal box).
  • 2025-06-18: Basic context upgrade, pre-installed with the latest version of Rust/Node/Python, and supports Bun runtime.
  • 2025-06-20: Agent upgrade - supports AGENTS.md warehouse command file, significantly reducing the abandonment rate.
  • 2025-06-26: GitHub Issues integration - adding the jules tag automatically triggers tasks.

Official release and pricing online (2025-08)

  • 2025-08-04: Support creating PR directly from UI.
  • 2025-08-05: With the context snapshot function, the startup speed of complex projects is greatly improved.
  • 2025-08-06: Officially released (Out of Beta), a total of 140,000+ public submissions; launched Free/Pro/Ultra three-level pricing. The default model is upgraded to Gemini 2.5 (think mode).
  • 2025-08-07: Web App screenshot verification - Jules can render the front-end page and return screenshots.
  • 2025-08-08: Critic Agent (code resistance review), Interactive Plan (interactive plan formulation), Web Search (active network search).

API and CLI open (2025-09 ~ 2025-10)

  • 2025-09-02: Example prompt words on the homepage.
  • 2025-09-03: Critic improvements - real-time display of review thought process.
  • 2025-09-04: Stacked Diff vertical comparison view.
  • 2025-09-09: Image upload support (JPEG/PNG, <5MB, only when task creation).
  • 2025-09-23: Automatic response to PR comments - Jules reads comments and pushes modifications.
  • 2025-09-29: File selector - pinpoint task file range.
  • 2025-09-30: Memory feature - cross-task memory warehouse preferences.
  • 2025-10-01: Bounded variable support.
  • 2025-10-02: Jules Tools CLI released - npm install -g @google/jules.
  • 2025-10-03: Jules REST API Alpha Release.

Gemini 3 intergenerational upgrade (2025-11 ~ 2026-01)

  • 2025-11-10: CLI update - parallel task PyPI installation fix, side comparison Diff view.
  • 2025-11-19: Gemini 3 Pro is online - clearer reasoning Agentic Memories and visual verification.
  • 2025-11-20: Repoless mode - no need to select a repository to start coding.
  • 2025-12-10: Scheduled Tasks, Suggested Tasks, Render integration.
  • 2026-01-26: Planning Critic (planned second review of Agent, failure rate reduced by 9.5%), performance optimization suggestions Scheduled Tasks edit/pause/resume.
  • 2026-01-30: Gemini 3 Flash becomes the base model (replacing 2.5 Pro), significantly improved in speed and capabilities.

MCP and deep integration (2026-02 ~ present)

  • 2026-02-02: MCP Server support - the first batch of integrated Linear, Stitch, Neon, Tinybird, Context7, Supabase.
  • 2026-02-19: CI Fixer (automatically repairs CI failures) + Commit Authoring (three signature modes).
  • 2026-03-09: Gemini 3.1 Pro becomes the default model of the Pro package, further improving the ability to solve complex problems.

Technical advantages

Jules’ technical advantages come from Google’s accumulation at three levels: large model inference, cloud infrastructure, and developer tool chain, rather than a simple encapsulation of a single model’s performance.

Model Generation Leading: Jules’ underlying model has been upgraded from Gemini 2.5 Pro in the beta stage to Gemini 3 Flash (basic model) in January 2026, and then Gemini 3.1 Pro will be available to Pro users in March 2026, maintaining a major version model upgrade rhythm of about 3-4 months. Each model upgrade is directly reflected in task success rate, inference quality and execution speed, and users can benefit without manual switching.

Isolated execution in the cloud: Unlike traditional IDE plug-ins that run locally, each task of Jules is executed in an independent Google Cloud VM, with Node.js, Python, Rust, Bun and other runtimes and Playwright browser testing tools pre-installed. This design brings three key advantages:

  • Security Isolation: The Agent's operation scope is limited to the VM, and even if malicious code is generated, it will not affect the host.
  • Contextual Consistency: The context of task execution is maintained uniformly by Google to avoid the compatibility issue of "can run on my machine".
  • Observability: Every step of the task (plan → modification → test → result) is recorded in the form of Activity and can be queried through API, forming an audit trail that cannot be tampered with.

Critic Agent + Planning Critic dual-layer review mechanism: Jules has embedded two review nodes in the code generation process-Planning Critic conducts adversarial questioning in the planning stage (reducing the failure rate by 9.5%), and Critic Agent reviews safety, efficiency, and edge cases line by line during the code modification stage. This two-layer mechanism of "review the plan first, then review the code" is a cutting-edge design among AI coding tools, which directly reduces the burden of manual review.

Context Management Toolbox: Jules controls the integrity and accuracy of code context through multiple mechanisms - the AGENTS.md warehouse directive file allows developers to pre-define project conventions, the file selector pinpoints task scope, the contextual variable script provides runtime configuration, and the Memory function maintains preference consistency across tasks. Together, these capabilities reduce the risk of Agents getting "lost in context" when working on large projects.

Tool Open List (Tool Surface)

As a coding agent, Jules does not directly expose the browser automation tool set, but provides developers with a programmable control surface through the following interfaces:

Tools/Interfaces Functions Calling methods
sources API List connected GitHub repositories REST GET /v1alpha/sources
sessions API Create/query/manage coding tasks REST POST/GET /v1alpha/sessions
approvePlan API Approve the execution plan formulated by Agent REST POST /v1alpha/sessions/{id}:approvePlan
sendMessage API Send commands to a running Session REST POST /v1alpha/sessions/{id}:sendMessage
activities API Query the step-level audit records of a task REST GET /v1alpha/sessions/{id}/activities
CLI remote new Create a new task from the terminal jules remote new --repo <repo> --session "<prompt>"
CLI remote pull Pull the results of completed tasks jules remote pull --session <id>
CLI remote list View repository or session list jules remote list --repo / --session
GitHub Label Trigger tasks through Issue labels Add jules label to GitHub Issues
MCP Servers Call external services during encoding Automatically triggered after configuring the API Key on the settings page

Architecture link

Developer ──→ Web UI / CLI / REST API ──→ Jules Orchestration layer ──→ Gemini LLM
                                                           │
                                                           ▼
                                          Cloud VM (Git clone → install dependencies → change code → run test → submit)
                                                           │
                                              ┌────────────┼─────────────┐
                                              ▼ ▼ ▼
                                          GitHub Repo MCP Servers Web Search
                                                       (Linear, (Documentation/code snippet
                                                        Supabase, search)
                                                        Neon etc.)

The control flow is from top to bottom: developers submit task descriptions through any interface → Jules orchestration layer calls Gemini model generation plan → execute code changes in Cloud VM → results are flowed back to GitHub PR.

Engineering Pitfall Guide

  1. Task Quota Management: The daily quota of the Free version is only 15 tasks, and complex requirements may consume 3-5 tasks (Plan → Execute → Repair → Retry). It is recommended to use the --parallel parameter to estimate the average consumption of a single task before deciding whether to upgrade the package. After the quota is exceeded, new tasks are blocked but existing tasks are not affected.

  2. Large repository context control: For repositories containing thousands of files, Jules may miss critical files due to context window limitations. Solutions include clearly defining the project structure and key file locations through the AGENTS.md file, using file selectors to limit task scope (rather than letting the Agent explore freely), and preloading test data through contextual variable scripts to avoid runtime failures.

  3. Security and irreversible operation management: Jules has full read and write permissions to the warehouse in the VM. Sessions created by the API in default mode will automatically approve the plan and execute it. For high-value warehouses, requirePlanApproval: true should be set to force manual review of each step of the plan; for irreversible operations such as CI write permissions and production bounded deployment, it is recommended to maintain the workflow of "manual confirmation PR → manual merge" instead of turning on automated PR.

3 minutes to get started quickly (CLI method)

#Install Jules command line tool
npm install -g @google/jules

# Log in to your Google account (the browser will be opened to complete OAuth authentication)
jules login

#Create a new task (automatically infer the warehouse of the current directory)
jules remote new --session "Supplement unit testing for the parseQueryString function in utils.js"

# View all active sessions
jules remote list --session

# Pull code changes for completed sessions
jules remote pull --session <session-id>

Web UI method: Visit https://jules.google.com → Log in with a Google account → Connect to the GitHub repository → Select the repository and enter the task description → Click "Give me a plan" → Start execution after reviewing the plan → View the Diff and create a PR after completion.

How to use

Relevant information has not been made public, please refer to the official real-time page.

Product Pricing

Jules' pricing structure is based on Google AI Pro/Ultra subscription, adopting a two-tier structure of "free trial → subscription upgrade":

Plan Daily task quota Concurrency upper limit Default model How to obtain
Free 15 tasks/day 3 Gemini 2.5 Pro Free, register directly
Pro 100 tasks/day 15 Gemini 3.1 Pro Google AI Pro subscription (@gmail.com required)
Ultra 300 tasks/day 60 Gemini 3.1 Pro (priority) Google AI Ultra subscription (@gmail.com required)

Key points of charging model:

  • The paid plan currently only supports personal Google accounts (@gmail.com), and Workspace accounts do not currently support upgrades.
  • Different members in the same family sharing group have independent task quotas and are not shared or pooled.
  • After the daily quota is exceeded, the new task button is disabled, existing tasks are not affected, and the quota is reset after rolling 24 hours.
  • REST API and CLI calls also consume daily task quotas and are not billed independently.
  • The public page does not display specific prices for pay-as-you-go or enterprise-customized plans. Enterprises need to contact the Google business team for procurement.

Hidden Costs:

  • Task quotas are billed by "times" rather than by "complexity" - a large refactoring may consume multiple tasks (planning/execution/repair/retry). It is recommended to monitor the task consumption of a single requirement in actual use.
  • For [email protected] users, there is currently no paid upgrade path, only the Free plan.
  • Google AI Pro/Ultra subscriptions include additional Google AI benefits beyond Jules (such as Gemini Advanced), and some costs can be shared with other Google services.

Application scenarios

Jules' asynchronous autonomous mode determines that it is most suitable for coding tasks with "clear boundaries, acceptable results, and no real-time interaction":

  • Daily Bug Fixing: Extract bug descriptions from GitHub Issues or PR comments, and Jules automatically locates the problem, writes fixes, and supplements regression tests. Especially suitable for trivial bugs where "you know what went wrong but fixing it manually is time-consuming". Typical benefits: The review time for a single bug fix is ​​reduced from 20-30 minutes to less than 5 minutes.
  • Dependency upgrades and large-scale refactoring: Framework version upgrades (such as Next.js, React, Angular) usually involve a lot of mechanical API replacement and configuration migration. Jules can complete a migration that would take days manually in one hour, and the generated Diffs are clearly structured and reviewable file by file.
  • Automated Testing Supplement: For legacy code that lacks test coverage, Jules can analyze function input and output, boundary conditions and automatically generate Jest/PyTest test suites. CI Fixer goes a step further and automatically analyzes logs and fixes when the CI pipeline fails, reducing developers' context switching costs.
  • Scheduled Code Maintenance: Scheduled Tasks allow teams to preset recurring tasks such as weekly dependency checks, daily lint repairs, and monthly technical debt cleanup without manual triggering. Suitable for teams with standardized code management processes.
  • Quick verification of technical prototypes: Repoless mode allows developers to quickly write scripts or verify ideas without needing to associate with a warehouse, and is suitable for exploratory coding and "disposable tool" scenarios.

Not suitable for scenarios: Jules is not suitable for pair programming that requires real-time interaction, changes involving irreversible production-bound operations, highly customized algorithm development that requires in-depth domain knowledge, and scenarios that have strict compliance requirements for code generation results (such as medical and financial regulatory codes).

Applicable people

Jules' asynchronous coding Agent pattern will be most valuable to:

  • Personal Developer: Suitable for developers who have a large number of coding tasks (upgrading dependencies, fixing bugs, and supplementary testing) that they "know how to do but don't want to do manually" on a daily basis. The Free plan can cover most personal needs. Requires basic experience in using GitHub and clear task decomposition ability.
  • Technical Lead & Architect: Ideal for delegating repetitive coding work to Jules and focusing on architectural design, code reviews, and higher-level engineering decisions. Requires the ability to write high-quality AGENTS.md files to constrain Agent behavior, as well as the ability to review Jules-generated code.
  • DevOps and Platform Engineering Teams: Good for embedding Jules into automated pipelines using Scheduled Tasks, CI Fixer, and REST APIs. You need to pay attention to quota management and API stability. The current API is still in the Alpha stage.
  • Open Source Project Maintainer: Suitable for entrusting bug fixes in Issues to Jules and automatically triggering them through the jules tag, reducing the maintainer's manual work. It is necessary to pay attention to the warehouse permission configuration and PR review process.

Not applicable to the crowd:

  • Developers who need real-time conversational programming experience (such as Cursor, Copilot mode).
  • Your organization uses Google Workspace and cannot subscribe to a paid plan through @gmail.com.
  • Teams that need to handle very large single warehouses (hundreds of thousands of files) or have strict customization requirements for execution context.
  • Scenarios where code compliance requirements are extremely high (such as DO-178C, HIPAA development process) and AI-generated code is not allowed to enter the code base directly.

Summary and Outlook

Jules is Google's core product in the field of AI coding agents, forming differentiated competition with GitHub Copilot (real-time completion), Cursor (conversational editing), and Devin (fully automated Agent). Its core advantage lies in the combination of "asynchronous execution + cloud isolation + Gemini generation model" - developers can leave after submitting tasks, and Jules independently completes the entire process from planning to PR in a secure cloud environment.

Current Limitations and Uncertainties:

  • Severe lack of enterprise-level capabilities: no Workspace account support, no SSO/auditing, no data residency options, and lack of infrastructure for enterprise procurement.
  • The API is in the Alpha stage: the endpoints, authentication methods, and model input and output formats are still subject to change, and are not suitable for building long-term dependency production integrations.
  • Task quota system instead of pay-as-you-go billing: For high-frequency, low-complexity tasks (such as file-by-file lint repair), the quota may be consumed much faster than expected.
  • Only English interface and English prompt: The threshold for non-English developers is higher.

Competitive positioning: Compared with the "fully autonomous software engineer" positioning of Devin (produced by Cognition), Jules focuses more on "asynchronous delegation of coding tasks" rather than full life cycle project management; compared with the real-time mode of Copilot/Cursor, Jules sacrifices interactivity in exchange for greater autonomous execution space. The three are not direct replacements, but choices for different workflow preferences.

Procurement/Adoption Risk Assessment: For individual developers and small teams, the Free plan can verify the actual effect of Jules in their technology stack at zero cost and with extremely low risk. For decision makers considering large-scale adoption of Teams, the biggest risk at this stage comes from the lack of Google Workspace support and gaps in enterprise-level features - until Google has a clear enterprise roadmap, it is not recommended to integrate Jules into the formal Teams development infrastructure. The recommended adoption path is: Personal Free trial → Pro subscription to accelerate personal efficiency → Wait for the evaluation team to expand after the enterprise solution is launched. Continue to pay attention to the MCP Server extension list API stability and Workspace support progress in the official changelog.

Related tools: GitHub Copilot, Cursor

Jules usage path

Jules provides three access methods, suitable for developers in different scenarios:

Access method Installation/startup Suitable scenarios Key restrictions
Web UI Browser access jules.google.com Quick experience, visual Diff review Browser context required
CLI (Jules Tools) npm install -g @google/jules Integrated into terminal workflow, script automation Requires Node.js context
REST API API Key authentication CI/CD integration, custom workflow Alpha version, specifications may change

Typical usage process (taking Web UI as an example):

  1. Visit jules.google.com and log in with your Google account.
  2. Connect to your GitHub account and authorize Jules to access the specified warehouse (you can choose all or limited warehouses).
  3. Select the target warehouse and branch in the warehouse selector and enter a clear and specific task description (for example, "Upgrade next.js to v15 and migrate to app directory").
  4. (Optional) Add bounded variables or bounded setup scripts to help Jules run the project correctly.
  5. Click "Give me a plan" → Jules clones the repository in the cloud VM, analyzes the code and generates an execution plan.
  6. Review the content of the plan and confirm that the modification scope and strategy are correct before approving the execution.
  7. Jules automates code modification, test running, and result verification.
  8. Review the modifications file by file in the Diff viewer, and click "Publish Branch" or "Open PR" after confirming that they are correct.
  9. (Optional) Merge after reviewing the PR on GitHub.

AGENTS.md file: Placing AGENTS.md in the root directory of the warehouse allows Jules to automatically read the project's agreed Agent description and interaction specifications, improving the quality of task completion. It is recommended that teams write this document before piloting.

Version Info

  • Gemini 3.1 Pro + CI Fixer ：Gemini 3.1 Pro becomes the default model for the Pro package; CI Fixer automatically detects and repairs CI failures; Commit Authoring supports three author signature modes. The specific functions and available areas are subject to the official real-time page.
  • MCP Server integration ：Access to MCP Server support, first integrated with Linear, Stitch, Neon, Tinybird, Context7 and Supabase.
  • Planning Critic + Gemini 3 Flash ：Gemini 3 Flash becomes the basic model (replacing 2.5 Pro); the Planning Critic secondary review Agent is introduced (the failure rate is reduced by 9.5%); the REST API adds Repoless and file output support; Scheduled Tasks supports editing/pause/resume.
  • Scheduled & Suggested Tasks ：Launched Scheduled Tasks (scheduled tasks) and Suggested Tasks (active scanning of TODO/performance optimization suggestions); integrated Render deployment automated fixes.
  • Gemini 3 Pro + Repoless + CLI ：Gemini 3 Pro is online; Repoless mode allows direct coding without repository; Jules Tools CLI is released (npm install -g @google/jules).
  • Jules REST API ：Jules REST API Alpha version is released, supporting session creation/management through curl; Memory function is online; Environment Variables support.
  • Official release (Out of Beta) ：Ended the beta stage, with a total of 140,000+ public submissions passed; officially launched three-level pricing of Free/Pro/Ultra; added core capabilities such as Critic Agent, Web Search, Interactive Plan, and Web App screenshot verification.
  • Beta release ：Jules is made public for the first time, providing basic coding agent capabilities such as GitHub integration, code repair, and dependency upgrade PR creation. There is no official precise date yet.

User Reviews

  • Loading reviews...