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

> Source: <https://dev.to/jubinsoni/jules-googles-async-coding-agent-is-changing-how-we-think-about-ai-and-software-development-3j0d>
> Published: 2026-05-29 18:12:09+00:00

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.

```
# Install Jules Tools CLI
npm install -g @google/jules-tools

# Authenticate
jules auth login

# Submit a task against a GitHub repo
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."

# Check task status
jules task status <task-id>

# List open tasks
jules task list --status=in-progress
# Install Gemini CLI
npm install -g @google/gemini-cli

# Add Jules extension
gemini extensions install https://github.com/gemini-cli-extensions/jules --auto-update

# Submit directly from your terminal
/jules Fix the flaky integration tests in auth/session_test.go. 
       Root cause appears to be missing teardown between test runs.

# Jules responds async — you get a PR link when it's done
python
import google.auth
from jules_client import JulesClient

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

# Submit a task programmatically
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}")

# Poll for completion (or use webhooks)
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}")
# .github/workflows/jules-debt.yml
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.

| Task Type | Jules Fit | Why |
|---|---|---|
| Bug fix with clear repro steps | ✅ Excellent | Deterministic target, testable outcome |
| Add test coverage to a module | ✅ Excellent | Well-defined scope, no design decisions |
| Dependency upgrades with API changes | ✅ Good | Mechanical but multi-file |
| Migrate module to new framework/ORM | ✅ Good | Repetitive pattern Jules handles well |
| Security patch + regression tests | ✅ Good | Scoped + CI validates automatically |
| Exploratory refactor (uncertain scope) | ⚠️ Risky | Scope drift, Jules may over-engineer |
| Greenfield architecture design | ❌ Wrong tool | No acceptance criteria to validate against |
| Real-time pair debugging | ❌ Wrong paradigm | Needs synchronous back-and-forth |

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

| Jules | Claude Code | OpenAI Codex | GitHub Copilot | |
|---|---|---|---|---|
| Execution model | Async (PR delivery) | Sync (interactive terminal) | Async (PR delivery) | Sync (inline suggestion) |
| Runtime environment | Google Cloud VM | Local / container | Cloud sandbox | Editor plugin |
| Network access in VM | ✅ Yes | ✅ Yes | ❌ No (strict sandbox) | N/A |
| GitHub integration | Native (issues → PR) | Via CLI | Native | Native |
| Languages supported | Node, Python, Go, Rust, Java | Any | Node, Python primary | Any |
| Parallel task execution | ✅ Yes | ❌ One at a time | ✅ Yes | ❌ One at a time |
| CI auto-fix loop | ✅ Yes (2026) | ❌ No | ❌ No | ❌ No |
| Context window | 2M tokens | ~200K tokens | ~128K tokens | ~8K tokens |
| Best for | Delegated ticket work | Complex collaborative tasks | Security-sensitive workflows | Inline acceleration |

**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](https://developers.googleblog.com/all-the-news-from-the-google-io-2026-developer-keynote/)

Google Blog — [100 things we announced at Google I/O 2026](https://blog.google/innovation-and-ai/technology/ai/google-io-2026-all-our-announcements/)

Google Research — [AI in software engineering at Google: Progress and the path ahead](https://research.google/blog/ai-in-software-engineering-at-google-progress-and-the-path-ahead/)

Google Cloud Blog — [Innovations from Google I/O 26 on Google Cloud](https://cloud.google.com/blog/products/ai-machine-learning/innovations-from-google-io-26-on-google-cloud)

TechCrunch — [Google's Jules enters developers' toolchains as AI coding agent competition heats up](https://tech.yahoo.com/ai/gemini/articles/google-jules-enters-developers-toolchains-180000308.html)

AI Builder Club — [Google I/O 2026: Everything That Matters for AI Builders](https://www.aibuilderclub.com/blog/google-io-2026-complete-roundup)