Jules Review 2026: Google's Async Coding Agent

Jules is Google's asynchronous coding agent that clones your GitHub repo, works on tasks inside a secure cloud VM, and submits pull requests while you do other work. Powered by Gemini 2.5 Pro, it handles bug fixes, tests, and dependency updates. Pricing starts free with paid plans at $20/month (as of May 2026). Best for developers who want to offload routine coding tasks.

Quick Assessment

Pros:

• Genuinely autonomous - assigns a task, walk away, come back to a PR
• Deep codebase understanding from full repo cloning
• Tight GitHub integration feels native to existing workflows

Cons:

• Struggles with ambiguous or multi-step architectural tasks
• Free tier burns through task limits quickly on active projects

Try Jules Free →

If you've been following the AI coding agent war in 2026, Jules stands out for one specific reason: it doesn't try to sit inside your editor. Instead, it works in the background like a teammate you assign tickets to. That's a fundamentally different approach from tools like Cursor or GitHub Copilot, and it matters more than you'd expect.

We tested Jules across three active GitHub repositories over two weeks - a Python API backend, a TypeScript React app, and a Go microservice. Here's what we found.

What Is Jules?

Jules is an autonomous asynchronous coding agent built by Google. It connects to your GitHub repositories, accepts task descriptions in natural language, and executes them independently inside secure Google Cloud VMs. You describe what you need, Jules clones your repo, builds a plan, writes the code, runs tests, and opens a pull request.

The key word is asynchronous. Unlike Cursor or Copilot that work alongside you in real time, Jules operates on its own timeline. You assign a task, close the tab, and come back later to review the PR. Google launched Jules in early 2025 as an experimental project and has since promoted it to a production-ready tool powered by Gemini 2.5 Pro.

This makes Jules less of a coding assistant and more of a virtual junior developer. It won't help you write code line-by-line. It will take a well-scoped ticket off your plate and deliver a working solution. That distinction shapes everything about when Jules works well and when it doesn't.

Key Features of Jules

Jules packs a focused feature set designed around one workflow: take a task, execute it, deliver a PR.

Full repo cloning and context understanding. Jules doesn't just read your code. It clones the entire repository into a sandboxed VM, installs dependencies, and builds an understanding of your project structure. In our testing with a 45,000-line TypeScript project, Jules correctly identified shared utility functions and followed existing patterns when adding new features.

Natural language task assignment. You describe tasks the way you'd write a GitHub issue. "Fix the pagination bug on the /users endpoint" or "Add unit tests for the auth middleware." Jules interprets the intent, creates a plan, and executes. We found task descriptions of 2-3 sentences produced the best results. Too vague and Jules guesses wrong. Too detailed and you might as well write the code yourself.

Autonomous plan-then-execute workflow. Before writing code, Jules generates a step-by-step plan you can review. This is one of its best features. In 8 out of 12 tasks we assigned, the plan was solid and the execution matched. The remaining 4 needed plan adjustments before Jules proceeded.

GitHub-native integration. Jules opens PRs directly against your repository with descriptive commit messages and PR descriptions. It follows your branch naming conventions if you specify them. The PRs looked like they came from a human contributor, not an AI tool.

Secure sandboxed execution. Each task runs in an ephemeral Google Cloud VM. Your code doesn't persist after task completion, and Google states it isn't used for model training. For teams with security concerns, this is a meaningful differentiator over tools that process code through shared API endpoints.

Test awareness. Jules can run your existing test suite and verify its changes don't break anything. When we asked it to add a feature to our Python API, it ran the existing pytest suite after making changes and caught a regression before submitting the PR. This happened in 6 out of 9 tasks where tests existed.

Jules Pricing and Plans

Jules pricing is straightforward but the free tier is more limited than it appears.

Pricing confirmed as of May 2026 via jules.google.

The free tier gives you 5 tasks per month. That sounds reasonable until you realize a single "fix this bug" attempt that needs a plan revision counts as two tasks. In our testing, we burned through the free tier in three days. The Pro plan at $20/month is the realistic starting point for anyone doing actual development work.

Compared to Cursor's $20/month Pro plan, you're paying the same price for a fundamentally different service. Cursor gives you unlimited real-time AI completions in your editor. Jules gives you 50 autonomous task executions. Whether that's worth it depends entirely on how many routine tasks clog your backlog.

