# Full Jules Documentation
___
## Docs
### Getting Started
Jules is an experimental coding agent that helps you fix bugs, add documentation, and build new features. It integrates with GitHub, understands your codebase, and works **autonomously** — so you can move on while it handles the task.
This guide will walk you through setting up Jules and running your first task.
## Login
1. Visit jules.google.com
2. Sign in with your Google account.
3. Accept the privacy notice (one‑time).
## Connect GitHub
Jules needs access to your repositories in order to work.
1. Click **Connect to GitHub account.**
2. Complete the login flow.
3. Choose *all* or specific repos that you want to connect to Jules.
4. You will be redirected back to Jules. If not, try refreshing the page.
Once connected, you'll see a **repo selector** where you can select the repo you want Jules to work with, and a prompt input box.
## Starting your first task
Jules runs in a virtual machine where it clones your code, installs dependencies, and modifies files.
1. Pick a repository from the repo selector.
2. Choose the branch you want Jules to work on. The default branch will be selected already. You do not have to modify this unless you want Jules to work on a specific branch.
3. Write a clear, specific prompt. For example, ```Add a test for "parseQueryString``` function in utils.js
4. (Optional) Add environment setup scripts.
5. Click **Give me a plan**
Once you submit a task, Jules will generate a plan. You can review and approve it before any code changes are made.

## Include AGENTS.md file
Jules now automatically looks for a file named AGENTS.md in the root of your repository. This file can describe the agents or tools in your codebase, such as what they do, how to interact with them, or any input and output conventions. Jules uses this file to better understand your code and generate more relevant plans and completions.
**Tip:** Keep AGENTS.md up to date. It helps Jules and your teammates work with your repo more effectively.
## Enabling notifications
You are free to leave Jules while it is running. To stay informed:
1. When prompted, enable browser notifications.
2. Go to **Settings --> notifications** at any time to enable or disable notifications.
You'll be notified when the task completes or needs your input.

