Jules by Google Review: Async AI Agent for GitHub (2026)

Most AI coding tools require you to be present. You type, they respond, you review, you iterate. Jules flips that model entirely. You hand it a task, walk away, and it opens a pull request while you're doing something else. That's not an incremental improvement on the tools you already use — it's a different thing altogether.

What is Jules?

Jules is Google's async AI coding agent. It lives in the cloud, connects directly to your GitHub repositories, and works on tasks independently — no local install, no terminal to babysit, no IDE to keep open. You describe what you want fixed or built, Jules spins up its own cloud environment, reads your code, writes a plan, makes the changes, and opens a pull request for you to review.

If you're not sure what an AI agent actually is versus a coding assistant, the explainer on Claude Code agents covers the concept clearly before diving into any specific tool.

The async model explained in plain English

With something like Cursor or Claude Code, you're in a back-and-forth session. The AI helps in real time, you stay in the loop, and you close the laptop when you're done. Jules doesn't work that way. You assign a task, Jules starts working asynchronously in the background, and you get notified when there's a pull request ready. Think of it less like a pair programmer and more like a junior developer you can assign a ticket to.

This matters for vibe coders specifically. The appeal isn't raw speed — it's that you can delegate a real task and not think about it again until there's something concrete to review.

How it connects to GitHub (not your local machine)

Jules integrates directly at the GitHub level. You authorize it to access your repositories, and it clones whatever repo it needs into an isolated cloud environment for each task. It doesn't touch your local machine at all. When it finishes, the output is a pull request on GitHub — not a file diff in a chat window, not a suggestion you have to copy and paste. A real PR you can review, comment on, request changes to, or merge.

As of this review, Jules only supports GitHub. GitLab and Bitbucket repos aren't supported.

How Jules works — step by step

The workflow is simpler than it sounds once you've done it once.

Assigning a task and what Jules does with it

You go to jules.google.com, connect your GitHub account, pick a repository, and type a task description. The quality of that description matters more than you might expect — we'll come back to this. Jules then spins up a cloud VM, clones the repo into it, and starts reading the codebase. This environment is fully sandboxed and ephemeral: it exists for the duration of the task and then disappears.

For writing better task descriptions, the guide on writing better prompts for AI coding tools applies directly here — good scoping translates well to Jules task inputs.

The planning phase and the Planning Critic agent

Before Jules writes a single line of code, it produces a plan: a step-by-step breakdown of what it's going to do and why. You can review and approve this plan before Jules executes, which is one of the better features of the tool. It's not just "trust me" — you can see the reasoning before anything changes.

Jules uses an internal Planning Critic agent to evaluate its own plan before presenting it to you. Google has cited a 9.5% reduction in task failures attributed to this self-review step. The basic idea is that a second model pass sanity-checks the plan before execution starts, which catches a meaningful percentage of plans that would otherwise go sideways.

Reading the pull request Jules opens

When Jules finishes, it opens a pull request on your GitHub repo. The PR includes a description of what it changed and why, references back to your original task description, and the actual code diff. You review it like any other PR. If something's wrong, you can reject it, comment, or assign Jules a follow-up task to iterate. There's also an audio changelog feature that generates a spoken summary of what Jules did — useful if you want a quick listen rather than reading through a full diff.

What Jules is actually good at

Jules isn't trying to be a full-stack AI IDE. It has a specific sweet spot, and inside that sweet spot it works well.

Bug fixes and small, well-scoped tasks

Jules is strongest when the task has a clear success condition. "Fix the null pointer exception in the user authentication flow" is a great Jules task. "Make the app better" is not. Isolated bug fixes, adding a missing error handler, updating a deprecated API call, writing tests for an existing function — these are the categories where Jules consistently produces usable pull requests.

The scoping principle is the same one that makes Aider work well from the terminal: the more contained the change, the better the output. The difference is Aider runs on your machine in a live session, while Jules runs in the cloud while you're offline.

Running multiple tasks concurrently (Pro tier)

On the paid tier, you can run up to 15 tasks concurrently. If you have a backlog of isolated fixes across multiple repos, you can assign them all at once and let Jules work through them in parallel. For the right kind of workload, this is genuinely powerful. On the free tier, concurrency is capped at 3.

What Jules struggles with

Large codebases and context window limits

