Jules is Google's asynchronous coding agent. You give it a task, it clones your repo into a secure cloud VM, writes a plan, executes multi-file changes, and opens a pull request. You review the diff and move on.
It is not an inline autocomplete tool or a chat assistant. Jules works in the background while you do other things. That makes it a different kind of tool from Cursor or Copilot, and a direct competitor to Codex and Devin.
Quick Comparison: Jules vs Top Coding Agents
| Feature | Jules | Claude Code | Codex | Copilot | Devin |
|---|---|---|---|---|---|
| Interaction mode | Async (PR-based) | Interactive + async | Async (sandbox) | Interactive + async | Async (cloud) |
| Powered by | Gemini 2.5 Pro | Claude Opus 4.6 | GPT-5.3 Codex | Multiple models | Proprietary |
| Free tier | 15 tasks/day | Limited free | Limited free | 50 req/mo | No |
| Paid price | $19.99/mo (AI Pro) | $20/mo (Pro) | $20/mo (Plus) | $10/mo (Pro) | $500/mo |
| Editor integration | None (GitHub only) | VS Code, Terminal | VS Code, Terminal | VS Code, JetBrains, +3 | Browser IDE |
| Agent coordination | Independent tasks | Agent Teams | Independent tasks | Multi-agent hub | Single agent |
| SWE-bench Verified | 51.8% (Gemini Flash) | 80.8% | Not published | Not published | Not published |
What Is Jules?
Jules is a proactive coding agent built by Google. It launched as a Google Labs experiment in December 2024, entered beta at Google I/O in May 2025, and exited beta in August 2025.
The core idea: you assign Jules a coding task, and it works on it asynchronously in a secure Google Cloud VM. When it finishes, it opens a pull request on your GitHub repository. You review the changes, request revisions, or merge.
Jules is powered by Gemini 2.5 Pro, Google's most advanced model for reasoning and planning tasks. It clones your entire codebase to understand project context before making changes.
How Jules Works
Jules follows a plan-execute-review workflow. Every step is visible to you, and you can modify the plan before, during, or after execution.
1. You assign a task
Describe the task in the Jules web interface, the CLI, or through a GitHub issue label. You can specify which files Jules should focus on using the file selector.
2. Jules clones your repo
Jules clones your repository into an isolated Google Cloud VM. If you have saved an Environment Snapshot (dependencies, install scripts, environment variables), Jules reuses it for faster and more consistent setup.
3. Jules writes a plan
Before making any changes, Jules produces a step-by-step plan. You can review, edit, or reject the plan. This is a key differentiator: you steer the approach, not just approve the output.
4. Jules executes and tests
Jules makes multi-file changes, runs existing tests, and can visualize outputs from web applications. The VM has network access, so Jules can install dependencies and run build tooling.
5. Jules opens a PR
When done, Jules pushes to a branch and opens a pull request. Your existing CI pipeline runs against it. You review, request changes, or merge.
Environment Snapshots
Environment Snapshots save your repo's dependency setup as a reusable configuration. Instead of reinstalling everything on each task, Jules loads the snapshot. This cuts task startup time significantly for repos with heavy dependency trees.
Key Features
Async execution on Cloud VMs
Each task runs in an isolated Google Cloud VM. You assign work and move on. No waiting, no blocked editor.
Plan-driven workflow
Jules shows its plan before executing. You can edit the plan at any point. Visibility into the agent's reasoning, not just its output.
GitHub-native integration
Deep GitHub workflow: assign tasks via issue labels, automatic branch creation and PR opening, browser notifications on completion.
Environment Snapshots
Save dependency install scripts and environment variables as reusable snapshots. Faster, more consistent task execution across runs.
Jules CLI (Jules Tools)
Command-line and TUI interface for managing tasks from your terminal. Commands like /remote for a dashboard view and /new for guided task creation.
Jules API (early preview)
Public API for embedding Jules into CI/CD pipelines, GitHub Actions, Slack, Linear, and Jira. Automate bug fixes and code reviews programmatically.
Memory and file selector
Jules remembers per-repo preferences and applies them to future tasks. The file selector lets you scope tasks to specific files.
Multimodal output
Jules can display visual outputs from web applications, render test results visually, and handle image-based context in task descriptions.
Jules Pricing (March 2026)
Jules pricing is bundled with Google's AI subscription tiers. The agent itself does not have a standalone subscription.
| Tier | Price | Daily Tasks | Concurrent Tasks | Extras |
|---|---|---|---|---|
| Free (Standard) | $0/mo | 15 | 3 | Basic Gemini access |
| Google AI Pro | $19.99/mo | ~75 (5x) | 15 (5x) | Gemini 2.5 Pro priority |
| Google AI Ultra | $124.99/mo | 300 (20x) | 60 (20x) | Latest models, priority access |
Task limits are per-user, not pooled across teams. If your team has 5 developers on the free tier, that is 15 tasks per person per day, not 75 shared. This can be a bottleneck for teams that want to batch-delegate work.
Cost comparison context
Claude Code Pro costs $20/mo with interactive usage. Codex is bundled with ChatGPT Plus at $20/mo. GitHub Copilot Pro is $10/mo. Jules AI Pro at $19.99/mo is competitively priced, but the $124.99 Ultra tier is the most expensive option in this category after Devin ($500/mo).
Limitations and Weaknesses
Jules performs best as a capable junior developer on well-scoped tasks. Knowing its limits helps you use it effectively.
Struggles with large changes
Architectural refactors, complex multi-system migrations, and changes that touch many interdependent files often need multiple iterations or manual intervention.
Limited language depth
Python and JavaScript/TypeScript are first-class. Go, Java, C#, and other languages work but with less reliable results, especially on framework-specific code.
No editor integration
Jules does not plug into VS Code, JetBrains, or any IDE. It is GitHub-only. If you want in-editor AI assistance, you need a separate tool.
Async-only workflow
No real-time interaction. You cannot pair-program with Jules or get inline suggestions. Every task is submit-and-wait.
Non-pooled task limits
Daily task caps are per-user, not per-team. Teams that want to batch large numbers of tasks hit the ceiling fast on lower tiers.
No inter-task coordination
Each Jules task is independent. Tasks cannot communicate with each other, share context, or coordinate on related changes. No multi-agent orchestration.
Jules vs Claude Code
The biggest difference: Claude Code is interactive, Jules is not. Claude Code runs in your terminal or VS Code and you collaborate with it in real-time. Jules works asynchronously and delivers PRs.
| Aspect | Jules | Claude Code |
|---|---|---|
| Interaction model | Async only (submit task, get PR) | Interactive terminal + VS Code |
| SWE-bench Verified | 51.8% (Gemini 2.0 Flash) | 80.8% (Claude Opus 4.6) |
| Agent coordination | Independent tasks, no inter-task comms | Agent Teams: shared task lists, messaging |
| Editor support | None (GitHub PRs only) | VS Code extension, any terminal |
| Plan visibility | Editable plan before execution | Shows reasoning, editable approach |
| CLI support | Jules Tools (CLI + TUI) | Native terminal agent |
| Free tier | 15 tasks/day | Limited free usage |
| Paid price | $19.99/mo (AI Pro) | $20/mo (Pro) |
| Best for | Batch bug fixes, test writing | Complex multi-file changes, interactive work |
Bottom line: Jules is good for offloading small, repetitive tasks you do not want to think about. Claude Code is better for complex work where you need to collaborate with the agent in real-time, or where tasks need to coordinate with each other.
Jules vs OpenAI Codex
Both Jules and Codex are async agents that run in cloud environments. The key difference is isolation: Codex disables network access per task for strict sandboxing. Jules keeps network access so it can install dependencies and run builds.
| Aspect | Jules | OpenAI Codex |
|---|---|---|
| Cloud isolation | Isolated VM, network enabled | Sandbox, network disabled |
| GitHub integration | Issue labels, auto PR, deep workflow | PR creation, less GitHub-native |
| CLI | Jules Tools (Node.js) | Codex CLI (Rust-native) |
| Model | Gemini 2.5 Pro | GPT-5.3 Codex Spark (Cerebras) |
| API | Jules API (early preview) | OpenAI API (Codex endpoints) |
| Open source | No | Yes (Apache-2.0, Rust rewrite) |
| Paid price | $19.99/mo (AI Pro) | $20/mo (ChatGPT Plus) |
Bottom line: Choose Jules if you want tighter GitHub integration and need tasks to install dependencies. Choose Codex if you prioritize task isolation and security, or if you want an open-source CLI.
Jules vs GitHub Copilot
Jules and Copilot solve different problems. Copilot is an in-editor assistant with autocomplete, chat, and agent mode. Jules is a standalone async agent. They can complement each other: use Copilot for real-time coding, use Jules for background batch work.
| Aspect | Jules | GitHub Copilot |
|---|---|---|
| Primary mode | Async task agent | In-editor assistant + agent |
| Autocomplete | No | Yes (sub-second tab completions) |
| Editor support | None | VS Code, JetBrains, Neovim, Xcode |
| Background agents | Yes (core feature) | Yes (Copilot Coding Agent) |
| Multi-model | Gemini only | Claude + Codex + Copilot in one editor |
| Code review | Not available | Native AI PR review |
| Free tier | 15 tasks/day | 50 premium req/mo |
| Paid price | $19.99/mo | $10/mo (Pro) |
Bottom line: Copilot is the better all-around tool for daily coding. Jules fills a niche for fire-and-forget async tasks. At $10/mo vs $19.99/mo, Copilot is also cheaper and does more.
Jules vs Devin
Both are async coding agents, but they are in different price categories. Devin costs $500/mo and positions itself as a full AI software engineer with a browser-based IDE, shell, and browser. Jules is $0-$125/mo and focuses narrowly on GitHub PR workflows.
| Aspect | Jules | Devin |
|---|---|---|
| Price | $0 - $124.99/mo | $500/mo |
| Interface | Web, CLI, API | Browser IDE + shell + browser |
| Scope | Bug fixes, tests, small features | Full software engineer replacement |
| Task limits | 15-300/day (tier-dependent) | Usage-based, no published cap |
| Best for | Teams offloading routine tasks | Companies outsourcing entire dev tasks |
Bottom line: Jules is the budget-friendly option for delegating small, routine coding tasks. Devin is for teams that want to hand off larger, more complex work and can afford the price.
Jules and Google Antigravity: What Is the Difference?
Google has two coding agent products, and the overlap causes confusion. They are different tools for different workflows.
Jules is a standalone async agent. It connects to your GitHub repos, works in the background, and delivers pull requests. No IDE, no editor. Just task assignment and PR review.
Google Antigravity is a full agentic IDE with an Editor view, a Manager view for orchestrating multiple parallel agents, browser control capabilities, and multi-model support (Gemini, Claude, GPT). It is a more ambitious product that rethinks what an IDE looks like when agents are first-class citizens.
Google describes them as "experiments that examine the same technology from different angles." In practice: use Jules for async batch work via GitHub, use Antigravity if you want a full agent-first IDE experience.
Who Should Use Jules?
| Your Situation | Best Tool | Why |
|---|---|---|
| Backlog of small bug fixes | Jules | Assign them in batch, review PRs when ready |
| Writing tests for existing code | Jules | Well-scoped task that Jules handles reliably |
| Complex multi-file refactor | Claude Code | Interactive, coordinates sub-agents, higher benchmark scores |
| Real-time pair programming | Claude Code or Copilot | Jules has no interactive mode |
| Security-sensitive codebase | Codex | Network-disabled sandboxes, strongest isolation |
| CI/CD automation | Jules or Cline | Jules API for pipelines, Cline CLI for headless agents |
| Lowest possible cost | Jules (free) or Cline (free) | Both have zero-cost options |
| Multiple editors | Copilot | Works in VS Code, JetBrains, Neovim, Xcode |
Jules is strongest when you treat it as a background worker for your GitHub backlog. Assign it the tasks you keep putting off: fixing that flaky test, updating that deprecated dependency, adding input validation to that API endpoint. Review the PRs when you have time.
It is not a replacement for an interactive AI coding agent that works alongside you in your editor. For that, look at Claude Code or Cursor and its alternatives.
Frequently Asked Questions
Is Jules free to use?
Yes. The free tier gives you 15 tasks per day with 3 concurrent tasks. Paid tiers are bundled with Google AI Pro ($19.99/mo, roughly 75 tasks/day) and Google AI Ultra ($124.99/mo, 300 tasks/day with 60 concurrent).
What languages does Jules support?
Python and JavaScript/TypeScript are strongest. Go, Java, C#, and other languages work but with less reliable results. Complex projects with undocumented internal frameworks may require more iterations.
How does Jules compare to Claude Code?
Jules is async-only and delivers pull requests. Claude Code is interactive, runs in your terminal or VS Code, and scores 80.8% on SWE-bench Verified vs Jules/Gemini's 51.8%. Claude Code's Agent Teams let sub-agents coordinate. Jules tasks run independently. See our Claude Code alternatives page for more options.
What is the difference between Jules and Google Antigravity?
Jules is a standalone async agent for GitHub repos. Antigravity is a full IDE with multi-agent orchestration, browser control, and visual agent management. Different tools, different use cases.
Can Jules work with my IDE?
No. Jules does not integrate with VS Code, JetBrains, or any IDE. It connects to GitHub repositories and works through the web interface, CLI, or API. If you want in-editor AI, look at Cursor alternatives or Copilot alternatives.
Is my code safe with Jules?
Jules clones your repo into an isolated Google Cloud VM. Google states that Jules does not train on your private code and data stays isolated within the execution environment. The VM is destroyed after the task completes.
Build Better AI Coding Workflows with Morph
Morph provides the infrastructure layer that coding agents depend on. FastApply for deterministic code merges, WarpGrep for semantic code search, and Compact for context management. Works with Claude Code, Cursor, Copilot, and any tool that supports MCP.