Google Jules

Google Jules is an asynchronous AI coding agent from Google Labs that connects directly to your GitHub repositories and converts issues into pull requests. You assign a task, Jules clones your repo into a secure cloud VM, builds a plan using Gemini 3 Pro, shows you a diff for approval, then opens the PR. It handles bug fixes, test writing, dependency updates, feature additions, and code migrations entirely in the background while you work on something else. The free tier gives 15 tasks per day with Gemini 2.5 Pro. Paid tiers on Jules Pro and Jules Ultra scale that up to 100 and 300 tasks per day respectively, with full Gemini 3 Pro access. By mid-2026 Jules has matured into a credible async alternative to Devin for teams already living inside GitHub.

When Google Labs shipped a quiet preview of Google Jules in late 2024, it was easy to dismiss as another AI experiment that would never see the light of a real engineering workflow. A coding agent that reads GitHub issues and opens pull requests sounds promising until you remember that Google has a long history of shipping interesting prototypes and then abandoning them. By May 2026, that skepticism looks misplaced. Jules hit public beta in May 2025, shipped a tiered pricing model, upgraded its backbone to Gemini 3 Pro on paid plans, and has quietly accumulated a user base of developers who assign it issues the way they’d assign work to a junior contractor. It’s not a toy anymore.

Quick verdict

Jules is the most accessible async coding agent on the market. The free tier is real, the GitHub integration is the tightest of any tool in this category, and Gemini 3 Pro gives it genuine chops on multi-file work. It doesn’t have Devin’s depth on complex tasks or its workflow integrations, but it costs a fraction of the price and requires zero setup. For GitHub-native teams, it earns a slot in the workflow before you’ve spent a dollar.

What is Google Jules, exactly?

Jules is an asynchronous AI coding agent. That word matters. It doesn’t sit in your editor autocompleting lines as you type. You give it a task, it does the work, and it comes back with a pull request. You review and merge, or push back and it revises. The interaction looks less like pair programming and more like assigning a ticket to a teammate who works in a different time zone.

The mechanics are straightforward. Connect Jules to a GitHub repository through OAuth. Trigger it by writing a prompt in the Jules interface, or tag any GitHub issue with the “jules” label. Jules clones the repo into a secure cloud VM, generates a step-by-step plan for your approval, executes it, then opens a pull request with a diff for your review.

Jules first appeared as an early prototype in December 2024, graduated to worldwide public beta in May 2025, and by mid-2026 has a defined pricing structure and a Gemini 3 Pro backbone on paid tiers. It’s past the “will it survive?” stage and into the “how does it fit into a real team?” stage.

What it does well is handle the category of work that’s clearly defined but time-consuming: fixing a reproducible bug, bumping a dependency and fixing the resulting breakages, adding test coverage to an existing feature, or building out a CRUD endpoint that follows the patterns already in the codebase. These are tickets that sit in backlogs for weeks not because they’re hard but because no one wants to context-switch into them. Jules handles them without that cost.

What it doesn’t try to do is replace exploratory problem-solving. It’s designed for the execution side of engineering work, after the thinking is done.

The features that earn it the Devin-comparison

Async ticket-to-PR workflow

The core loop is the product. You assign a task, Jules works asynchronously, you review a pull request. That’s it. The value is in how faithfully the implementation delivers on that promise.

In practice, the flow is tighter than you’d expect. The GitHub label integration means you don’t need to use a separate Jules interface at all for routine issue work. Tag an issue with “jules,” and Jules picks it up in queue, runs through its planning step, and comes back to you with a diff. For teams that track work in GitHub Issues, this slots in with no change to existing habits.

The async model also enforces a useful discipline: you’re forced to write a clear enough description for Jules to act on. Vague tickets come back with vague results. Teams that adopt Jules often find their issue quality improving as a side effect.

Cloud sandbox with full toolchain

Jules doesn’t execute on your machine. Every task gets its own Google Cloud VM, provisioned at task start and torn down when the PR is ready. Inside that VM, Jules has shell access, can install dependencies, and can run your build and test pipeline.