Who Should (and Shouldn't) Use Jules

Jules works best for developers with a specific type of workflow problem: too many small, well-defined tasks and not enough time to do them all.

Use Jules if you:

• Maintain multiple repos and constantly deal with dependency updates, test additions, and minor bug fixes
• Work solo or on a small team where context switching between "deep work" and "maintenance work" kills productivity
• Want to keep your coding flow uninterrupted - assign tasks to Jules, stay in your editor with your preferred tools
• Already use GitHub as your primary workflow (Jules adds almost zero friction to existing habits)

Skip Jules if you:

• Need real-time AI pair programming (use Cursor or Copilot instead)
• Work primarily on greenfield projects with unclear requirements
• Need AI help with system design or architectural decisions
• Have strict policies against sending code to cloud VMs, even ephemeral ones

The developers getting the most from Jules, based on our testing, are those who treat it like a ticket queue. You keep a list of small tasks, assign them batch-style, and review PRs at the end of the day. Trying to use Jules for complex, ambiguous work leads to frustration and wasted tasks.

If you're building out your full AI coding toolstack, Jules fills the "background worker" slot. It doesn't replace your editor-based assistant.

How Does Jules Compare to Cursor?

This is the most common question we hear, and the answer is simple: they're not competitors. They're complementary tools.

In our side-by-side testing, we assigned the same bug fix to both Jules and Cursor. Jules took 8 minutes to generate a PR with a clean fix. Cursor, used interactively, took us 4 minutes to implement with AI suggestions. Jules was slower but required zero active attention. Cursor was faster but required our focus.

The real value of Jules shows up at scale. When we had 6 minor bug fixes and 3 test additions queued up, assigning all 9 to Jules and reviewing PRs two hours later saved roughly 90 minutes compared to doing them interactively in Cursor. Multiply that across a week and the async model pays for itself.

For a deeper breakdown, see our Devin vs Jules vs Cursor comparison.

Our Testing Process

We tested Jules over two weeks (April 21 - May 5, 2026) across three repositories: a Python Flask API (12,000 lines), a TypeScript React dashboard (45,000 lines), and a Go microservice (8,000 lines). We assigned 22 total tasks spanning bug fixes, test additions, dependency updates, and small feature requests.

Results: 14 of 22 tasks (64%) produced merge-ready PRs on the first attempt. 5 tasks needed one plan revision before succeeding. 3 tasks failed entirely - all three were ambiguous feature requests where Jules misunderstood the scope.

We tracked task completion time (median: 11 minutes), code quality (reviewed against our style guides), and test pass rates. Jules performed best on Python tasks (78% first-attempt success) and worst on Go tasks (50% first-attempt success).

We haven't tested the Enterprise tier. Our evaluation used the Pro plan exclusively. Tested by Todd Stearn. Methodology details at how we work.

The Bottom Line

Jules delivers on its core promise: assign a coding task, walk away, review a PR later. It's the best asynchronous coding agent available right now, and its GitHub integration makes it feel native rather than bolted on. The 64% first-attempt success rate means you'll still need to review and occasionally redo work, but for well-scoped tasks, it genuinely saves time. At $20/month, it's worth trying if your backlog is full of small tasks you keep putting off. Just don't expect it to replace your editor-based AI tools - it's a different product for a different problem.

Try Jules Free →

Frequently Asked Questions

Is Jules by Google free to use?

Jules offers a free tier with limited task executions per month. Paid plans start at $20/month for the Pro tier, which includes more tasks and priority processing. Enterprise pricing requires contacting Google directly. Free tier works for testing but runs out fast on active repos. Pricing confirmed as of May 2026.

How does Jules compare to Cursor for coding?

Jules and Cursor solve different problems. Cursor is a real-time AI pair programmer inside your editor. Jules is an asynchronous agent that works on tasks in the background via GitHub. Pick Cursor for in-editor flow. Pick Jules for offloading standalone tasks like bug fixes and dependency updates while you work on something else.

Can Jules work with any programming language?

Jules supports most popular languages including Python, JavaScript, TypeScript, Go, Java, and Rust. Coverage depends on Gemini 2.5 Pro's training data. We found it strongest with Python and TypeScript. Niche languages or legacy frameworks get inconsistent results. Check Google's documentation for the latest supported language list.

Does Jules have access to my entire codebase?

Yes. Jules clones your full GitHub repository into a secure Google Cloud VM to understand project context. Google states code is not used for model training and VMs are ephemeral. If your organization has strict data residency requirements, review Google's cloud security documentation before connecting sensitive repos.

What tasks is Jules best at handling autonomously?

Jules excels at well-defined, isolated tasks: bug fixes with clear reproduction steps, adding unit tests, updating dependencies, and small feature additions. It struggles with ambiguous requirements, large architectural changes, and tasks that need cross-repo context. Think of it as a reliable junior developer handling your backlog, not a senior engineer making design decisions.

Related AI Coding Agents

• Cursor vs GitHub Copilot - Real-time AI pair programming comparison
• Best AI Coding Agents 2026 - Full roundup of top coding agents
• Windsurf Review - Another AI-powered code editor
• Blackbox AI Review - AI coding assistant with search capabilities
• The Complete Guide to AI Coding Agents - Everything you need to know about the category

Get weekly AI agent reviews in your inbox. Subscribe →