Agentic coding with Google Jules

If you like coding agents, such as Gemini CLI and its competitors, but you get tired of supervising them closely and you would like to see a coding agent that does more on its own, safely, then consider Google Jules. The goal here is to have a tool that is an amplifier for your software development efforts. People used to hope for 10x amplification of programming productivity. Now they are speculating about 100x.

“Jules is an experimental coding agent that helps you fix bugs, add documentation, and build new features. It integrates with GitHub, understands your code base, and works asynchronously—so you can move on while it handles the task,” according to Google’s description. Jules has a web interface and runs in the Google cloud.

By “integrates with GitHub,” Google means that Jules connects with and uses your GitHub repository, which pretty much guarantees that you can review its code and reject anything you don’t like. That makes Jules inherently safe. Jules runs in a virtual machine, where it clones your code, installs dependencies, and modifies files.

You interact with Jules using Jules Tools, a command-line interface (CLI) that allows you to delegate coding tasks to Jules and monitor its progress. A CLI is the most natural way to interact with a coding agent for many programmers and for most use cases.

Google Jules competes with OpenAI Codex Cloud and Codex CLI, Claude Code, Windsurf, Augment Code, Amp, Cline, Zencoder, and Google’s own Gemini CLI. There are differences among all of these, of course.

Getting started with Jules

To start using Jules, visit jules.google.com, sign in with your Google account, and accept the one‑time privacy notice. Then connect Jules to your GitHub repositories by clicking “Connect to GitHub account,” completing the login flow, and choosing “all” or specific repos that you want to connect to Jules. I chose “all.” Then go back to Jules.

You’ll see something like the second screen shot below, where you can pick a repo and a branch to work on, and enter a prompt. You might like to get your bearings (in 90 seconds) from this video.

Screen shot of Jules intro page. The buttons at the top right are live links. The page below what’s shown explains how Jules works.
Foundry

Jules opening page. I have already connected Jules to my GitHub repositories, selected a repo and branch, and typed a prompt: “Pick an open bug report and try to fix it.” The next step will be to generate and review a plan. The repo is one I forked.
Foundry

Getting started with Jules Tools

To get started, install the tool globally using npm:

[sudo] npm install -g @google/jules

To authenticate, log in:

jules login

The commands you can use in Jules Tools are here.

Jules VM

Jules runs code in a secure, cloud-based virtual machine (VM) with internet access running Ubuntu Linux. The preinstalled developer tools include Node.js, Bun, Python, Go, Java, Rust, and more. You can add a setup script on a per-repo basis using the “Configuration” option. I thought I might need to do that for a TypeScript project, but it was handled by npm without my intervention.

Running tasks with Jules

You can start Jules working on your tasks in several ways. In the web interface, as we discussed earlier, pick a repo and a branch to work on, and then enter a prompt. If you have files or images to add to the prompt for context, use the paper clip icon at the lower left. Drop down the plan selector and choose “Interactive plan,” “Review plan,” or “Plan and go,” depending on your preference. Then click on the right arrow to kick off the task.

Be specific. Jules calls the Gemini model, which (sadly) can’t read your mind. “Fix this” or “Fix everything” are too vague to work. On the other hand, “Pick an open bug report and try to fix it” should work fine on a repository that has open bug reports. If and when the session is successful, you’ll have the opportunity to either modify the original branch or create a new branch with the fix, and the option to create and submit a pull request (PR) if you wish.

You can also run tasks from Jules Tools. The basic non-interactive command is:

jules remote new --repo --session ''

For example:

jules remote new --repo torvalds/linux --session 'write unit tests'

Finally, you can start tasks from a GitHub issue by applying the label “jules” (case insensitive).

Reviewing plans and code

Jules’ plans start with a description of its intentions, a step-by-step breakdown, and assumptions or set-up steps. You can open each step to see its details if you wish. You can give feedback in the chat. When you’re ready, click “Approve plan.” If you don’t respond, Jules will eventually auto-approve its plan.

You can chat with Jules at any time, even if it’s working. For example, you can 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 update its plan if it needs to.

Jules displays an activity feed as it works. When it makes code changes, it displays a mini-diff. You can expand a mini-diff into a full diff editor. As with plans, you can comment on code to give feedback, ask for revisions, or ask for additional tests or cleanup.

Managing Jules tasks and your repos

To start a new task, click on the Jules icon to get to the home screen, click the + button in a task view, or click “New session” in a repo view. You can pause or delete active tasks from the task view. You can give Jules access to more repositories in GitHub by clicking the “Add repository” item at the bottom of the repo selector drop-down.

Using Jules Tools

Jules Tools does a decent job of documenting itself:

martinheller@Mac Code % jules help
A CLI for Jules, the asynchronous coding agent from Google.

Usage:
jules [flags]
jules [command]

