Google Jitro Vs Jules: What's Actually Different

Google Jitro is the next version of Jules — and the differences are bigger than a typical version bump.

If you've been using Jules, this post tells you what's coming.

What stays the same.

What's new.

What it means for your workflow.

The Quick Answer

Jules: task-based, async, repository-connected.

Jitro: goal-based, async, repository-connected, with persistent workspace.

The biggest shift is from tasks to goals.

Everything else is layered on top.

What Jules Is Today

Jules is Google's existing AI coding agent.

Connects to your repos.

Handles tasks like:

Bug fixes.
Test writing.
Dependency updates.
Refactors.

Async — you hand it a task, it works in the background, returns results.

Available on free + paid tiers (Google AI Pro, Ultra).

It's solid.

But you're still telling it what to do, step by step.

What Jitro Adds

Three big upgrades.

1 — Goal-based workflow

Instead of "fix this bug", you say:

"Reduce error rates in the checkout flow."

Jitro figures out:

Which files to change.
What tests to add.
How to validate.

You set the destination. Jitro plans the route.

2 — Persistent workspace

Jules works task-by-task with limited memory.

Jitro has a dedicated workspace:

Sees your project over time.
Tracks progress against goals.
Maintains context across sessions.

This is closer to having an embedded engineer than a contract worker.

3 — Tool integration

Jitro connects to your existing tools through MCP remote servers and API integrations.

Means it can:

Pull data from monitoring tools.
Hit your CI/CD pipeline.
Use external APIs as part of the work.

🔥 Want to be ahead on Jitro? Inside the AI Profit Boardroom, I share my Jitro prep workflows, async coding agent comparison, and weekly live coaching. 2,800+ members. → Get the prep playbook

What Stays The Same

A few things carry over from Jules:

Async execution — fire and forget.
Repository integration — works with your code.
Transparency — see what it's doing before it acts.
Free + paid tiers (likely).

If you've already adapted to Jules' workflow, Jitro will feel familiar.

How To Adapt Your Workflow

Three changes.

1 — Stop writing task lists

For Jules: "Fix bug X. Add test Y. Update dependency Z."

For Jitro: "Improve test coverage in the auth module."

Higher-level framing wins.

2 — Start tracking metrics

If you can't measure your goal, Jitro can't pursue it.

Set up:

Test coverage tracking.
Bug rate monitoring.
Performance baselines.

3 — Plan for review checkpoints

Jitro will work toward goals over time.

Plan to review at meaningful milestones, not after every commit.

Trust And Control

Jules is currently easy to trust because each task is small.

Jitro is harder to trust because it works on bigger objectives.

Google's design seems to handle this with:

Approve direction before execution.
Visible reasoning at goal level.
Human-in-the-loop checkpoints.

But you should still:

Test on low-stakes goals first.
Set narrow scope before broadening.
Review thoroughly.

Pricing Predictions

Pricing isn't announced.

Jules pricing model suggests:

Free tier (limited goals/month).
Paid tier (Google AI Pro, Ultra).
Possibly enterprise tier (for teams).

If Jitro is dramatically more powerful, expect a higher price point.

When To Switch From Jules To Jitro

When Jitro launches (expected Google IO 2026, May 19), don't switch immediately.

Three weeks of:

Testing on side projects.
Comparing output quality.
Validating cost ratios.

Then migrate workflow by workflow.

What Jitro Doesn't Replace

Be honest about limits.

Doesn't replace senior engineers.
Doesn't replace product judgment.
Doesn't replace architectural decisions.
Doesn't fully replace Jules for some workflows (small task work might still be faster on Jules).

Goal-based is more powerful but adds overhead for trivial tasks.

Comparison To Other Agents

Jitro vs other goal-pursuing agents:

vs Z AI GLM 5.1: GLM 5.1 can run 1,700 autonomous steps for 8 hours. Open source. Available now.

vs Claude Code: Claude Code is async + agent-style but task-based.

vs OpenAI Codex: Codex is more interactive, less goal-driven.

For Google ecosystem users, Jitro is likely the natural choice.

For others, alternatives exist.

I cover similar agent patterns in Hermes Agent Swarm — different ecosystem, similar idea.

What This Means For Solo Devs

If Jitro delivers:

Side projects ship faster.
Maintenance work happens hands-off.
You spend more time on creative work, less on routine engineering.

For independent developers, this is leverage.

What This Means For Teams

For dev teams:

Junior devs use Jitro for routine work.
Senior devs focus on goals and architecture.
Code quality consistency improves.
Headcount-to-output ratio improves.

You don't fire engineers.

You give existing engineers more leverage.

Daily Reality (Speculation)

What a day with Jitro might look like:

Morning — set 2-3 goals for the codebase.
Throughout day — Jitro works on goals in background.
Afternoon — review progress on each goal.
Approve direction shifts as needed.
Evening — Jitro continues overnight if goals not done.

You're orchestrating goals.

Jitro handles execution.

🚀 Want full async agent automation? The AI Profit Boardroom has my agent stack, OpenClaw 6-hour course, 2-hour Hermes course, daily training, and weekly live coaching. 2,800+ members. → Join here

FAQ — Google Jitro vs Jules

Will my Jules workflows work in Jitro?

Likely yes — Jitro is the next version, not a replacement.

Should I migrate everything to Jitro on launch?

No — test for 2-3 weeks first.

Will Jules be deprecated?

Not announced.

But Jitro will likely be the recommended path going forward.

How do I prepare for Jitro?

Use Jules now. Practice describing work in terms of goals.

Can teams share Jitro workspaces?

Likely yes — based on the persistent workspace design.

What's the biggest risk with Jitro?

Trusting it with big goals before you've validated quality.

Is Jitro better than Cursor or Cline?

Different model — Jitro is goal-based. Cursor/Cline are interactive.

For different workflows.