This matters for correctness. Jules doesn’t just generate code that looks plausible. It runs the code, watches the tests, catches build errors, and iterates until the output is clean. The diff it shows you is code that has actually executed. Your local environment stays untouched, and there’s nothing to install beyond the GitHub OAuth connection.

The VM isolation also handles the private repository concern. Code is cloned into an ephemeral environment, and Google states clearly that private repository contents are not used for model training. The VM is destroyed after execution.

Gemini 3 Pro under the hood

The free tier runs on Gemini 2.5 Pro, which handles straightforward tasks well. Jules Pro and Ultra use Gemini 3 Pro, and the difference shows on complex multi-file work. Gemini 3 Pro holds more context, traces dependencies more reliably, and produces refactors with better internal consistency across large surface areas.

For a single-file bug fix, the model difference is marginal. For a refactor touching fifteen interconnected files, 3 Pro produces cleaner results. If your tasks are self-contained, the free plan is a genuine tool, not a limited demo. If you’re pushing Jules on more complex work, the model upgrade in the paid tier pays for itself quickly.

GitHub-native integration

Jules is the most GitHub-native async coding agent available. The label-based trigger means zero interface switching. Every output is a pull request with standard commits, a diff, and a description. Your existing CI pipeline runs against it automatically. Your branch protection rules, required status checks, and code review tooling all apply to Jules PRs exactly as they would to a human teammate’s work.

That tight integration matters enormously in daily use. Every other async agent requires a separate dashboard or a webhook configuration. Jules speaks GitHub natively, and the PR descriptions it generates explain what it did and why, which makes review faster and gives you an audit trail for later.

Plan review before execution

Before Jules writes a single line of code, it shows you its plan: which files it will touch, what changes it will make, how it intends to approach the problem. You can push back on the plan, add constraints, or approve and let execution proceed.

This step is the most important part of the workflow for complex tasks. It’s where you catch misunderstandings before they become expensive. If Jules has interpreted your issue description incorrectly, you find out in the plan review rather than after it’s written code in the wrong direction. For simple tasks, you’ll approve immediately. For anything touching core logic, two minutes on the plan is worth it.

Pricing

Jules runs a three-tier model. The free plan gives you 15 tasks per day with 3 concurrent tasks, running on Gemini 2.5 Pro. That’s a genuine, functional free tier. Fifteen tasks per day is enough to close real issues, not enough to use Jules as your team’s primary engineering resource.

Jules Pro runs around $20 per month and raises the ceiling to 100 tasks per day with 15 concurrent tasks and full Gemini 3 Pro access. At $20/month the math favors even moderate use: if Jules closes two or three tickets a month that would otherwise cost an engineer an hour each, it’s paid for.

Jules Ultra sits at the top with 300 tasks per day and 60 concurrent tasks with priority model access, targeting platform teams running Jules across a large backlog at scale.

Comparing this to Devin, the price gap is stark. Devin starts at $500 per month with no free tier. Jules enters at $0, and the Pro tier is priced at roughly 4% of Devin’s monthly minimum. Pricing is task-based, not per-seat, which works well for small teams where one or two people manage Jules on behalf of a larger group.

Where Jules wins and where it doesn’t

Jules wins on well-scoped, GitHub-native work. A repro-ready bug fix. A test-coverage gap on a specific module. A dependency version bump with downstream breakages. A new API endpoint that follows the existing patterns in the codebase. These are the tasks where Jules produces PR-ready output without requiring meaningful back-and-forth.

It also wins on accessibility. The free tier is the lowest friction entry point in the async coding agent category. You can be assigning real issues to Jules within five minutes of visiting the site. No credit card, no sales call, no enterprise agreement.

Where Jules doesn’t win is on depth. Tasks that require understanding your team’s broader engineering vision, navigating business logic that isn’t documented in the codebase, or making architectural decisions with non-obvious tradeoffs are still better handled by Claude Code with a human directing the session, or by a senior developer who knows the system.

The lack of Slack or Linear integration is also a real gap for teams that manage work through those tools. If your engineering workflow is Jira tickets and Slack standups, Jules requires an extra translation step to fit in. You can work around it, but it’s friction that Devin doesn’t have.

