Jules: Google's Async Coding Agent Is Changing How We Think About AI and Software Development

There's a quiet architectural shift happening in how we build software, and it doesn't look like what most people expected.

We've spent the last two years treating AI like a very fast autocomplete — a co-pilot sitting shotgun, responding the moment we type. Cursor, Copilot, Gemini Code Assist: all synchronous, all requiring you to stay in the loop, all fundamentally keeping you as the CPU driving execution.

Jules breaks that model.

Google's async coding agent, which went generally available in 2025 and got major updates at I/O 2026, doesn't help you write code faster. It removes you from the writing loop entirely. You assign a task. Jules works. You review a pull request. That's it.

This article breaks down how Jules works technically — with architecture diagrams, sequence flows, and real code — and why the async model might be more significant than it first appears.

Jules is not an IDE plugin. It's not an inline suggestion engine. It's not a chat interface for your codebase.

Jules is a task-based async agent. You give it a scoped coding task — fix a bug, migrate a module, add a feature, write tests — and it:

When it's done, you're not staring at a chat window waiting to approve line-by-line edits. You're reviewing a PR — just like you would from any engineer on your team.

The 2026 update closes the loop further: if the CI/CD pipeline fails on the Jules-authored PR, Jules automatically receives the error, analyzes it, applies a fix, and re-pushes the commit — often without any human intervention at all.

Here's how the components fit together:

Key architectural choices:

npm install

, run builds, call APIs — unlike Codex which sandboxes with no egressThe sequence below shows what happens from task assignment to merged PR, and where the developer is actually free:

The key insight: the developer's attention is only required at step 1 (spec) and step 12 (review). Everything in between is Jules.

npm install -g @google/jules-tools

jules auth login

jules task create \
  --repo your-org/your-repo \
  --branch main \
  "Fix the race condition in payment/processor.go — 
   two concurrent requests can double-charge. 
   Add regression tests covering the concurrent case."

jules task status <task-id>

jules task list --status=in-progress
npm install -g @google/gemini-cli

gemini extensions install https://github.com/gemini-cli-extensions/jules --auto-update

/jules Fix the flaky integration tests in auth/session_test.go. 
       Root cause appears to be missing teardown between test runs.

python
import google.auth
from jules_client import JulesClient

credentials, project = google.auth.default()
client = JulesClient(credentials=credentials)

task = client.tasks.create(
    repo="your-org/your-repo",
    branch="main",
    description="""
        Migrate the UserRepository class from raw SQL to 
        the new ORM layer introduced in db/orm.py.
        Preserve all existing query behaviour and update tests.
    """,
    labels=["migration", "automated"]
)

print(f"Task submitted: {task.id}")
print(f"Track at: {task.url}")

import time
while task.status not in ["completed", "failed"]:
    time.sleep(30)
    task = client.tasks.get(task.id)

if task.status == "completed":
    print(f"PR ready: {task.pull_request_url}")
name: Weekly tech debt sweep

on:
  schedule:
    - cron: '0 9 * * MON'   # Every Monday at 9am

jobs:
  sweep:
    runs-on: ubuntu-latest
    steps:
      - name: Submit Jules tasks from tech-debt.md
        uses: google/jules-action@v1
        with:
          jules-api-key: ${{ secrets.JULES_API_KEY }}
          task-file: .github/tech-debt.md
          branch: main
          auto-merge: false   # Always require human review

Jules excels when the unit of work maps to a ticket. The sharper your spec, the better the output.

The honest rule of thumb: if you could write a solid Jira ticket for it, Jules can probably do it.

What's working:

What's still incomplete:

Jules isn't a replacement for engineers. It's a redefinition of what "engineering work" means at the margin.

The value of a senior engineer is increasingly not in the ability to implement — it's in:

Google I/O 2026 framed this explicitly: the engineers who get the most from agentic coding will be those who run both patterns in parallel — async for ticket-level work, sync for exploration — not those who pick a favorite.

Jules is a real tool for real workflows right now. If you have a backlog of well-scoped tasks and a codebase with decent test coverage, it's worth spinning up.

Google Developers Blog — All the news from the Google I/O 2026 Developer keynote

Google Blog — 100 things we announced at Google I/O 2026

Google Research — AI in software engineering at Google: Progress and the path ahead

Google Cloud Blog — Innovations from Google I/O 26 on Google Cloud

TechCrunch — Google's Jules enters developers' toolchains as AI coding agent competition heats up

AI Builder Club — Google I/O 2026: Everything That Matters for AI Builders