Agentic AI Coding with Google Jules

Image by Author

# Introduction

 
If you have been writing code in the past couple of months, I am pretty sure you must have noticed a shift. AI is no longer something that just suggests snippets; it has gone beyond that, it’s starting to act. Developers are moving from assistive tools like Copilot to agentic systems that understand a goal, plan a sequence of steps, and execute them on their own.

Google Jules sits at the front of that curve. It’s not a chat assistant that lives in your IDE; it’s a fully asynchronous coding agent. You tell it what you want fixed, updated, or tested, and it does the work remotely, from cloning your repo, editing code in a secure cloud VM, running tests, and opening a pull request for review.

The difference is subtle but profound: Jules doesn’t wait for you to type. It acts independently, guided by your intent and the context of your codebase. It reads your documentation, runs builds, shows its plan before touching anything, and even explains each change in a diff view. While you focus on architecture or design, Jules quietly handles the maintenance tasks that consume most of a developer’s day, such as version bumps, flaky tests, forgotten docstrings, and low-impact bugs.

# What Makes Jules Different?

 
Most AI coding tools still live inside your editor. They autocomplete functions, suggest patches, or refactor small snippets while you supervise line by line. Jules doesn’t do that. It moves the entire workflow outside your local environment and runs it asynchronously in the cloud.

When you assign Jules a task, let’s say, “Upgrade the app to Next.js 15 and migrate to the app directory,” it doesn’t just predict. It pulls your repository from GitHub, sets up a virtual machine, installs dependencies, writes and tests the changes, and presents a plan and diff before making any changes to your main branch.

That end-to-end workflow is what makes Jules different from suggestion-based assistants like Copilot or Cody. It’s not helping you write code faster; it’s helping you finish work you’d rather not do at all.

The platform is built around four core ideas:

• GitHub-Native Integration — Jules works through issues, branches, and pull requests like a teammate. You can even assign it tasks directly by adding the jules label to an issue.
• Cloud Execution Environment — Every task runs in a clean Ubuntu VM with Node.js, Python, Go, Rust, Java, and Docker preinstalled. No local setup, no dependency drift.
• Transparent Reasoning — Jules shows you its plan, explains each step, and generates diffs before merging. You see exactly what it’s thinking.
• Asynchronous Autonomy — Once started, Jules keeps working even if you close the browser. You get notified when it’s done.

# The Jules Architecture

 
Jules is a workflow system wrapped around a large language model, Gemini 2.5 Pro,  and a cloud-based execution layer. It combines structured automation with agent reasoning, meaning every step (plan, edit, test, PR) is observable, traceable, and reversible.

Image by Author

Here’s how it actually works behind the scenes:

• Task Initialization: When you describe a task (“Add integration tests for auth.js”), Jules creates a session linked to your GitHub repo and branch. It fetches the repository metadata and environment hints from files like README.md or AGENTS.md.
• Environment Setup: Jules spins up a short-lived Ubuntu virtual machine in the cloud. It installs your dependencies automatically or runs your setup script — npm install, pytest, make build, whatever you define. Everything runs in isolation, so your repo stays safe.
• Reasoning and Planning: Using Gemini 2.5 Pro, Jules analyzes the codebase and your prompt to produce a plan: which files to modify, which functions to touch, and which tests to create. It presents this plan for review before executing. You can edit or approve it directly in the interface.
• Code Generation and Testing: Once approved, Jules executes each step inside the VM. It writes or modifies code, runs the test suite, validates the output, and logs every result in an activity feed. This is where you can watch Jules “think aloud” — explaining why it changed each file.
• Diff and Review: Every edit comes with a Git diff. You can expand it, review the patch, and download or copy snippets. Jules explains each change in natural language and often links it back to the plan step that caused it.
• Commit and PR Creation: Finally, Jules pushes the updated branch to GitHub and opens a pull request, where you (or your CI pipeline) can review and merge. You stay the owner of the repo — Jules only commits as an assistant.

The entire system runs asynchronously. You can close your laptop, get coffee, or work on another branch while Jules finishes a build or test run. When it’s done, it sends a browser notification or updates the UI.

# Getting Started with Jules

 
Jules is designed to feel effortless from the first click. You don’t need to install or configure anything; it runs entirely in the cloud, with GitHub as the entry point. Here’s what the typical onboarding flow looks like.

// 1. Log in and Connect to GitHub

Go to jules.google and sign in with your Google account. After accepting the privacy notice, you’ll be prompted to connect your GitHub account. Jules only works with repositories you explicitly grant access to, so you can choose to connect all or just a few projects.

Once connected, you’ll see your repositories listed in a selector. Choose one, and Jules will automatically detect its branches, README, and build context.

Image by Author

// 2. Write a Clear Task Prompt

At the heart of Jules is the prompt box, which is where you describe what you want done. You can type plain English instructions like:

Add a test for parseQueryString() in utils.js

To assign a task directly from GitHub, simply add the label ‘jules‘ to an issue. Jules will pick it up automatically, generate a plan, and start preparing a VM.

You can even attach images (such as UI mockups or bug screenshots) to provide more context. Jules uses these as visual hints, not as assets to commit to your repo.

// 3. Review the Plan

Before any code is written, Jules shows you its reasoning, a structured breakdown of the steps it intends to take. You can expand each step, leave comments, or request adjustments directly in the chat. Once you approve the plan, Jules starts executing inside a fresh virtual machine.