Examples:
jules # Launch the TUI
jules remote list --session # List all the sessions on Jules
jules remote list --repo # List all the repos connected to Jules
jules remote pull --session 123456 # Pull the result of the session (ID: 123456)

# Create a remote session
jules remote new --repo torvalds/linux --session 'write unit tests'

# Create multiple remote sessions for each task in TODO.md
cat TODO.md | while IFS= read -r line; do
jules remote new --repo. --session '$line';
done

# Create a remote session based on the first issue that's assigned to @me on this GitHub repo
gh issue list --assignee @me --limit 1 --json title | jq -r '.[0].title' | jules remote new --repo.

# Use Gemini CLI to analyze GitHub issues and send the hardest one to Jules
gemini -p 'find the most tedious issue, print it verbatimn$(gh issue list --assignee @me)' | jules remote new --repo.

Available Commands:
completion Generate the autocompletion script for the specified shell
help Help about any command
login Login your Google account to use Jules
logout Logout your Google account
remote Interact with remote sessions, e.g. new/list/pull
version Show the version

Flags:
-h, --help help for jules
--theme string Which theme to use, dark/light (default 'dark')

Use 'jules [command] --help' for more information about a command.

Note that Jules Tools can also update itself. On a Mac where the CLI has been installed globally, that requires root (sudo) privilege.

Some tests with Jules

I tested Jules in two forked repos, websocket (Go) and qwen-code (TypeScript). In both cases I asked it to pick an open bug report and try to fix it. I could have used some of the script suggestions in the Jules Tools help; I didn’t want to complicate things.

Jules settings. Note that I’m on the basic plan.
Foundry

Jules is offering to notify me when it is ready for me to review a plan or results.
Foundry

The black boxes are progress notifications. The boxes with blue numbers are the plan.
Foundry

Plan items 1 and 2 are complete, and the code changes are shown at the right.
Foundry

All done, waiting for my review. Jules’ code review is glowing, which you might interpret as sucking up—to itself. This was a particularly easy fix to make.
Foundry

Viewing the new branch generated by Jules in my fork of the websocket repo. Note the two files modified one minute ago.
Foundry

Forking another public repo, QwenLM/qwen-code, so that I can test Jules on it.
Foundry

I’m using the same prompt on a different repo. This project is much more active and has many open bug reports.
Foundry

Jules Tools, displaying its terminal UI. The CLI interacts with the Jules web and allows you to manage multiple Jules sessions.
Foundry

Progress on the qwen-code bug fix. The code changes look good, but the changes to the JSON file shouldn’t be included in the PR. Note that there were build errors, which Jules noticed and fixed.
Foundry

In its code review, Jules noticed the problem with the JSON file and in response, the main Jules thread removed it from the fix.
Foundry

We’re looking at the “blame” view of the new branch of my qwen-code fork in GitHub. The logic change is in lines 28 to 30 (at right) of the file we’re viewing (at left). Digging into the commit would have shown us essentially the same information if we hadn’t known where to look.
Foundry

Well done, Jules

I was pleasantly surprised by how well Jules performed. Putting gemini-2.5-pro inside a feedback loop where it can see compiler, linter, and run-time errors greatly improves the final results. That made Jules behave better than Gemini CLI, and more like Claude Code and OpenAI Codex.

I did my review within the constraints of the free Jules plan, which allows 15 daily tasks and three concurrent tasks. If I were using it heavily for real work, I could see paying for the Google AI Pro plan, which allows 100 daily tasks and 15 concurrent tasks, for $19.99 per month. That doesn’t necessarily mean that I would give up my ChatGPT or GitHub Copilot subscriptions, however.

As always, you are responsible for reviewing, testing, and debugging the code produced by any AI, even though agents like Jules do a certain amount of that themselves. And as has been the case for the last couple of years, new AI models and agents are dropping frequently, to the extent that not even someone tracking the field full-time can keep up with all the new developments.

Cost

Free basic plan with 15 daily tasks, three concurrent. Google AI Pro plan: 100 daily tasks, 15 concurrent, $19.99/month. Google AI Ultra plan: 300 daily tasks, 60 concurrent, $249.99/month.

Platform

Node.js for Jules CLI; Windows, macOS, Linux.

Bottom line

Google’s Jules performs better than its Gemini CLI despite using the same model, and more like Anthropic’s Claude Code and OpenAI’s Codex. Just be sure to cast a cold eye on its output, as you would any AI model or agent, since they are prone to making things up.

Pros

Works fairly well to generate and fix code in GitHub repositories.

Can operate asynchronously for moderately complex changes.

You can interrupt it at any time.

Limits are per task, not per token.

Cons

Currently limited to GitHub repos.

May not be as good as OpenAI’s Codex or Anthropic’s Claude Code for some use cases.

You need to double-check its work.