Finally, the async model means you can’t course-correct mid-execution the way you can when using an interactive agent. If Jules starts down the wrong path, you wait for the diff to see the problem, rather than catching it live.

Who Jules is built for

The clearest fit is the developer managing a GitHub Issues backlog who wants to close tickets without interrupting their own deep work. Assign in the morning, review PRs in the afternoon. Open-source maintainers are another natural fit: triage incoming issues, tag the clearly scoped ones with the “jules” label, and let Jules generate first-pass PRs you then review and polish.

Small engineering teams in active product cycles benefit when a sprint mixes bounded execution tasks with harder problems. Jules takes the former, humans take the latter.

Jules is less useful in early discovery mode, where specs change faster than any async agent keeps up, or in heavily interdependent systems where every change requires context buried in Slack history rather than written in the codebase.

Jules vs the alternatives

vs Devin: Both produce pull requests from async task assignment. Devin goes deeper on genuinely complex, multi-system work and has Slack and Linear integrations that fit larger engineering teams. But Devin starts at $500/month with no free tier. Jules enters at $0 and Pro is roughly $20/month. For teams whose work is GitHub-native and well-scoped, Jules does the job at a fraction of the price. If you need Devin’s depth and integrations, pay for them. If GitHub Issues is your primary workflow surface, Jules is the better starting point. See our Claude Code vs Devin comparison for more context on how this category shakes out.

vs OpenHands: OpenHands is open-source with strong self-hosting appeal. If you need on-premise execution for compliance reasons, it’s the right call. It’s more configurable than Jules, but configuration has a cost. Jules requires zero infrastructure management and has a polished GitHub integration that OpenHands doesn’t match out of the box.

vs Claude Code: These aren’t competing for the same workflow. Claude Code is synchronous and interactive; you stay in the loop and shape the session as it runs. Jules is asynchronous; you assign and walk away. Claude Code wins on exploratory and complex debugging work. Jules wins when the spec is written and you don’t want to spend time on execution. Many developers use both. See our AI coding agent guide if you’re still deciding which fits your workflow.

Getting started

Sign in at jules.google with a Google account and connect your GitHub account via OAuth. Jules will ask for repository access. Grant it to the repos you want to use it on.

From there, two paths: write a task prompt directly in the Jules interface, or add the “jules” label to any GitHub issue. Jules picks it up and starts planning.

Either way, the first thing you’ll see is Jules’s plan. Read it carefully for your first few tasks. You’ll calibrate how Jules interprets your issue descriptions, and that calibration pays off in better PRs. Approve the plan, wait for execution (most tasks complete in 15 to 30 minutes), then review the diff. If something’s off, push back and Jules revises. The revision loop is fast.

The bottom line

Google Jules has earned its place in the async coding agent conversation. It arrived in 2024 as an experiment, matured through 2025, and by mid-2026 it’s a practical tool with a real free tier, credible model backing in Gemini 3 Pro, and the tightest GitHub integration in the category. It’s not trying to be Devin for every team. It’s trying to be the right tool for teams that already live in GitHub, have well-maintained issue backlogs, and want an async agent that slots in without friction or a large budget commitment.

If you’re already curious about async coding agents but the $500/month floor for Devin has kept you on the sidelines, Jules is where you start. Fifteen tasks a day, no credit card, your actual GitHub repos. Give it a real issue and see what it does with it.

Key features

• Async GitHub issue to pull request workflow
• Cloud VM sandbox with full toolchain per task
• Gemini 3 Pro model on paid tiers
• Native GitHub label integration for issue assignment
• Visible plan with developer approval before execution
• Parallel task execution across multiple concurrent issues
• Audio changelogs summarizing commit history

Pros and cons

Who is Google Jules for?

• Closing routine GitHub issues without interrupting the human team
• Automated dependency updates and version bumps across a codebase
• Writing or expanding test coverage for existing features
• Fixing well-scoped bugs reported in issue trackers

Alternatives to Google Jules

If Google Jules isn't quite the right fit, the closest alternatives are devin , openhands , and claude-code . See our full Google Jules alternatives page for side-by-side comparisons.