Jules is powered by Gemini 2.5 Pro, which has a large context window — but it's not infinite. On very large codebases with deeply interconnected files, Jules can miss important context and produce changes that work in isolation but break something elsewhere. It doesn't have the same ability as an IDE-based tool to interactively navigate and ask clarifying questions mid-task. What you described at the start is all it has to work with.

Vague or ambiguous task descriptions

This is the most common failure mode for new users. Jules interprets your task description literally and fills gaps with assumptions. If the description is ambiguous, Jules will pick an interpretation — often a reasonable one, sometimes the wrong one — and build an entire plan around it. The planning phase helps catch some of this, but it doesn't compensate for a poorly scoped input. The fix is simple: be specific. Name the file, name the function, describe the expected behavior you want.

Daily task quotas on the free tier

The free tier allows 15 tasks per day. If you're using Jules seriously for a project, 15 tasks goes faster than you'd expect, especially if you're iterating on tasks that need a second pass. Once you hit the limit, you're done for the day. This is the most common complaint from users who try Jules as a daily driver on the free plan.

Jules pricing: free vs Google AI Pro

Jules uses a two-tier pricing model tied to Google's AI subscription.

Free tier: 15 tasks/day, 3 concurrent

The free tier is real and usable, not a trial. You get 15 tasks per day with up to 3 running at the same time. For occasional use — a bug fix here, a test here — this is enough. For daily reliance on Jules as a core part of your workflow, 15 tasks is a ceiling you'll hit.

Google AI Pro ($19.99/month): 100 tasks/day, 15 concurrent

The paid tier is accessed through Google AI Pro at $19.99/month. You get 100 tasks per day and 15 concurrent tasks. Jules may also be bundled into Google One AI Premium — worth checking if you already subscribe to that. The jump from 15 to 100 daily tasks is significant for anyone using Jules as a real development tool.

Jules vs other async agents: Goose, Aider, GitHub Copilot

Jules isn't the only tool trying to automate coding tasks, but the comparison isn't quite apples-to-apples.

• Goose is an open-source local agent that runs in your terminal and can be pointed at any LLM. It's more flexible and free, but it runs on your machine while you're present — it's not async in the same way Jules is. You still need to watch the session.
• Aider is a terminal-based git agent that writes code and commits directly to your repo. It's fast and controllable, but again it's a live session tool — you're in the terminal, watching it work.
• GitHub Copilot is deeply integrated into IDEs and now includes some agent capabilities, but its model is still fundamentally IDE-first. Jules is GitHub-native in a way Copilot isn't — Jules produces PRs as its primary output, not in-editor suggestions.

The category Jules is actually in — fully async, cloud-based, PR-as-output — doesn't have many direct competitors yet. If you want Claude Code doing async work via GitHub instead of Jules, the GitHub MCP setup guide shows how to wire that up, though it's a more manual arrangement.

Who should use Jules?

The vibe coder case: delegate and walk away

If your workflow involves accumulating a list of small fixes, known bugs, or isolated improvements, Jules fits naturally into that pattern. Assign five tasks before you go to bed. Wake up, review five pull requests, merge the ones that look good. That's a genuinely different relationship with a coding tool than anything else on the market right now.

The key mindset shift: stop thinking of Jules as a tool you use and start thinking of it as a task queue you manage. You don't have to be present while it works.

When to stick with an IDE tool instead

Jules is not the right choice when the task is too large or too exploratory to scope cleanly in a text description. If you're building a new feature from scratch, need to make architectural decisions partway through, or are working in a codebase Jules doesn't have enough context to navigate effectively, you'll get better results from a live IDE tool like Cursor, Windsurf, or Cline — tools where you can steer in real time.

Jules also isn't a replacement for an interactive debugging session. If you need to inspect runtime state, step through logic, or figure out why something is broken before you know how to fix it — stay in your IDE.

Verdict

Jules is the most compelling async AI agent available right now, and the free tier is genuinely usable. The PR-as-output model is the right abstraction for delegating tasks rather than babysitting sessions.

The caveats are real: the 15-task daily limit will frustrate you if you try to use it heavily on free, large codebases are still a rough edge, and task quality lives or dies on how well you can describe what you want. But for isolated bug fixes, test additions, and small scoped tasks on GitHub repos — Jules delivers.

If you're a vibe coder who wants to hand off a backlog of known fixes and come back to pull requests, Jules is worth setting up today. The free tier is enough to find out whether it fits your workflow before committing to the paid plan.