Most AI coding tools are synchronous. You ask, they answer. You review, you accept or reject. The human is in the loop by design — which is another way of saying the human is the bottleneck by design.
Jules, Google’s async coding agent, takes a different approach. You give it a GitHub issue. You walk away. It comes back with a pull request. If the CI checks fail on that PR, Jules detects the failure, develops a fix, commits it, and resubmits — without you touching a keyboard.
Now generally available with Gemini 3.1 Pro as its default model for Pro users, Jules is worth a proper deep dive.
The Architecture: Async VM, Not Terminal Takeover#
The fundamental distinction between Jules and tools like Cursor or GitHub Copilot is the execution model.
Cursor operates inside your IDE. Copilot lives in your editor. Both require you to be present, reviewing suggestions in real time. Jules runs in an isolated VM on Google’s infrastructure, spawned when you assign it a task and torn down when it’s done. You get a PR in your inbox when the work is complete.
This has several concrete implications:
- No context switching. You don’t hand Jules your keyboard. You assign it a GitHub issue, the same way you’d assign it to a junior developer, and continue with your own work.
- Reproducible environment. The VM is clean and consistent — no “works on my machine” drift, no local dependency conflicts bleeding into the agent’s output.
- Parallel workstreams. You can queue multiple Jules tasks simultaneously. While Jules is debugging one issue, it can be writing tests for another.
The tradeoff is latency. An async agent that runs in a cloud VM will never feel as snappy as an autocomplete suggestion. But that is the wrong comparison. Jules is competing with the time it would take you to do the work, not with how quickly a suggestion pops up.
The CI Fixer: Why This Is the Milestone#
The most significant recent addition is the CI failure loop.
When Jules opens a PR and a GitHub Actions check fails, Jules does not stop and wait for you to review the error. It receives the CI output, reasons about the failure, develops a fix, commits it to the branch, and resubmits. The loop closes automatically.
This is a meaningful shift. Every async coding agent can open a PR. That’s table stakes. The breakdown that required human intervention was always: “the CI failed.” Someone had to read the error, interpret it, write the fix, push, and wait again. Jules now handles that entire sequence.
The practical implication: for straightforward CI failures — lint errors, type mismatches, failing unit tests with clear error messages — Jules can fully resolve an issue start-to-finish without any human involvement in the middle. You assigned the issue, you get a green PR. That’s the agentic promise, actually delivered.
Does it work on complex CI failures involving environment configuration, flaky tests, or cascading dependency issues? Less reliably. But the 80% case — deterministic, readable CI output that maps to a specific code change — is now handled.
Gemini 3.1 Pro: The Model Upgrade That Matters#
Jules’ March 9 upgrade to Gemini 3.1 Pro as the default model for Google Pro users is not a minor version bump.
Gemini 3.1 Pro delivers 2x+ reasoning improvement over Gemini 3 Pro and ranks first on 12 of 18 tracked coding and reasoning benchmarks. It supports a 1M token context window with 65K output tokens — enough to reason over large codebases in a single pass rather than chunking and losing coherence.
For Jules specifically, the reasoning uplift matters because Jules is not just executing instructions. It is doing the kind of multi-step reasoning that software debugging requires: reading the issue, finding the relevant code, forming a hypothesis about the root cause, implementing a fix, anticipating side effects, writing tests. Each of those steps compounds. A 2x reasoning improvement does not produce 2x better PRs, but it meaningfully raises the ceiling on which tasks Jules can handle autonomously versus where it needs to kick back to a human.
Audio Changelogs: Surprisingly Useful#
Jules offers audio summaries of recent commits — a listenable changelog of what changed in your repository.
This sounds like a novelty feature until you think about the use cases. Async development environments, especially teams using multiple AI agents in parallel, generate commit history faster than a human can read it. An audio summary you can play during a commute or between meetings is a genuinely practical way to stay oriented in a fast-moving codebase.
It also fits a broader trend: AI agents are generating more output than developers can synchronously review. Tools that help humans efficiently process that output — instead of requiring them to read every diff — become more valuable as agent output volume increases.
Commit Attribution: The Right Level of Control#
Jules gives you three commit authorship modes:
- Jules sole author — Jules’ name and email on the commit
- Co-authored: Jules + You — shared credit, Jules primary
- Co-authored: You + Jules — shared credit, you primary
This is a small feature that signals the right philosophy. Attribution matters for code review, for audit trails, for understanding provenance. The answer is not to hide that an agent wrote the code. The answer is to make attribution accurate and configurable.
Pricing and Access#
Jules’ pricing structure reflects its async positioning:
- Free: 15 tasks per day
- Pro ($19.99/month): approximately 75 tasks per day + Gemini 3.1 Pro default
- Ultra ($124.99/month): approximately 300 tasks per day
For comparison, Claude Code’s Agent Teams feature requires Opus 4.6 and a Pro or Max subscription, with token costs approximately 7x higher per task than single-agent operation. Jules’ flat task-based pricing is simpler to reason about for budgeting purposes, though it obscures the complexity dimension — a simple lint fix and a multi-file refactor count as one task each.
Jules vs. Claude Code: Two Agentic Models#
Jules and Claude Code both target the “actually autonomous” category of AI coding tools, but they represent different architectural philosophies.
Jules is GitHub-native and async. Its integration surface is a GitHub issue. Its output is a pull request. It is deliberately not your interactive coding environment — it is an async contributor on your team. The CI loop is its clearest expression of this: Jules is designed to operate without you, and the CI fixer removes the last common interruption point.
Claude Code is terminal-native and interactive-but-autonomous. It is designed for developers who want to be present in the workflow, orchestrating agents from a terminal rather than an IDE. Claude Code Agent Teams allow you to address individual agents directly, see their work in real time via tmux panels, and intervene at any point. The autonomy is opt-in and granular.
Neither model is strictly superior. Jules is more appropriate when you want to delegate and return to a completed PR. Claude Code is more appropriate when you want to run a complex, multi-step workflow and maintain strategic oversight of what the agents are doing.
The convergence point is agentic engineering — developers who are orchestrators, not implementors. Jules takes the delegation model to its logical conclusion. Claude Code takes the orchestration model to its. Both are more honest about what AI coding assistance actually is in 2026 than any IDE plugin that adds autocomplete and calls itself an agent.
Bottom Line#
Jules is now a serious async coding agent. Gemini 3.1 Pro raises the capability floor, the CI fixer closes the loop that previously required human intervention, and the async VM model keeps your local environment clean. For GitHub-centric teams that want to delegate implementation tasks to an AI contributor without restructuring their workflow around a new tool, Jules is the most mature option available.
The CI fixer is the feature to watch. If it proves reliable on a wide range of projects in real-world use, the argument for keeping a human in the middle of a CI debug cycle gets hard to make.
Sources: Jules Changelog — Gemini 3.1 Pro Upgrade (March 9, 2026) · Jules Full Changelog · Google Blog — Jules GA · Google DeepMind — Gemini 3.1 Pro · LogRocket AI Dev Tool Power Rankings