## What's next?
- [Running a task with Jules](/docs/running-tasks/) - Full walkthrough
- [Environment setup](/docs/environment/) - Make Jules smarter about your project
- [Reviewing plans & feedback](/docs/review-plan/) - how to approve and integrates
Want to dive into real-world use cases? Check out the [Jules Awesome Prompts repo](https://github.com/google-labs-code/jules-awesome-list).
___
### Environment setup
Jules runs each task inside a secure, short-lived virtual machine (VM). This lets it clone your repository, install dependencies, and run tests.
For simple environments, Jules studies your repository to learn how to quickly setup your environment without a provided setup script. Jules will also refer to agents.md or your readme.md file for hints to setup an environment on the fly.
For compex environments, you can provide a **setup script** to be run explicitly that prepare the environment.
## What's preinstalled?
Every Jules VM runs Ubuntu Linux and includes many popular developer tools out of the box:
- Node.js
- Bun
- Python
- Go
- Java
- Rust
The latest versions can be seen here:
```bash
-------- Python --------
✅ python3: Python 3.12.11
✅ python: Python 3.12.11
✅ pip: pip 25.1.1 from /home/jules/.pyenv/versions/3.12.11/lib/python3.12/site-packages/pip (python 3.12)
✅ pipx: 1.4.3
✅ poetry: Poetry (version 2.1.3)
✅ uv: uv 0.7.13
✅ black: black, 25.1.0 (compiled: yes)
✅ mypy: mypy 1.16.1 (compiled: yes)
✅ pytest: pytest 8.4.0
✅ ruff: ruff 0.12.0
✅ pyenv: available
system
3.10.18
3.12.11 (set by /home/jules/.pyenv/version)
-------- NodeJS --------
✅ node: v22.16.0 *
v18.20.8 *
v20.19.2 *
→ v22.16.0 *
system *
✅ nvm: available
✅ npm: 11.4.2
✅ yarn: 1.22.22
✅ pnpm: 10.12.1
✅ eslint: v9.29.0
✅ prettier: 3.5.3
✅ chromedriver: ChromeDriver 137.0.7151.70
(dfa4dc56b2ahb56eb2a14cad006ea5e68c60d5de-refs/branch-heads/7151@{#1875})
-------- Java --------
✅ java: openjdk version "21.0.7" 2025-04-15
OpenJDK Runtime Environment (build 21.0.7+6-Ubuntu-0ubuntu124.04)
OpenJDK 64-Bit Server VM (build 21.0.7+6-Ubuntu-0ubuntu124.04, mixed mode, sharing)
✅ maven: Apache Maven 3.9.10 (5f519b97e9448438d878815739f519b2eade0a91d)
✅ gradle: Gradle 8.8
-------- Go --------
✅ go: go version go1.24.3 linux/amd64
-------- Rust --------
✅ rustc: rustc 1.87.0 (17067e9ac 2025-05-09)
✅ cargo: cargo 1.87.0 (99624be96 2025-05-06)
-------- C/C++ Compilers --------
✅ clang: Ubuntu clang version 18.1.3 (1ubuntu1)
✅ gcc: gcc (Ubuntu 13.3.0-6ubuntu2~24.04) 13.3.0
✅ cmake: cmake version 3.28.3
✅ ninja: 1.11.1
✅ conan: Conan version 2.17.0
-------- Docker --------
✅ docker: Docker version 28.2.2, build e6534b4
✅ docker: Docker Compose version v2.36.2
-------- Other Utilities --------
✅ awk: GNU Awk 5.2.1, API 3.2, PMA Avon 8-g1, (GNU MPFR 4.2.1, GNU MP 6.3.0)
✅ curl: curl 8.5.0 (x86_64-pc-linux-gnu) libcurl/8.5.0 OpenSSL/3.0.13 zlib/1.3 brotli/1.1.0 zstd/1.5.5 libidn2/2.3.7 libpsl/0.21.2 (+libidn2/2.3.7) libssh/0.10.6/openssl/zlib nghttp2/1.59.0 librtmp/2.3 OpenLDAP/2.6.7
✅ git: git version 2.49.0
✅ grep: grep (GNU grep) 3.11
✅ gzip: gzip 1.12
✅ jq: jq-1.7
✅ make: GNU Make 4.3
✅ rg: ripgrep 14.1.0
✅ sed: sed (GNU sed) 4.9
✅ tar: tar (GNU tar) 1.35
✅ tmux: tmux 3.4
✅ yq: yq 0.0.0
```
You can check installed versions by adding commands like `node -v` to your setup script and clicking **Run to Validate**.
To view all preinstalled tools, you can use this command in your setup script and click **Run to Validate**.
```
set +x; . /opt/environment_summary.sh
```
## Add a setup script
To help Jules install dependencies and run tests:
1. Click on the repo on the left sidebar (under codebases)
2. Select Configuration at the top
3. In the "Initial Setup" window, enter the commands needed to install dependencies and prep your project
For example:
```bash
npm install
npm run test
## Test your setup script
Click **Run and Snapshot** to check that your setup script works. Upon success a snapshot of your environment will be created.
## Environment Snapshots
After you click **Run and Snapshot** you environment setup script will be run and you will see the results. Upon success, a snapshot of your environment is taken. This snapshot will be used for future Jules tasks started from this repository. This is especially useful for complex environments with long setup times.
## Validation tips
- You can check installed versions by adding commands like `node -v` to your setup script and clicking **Run to Validate**.
- Always include commands to install packages, run linters, or execute tests.
- Use the validation button to catch errors early.
- Keep your setup lightweight and fast
___
### Running tasks
Once you’ve logged in and connected GitHub, you’re ready to start coding with Jules. This guide walks through the key steps of running a task — from selecting a repo to writing your prompt and setting up notifications.
## Choose a repo and branch
Jules needs a repo and branch to work on. After logging in:
1. Open the **repo selector** dropdown.
2. Select the repository you'd like Jules to work on.
3. Choose the branch you want to base your changes on.
Jules remembers your last-used repo, so you'll always see the last used repo in the repo selector.
## Write a clear prompt
Jules works best when your prompt is specific and scoped. Use plain language — no need for perfect grammar or code.
## Attach visual context
You can upload images when initiating a task in Jules. Visuals like UI mockups, front-end glitches, screenshots, diagrams, or inspiration help clarify context when used with your natural language prompt. How to use it:
1. Drag-and-drop or browse to upload one or more images at task creation.
2. Total upload size must stay under 5MB.
3. Supported formats: PNG and JPEG.
4. Images are only attachable during initial task setup; not yet available in follow-up prompts.
Jules ingests these visuals to inform its understanding and output. They wont be embedded in code or committed to your repository. If you want visual assets included in code, upload them to your repo separately.
**✅ Good prompts**
- Add a loading spinner while ```fetchUserProfile``` runs
- Fix the 500 error while submitting the feedback form
- Document the `useCache hook with JSDoc`
**🚫 Avoid**
- Fix everything
- Optimize code
- Make this better
If Jules needs more clarity, it will ask for feedback before writing code.
## Watching Jules work
Once the plan is approved, Jules will start coding.
You will see:
- An **activity feed** as each step completes
- Inline explanations of each change
- A **mini diff** preview for each file
Use the **diff editor** for a full view across all files.
## Final summary & branch creation
When Jules finishes a task, it provides a summary of everything it accomplished.
- ✅ **Files changed**
- ⏱ **Total runtime**
- ➕ **Lines of code added/changed/removed**
- 🌿 **Option to create branch** and **commit message**
You can click **Create branch** to push the changes. Note that:
- You are the branch owner
- Jules appears as the commit author
- You can open a PR from this branch in GitHub

## Giving feedback mid-task
You can send feedback to Jules while it's working:
- Type directly into the chat box
- Ask Jules to change its approach, revise code, or clarify logic
- Jules will respond and, if needed, replan or revise the task
You can intervene at any time, you're in control.
## Pausing Jules
You can pause Jules at any time by clicking the **"pause"**.
When Jules is paused it won't do any work, and will wait for your next set of instructions. You can prompt it again, unpause it, or delete the task.
## Starting tasks from GitHub Issues
You can start a task from a **GitHub issue** by applying the label "jules" (case insensitive). Make sure that the Jules GitHub app is authorized to access the repo.
Select an issue, then click the gear icon next to "Labels". Then add the label "jules" (case insensitive) to the issue.
Soon, you will see Jules comment automatically on the issue. When Jules is finished with the issue, it will provide a link to the pull request where you can review its work.
___
### Scheduled tasks
Jules allows you to set up recurring tasks ensuring continuous execution of routine codebase maintenance, monitoring, or updates without the need for manual re-prompting.
## Creating a Scheduled Task
You can convert any standard task into a recurring one directly from the task input field.
1. Navigate to the main **Task Input** field.
2. Click the **Planning** dropdown located at the bottom right of the input area.
3. Select **Scheduled Task** from the menu.
4. Configure the **Frequency** and **Cadence** (e.g., Daily, Weekly) using the settings that appear at the top of the input field.
5. Write your task prompt and click **Submit**.

The task is now active and will execute automatically at the specified times.
## Managing Scheduled Tasks
Once a task is created, you can view and manage it within your dashboard.
To find your tasks, look for the **Scheduled** tab located immediately **under the text field** in the dashboard. From this view, you can:
* **Monitor Status**: See when the task last ran and when it is scheduled to run next.
* **Delete**: Remove the scheduled task permanently.
Editing an existing scheduled task is not currently supported. You will need to delete the task and create a new one.
## Common Use Cases
Scheduled tasks are best used for maintenance jobs that require consistency but minimal human oversight. We've added three templated scheduled tasks that our friends at [Stitch](https://stitch.withgoogle.com/) (Google's AI Design tool) uses. They include:
| Use Case | Description |
| :--- | :--- |
| **Performance** | A performance-obsessed agent who makes the codebase faster, one optimization at a time. |
| **Design** | UX-focused agent who adds small touches of delight and accessibility to the user interface. |
| **Security** | A security-focused agent who protects the codebase from vulnerabilities and security risks.
___
### Suggested tasks
Jules can autonomously scan your codebase to identify areas for improvement and propose implementation plans. These are presented as **Suggested Tasks**.
Currently, this experimental feature focuses on identifying and resolving **#TODO** comments left in your code, with more capabilities coming soon.
## Enabling Suggested Tasks
To receive suggestions, you must explicitly enable "Proactivity" for each repository you want Jules to monitor.
1. Navigate to the **Codebases** field in the left panel.
2. Select the specific repository (codebase) you wish to activate.
3. With the codebase selected, open the **Proactivity** tab in the left panel.
4. Toggle **Proactivity** to **On**.

Once enabled, Jules will immediately begin scanning the codebase. After a few minutes, if a resolvable issue is found, a suggestion will appear for your review.
**Note:** At launch, you are only able to enable proactivity on up to 5 repositories.
## Reviewing and Running Suggestions
When Jules identifies a potential task (such as a simple `#TODO`), it will surface a suggested fix. You will also recieve an email periodically when new tasks have been found.
1. Review the suggestion card that appears in your dashboard.
2. Click on the suggestion to see the context and the rationale.
3. If you agree with the plan, click **Start** to have Jules start working on the task.
## Feedback and Dismissal
You remain in control of your backlog. If a suggestion is not relevant or not a priority, you can dismiss a suggestion. Jules uses this feedback to better understand your preferences and improve future suggestions.
## Configuration & Limits
* **Scan Frequency**: Jules scans your repositories periodically to look for new suggestions.
* **Repository Limit**: You can currently enable Suggested Tasks on up to **five repositories**.
* **Current Scope**: The feature currently looks for **#TODO comments** that describe resolvable tasks.
___
### Planning
Once you start a task in Jules, it generates a **plan** before writing any code. This lets you know the direction Jules will take while it works on the task. From here, you can also iterate with Jules on the plan before any code is written.
## Reviewing the plan
After setup (cloning your repo, initializing the VM, and installing dependencies), Jules will present its plan.
You'll see:
- A natural language description of what Jules intends to direction
- Step-by-step breakdowns
- Any assumptions or setup steps
1. Open each step by expanding them to read through each one.
2. Give feedback using the chat input if you need.
3. Click **approve plan** when you're ready for Jules to begin executing and writing code.
**Note:** If you navigate away, Jules will eventually auto-approve the plan, which is set on a timer. So there is no need to babysit.

## Giving feedback
At any point, you can use the chat box to talk to Jules.
- Ask it to revise a step
- Point out something it missed
- Clarify your original request
- Answer its questions, or provide additional information Jules may need
Jules will respond and update its plan if needed.

___
### Reviewing code
Once you approve a plan, Jules begins working inside a virtual machine. As it completes steps, you’ll see an activity log with Jules' thoughts and code updates. This page walks you through what to look for and how to respond.
## Activity feed
As Jules works, you'll see a real-time **activity feed** that logs:
- Each step it completes
- Descriptions of what it did
- Any outputs or errors encountered
- Requests for additional information or feedback
This feed gives you insight into Jules' decision-making and progress.
## Code diffs
When Jules changes code, you’ll see a **mini diff** directly in the feed. For a more complete view:
- On the right pane, you can view a full screen expanded **diff editor** to see all changes across files
- The **diff editor** only shows files where it modified or added code.
- Expand the diff editor to full screen, or drag the left sidebar of the diff editor to slide it to your preferred width
You can download and copy code that Jules has written from the download and copy icons located in the top right of the diff editor panel. When you copy code, only the updated code will save to your clip board (not the full diff).
This is your central hub for understanding the scope of the changes Jules made to your repo.

## Interactive feedback
You can interact with Jules in real-time through the chat box:
- Ask it to revise logic or naming
- Request additional tests or cleanup
- Give corrections like "return an empty string instead of None"
## Task summary
When the task completes, Jules provides a final summary which includes:
- ✅ **Files changed**
- ⏱ **Total runtime**
- ➕ **Lines of code added/changed**
- 🌿 **Branch name** and **commit message**

## Pushing to GitHub
Click **Publish branch** or **Publish PR** to push Jules' changes to GitHub:
- Jules will appear as a commit author on the branch, if you manually create a PR from the branch, you will be the PR author
- When publishing a PR, Jules will appear as the creator of the PR
Once a branch is published, you can continue editing the branch, review it as a GitHub PR, or delete it.
Once a PR is created, you can send it for review, or merge the PR into your codebase.
___
### Managing tasks and repos
To start a new task:
1. Click the Jules icon to return to the home screen and a blank prompt input
2. Use the **+** button in the top navigation on the task view
3. From within a specific repo view, click **new task**
You can launch multiple tasks at a time to run them simultaneously. If you are viewing an existing task, or repo page when you kick off a new task, that task will load and begin running in the background. You will have to navigate to the task to check for updates, approve the plan, etc.
Each task runs in its own virtual machine and maintains its own logs, environment setup, and code changes.
## Pausing or deleting tasks
Sometimes you need to stop Jules mid-task or clean up old runs.
- To **pause** a task: click the **pause**.
- To **delete** a task: hover over the task in the repo view and click the **trash icon**.
> Paused tasks can be resumed later; deleted tasks are removed permanently.


## Managing repositories
Jules can only access repositories you explicitly allow through GitHub. In the future, Jules will work with more version control systems.
### Selecting a repo
If you've already granted Jules access to all your repos:
- Use the dropdown when starting a task to choose any authorized repo
- Enroll new from the left sidebar
- Search for your repo using the **repo selector**

### Granting access to more repos
To give Jules access to more of your repositories:
1. Go to [github.com](https://github.com)
2. Click your profile photo --> **settings**
3. In the left sidebar, click **applications**
4. Find **Google Labs Jules** and click **configure**
5. Under **repository access**, select additional repos
6. Click **save**
You can also authorize new repositories via the **repo selector** in Jules. Open the repo selector and scroll to the bottom to click on **+Add repository**. This will take you to GitHub, where you can select additional repositories to grant access for Jules.
___
### Repo view
The repo view gives you a focused workspace for interacting with a specific repository. From here, you can view task history, manage running tasks, and configure your environment.
## Accessing the repo view
There are two ways to open a repo view:
1. Click on any repository name from the sidebar task list
2. Select a repo from the task picker, then click into it after starting a task
This opens a view scoped to that repository, including task history and available actions.
## Viewing tasks by repo
Inside the repo view, you'll see a list of all tasks associated with that repo:
- **Running** tasks are listed at the top
- **Completed** tasks include full logs and diffs
- **Failed** or **waiting** tasks are clearly labeled
You can click on any task to reopen it, review the plan, or continue feedback.
## Starting a new task
From the repo view, you can start a new task scoped to that repository:
- Click **new tasks** in the top right corner
- This will preselect the repo and branch
- Enter your prompt and optimal setup script as usual
___
### Errors and failures
Even though Jules automates many parts of the development process, things can go wrong such as environment misconfigurations to task failures. This page covers how Jules reports errors, what it does automatically, and how you can debug issues.
## How errors are reported
Jules surfaces errors in two key places:
- The **activity feed**, where the step failed is logged
- A **notification badge** (red dot) in the UI
These errors can show up whether the task has failed completely or simply requires your intervention.
## Automatic retry behavior
Jules will attempt to retry failed steps automatically when possible. For example:
- Network hiccups
- Transient install errors
- Slow dependency resolutions
After multiple retries, if the problem persists, the task will be marked as **failed**.
## Common causes of failure
The most frequent issues are:
- Incomplete or missing **environment setup scripts**
- Prompts that are too vague or overly broad
- Repos with unusual or nonstandard build systems
- Long-running processes (like `npm run dev`) included in setup
## Debugging environment setup
You can retry a task by:
- Clicking **rerun** from the task summary view
- Modifying your setup script or prompt before restarting the task
Make sure to address any specific feedback from the failure logs.
___
### Usage and limits
# **Jules Plans**
Jules is available with different plans designed to meet your specific needs, from individual exploration to intensive, professional development. For our initial launch, paid plans are accessed through a Google One subscription.
**Note on Plan Availability**
Paid Jules plans are accessed via a Google AI Plans subscription, which is currently available only for individual Google Accounts (ending in @gmail.com).
We are actively working on providing upgrade paths for other user types. In the meantime, If you are a business power user and need more access to Jules, please fill out [this interest form](https://docs.google.com/forms/d/e/1FAIpQLSeYzhMjUyHoLlIYl83cAjdaBCjsxzlx1vzIkgYwU9AvB_wm9A/viewform?usp=dialog) and we will get back to you.
---
## **Plan Comparison**
The table below outlines the key differences between the available plans. All plans have access to the same powerful Gemini models, with different number of task limits. These offerings will evolve, with more advanced models and features planned in the future.
| Plan | Jules | Jules in Pro | Jules in Ultra |
| :---- | :---- | :---- | :---- |
| **Best For** | Evaluating Jules on real work | Daily coding with higher intensity | Power users & agent-heavy workflows |
| **Daily Tasks (rolling 24 hours)** | 15 | 100 | 300 |
| **Concurrent Tasks** | 3 | 15 | 60 |
| **Model Access** | Gemini 2.5 Pro | Higher access to the latest model (starting with Gemini 3 Pro) | Priority access to the latest model (starting with Gemini 3 Pro) |
## **How to Upgrade**
You can access the powerful features of our paid plans by subscribing to a corresponding Google AI plan.
### **Jules in Pro**
Jules in Pro is included as a benefit of the [**Google AI Pro plan**](https://one.google.com/ai). Upgrading gives you significantly higher task limits, perfect for professional development workflows.
### **Jules in Ultra**
Jules in Ultra is included as a benefit of the [**Google AI Ultra plan**](https://one.google.com/ai). This plan provides our highest limits for the most demanding, large-scale projects and workflows.
---
## **Frequently Asked Questions**
**Why are paid plans only available for @gmail.com accounts right now?**
For our initial launch, we are launching in the Google AI Plans, which currently serves individual Google Accounts. We are working to quickly support other upgrade paths for users who have enterprise or Workspace accounts.
**Will the features and limits in these plans change over time?**
We may adjust limits and features as we learn how people are using the product. Our goal is to continue adding value, especially to the Pro and Ultra tiers, with differentiators like access to more advanced models, queue prioritization, more planned for the future.
**If my Google One plan is shared with my family, are my Jules task limits shared?**
For this launch, task limits are not shared or pooled. Each member of a shared family plan is treated as an individual user with their own set of task limits.
**What happens if I use all my tasks for the day?**
Once you reach your daily task limit (rolling 24 hour window), you will not be able to trigger new tasks until the limit resets. When you are at your limit, you may see calls to action within the product prompting you to upgrade to a higher plan.
**I have a Google AI plan, but I can't access Jules. Why?**
Jules has a stricter age requirement than some Google One plans. To use Jules, you must be 18 years of age or older. Therefore, some members of a Google One plan who are under 18 may not have access to Jules benefits, even if the plan itself is active
**Can I still access my tasks when I hit a limit?**
When you hit a limit:
- The **new task** button will be disabled
- A tooltip or error message will explain the reason
- You can continue reviewing or managing existing tasks
- Task history and feedback are unaffected
___
### Feedback and support
Jules is in active development, and your feedback directly shapes what we build next. We want to hear from you whether you've found a bug, want to suggest an improvement, or have an idea for a feature.
## Giving feedback in the UI
You can send feedback directly from within Jules:
1. Click the **feedback** button in top the navigation bar
2. Select 👍 or 👎
3. Fill out the short form and submit
Your feedback goes directly to the Google Labs team.
## What happens after you submit feedback
Your feedback is reviewed by the Jules product and engineering team regularly. We use it to:
- Prioritize new features and fixes
- Understand friction points in your workflow
- Identify common patterns and corner cases
We won't be able to reply to every submission, but we do read all of them.
## Feature requests
Got something you'd love Jules to support? Tell us:
- What you were trying to do
- What got in your way
- How you imagine it could work
Clear, real-world examples are especially helpful.
**Thank you** for helping us make Jules better.
___
### FAQ
## What is Jules?
Jules is a software coding agent that helps you fix bugs, add documentation, update your app, and implement new features. It integrates with GitHub and works autonomously — meaning you can submit a task, go do something else, and return when it's done. Jules is currently in Public Beta.
## Is Jules available without cost?
Jules has multiple plans to fit your development needs, including a plan available to all users without cost. See the [Limits and Plans](./../usage-limits) section for more details.
## How does Jules work under the hood?
Each task runs in a fresh virtual machine where Jules clones your repo, installs dependencies, and makes changes based on your prompt. You can provide setup scripts to ensure your project builds and tests correctly.
## How does Jules run code, and what should I know about security?
When you run code in Jules, it's executed in a secure, cloud-based virtual machine (VM) with internet access. While this gives you powerful tools to test, build, and debug in context, it's important to treat the environment with the same security precautions you would for any public or shared compute surface. If you're not sure whether something is safe to run, we recommend reviewing it carefully (including non-code components). Jules is a large language model based system which operates on both the code and non-code files in a repository.
**You are responsible for the code you run.** That means:
- **Don’t commit secrets** (like API keys, tokens, or credentials) to your repo, especially if you’re pulling code into Jules from a Git provider.
- **Avoid known security vulnerabilities** in your dependencies or scripts. Consider following [GitHub’s Quickstart](https://docs.github.com/en/code-security/getting-started/quickstart-for-securing-your-repository) for securing your repository if you’re using GitHub.
- **Be cautious with third-party packages or shell commands** that could compromise your system, your data, or others.
## Can Jules run long-lived commands like ```npm run dev```?
No. Long-running processes like dev servers or watch scripts aren’t currently supported in setup scripts. Use discrete install/test commands instead.
## What languages does Jules support?
Jules is language agnostic but works best with projects that use:
- JavaScript/TypeScript
- Python
- Go
- Java
- Rust
Support depends on what's installed on the VM and the clarity of your environment setup script.
## Can I leave Jules while its working?
Yes! Jules is designed to be autonomous. You can leave the app after submitting a task. Make sure to [enable notifications](../#enabling-notifications) so you’ll be alerted when a plan is ready or a task completes.
## How do I provide feedback or report a bug?
Click the **[feedback](../feedback)** button in the bottom left of the Jules UI. No account or tracking system required — feedback goes straight to the team.
## What happens if a task fails?
Jules will retry automatically. If it continues to fail, it will mark the task as failed and notify you. Common causes include broken setup scripts or vague prompts.
You can revise and rerun the task once you've addressed the issue.
## How many tasks can I run?
Limits are listed [here](./../usage-limits).
## Can I change which repos Jules has access to?
Yes. Go to your GitHub settings:
1. Click your profile --> **settings**
2. Select **applications** in the sidebar
3. Find **Google Labs Jules** and click **configure**
4. Adjust repository access
Then refresh Jules and your new repos will appear. [Learn more about managing tasks and repositories](./../tasks-repos).
## Does Jules train on private repos?
No. Jules does **not** train on private repository content. Privacy is a core principle for Jules, and we do not use your private repositories to train models. [Learn more](https://jules.google.com/legal) about how your data is used to improve Jules.
___
### Contact
If you have any questions, feedback, or need assistance, please join our [Discord](https://discord.gg/googlelabs) or follow us on [X](https://x.com/julesagent).
___
## REST API
### Quickstart
The Jules REST API lets you programmatically access Jules's capabilities to automate and enhance your software development lifecycle. You can use the API to create custom workflows, automate tasks like bug fixing and code reviews, and embed Jules's intelligence directly into the tools you use every day, such as Slack, Linear, and GitHub.
The Jules REST API is in an alpha release, which means it is experimental. Be aware that we may change specifications, API keys, and definitions as we work toward stabilization. In the future, we plan to maintain at least one stable and one experimental version.
## Authentication
To get started with the Jules REST API, you'll need an API key.
### Generate Your API Key
In the Jules web app, go to the **[Settings](https://jules.google.com/settings#api)** page to create a new API key. You can have at most 3 API keys at a time.

### Use Your API Key
To authenticate your requests, pass the API key in the `X-Goog-Api-Key` header of your API calls.
Keep your API keys secure. Don't share them or embed them in public code. For your protection, any API keys found to be publicly exposed will be [automatically disabled](https://cloud.google.com/resource-manager/docs/organization-policy/restricting-service-accounts#disable-exposed-keys) to prevent abuse.
## API concepts
The Jules REST API is built around a few core resources. Understanding these will help you use the API effectively.
- **Source** — An input source for the agent (e.g., a GitHub repository). Before using a source using the API, you must first [install the Jules GitHub app](/docs/) through the Jules web app.
- **Session** — A continuous unit of work within a specific context, similar to a chat session. A session is initiated with a prompt and a source.
- **Activity** — A single unit of work within a Session. A Session contains multiple activities from both the user and the agent, such as generating a plan, sending a message, or updating progress.
## Your first API call
We'll walk through creating your first session with the Jules REST API using curl.
1. ### List your available sources
First, you need to find the name of the source you want to work with (e.g., your GitHub repo). This command will return a list of all sources you have connected to Jules.
```bash
curl -H "x-goog-api-key: $JULES_API_KEY" \
https://jules.googleapis.com/v1alpha/sources
```
The response will look something like this:
```json
{
"sources": [
{
"name": "sources/github/bobalover/boba",
"id": "github/bobalover/boba",
"githubRepo": {
"owner": "bobalover",
"repo": "boba"
}
}
],
"nextPageToken": "github/bobalover/boba-web"
}
```
2. ### Create a new session
Now, create a new session. You'll need the source name from the previous step. This request tells Jules to create a boba app in the specified repository.
```bash
curl 'https://jules.googleapis.com/v1alpha/sessions' \
-X POST \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $JULES_API_KEY" \
-d '{
"prompt": "Create a boba app!",
"sourceContext": {
"source": "sources/github/bobalover/boba",
"githubRepoContext": {
"startingBranch": "main"
}
},
"automationMode": "AUTO_CREATE_PR",
"title": "Boba App"
}'
```
The `automationMode` field is optional. By default, no PR will be automatically created.
The immediate response will look something like this:
```json
{
"name": "sessions/31415926535897932384",
"id": "31415926535897932384",
"title": "Boba App",
"sourceContext": {
"source": "sources/github/bobalover/boba",
"githubRepoContext": {
"startingBranch": "main"
}
},
"prompt": "Create a boba app!"
}
```
You can poll the latest session information using `GetSession` or `ListSessions`. For example, if a PR was automatically created, you can see the PR in the session output:
```json
{
"name": "sessions/31415926535897932384",
"id": "31415926535897932384",
"title": "Boba App",
"sourceContext": {
"source": "sources/github/bobalover/boba",
"githubRepoContext": {
"startingBranch": "main"
}
},
"prompt": "Create a boba app!",
"outputs": [
{
"pullRequest": {
"url": "https://github.com/bobalover/boba/pull/35",
"title": "Create a boba app",
"description": "This change adds the initial implementation of a boba app."
}
}
]
}
```
By default, sessions created through the API will have their plans automatically approved. If you want to create a session that requires explicit plan approval, set the `requirePlanApproval` field to `true`.
3. ### List sessions
You can list your sessions as follows:
```bash
curl 'https://jules.googleapis.com/v1alpha/sessions?pageSize=5' \
-H "x-goog-api-key: $JULES_API_KEY"
```
4. ### Approve a plan
If your session requires explicit plan approval, you can approve the latest plan as follows:
```bash
curl 'https://jules.googleapis.com/v1alpha/sessions/SESSION_ID:approvePlan' \
-X POST \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $JULES_API_KEY"
```
5. ### Interact with the agent
To list activities in a session:
```bash
curl 'https://jules.googleapis.com/v1alpha/sessions/SESSION_ID/activities?pageSize=30' \
-H "x-goog-api-key: $JULES_API_KEY"
```
To send a message to the agent:
```bash
curl 'https://jules.googleapis.com/v1alpha/sessions/SESSION_ID:sendMessage' \
-X POST \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $JULES_API_KEY" \
-d '{
"prompt": "Can you make the app corgi themed?"
}'
```
The response will be empty because the agent will send its response in the next activity. To see the agent's response, list the activities again.
## Next steps
___
### Overview
The Jules REST API allows you to programmatically create and manage coding sessions, monitor progress, and retrieve results. This reference documents all available endpoints, request/response formats, and data types.
## Base URL
All API requests should be made to:
```
https://jules.googleapis.com/v1alpha
```
## Authentication
The Jules REST API uses API keys for authentication. Get your API key from [jules.google.com/settings](https://jules.google.com/settings).
```bash
curl -H "x-goog-api-key: $JULES_API_KEY" \
https://jules.googleapis.com/v1alpha/sessions
```
## Endpoints
## Common Patterns
### Pagination
List endpoints support pagination using `pageSize` and `pageToken` parameters:
```bash
# First page
curl -H "x-goog-api-key: $JULES_API_KEY" \
"https://jules.googleapis.com/v1alpha/sessions?pageSize=10"
# Next page (using token from previous response)
curl -H "x-goog-api-key: $JULES_API_KEY" \
"https://jules.googleapis.com/v1alpha/sessions?pageSize=10&pageToken=NEXT_PAGE_TOKEN"
```
### Resource Names
Resources use hierarchical names following Google API conventions:
- Sessions: `sessions/{sessionId}`
- Activities: `sessions/{sessionId}/activities/{activityId}`
- Sources: `sources/{sourceId}`
### Error Handling
The API returns standard HTTP status codes:
| Status | Description |
|--------|-------------|
| `200` | Success |
| `400` | Bad request - invalid parameters |
| `401` | Unauthorized - invalid or missing token |
| `403` | Forbidden - insufficient permissions |
| `404` | Not found - resource doesn't exist |
| `429` | Rate limited - too many requests |
| `500` | Server error |
Error responses include a JSON body with details:
```json
{
"error": {
"code": 400,
"message": "Invalid session ID format",
"status": "INVALID_ARGUMENT"
}
}
```
___
### Authentication
The Jules REST API uses API keys for authentication. You'll need a valid API key to make API requests.
## Getting Your API Key
1. Go to [jules.google.com/settings](https://jules.google.com/settings)
2. Find the **API Key** section
3. Click **Generate API Key** (or copy your existing key)
4. Store the key securely — it won't be shown again
Keep your API key secret. Don't commit it to version control or share it publicly.
## Using Your API Key
Include the API key in the `x-goog-api-key` header with every request:
```bash
curl -H "x-goog-api-key: YOUR_API_KEY" \
https://jules.googleapis.com/v1alpha/sessions
```
### Environment Variable (Recommended)
Store your API key in an environment variable:
```bash
export JULES_API_KEY="your-api-key-here"
```
Then use it in requests:
```bash
curl -H "x-goog-api-key: $JULES_API_KEY" \
https://jules.googleapis.com/v1alpha/sessions
```
## Example: Create a Session
```bash
curl -X POST \
-H "x-goog-api-key: $JULES_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"prompt": "Add unit tests for the utils module",
"sourceContext": {
"source": "sources/github-owner-repo",
"githubRepoContext": {
"startingBranch": "main"
}
}
}' \
https://jules.googleapis.com/v1alpha/sessions
```
## Example: List Sessions
```bash
curl -H "x-goog-api-key: $JULES_API_KEY" \
https://jules.googleapis.com/v1alpha/sessions
```
## Troubleshooting
### "API key not valid"
- Verify you copied the entire key without extra spaces
- Check that the key hasn't been revoked in [settings](https://jules.google.com/settings)
- Generate a new key if needed
### "Permission denied"
- Verify your account has access to Jules
- Check that you have access to the requested resources (sessions, sources)
### "Quota exceeded"
- You may have hit rate limits
___
### Sessions
Sessions are the core resource in the Jules REST API. A session represents a unit of work where Jules executes a coding task on your repository.
## Create a Session
### Request Body
### Example Request
```bash
curl -X POST \
-H "x-goog-api-key: $JULES_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"prompt": "Add comprehensive unit tests for the authentication module",
"title": "Add auth tests",
"sourceContext": {
"source": "sources/github-myorg-myrepo",
"githubRepoContext": {
"startingBranch": "main"
}
},
"requirePlanApproval": true
}' \
https://jules.googleapis.com/v1alpha/sessions
```
### Response
Returns the created [Session](/docs/api/reference/types#session) object:
```json
{
"name": "sessions/1234567",
"id": "abc123",
"prompt": "Add comprehensive unit tests for the authentication module",
"title": "Add auth tests",
"state": "QUEUED",
"url": "https://jules.google.com/session/abc123",
"createTime": "2024-01-15T10:30:00Z",
"updateTime": "2024-01-15T10:30:00Z"
}
```
## List Sessions
### Query Parameters
### Example Request
```bash
curl -H "x-goog-api-key: $JULES_API_KEY" \
"https://jules.googleapis.com/v1alpha/sessions?pageSize=10"
```
### Response
```json
{
"sessions": [
{
"name": "sessions/1234567",
"id": "abc123",
"title": "Add auth tests",
"state": "COMPLETED",
"createTime": "2024-01-15T10:30:00Z",
"updateTime": "2024-01-15T11:45:00Z"
}
],
"nextPageToken": "eyJvZmZzZXQiOjEwfQ=="
}
```
## Get a Session
### Path Parameters
### Example Request
```bash
curl -H "x-goog-api-key: $JULES_API_KEY" \
https://jules.googleapis.com/v1alpha/sessions/1234567
```
### Response
Returns the full [Session](/docs/api/reference/types#session) object including outputs if the session has completed:
```json
{
"name": "sessions/1234567",
"id": "abc123",
"prompt": "Add comprehensive unit tests for the authentication module",
"title": "Add auth tests",
"state": "COMPLETED",
"url": "https://jules.google.com/session/abc123",
"createTime": "2024-01-15T10:30:00Z",
"updateTime": "2024-01-15T11:45:00Z",
"outputs": [
{
"pullRequest": {
"url": "https://github.com/myorg/myrepo/pull/42",
"title": "Add auth tests",
"description": "Added unit tests for authentication module"
}
}
]
}
```
## Delete a Session
### Path Parameters
### Example Request
```bash
curl -X DELETE \
-H "x-goog-api-key: $JULES_API_KEY" \
https://jules.googleapis.com/v1alpha/sessions/1234567
```
### Response
Returns an empty response on success.
## Send a Message
Use this endpoint to provide feedback, answer questions, or give additional instructions to Jules during an active session.
### Path Parameters
### Request Body
### Example Request
```bash
curl -X POST \
-H "x-goog-api-key: $JULES_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"prompt": "Please also add integration tests for the login flow"
}' \
https://jules.googleapis.com/v1alpha/sessions/1234567:sendMessage
```
### Response
Returns an empty [SendMessageResponse](/docs/api/reference/types#sendmessageresponse) on success.
## Approve a Plan
This endpoint is only needed when `requirePlanApproval` was set to `true` when creating the session.
### Path Parameters
### Example Request
```bash
curl -X POST \
-H "x-goog-api-key: $JULES_API_KEY" \
-H "Content-Type: application/json" \
-d '{}' \
https://jules.googleapis.com/v1alpha/sessions/1234567:approvePlan
```
### Response
Returns an empty [ApprovePlanResponse](/docs/api/reference/types#approveplanresponse) on success.
## Session States
Sessions progress through the following states:
| State | Description |
|-------|-------------|
| `QUEUED` | Session is waiting to be processed |
| `PLANNING` | Jules is analyzing the task and creating a plan |
| `AWAITING_PLAN_APPROVAL` | Plan is ready and waiting for user approval |
| `AWAITING_USER_FEEDBACK` | Jules needs additional input from the user |
| `IN_PROGRESS` | Jules is actively working on the task |
| `PAUSED` | Session is paused |
| `COMPLETED` | Task completed successfully |
| `FAILED` | Task failed to complete |
___
### Activities
Activities represent events that occur during a session. Use the Activities API to monitor progress, retrieve messages, and access artifacts like code changes.
## List Activities
### Path Parameters
### Query Parameters
### Example Requests
```bash
curl -H "x-goog-api-key: $JULES_API_KEY" \
"https://jules.googleapis.com/v1alpha/sessions/1234567/activities?pageSize=20"
```
```bash
# Define the endpoint to prevent overflow
ENDPOINT="https://jules.googleapis.com/v1alpha/sessions/1234567/activities"
TIMESTAMP="2026-01-17T00:03:53.137240Z"
curl -H "x-goog-api-key: $JULES_API_KEY" \
"$ENDPOINT?createTime=$TIMESTAMP"
```
### Response
```json
{
"activities": [
{
"name": "sessions/1234567/activities/act1",
"id": "act1",
"originator": "system",
"description": "Session started",
"createTime": "2024-01-15T10:30:00Z"
},
{
"name": "sessions/1234567/activities/act2",
"id": "act2",
"originator": "agent",
"description": "Plan generated",
"planGenerated": {
"plan": {
"id": "plan1",
"steps": [
{
"id": "step1",
"index": 0,
"title": "Analyze existing code",
"description": "Review the authentication module structure"
},
{
"id": "step2",
"index": 1,
"title": "Write unit tests",
"description": "Create comprehensive test coverage"
}
],
"createTime": "2024-01-15T10:31:00Z"
}
},
"createTime": "2024-01-15T10:31:00Z"
}
],
"nextPageToken": "eyJvZmZzZXQiOjIwfQ=="
}
```
## Get an Activity
### Path Parameters
### Example Request
```bash
curl -H "x-goog-api-key: $JULES_API_KEY" \
https://jules.googleapis.com/v1alpha/sessions/1234567/activities/act2
```
### Response
Returns the full [Activity](/docs/api/reference/types#activity) object:
```json
{
"name": "sessions/1234567/activities/act2",
"id": "act2",
"originator": "agent",
"description": "Code changes ready",
"createTime": "2024-01-15T11:00:00Z",
"artifacts": [
{
"changeSet": {
"source": "sources/github-myorg-myrepo",
"gitPatch": {
"baseCommitId": "a1b2c3d4",
"unidiffPatch": "diff --git a/tests/auth.test.js...",
"suggestedCommitMessage": "Add unit tests for authentication module"
}
}
}
]
}
```
## Activity Types
Activities have different types based on what occurred. Each activity will have exactly one of these event fields populated:
### Plan Generated
Indicates Jules has created a plan for the task:
```json
{
"planGenerated": {
"plan": {
"id": "plan1",
"steps": [
{ "id": "step1", "index": 0, "title": "Step title", "description": "Details" }
],
"createTime": "2024-01-15T10:31:00Z"
}
}
}
```
### Plan Approved
Indicates a plan was approved (by user or auto-approved):
```json
{
"planApproved": {
"planId": "plan1"
}
}
```
### User Messaged
A message from the user:
```json
{
"userMessaged": {
"userMessage": "Please also add integration tests"
}
}
```
### Agent Messaged
A message from Jules:
```json
{
"agentMessaged": {
"agentMessage": "I've completed the unit tests. Would you like me to add integration tests as well?"
}
}
```
### Progress Updated
A status update during execution:
```json
{
"progressUpdated": {
"title": "Writing tests",
"description": "Creating test cases for login functionality"
}
}
```
### Session Completed
The session finished successfully:
```json
{
"sessionCompleted": {}
}
```
### Session Failed
The session encountered an error:
```json
{
"sessionFailed": {
"reason": "Unable to install dependencies"
}
}
```
## Artifacts
Activities may include artifacts—outputs produced during execution:
### Code Changes (ChangeSet)
```json
{
"artifacts": [
{
"changeSet": {
"source": "sources/github-myorg-myrepo",
"gitPatch": {
"baseCommitId": "a1b2c3d4e5f6",
"unidiffPatch": "diff --git a/src/auth.js b/src/auth.js\n...",
"suggestedCommitMessage": "Add authentication tests"
}
}
}
]
}
```
### Bash Output
```json
{
"artifacts": [
{
"bashOutput": {
"command": "npm test",
"output": "All tests passed (42 passing)",
"exitCode": 0
}
}
]
}
```
### Media
```json
{
"artifacts": [
{
"media": {
"mimeType": "image/png",
"data": "base64-encoded-data..."
}
}
]
}
```
___
### Sources
Sources represent repositories connected to Jules. Currently, Jules supports GitHub repositories. Use the Sources API to list available repositories and get details about specific sources.
Sources are created when you connect a GitHub repository to Jules through the web interface. The API currently only supports reading sources, not creating them.
## List Sources
### Query Parameters
### Example Request
```bash
curl -H "x-goog-api-key: $JULES_API_KEY" \
"https://jules.googleapis.com/v1alpha/sources?pageSize=10"
```
### Response
```json
{
"sources": [
{
"name": "sources/github-myorg-myrepo",
"id": "github-myorg-myrepo",
"githubRepo": {
"owner": "myorg",
"repo": "myrepo",
"isPrivate": false,
"defaultBranch": {
"displayName": "main"
},
"branches": [
{ "displayName": "main" },
{ "displayName": "develop" },
{ "displayName": "feature/auth" }
]
}
},
{
"name": "sources/github-myorg-another-repo",
"id": "github-myorg-another-repo",
"githubRepo": {
"owner": "myorg",
"repo": "another-repo",
"isPrivate": true,
"defaultBranch": {
"displayName": "main"
},
"branches": [
{ "displayName": "main" }
]
}
}
],
"nextPageToken": "eyJvZmZzZXQiOjEwfQ=="
}
```
### Filtering
Use the `filter` parameter to retrieve specific sources:
```bash
# Get a specific source
curl -H "x-goog-api-key: $JULES_API_KEY" \
"https://jules.googleapis.com/v1alpha/sources?filter=name%3Dsources%2Fgithub-myorg-myrepo"
# Get multiple sources
curl -H "x-goog-api-key: $JULES_API_KEY" \
"https://jules.googleapis.com/v1alpha/sources?filter=name%3Dsources%2Fsource1%20OR%20name%3Dsources%2Fsource2"
```
## Get a Source
### Path Parameters
### Example Request
```bash
curl -H "x-goog-api-key: $JULES_API_KEY" \
https://jules.googleapis.com/v1alpha/sources/github-myorg-myrepo
```
### Response
Returns the full [Source](/docs/api/reference/types#source) object:
```json
{
"name": "sources/github-myorg-myrepo",
"id": "github-myorg-myrepo",
"githubRepo": {
"owner": "myorg",
"repo": "myrepo",
"isPrivate": false,
"defaultBranch": {
"displayName": "main"
},
"branches": [
{ "displayName": "main" },
{ "displayName": "develop" },
{ "displayName": "feature/auth" },
{ "displayName": "feature/tests" }
]
}
}
```
## Using Sources with Sessions
When creating a session, reference a source using its resource name in the `sourceContext`:
```bash
curl -X POST \
-H "x-goog-api-key: $JULES_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"prompt": "Add unit tests for the auth module",
"sourceContext": {
"source": "sources/github-myorg-myrepo",
"githubRepoContext": {
"startingBranch": "develop"
}
}
}' \
https://jules.googleapis.com/v1alpha/sessions
```
Use the List Sources endpoint to discover available source names, then use the Get Source endpoint to see available branches before creating a session.
___
### Types
This page documents all data types used in the Jules REST API.
## Core Resources
### Session
A session represents a unit of work where Jules executes a coding task.
### SessionState
Enum representing the current state of a session:
| Value | Description |
|-------|-------------|
| `STATE_UNSPECIFIED` | State is unspecified |
| `QUEUED` | Session is waiting to be processed |
| `PLANNING` | Jules is creating a plan |
| `AWAITING_PLAN_APPROVAL` | Plan is ready for user approval |
| `AWAITING_USER_FEEDBACK` | Jules needs user input |
| `IN_PROGRESS` | Jules is actively working |
| `PAUSED` | Session is paused |
| `FAILED` | Session failed |
| `COMPLETED` | Session completed successfully |
### AutomationMode
Enum for session automation settings:
| Value | Description |
|-------|-------------|
| `AUTOMATION_MODE_UNSPECIFIED` | No automation (default) |
| `AUTO_CREATE_PR` | Automatically create a pull request when code changes are ready |
---
### Activity
An activity represents a single event within a session.
---
### Source
A source represents a connected repository.
---
## Plans
### Plan
### PlanStep
---
## Artifacts
### Artifact
### ChangeSet
### GitPatch
### BashOutput
### Media
---
## GitHub Types
### GitHubRepo
### GitHubBranch
### GitHubRepoContext
---
## Context Types
### SourceContext
---
## Output Types
### SessionOutput
### PullRequest
---
## Activity Event Types
### PlanGenerated
### PlanApproved
### UserMessaged
### AgentMessaged
### ProgressUpdated
### SessionCompleted
No additional properties.
### SessionFailed
---
## Request/Response Types
### SendMessageRequest
### SendMessageResponse
Empty response on success.
### ApprovePlanRequest
Empty request body.
### ApprovePlanResponse
Empty response on success.
### ListSessionsResponse
### ListActivitiesResponse
### ListSourcesResponse
___
## Jules Tools (CLI)
### Reference
Jules Tools is a lightweight command-line interface (CLI) for interacting with Jules, Google's autonomous AI coding agent. It allows you to manage coding sessions, inspect progress, and integrate Jules into your existing development workflows and scripts directly from your terminal.
Think of Jules Tools as both a command surface and a dashboard for your coding agent, designed to keep you in your flow without needing to switch to a web browser.
## Installation
To get started, install the tool globally using npm or pnpm.
```
npm install -g @google/jules
```
Once installed, the jules command will be available in your terminal.
### Authentication
Before you can use the tool, you must authenticate with your Google account.
### Login
```
jules login
```
This command will open a browser window to guide you through the Google authentication process.
### Logout
To log out from your account:
```
jules logout
```
## Usage
The CLI is built around commands and subcommands. You can get help for any command by using the -h or --help flag.
```
# Get general help
jules help
# Get help for a specific command (e.g., remote)
jules remote --help
```
### Global Flags
- `-h`, `--help`: Displays help information for jules or a specific command.
- `--theme `: Sets the theme for the terminal user interface (TUI). Options are `dark` (default) or `light`.
Example: `jules --theme light`
### Available Commands
`version`
Shows the currently installed version of the Jules Tools CLI.
```
jules version
```
`remote`
The `remote` command is the primary way to interact with Jules sessions running in the cloud. It has several subcommands.
`remote list`
Lists your connected repositories or active sessions.
- `--repo`: Flag to list all repositories connected to Jules.
- `--session`: Flag to list all your remote sessions.
_Examples:_
```
# List all connected repositories
jules remote list --repo
# List all active and past sessions
jules remote list --session
```
`remote new`
Creates a new remote session to delegate a task to Jules.
Jules can automatically infer the repository from your current working directory, so you can often omit the `--repo` flag.
- `--repo `: Specifies the repository for the session (e.g., torvalds/linux or . for the current directory's repo).
- `--session ""`: A string describing the task for Jules to perform.
- `--parallel `: Starts multiple parallel sessions to work on the same task.
_Example:_
```
# Start a new session to write unit tests in the 'torvalds/linux' repo
jules remote new --repo torvalds/linux --session "write unit tests"
```
`remote pull`
Pulls the results (e.g., code changes) from a completed session.
- `--session `: The ID of the session you want to pull.
_Example:_
```
# Pull the results for session ID 123456
jules remote pull --session 123456
```
`completion`
Generates an autocompletion script for your shell (e.g., bash, zsh) to enable tab completion for jules commands.
```
# Generate completion script for bash
jules completion bash
```
## Interactive Dashboard (TUI)
For a more interactive, visual experience, you can launch the Terminal User Interface (TUI) by running the jules command without any arguments.
```
jules
```
The TUI provides a dashboard view of your sessions, a side-by-side diff viewer for reviewing changes, and guided flows for creating new ones, similar to the web UI.
___
### Examples
Jules Tools is designed to be scriptable and can be composed with other command-line tools.
Below are some examples of Jules Tools in action:
**1. Create sessions from a TODO.md file:**
Assign each line item from a local TODO.md file as a new session in the current repository.
```
cat TODO.md | while IFS= read -r line; do
jules remote new --repo . --session "$line"
done
```
**2. Create a session from a GitHub Issue:**
Pipe the title of the first GitHub issue assigned to you directly into a new Jules session. (Requires the gh and jq CLIs).
```
gh issue list --assignee @me --limit 1 --json title \
| jq -r '.[0].title' \
| jules remote new --repo .
```
**3. Use Gemini to analyze and assign the hardest issue to Jules:**
Use the Gemini CLI to analyze your assigned GitHub issues, identify the most tedious one, and pipe its title to Jules.
```
gemini -p "find the most tedious issue, print it verbatim\n$(gh issue list --assignee @me)" \
| jules remote new --repo .
```
___
## Changelog
### All Updates
> Content not found for: /changelog/
___
### Jules Turndown
We’re writing to let you know that as part of our work to unify our agentic coding efforts, Jules will wind down on December 31, 2026. You have until November 11, 2026 to continue finishing up sessions. After November 11, 2026, we will be turning Jules to read-only until the end of the year.
When we launched Jules, it was an experiment to learn how asynchronous coding agents could help you tackle your backlog and ship faster. What you built with it taught us where agentic development is headed, and those learnings are shaping products across Google, including our agent-first platform, Google Antigravity.
You can now export everything Jules knows about your work into a local folder: account settings, environment variables, scheduled tasks, connected repositories, memories, setup scripts, and every session, including its prompt, plan, full activity log, and code patches.
Your code, branches, and pull requests already live in GitHub, so they stay where they are. The export covers the configuration and history that live inside Jules.
To export, install [Jules Tools](/docs/cli/reference) and sign in:
```bash
npm install -g @google/jules
jules login
```
Then open a CLI coding agent, such as [Antigravity CLI](https://antigravity.google/product/antigravity-cli), from your home directory and paste the export prompt below. The agent checks your setup, runs the export, and tells you what it saved.
Show the export prompt
````text title="Export prompt"
I want to export all my data from Google Jules into a local folder: settings, environment
variables, scheduled tasks, connected repos, memories, setup scripts, and every session (prompt,
plan, full activity log, and code patches). Please do this in order:
1. Setup
- Check whether the Jules CLI is installed (`which jules`). If it isn't, install it with
`npm install -g @google/jules`. If npm isn't installed, tell me and stop.
- Check whether I'm logged in: `security find-generic-password -s jules-cli -a default`
on macOS (metadata only, without -w), or `secret-tool lookup service jules-cli username default`
on Linux. If there's no entry, ask me to run `! jules login` myself. It's an interactive
browser sign-in, so don't try to run it for me. Wait until I say it's done.
- Run `jules remote list --repo`. If it fails with a 401 and asks about GitHub, tell me to
connect my GitHub account at
https://github.com/apps/google-labs-jules/installations/select_target and wait for me to
confirm. If I've never used Jules with GitHub repos, I can skip this; the export will just
have no repo data.
2. Export: save the script below to a file and run it from my home directory. Then tell me what
was exported (the counts it prints) and the full path of the folder. Don't print my access
token or the values in env-variables.json.
Problems someone else already ran into:
- The Jules CLI stores its login in the macOS Keychain (service "jules-cli", account "default")
as "go-keyring-base64:". The script decodes that. The access token expires about
an hour after login; if you get 401s on every call, run any `jules` command or ask me to run
`! jules login` again.
- If ListSources returns 401 "missing required authentication credential" but the other calls
work, my GitHub account isn't connected to Jules (see step 1).
- Settings, env vars, repos and memories come from an internal `$rpc` endpoint. Sessions come
from REST endpoints under https://aida.googleapis.com/v1/swebot (/tasks, /tasks/{id},
/tasks/{id}/activities), which are what the CLI itself uses. Both are undocumented, so if a
call starts returning 404/400, tell me which one rather than guessing at fixes.
- The repo list doesn't include setup scripts or test commands; the script recovers them from
each session's code output (repoMetadata). Empty memories responses ({}) just mean there are
no memories.
- The API may return a few more sessions than `jules remote list --session` shows (older ones).
That's expected.
```python
import base64, json, pathlib, re, subprocess, sys, urllib.error, urllib.parse, urllib.request
def get_token():
for cmd in [["security", "find-generic-password", "-s", "jules-cli", "-a", "default", "-w"],
["secret-tool", "lookup", "service", "jules-cli", "username", "default"]]:
try:
out = subprocess.check_output(cmd, stderr=subprocess.DEVNULL).decode().strip()
if out.startswith("go-keyring-base64:"):
out = base64.b64decode(out.split(":", 1)[1]).decode()
if out: return json.loads(out)["access_token"]
except Exception: pass
p = pathlib.Path.home() / ".jules/cache/oauth_creds.json"
if p.exists(): return json.loads(p.read_text())["access_token"]
sys.exit("Run `jules login` first.")
TOKEN = get_token()
HEADERS = {"Authorization": f"Bearer {TOKEN}", "Content-Type": "application/json"}
RPC = "https://aida.googleapis.com/$rpc/language_labs.aida.swebot.proto.SweBotService"
REST = "https://aida.googleapis.com/v1/swebot"
OUT = pathlib.Path("./jules-export"); OUT.mkdir(exist_ok=True)
errors = []
def rpc(m, b=None):
req = urllib.request.Request(f"{RPC}/{m}", data=json.dumps(b or {}).encode(), headers=HEADERS, method="POST")
with urllib.request.urlopen(req, timeout=60) as r: return json.loads(r.read().decode() or "{}")
def get(path, **params):
q = ("?" + urllib.parse.urlencode(params)) if params else ""
with urllib.request.urlopen(urllib.request.Request(f"{REST}{path}{q}", headers=HEADERS), timeout=60) as r:
return json.loads(r.read().decode() or "{}")
def paged(fetch, key):
items, token = [], None
while True:
resp = fetch(token)
items += resp.get(key, [])
token = resp.get("nextPageToken")
if not token: return items
def safe(s): return re.sub(r"[^a-zA-Z0-9._-]", "_", s)
def dump(path, obj): path.parent.mkdir(parents=True, exist_ok=True); path.write_text(json.dumps(obj, indent=2))
# Account-level data
dump(OUT / "user-settings.json", rpc("GetUserSettings"))
dump(OUT / "env-variables.json", rpc("ListEnvironmentVariables"))
dump(OUT / "scheduled-tasks.json", rpc("ListScheduledTasks"))
# Repos (sources) and their memories
sources = paged(lambda t: rpc("ListSources", {"pageSize": 100, **({"pageToken": t} if t else {})}), "sources")
dump(OUT / "sources.json", sources)
mem_repos = 0
for src in sources:
sid = src.get("sourceId") or src.get("id") or src.get("name", "").removeprefix("sources/")
try:
mems = paged(lambda t: rpc("ListMemories", {"sourceId": sid, "pageSize": 100, **({"pageToken": t} if t else {})}), "memories")
except urllib.error.HTTPError as e:
errors.append(f"memories {sid}: HTTP {e.code}"); continue
if mems:
mem_repos += 1
d = OUT / "repos" / safe(sid)
dump(d / "memories.json", mems)
(d / "memories.md").write_text("# Memories\n\n" + "\n".join(
f"- {m.get('Fact') or m.get('fact') or m.get('content')}" for m in mems if not m.get("archived")) + "\n")
# Sessions: full detail, activity log, patches, and a readable summary
sessions = paged(lambda t: get("/tasks", pageSize=100, **({"pageToken": t} if t else {})), "tasks")
dump(OUT / "sessions.json", sessions)
setup = {} # latest setup script / test command seen per repo
patches = 0
for s in sorted(sessions, key=lambda s: s.get("createdAt", "")):
tid = s["id"]; d = OUT / "sessions" / tid
try:
task = get(f"/tasks/{tid}").get("task", {})
acts = paged(lambda t: get(f"/tasks/{tid}/activities", pageSize=100, **({"pageToken": t} if t else {})), "activitySteps")
except urllib.error.HTTPError as e:
errors.append(f"session {tid}: HTTP {e.code}"); continue
dump(d / "session.json", task)
dump(d / "activities.json", acts)
commits = [o["gitCommit"] for o in task.get("outputs", []) if "gitCommit" in o]
for i, c in enumerate(commits, 1):
if c.get("patch", {}).get("unidiff"):
(d / f"patch-{i}.diff").write_text(c["patch"]["unidiff"]); patches += 1
meta = c.get("repoMetadata", {})
if meta.get("environmentSetupScript") or meta.get("testCommand"):
setup[task.get("sourceId") or meta.get("name") or tid] = meta
plan = task.get("latestPlan", {}).get("steps", [])
kinds = {}
for a in acts:
for actor, v in a.items():
if isinstance(v, dict):
for k in v: kinds[f"{actor}.{k}"] = kinds.get(f"{actor}.{k}", 0) + 1
lines = [f"# {task.get('title') or s.get('suggestedTitle') or tid}", "",
f"- **ID:** {tid}", f"- **Repo:** {task.get('sourceId', '')}",
f"- **Status:** {task.get('taskStatus', '')}", f"- **Created:** {task.get('createdAt', '')}",
f"- **Completed:** {task.get('completedAt', '')}", "", "## Prompt", "", task.get("description", ""), ""]
if plan: lines += ["## Latest plan", ""] + [f"{p.get('index', 0) + 1}. {p.get('title', '')}" for p in plan] + [""]
if commits: lines += ["## Code outputs", ""] + [
f"- `patch-{i}.diff`: {c.get('title') or (c.get('commitMessage') or '').split(chr(10))[0]} (branch `{c.get('gitBranchName', '')}`)"
for i, c in enumerate(commits, 1)] + [""]
if pub := task.get("latestPublish", {}).get("commitInfo"):
lines += ["## Published", "", f"- Commit `{pub.get('commitId', '')}` on `{pub.get('branchName', '')}`", ""]
lines += ["## Activity", "", f"{len(acts)} steps (full log in `activities.json`):", ""] + [f"- {k}: {n}" for k, n in sorted(kinds.items())]
(d / "summary.md").write_text("\n".join(lines) + "\n")
for sid, meta in setup.items():
d = OUT / "repos" / safe(sid); d.mkdir(parents=True, exist_ok=True)
if meta.get("environmentSetupScript"): (d / "setup.sh").write_text(meta["environmentSetupScript"] + "\n")
if meta.get("testCommand"): (d / "test-command.txt").write_text(meta["testCommand"] + "\n")
print(json.dumps({"repos": len(sources), "repos_with_memories": mem_repos, "sessions": len(sessions),
"patches": patches, "repos_with_setup_or_test": len(setup),
"error_count": len(errors), "errors": errors[:10]}, indent=2))
print(f"Exported all Jules data to {OUT.resolve()}")
```
````
Your data lands in `~/jules-export`: connected repositories in `sources.json`, a folder per repository with its setup script, test command, and memories, your settings, environment variables, and scheduled tasks as JSON, and a folder per session with a readable `summary.md`, the full activity log, and its diffs.
`env-variables.json` contains your environment variable values, so keep the export folder private and out of your repositories. If you use Jules with GitHub, make sure your [GitHub account is connected](https://github.com/apps/google-labs-jules/installations/select_target) first, or the export won't include repository data.
___
### Gemini 3.1 Pro is now available in Jules

Gemini 3.1 Pro is now available in Jules for Google Pro plan users. 3.1 Pro is a smarter, more capable baseline for complex problem-solving.

This replaces Gemini 3 Pro as the default model for Pro users. Give it a try and let us know what you think.
___
### Auto-Fixing CI Failures and configure Jules to commit as you
### CI Fixer
Jules now automatically detects and fixes CI failures on pull requests it creates. When a check fails in GitHub Actions, Jules receives the error, works through a fix, and resubmits the PR — all without manual intervention.

Previously, a failed CI check on a Jules PR would stall your workflow. Resolving it required setting up REST API calls or manually copy-pasting error logs back to Jules. CI Fixer closes that gap. Jules now operates in a loop — fixing, committing, and resubmitting — so your PRs keep moving forward.
### Commit Authoring
You can now control how commits from Jules are attributed on GitHub. Three authorship modes are available:
* **Jules:** Jules is the sole author of all commits (default, existing behavior).
* **Co-authored (Jules + You or You + Jules):** Commits are co-authored by both you and Jules, crediting both contributors.
* **User only:** You are the sole author. Jules applies its changes under your identity.

Previously, Jules authored every commit and PR, which meant your GitHub contribution graph didn't reflect the work you initiated. Setting the commit authorship in to co-authored to you or you + Jules, makes it clear to contributors and PR reviewers who is driving each change.
It applies at the user level across all repositories and all task types — scheduled, suggested, and manually triggered tasks.
#### Setting commit authorship
1. Go to the Jules Settings page
1. Open the **Commit Authoring** section
1. Select your preferred authorship mode
1. All future sessions will use the selected attribution
___
### MCP support comes to Jules

Today we're launching MCP Server support in Jules starting with: Linear, Stitch, Neon, Tinybird, Context7, and Supabase.
Add a service connection in the Settings page and will trigger the MCP server tools in a session when it detects the need for a tool call.
### Getting started
Our MCP server integration uses API key authentication. To get started:
1. Get the service's API key (such as Linear or Stitch)
1. Go to the Jules Settings page
1. Click on the MCP section
1. Plug in your API key for that specific service
1. Kick off a new session
1. Jules will trigger the MCP server tools when it detects the need for the call

### Focus on Security
It might seem odd for us to limit which MCP servers Jules can connect to. However, we are wanted to start with a focus on security. Jules operates within a cloud development environment connected to your GitHub repositories, so we prioritize a **security-first** approach to third-party integrations.
By hand-selecting these initial servers, we can:
* **Validate Data Flow:** We ensure that each server adheres to strict data-handling standards, keeping your source code and API keys isolated.
* **Audit Tool Permissions:** We verify that each server only requests the specific permissions it needs to function, preventing "over-privileged" access to your environment.
* **Ensure Stability:** A vetted integration means fewer connection drops and a more predictable experience when Jules interacts with your external data.
We plan to expand this list as we work with more partners.
### Tell us what to add next
If you have an MCP server in mind, you can let us know in the settings panel what we should add next.
___
### Gemini 3 Flash is now the base model in Jules

Today we're launching Gemini 3 Flash in Jules for all users on all tiers.
It's our new base model that's faster and significantly more capable than our previous base model, Gemini 2.5 Pro. If it feels like Jules feels like it had a double espresso, you now know why.

Give it a spin and let us know what you think.
___
### Introducing the Planning Critic for Auto-Approved Plans

We’ve introduced a secondary agent—the Planning Critic—to review all plans that do not require human intervention. Before Jules executes a single line of code, this agent rigorously critiques and refines the proposed plan. While this adds a small amount of time to the planning phase, the result is a 9.5% reduction in task failure rates and significantly higher quality execution paths.
___
### Jules now finds performance optimizations

Jules now surfaces Performance Optimizations Jules has expanded its detection capabilities.
In addition to standard TODOs, Jules now proactively identifies performance optimizations within your code. These suggestions appear alongside your existing TODOs in the Suggested Tasks view, helping you catch bottlenecks and inefficiencies just as easily as you catch unfinished code.
___
### REST API: Repoless, File Outputs, and Activity Filters
```shell
PROMPT_CONTENT=$(jq -Rs . < my_prompt.md)
curl 'https://jules.googleapis.com/v1alpha/sessions' \
-X POST \
-H "Content-Type: application/json" \
-H "x-goog-api-key: $JULES_API_KEY" \
-d "{
\"prompt\": $PROMPT_CONTENT,
\"
```
### Repoless support in the REST API
Repoless comes to the REST API and we think this has **massive potential**. A repoless session in a sense becomes serverless, because it creates an ephemeral cloud dev environment with Node, Python, Rust, Bun, and other runtimes preloaded on the image.
The massive potential is that this serverless environment comes with an AI coding agent.
With a single API call you can spawn a serverless dev environment with only the context in your prompt. When it's done you can download the file outputs from the session.
We can't wait to see what you all do with this one.
### Get the entire file outputs from a session
```
┌──────────────────────────────────────────────────────────────────────────────┐
│ FILES CHANGED │
├──────────────────────────────────────────────────────────────────────────────┤
│ [M] bun.lock +567 -163 │
│ [A] bunfig.toml +2 -0 │
│ [M] examples/simple/main.ts +2 -1 │
│ [M] packages/core/src/client.ts +21 -6 │
│ [M] packages/core/src/network/adapter.ts +46 -13 │
│ [A] packages/core/src/retry-utils.ts +89 -0 │
│ [M] packages/core/src/sources.ts +2 -0 │
│ [M] packages/core/src/streaming.ts +15 -51 │
│ [M] packages/core/src/types.ts +12 -0 │
│ [M] packages/core/tests/automated_session.test.ts +125 -0 │
│ [M] packages/core/tests/network/adapter.test.ts +109 -0 │
│ [A] packages/core/tests/retry-utils.test.ts +140 -0 │
│ [M] packages/core/tests/sources.test.ts +21 -0 │
├──────────────────────────────────────────────────────────────────────────────┤
│ Summary: 13 files changed +1,151 insertions, -234 │
└──────────────────────────────────────────────────────────────────────────────┘
Session finished: completed
```
Speaking of file outputs, we just made that a lot easier. When a session completes a task, you can now get the entire change set.
This is stored in a git patch format for parsing changes such as additions, modifications, and deletions.
### Timestamp based filters for Session Activities
```bash
ENDPOINT="https://jules.googleapis.com/v1alpha/sessions/1234567/activities"
TIMESTAMP="2026-01-17T00:03:53.137240Z"
curl -H "x-goog-api-key: $JULES_API_KEY" \
"$ENDPOINT?createTime=$TIMESTAMP"
```
Each Jules Session has a collection of activities that represent the steps Jules took to complete the task. These activities are immutable and can be used to reconstruct the session.
Activities follow the event source pattern, meaning once they occur they never change. They are a record in time of the steps Jules took to complete the task. Since they never change, you can cache them aggressively.
We added a `createTime` filter that works like a range cursor and allows you to only fetch new activities over the network.
This may seem like a small optimization but stay tuned. We have some big news around this one.
___
### Update Scheduled Tasks

Quick quality-of-life update: You no longer need to delete and recreate a scheduled task just to fix a typo or change the timing.
You can now **Edit**, **Pause**, and **Resume** your tasks directly from the menu. It’s a small change that saves a lot of clicking.
___
### Enable suggested tasks to let Jules find issues proactively

Jules can now work proactively in the background to improve your code. With Suggested Tasks, Jules scans your repository for potential improvements and presents them on your repo page.
To get started, enable the proactive suggestions toggle on the repo page.
- **Tackle the #TODOs**: In this initial release, Jules focuses on identifying `#TODO` comments in your code. It reads the context, formulates a plan, and presents it for your approval—turning idle comments into active solutions. More use cases coming soon.
- **Continuous Improvement**: Once enabled, Jules continuously monitors your codebase. You don't have to ask; just check your dashboard for new suggestions and approve the ones you want.
This experimental feature is available today for Google AI Pro and Ultra subscribers on up to five repositories.
Read more at: [Suggested Tasks](https://jules.google/docs/suggested-tasks/).
___
### Put routine maintenance on autopilot with Scheduled Tasks

You can now set recurring tasks for Jules. Whether it’s a weekly dependency check, a nightly lint fix, or a monthly cleanup, just define it once and Jules will handle the rest on your schedule.
To get started, navigate to the **Scheduled** tab on your repo page to configure your first task.
- **Set it and forget it**: Define your maintenance chores once. Jules will wake up, perform the task, and open a PR without you needing to lift a finger.
- **Never miss a beat**: No more manual prompts for the stuff that needs to happen every week. Ensure consistent code quality and dependency hygiene by automating your routine work.
This feature is available today for all Jules users.
Read more at: [Scheduled Tasks](https://jules.google/docs/scheduled-tasks/).
___
### Automated fixes for Render deployments

We’ve integrated with Render to handle the last mile of shipping code. Jules can now detect failed builds, analyze the logs, and push fixes to its PRs before you even know your build failed.
To enable this, go to your Render Dashboard, open the Help menu (top-right), and click Coding Agents to provision your API Key. Paste this key into Settings > Integrations in Jules.
1. **Instant Recovery:** No more context switching to dig through console logs. Jules detects the failure immediately and identifies the root cause.
2. **Proactive Fixes:** Instead of just alerting you to an error, Jules writes the code to fix it. Review the solution as a standard commit on your PR, merge it, and get back to green.
This integration is available now. Check out the [docs](/integrations) for the full setup guide, including enabling PR previews.
**Note:** For now, Jules only fixes PRs it has created.
___
### Start from scratch—instantly

You can now start a Jules task immediately without selecting a repository. We’ve removed the speed bump between your idea and your code, allowing you to capture that spark of inspiration without the overhead.
To trigger this, simply click the "X" next to the selected repo to start a fresh, repoless session.
- **Skip the Detour**: Previously, starting a fresh journey meant hopping over to GitHub to create an empty repo first. Now, you can bypass that context switch entirely and keep your momentum.
- **Instant Ideation**: Whether you are prototyping a new feature or writing a quick script, you can dive straight into the logic. Just describe what you want, and Jules gets to work.
This update is available now for all users starting a new task.
___
### Introducing Gemini 3 Pro

Gemini 3 Pro is now available in Jules. This is the newest generation of the Gemini family, bringing clearer reasoning, stronger instruction following, and a meaningful lift in day-to-day reliability.
- **Coherent Planning**: Multi-step tasks hold together more naturally. The agent requires less management during transitions, meaning your work moves forward with fewer detours.
- **Visual Verification**: Leveraging the improved multimodal capabilities of Gemini 3 Pro, Jules renders and verifies web app outcomes with significantly higher precision.
- **Agentic Memories**: The new model utilizes context more effectively, helping Jules adapt to your coding preferences and project nuances more reliably over time.
Gemini 3 Pro is rolling out now to Google AI Ultra users and will be available to Pro users in the coming days.
___
### New Jules Tools CLI Updates: Side-by-Side Diffs, Repo Inference, and More

We've been busy shipping a bunch of new updates to the Jules Tools CLI to make your experience smoother and more powerful. Here’s a rundown of what’s new:
#### Parallel Task Execution
You can now start multiple parallel tasks for the same prompt using the `--parallel` flag with `jules remote new`. This is useful for getting multiple suggestions from Jules at once (max of 5).
- **Added**: `--parallel` flag to `remote new` command.
#### v0.1.40 - WSL/Arch Linux Credential Fixes
We've refactored how we handle authentication to resolve credential issues for users on WSL and Arch Linux. This means broader platform support and no more login issues.
#### v0.1.39 - OAuth2 Error Handling Improvements
We've enhanced our OAuth2 flow to be more resilient with better error recovery, making the authentication process more reliable.
#### v0.1.38 - Repository Inference Feature
To shorten CLI commands and reduce configuration, we've added repository inference. Now, Jules can automatically detect the repository from your current directory, so you don't have to specify it manually.
#### v0.1.37 - PNPM Installation Fixes
We've added better support for the PNPM package manager, ensuring full compatibility for a wider range of JavaScript projects.
#### v0.1.36 - Side-by-Side Diff Viewer + Bug Fixes
Reviewing code is now faster and more readable with the new side-by-side diff viewer in the TUI. We've also added comprehensive test coverage and fixed bugs related to auto-approval and timeout validation.
___
### Introducing the Jules API

You can now programmatically access Jules's capabilities to automate your work and build powerful integrations. The Jules API is designed to help you seamlessly integrate Jules into your existing development workflows, unlocking new ways to automate and enhance the entire software development lifecycle.
**With the API, you can:**
- Create custom integrations with tools like Slack for "ChatOps" workflows, allowing you to assign tasks directly from your chat client.
- Automate bug fixing and feature implementation by connecting Jules to your project management tools like Linear or Jira.
- Integrate Jules directly into your CI/CD pipelines in services like GitHub Actions.
Here’s a quick example of how to create a new task (a "Session") using a cURL command:
```
curl 'https://jules.googleapis.com/v1alpha/sessions' \
-X POST \
-H "Content-Type: application/json" \
-H 'X-Goog-Api-Key: YOUR_API_KEY' \
-d '{
"prompt": "Create a boba app!",
"sourceContext": {
"source": "sources/github/bobalover/boba",
"githubRepoContext": {
"startingBranch": "main"
}
},
"title": "Boba App"
}'
```
For more examples see the [API documentation](https://developers.google.com/jules/api).
___
### Jules in the command line

We’re launching Jules Tools, a new command-line interface designed to give you direct control over your AI coding agent, making it scriptable, customizable, and easy to integrate into your existing workflows.
**Key Features:**
- **Direct Control:** Create tasks (jules remote new), list active sessions (jules remote list), and monitor Jules without leaving your command line.
- **Apply Patches Locally:** Instantly pull work-in-progress code from an active Jules session and apply it to your local machine. This lets you test changes immediately, without waiting for a commit to GitHub.
- **Scriptable & Composable:** Integrate Jules into your automations by piping in output from other tools like gh, jq, or cat.
- **Interactive Dashboard:** For a more guided experience, launch the built-in terminal user interface (TUI) to create and manage tasks step-by-step.
**How to Install:**
Install globally via npm:
```npm install -g @google/jules```
Or run directly without a permanent installation:
```npx @google/jules```
**Starter Commands to Try:**
See all available commands:
```jules help```
List all repos connected to Jules:
```jules remote list --repo```
Create a new task in a specific repo:
```jules remote new --repo torvalds/linux --session "write unit tests"```
If you run into any issues, please share your experience with us via in-app feedback or on our [Discord channel](https://discord.com/channels/1172568727942860810/1374062797519847505).
___
### Use Environment Variables In Jules

You can now provide Jules with environment variables at the repository level. This enables Jules to access the project-specific configurations it needs to complete tasks, like running builds, executing tests, or interacting with different services.
**How It Works**:
- **Add Variables in Repo Settings:** Navigate to your repository's settings page to add your environment variables. They will be associated directly with your project.
- **Enable for a Task:** When you start a new task with Jules, you'll have the option to make these environment variables available to it.
- **Task-Long Access:** Once enabled for a specific task, Jules will have access to the variables for the entire duration of that task. Please note that this setting cannot be changed after the task has begun.
We're excited to see how this unlocks new and more complex workflows for you and your team! Let us know if you have any feedback.
___
### Jules gains memory!

**Jules Memory for Repositories:** We're excited to introduce a new Memory feature! Jules now has the ability to learn from your interactions.
- **How it works:** During a task, Jules will save your preferences, nudges, and corrections.
- **The benefit:** The next time you run the same or a similar task in that specific repository, Jules will reference its memory to better anticipate your needs and follow your established patterns, leading to more accurate results with less guidance.
- **Settings:** You can toggle memory on or off for the repo in the repo settings page under “Knowledge”
___
### Tell Jules exactly what file to work on using file selector

You can now tell Jules exactly which files to work with for any given task. Use the new file selector to easily and precisely reference specific files.
This removes ambiguity and gives you more granular control over Jules's actions, helping to tighten the context for your task.
___
### Jules Acts on PR Feedback

Jules is now able to read and respond to your comments on pull requests!
When you start a review, Jules will add a 👀 emoji to each comment to let you know it's been read. Based on your feedback, Jules will then push a commit with the requested changes.
For more control, you can switch to **Reactive Mode** in your [global Jules UI settings](https://jules.google.com/settings). In this mode, Jules will only act on comments where you specifically mention `@Jules`.
___
### All Hands on Deck!

Ahoy, mateys! To celebrate International Talk Like a Pirate Day, we've given Jules a temporary map to the treasure.
- Jules Speaks Pirate: You'll find your AI agent's responses are a bit more... swashbuckling... for today only.
- Same Great Logic: Fear not! Beneath the eyepatch and Jolly Roger, it's the same powerful coding engine ready to help you plunder that backlog and send bugs to Davy Jones' locker.
___
### Image upload

You can now upload images when creating a task in Jules. Use this to show frontend bugs, design inspiration, UI mocks, or any visual context you want Jules to consider while generating code.
For now:
- Only JPEG and PNG formats are supported.
- You can uplaod as many images as you want, as long as the total size is under 5MB.
- Image upload is only supported at task creation (we're working on enabling it for follow-up prompts soon).
Note: If your task involves using assets (e.g. logos) directly in code, those must still be committed to your GitHub repo.
[Read more](https://jules.google/docs/running-tasks/) about Jules image support.
___
### Stacked Diff

To improve the code review experience, we've introduced a new stacked layout for the diff viewer. This change displays diffs for multiple files vertically on a single screen. The stacked view makes it easier to see related changes across your codebase at a glance, providing better context and speeding up your review process.
Changes:
- The diff viewer now stacks file changes vertically by default
- You can also toggle back to the previous tabbed diff viewer
___
### Improved Jules Critic

We've shipped significant improvements to the Jules critic agent, making its feedback more insightful and reliable. To increase transparency and give you more insight into its evaluation process, you can now see the critic's real-time analysis as it works.
Changes:
- The critic's thought process is now visible in the UI, showing its step-by-step evaluation of the code in real-time.
- The critic's now incorporates more contextual information when making decisions, leading to more accurate and relevant feedback on potential bugs and logic flaws.
___
### Jules Sample Prompts

To help new users get started with Jules, we've added sample prompts to the home page. These static prompts provide examples of how to use Jules and can be added to the text box with a single click.
Changes:
- Sample prompts are now displayed on the home page for all users.
- Clicking on a sample prompt will add the text of the prompt to the input box.
___
### Render images in the diff viewer

Jules now intelligently renders images within the diff viewer, providing an immediate visual context for your modifications.
This means:
- Instant Visual Feedback: When Jules generates images (like charts, diagrams, or web UI screenshots), you'll see the actual image in the diff, not just its code representation.
- Streamlined Workflow: No need to switch between tools or download files to see the results. Jules keeps everything in one place.
Try it out! Ask Jules to render an output, like a graph based on data, and commit it to your repository. You'll be able to see the generated image seamlessly within your diff viewer.
___
### Export at any time

You're now in full control of when your code gets to GitHub. No need to wait for a task to finish or ask Jules to do it for you. At any point during a task, just click the GitHub icon in the top right to publish the current work-in-progress as a new branch or open a pull request. This gives you more flexibility and control to review, test, or take over whenever you’re ready.
___
### Increasing the VM Size to 20GB
We heard your feedback about running into disk space limits on larger projects. To address this, we've significantly increased the available disk space in the Jules VM to 20GB. This provides more room for large dependencies, build artifacts, and complex repositories, reducing disk-related failures so Jules can tackle bigger tasks. Happy Julesing!
___
### Jules can surf the web

Jules can now proactively search the web for relevant content, documentation, or code snippets to help complete your tasks. This means Jules can get the information it needs, resulting in more accurate and successful task completion.
In Summary:
- Jules can find the latest documentation for dependencies/libraries you're using
- Jules can proactively find examples or code snippets that can help inform its implementation
**Note**: web search works best when working on technical documentation. Queries like: "What is the latest news today?" are not supported.
___
### Interactive Plan

Meet Interactive Plan. Instead of jumping straight to the solution, Jules will now read your codebase, ask clarifying questions, and work with you to refine the plan. This collaborative approach gives you more control and ensures you're on the same page, leading to higher-quality code and a more reliable solution.
In summary:
- Trigger the interactive plan from the dropdown when you start a task
- Jules will start a brainstorm with you and ask clarifying questions
___
### Critic Agent

Great developers don’t just write code, they question it. And now, so does Jules. We’ve built the Jules critic agent to ensure that every line of code isn't just functional, but robust, secure, and efficient. It acts as an internal peer reviewer, challenging every proposed change to elevate the quality of the final output.
Some high level notes:
- **Critic-augmented generation:** The Jules critic is integrated directly into the generation process. Every proposed change undergoes adversarial review before completion.
- **Improved code quality:** The critic flags subtle bugs, missed edge cases, and inefficient code. Jules then uses this feedback to improve the patch in real-time.
- **A new kind of review:** The critic is not just another linter or test. It understands the intent and context behind code, similar to a human peer reviewer.
- **Built on research:** This feature draws on research into multi-step, tool interactive critiquing and actor-critic reinforcement learning, where an "actor" generates and a "critic" evaluates.
___
### Jules can test web-apps and show you the results

Next time you are working on a front end project with Jules, ask it to verify its work and it'll render the website and send you back a screenshot!
- Ask Jules to complete a web development task and to verify the front end
- Jules will send you a screenshot of the front end along with any code changes
- The default Jules base image now includes Playwright for front end testing
- Users can also add images in the form of public URLs for Jules to use as input
___
### Jules is out of beta!

Today we are thrilled to announce that Jules is no longer in beta! Since launch just two months ago, Jules has passed over 140k public commits. Thank you to our amazing beta users for all your support and feedback.
In addition, we’re launching our pricing plans to unlock higher task limits, along with a bunch of quality improvements in the Jules app and agent. Here are the details:
- Get higher task limits through the Google AI Pro and Ultra plans. More details at [Limits and Plans](./../usage-limits).
- Jules now uses the power of Gemini 2.5 thinking when creating its plan, resulting in higher quality plans and more complete tasks
- Numerous bug fixes so Jules gets stuck less, and is better at following your instructions in agents.md
___
### Environment snapshots for faster tasks

Jules now creates a snapshot of your environment when you add environment setup scripts. For complicated environment, users should see faster and more consistent task execution.
In summary:
- Jules will now snapshot your environment when you provide an environment setup script
- Snapshots are loaded automatically next time you run a task
- This provides for faster task startups, especially for complex environments
- You can find environment configuration by clicking the “codebase” in the left hand panel, or by clicking the “configure environment” button in the task pane.
___
### Open A PR directly from Jules

Closing the loop from task to merge 🤝
Jules can now open a pull request directly from the UI.
After a task completes, just use the new dropdown next to the ‘Publish Branch’ button to open a PR. Jules will request to merge the newly published branch into main, streamlining your entire workflow. Less context switching, faster merging.
___
### Added Bun runtime support

Jules now supports [Bun](https://bun.sh/). You can run tasks using Bun out of the box, no extra setup required. This expands compatibility for projects that use Bun instead of Node.
[Read more](https://jules.google.com/docs/environment/) about the jules base image and what tooling works with Jules.
___
### Improved task controls and other 💅 UI delight

- Pause, resume, and delete tasks—without losing your sense of place. Available from sidebar and repo view. You can even quickly copy task urls!
- Non-urgent task icons are now more recessive
- Certain hover states—which did not look good—have been toned back.
- System messages have more consistent padding and borders
[Learn more about running a task.](https://jules.google.com/docs/running-tasks/)
___
### Jules now listens to GitHub issues

Add the label 'jules' to any GitHub issue to start a task in Jules. That’s it—label on, task live.
How to summon Jules:
- Open a GitHub issue.
- Click the gear next to “Labels”.
- Add the label 'jules.'
Make sure the Jules GitHub App has access to your repo. After that, Jules takes it from there. [Read more about running tasks in Jules](https://jules.google/docs/running-tasks/)!
___
### Jules Agent Update: Faster, Smarter, More Reliable

We’ve shipped a big upgrade to the Jules agent under the hood.
What’s new:
- **Smarter context.** Jules reads from AGENTS.md if it’s in your repo.
- **Improved performance.** Tasks now complete faster—no numbers to share just yet, but you’ll feel it.
- **Significantly reduced punting.** We tightened the loop to keep Jules moving forward.
- **More reliable setup.** If you’ve added an environment setup script, Jules now runs it consistently.
- **Better test habits.** Jules is more likely to write and run tests on its own.
Check out the [Getting Started](https://jules.google/docs/) guide to learn more about AGENTS.md support.
___
### Modernized base environment and updated toolchains

We've overhauled the Jules development environment to move beyond the default Ubuntu 24.04 LTS packages. This includes:
- Explicitly installing newer versions of key toolchains like Rust, Node, and Python, addressing long-standing version issues.
- Adding finer-grained control over installation steps via custom scripts instead of relying solely on apt.
- Introducing support for multiple runtimes, improved isolation, and version pinning to reduce drift and better match developer expectations.
These changes unblock several issues developers encountered with outdated dependencies and improve alignment with modern project requirements.
[Read about the Jules environment setup to learn more about what’s pre-installed.](https://jules.google/docs/environment/)
___
### Customization and Efficiency Enhancements

**Performance upgrades:** Enjoy a smoother, faster Jules experience with recent under-the-hood improvements.
**Quickly copy and download code:** New copy and download buttons are now available in the code view pane, making it easier to grab your code directly from Jules.
**Stay focused with task modals:** Initiate multiple tasks seamlessly through a new modal option, allowing you to keep your context and workflow intact. [Learn more](https://jules.google/docs/tasks-repos/) about kicking off tasks.
**Adjustable code panel:** Customize your workspace by adjusting the width of the code panel to your preferred viewing experience.
[Check out the docs](https://jules.google/docs/code/) to learn more about how to download code that Jules writes.
___
### A faster, smoother and more reliable Jules
This week, our focus has been on improving reliability, fixing our GitHub integration, and scaling capacity.
**Here’s what’s we shipped:**
- Updated our limits to 60 tasks per day, 5 concurrent.
- We substantially improved the reliability of the GitHub sync. Export to GitHub should also be fixed on previously created tasks.
- We’ve decreased the number of failure cases by 2/3
Learn more [about usage limits.](./../usage-limits)
___
### Improving Stablity
We’ve been heads down improving stability and fixing bugs—big and small—to make Jules faster, smoother, and more reliable for you.
**Here’s what’s fixed:**
- Upgraded our queuing system and added more compute to reduce wait times during peak usage
- Publish Branch button is now part of the summary UI in the activity feed so it's easier to find
- Bug vixes for task status and mobile
[Learn more](https://jules.google.com/docs/code/#pushing-to-github) about how to publish a branch on GitHub.
___
### Jules is here

Today, we're launching **Jules,** a new AI coding agent.
Jules helps you move faster by working autonomously on tasks in your GitHub repo. It can fix bugs, update dependencies, migrate code, and add new features.
Once you give Jules a task, it spins up a fresh dev environment in a VM, installs dependencies, writes tests, makes the changes, runs the tests, and opens a pull request. Jules shows its work as it makes progress, so you never have to guess what code it's writing, or what it's thinking.
**What Jules can do today**
- Fix bugs with test verified patches
- Handle version bumps and dependency upgrades
- Perform scoped code transformations
- Migrate code across languages or frameworks
- Ship isolated, scoped, features
- Open PRs with runnable code and test results
[Get started with the Jules documentation](/), and visit jules.google.com to run your first Jules task.
___