Image by Author

// 4. Watch Jules Work

In the activity feed, you’ll see live logs of what Jules is doing,  installing dependencies, modifying files, running tests, or generating diffs. You can step away; it’s asynchronous by design.

 
When it’s done, you’ll get a summary showing:

• Files changed
• Total runtime
• Lines of code added or modified
• Branch created with commit message

Image by Author

From there, you can click Publish PR, and Jules will open a GitHub pull request with their changes already pushed. You can then review and merge the PR once you are satisfied with it. 

# The Jules CLI

 
While the web app gives you a visual dashboard, the Jules Tools CLI brings the same power directly to your terminal. It’s lightweight and integrates smoothly into your everyday developer workflows. You can use it to start tasks, check progress, or pull results without ever leaving your editor or CI/CD pipeline.

// 1. Installation and Login

Jules Tools is available through npm. Install it globally with:

npm install -g @google/jules

After installation, log in with your Google account:

A browser window will open for authentication, and once confirmed, you’ll have full access to your Jules sessions.

// 2. Checking Repositories and Sessions

The CLI lets you view all connected GitHub repositories and active sessions.

# List connected repos
jules remote list --repo

# List active or past sessions
jules remote list --session

This mirrors what you’d see on the Jules dashboard, but in terminal form, handy for automated checks or when working on a headless server.

// 3. Creating a New Session

Starting a new coding task is just as simple:

jules remote new --repo . --session "Add TypeScript definitions to utils/"

This command tells Jules to fetch the current repository, spin up a secure cloud VM, and begin planning. You’ll get a session ID in return, which you can use to monitor or pull changes later.

// 4. Pulling Results Back

Once Jules finishes a task and creates a pull request, you can bring the resulting changes back to your local environment:

jules remote pull --session 123456

This is useful for CI systems or teams that want to review changes offline before merging.

// 5. Launching the TUI

If you prefer visuals, you can simply type:

This launches the Terminal User Interface (TUI), a minimal dashboard that shows live sessions, tasks, and their progress, all inside your terminal. It’s the perfect blend of automation and visibility.

# Choosing Jules Plans that Fit Your Workflow

 
Jules is built to scale with your coding,  from solo debugging to enterprise-level agile development. It’s available in three tiers, each tuned for different workloads, but all powered by the same Gemini 2.5 Pro model. 

Paid plans are managed through Google AI Plans, currently available only for individual @gmail.com accounts. Google has confirmed that Workspace and enterprise paths are coming soon.

Once you’ve used your daily quota (measured over a rolling 24-hour period), you can still view and manage existing sessions; however, you cannot start new ones until the limit resets. Jules will display a tooltip or “Upgrade” prompt when that happens.

Each plan enforces its own concurrency limit, which determines the maximum number of VMs that can run concurrently. Exceeding it simply queues tasks, ensuring safe parallel execution without conflicts.

Every Jules session spins up a secure virtual machine with real compute cost. Limits ensure stability, isolate workloads, and protect repository data from overuse or abuse. They also help Google benchmark performance for upcoming multi-agent upgrades.

# Privacy, Security, and Data Handling

 
When an AI system runs your code, trust isn’t optional; it’s everything. Jules was designed from the ground up with developer privacy in mind. Every repository, task, and environment is handled in isolation, and none of your private data is used for model training.

Here’s what that means in practice:

1. Short-Lived, Isolated Virtual Machines: Each task Jules runs takes place in a temporary cloud VM. Once the task completes, whether it succeeds or fails, the environment is destroyed. No persistent containers, no shared volumes, and no long-lived processes. This sandbox model protects your repository from leaks or cross-contamination between runs. Every new task starts clean.
2. Explicit Repository Access: Jules can only access the repositories you authorize through GitHub. To stop a repository from working, simply revoke its access through your GitHub application settings.
3. No Training on Private Code: Unlike some assistants that silently collect context, Jules does not train on private repositories. Your prompts, diffs, and commits are used only for that session’s execution, never for improving the model. This point is central to Google’s approach to agentic systems: the model may improve through aggregate learning, but not from your personal or corporate code.
4. Safe Execution and Dependency Handling: All builds happen in a fully sandboxed environment. You can inspect every command that runs via the activity feed or logs. If something looks risky, you can pause or delete the task at any time.
5. Transparent Logs and Full Auditability: Every action Jules takes, e.g. plan creation, diff generation, testing, commit, or PR, is logged. You can download or review these logs later for compliance or auditing.

# Wrapping Up

 
Software development is entering an agentic phase, where AI doesn’t just assist, but participates. Google Jules is one of the clearest examples of that shift.

It integrates directly with GitHub, runs tasks safely in its own VM, validates its output through tests, and shows its reasoning and diffs before merging anything. Whether you’re fixing a bug, refactoring a feature, or cleaning up dependencies, Jules gives you a way to move faster without cutting corners.

For teams exploring automation or developers tired of maintenance overhead, this is where the next generation of AI tooling begins. Explore it yourself at jules.google and see what it feels like to code alongside an agent that truly works with you.
 
 

Shittu Olumide is a software engineer and technical writer passionate about leveraging cutting-edge technologies to craft compelling narratives, with a keen eye for detail and a knack for simplifying complex concepts. You can also find Shittu on Twitter.