Google's Jitro: AI That Codes Itself Now

Google's new AI agent JITRO doesn't wait for your prompt and that's the whole story here. Every AI coding tool you've seen so far works the same way. You spot a problem, you write a prompt, the AI implements it, you review it, you write another prompt, rinse and repeat. It's faster than doing it yourself but you're still doing all the thinking here, right?

You're still in the seat making every call. Google is building something different. It's reportedly called JITRO. Internally it's the next version of JOOLS, Google's AI coding agent.

And the way it works flips the whole model on its head. So you don't tell it what to do step by step. You tell it what you want to achieve. You set a goal and it figures out what needs to change.

Then it gets to work. Think about what that means for a second. So right now, every AI coding tool, cursor, github copilot, OpenAI's codex agent, they all need you to define the specific task, right? Fix this bug, write this function, improve this page.

You're the one identifying the problem and framing the solution. JITRO is reportedly being built to skip that step. You say I want our error rate down or I want better test coverage on this product and the agent goes and figures out what actually needs changing in the code base to get you there. Now let me be clear, this hasn't launched officially yet.

Google hasn't officially announced it. This is based on internal signals, early evidence and reporting. A wait list is expected, but the direction Google is heading here is clear. And the timing matters because Google I O 2026 kicks off on May the 19th.

This is exactly the kind of announcement that they'd want to make on stage. And here's a question that people aren't asking, but they should be. Why does this matter, right? Well, bear with me for a second because this affects you even if you never write a line of code.

If you're running a business, agency, e-commerce store, service business, you probably work with developers of tools that have technical components. You give them tasks, you review outputs, you catch problems, you follow up, you manage the whole loop. What JITRO is doing to the developer workflow is the same shift that's coming to every workflow. The move from prompt and execute to goal and figure it out.

That shift is already happening in AI tools you use every day. You're going to see it accelerate fast. And if you're the person who understands how to set good goals for an AI agent, not just good prompts, you're going to be ahead of 99% of people who are still stuck in the prompt and walk away loop, right? And let's dig into what makes JITRO actually different from what exists right now because the technical details are worth understanding it too.

JOOLS, the current version, already does something most AI coding tools don't, right? It runs asynchronously. So whilst other tools like Cursor make you sit and wait for each output, JOOLS works in the background. You go off and do something else.

It comes back with a plan, it's reasoning, and the actual changes it made. During the beta, JOOLS helped developers make over 140,000 code improvements. It's out of beta now. It's available in Google AI Pro and Ultra subscriptions.

So it's not a concept, it's a live real tool people are using. But even JOOLS, as it stands, still needs you to define the task, right? Fix this issue, do this thing. It executes JITRO shifts to what the reporting calls KPI-driven development.

So you set a metric you want to move. The agent identifies what's in the way of moving it and then it works on that autonomously inside a dedicated persistent workspace. The word persistent is important here. Current coding agents are usually one shot, right?

You open a session, you do a thing, and then you close it. There's no memory of what you're working toward, no continuity. JITRO is reportedly being built with a workspace where you can list goals, track what the agent has learned, and configure what tools it can use. It remembers context, it builds on what it already knows about your setup.

And here's where JITRO is being smart about the rollout. It's not a fire and forget system. You set a goal, you review the agent's approach, you approve the direction, and the autonomy here is real. Now inside the AR Profit Boarding, we've got a 30-day roadmap specifically built around using AI agents like JOOLS for client work.

How to set them up, how to frame goals so they actually produce useful outputs, and how to hand off repeatable tasks so you stop doing them manually. We've got 2,800 business owners in there. A lot of them already running AI agents for lead gen content and client delivery. You get four coaching calls every week, daily tutorials, and a prompt library built around real workflows.

If you want to get ahead of this shift from prompt-based to goal-based AI, link in the comments description, or go to the AIProfitBoarding.com to get access. Now let's talk about the bigger picture here because JITRO isn't just a product update. It's a signal about where every AI tool is heading. The current generation of AI tools made you faster at doing the things you already do, right?

You still do the thinking, you still frame the problem. AI executes it faster. That's genuinely useful, but it's only the first version of this. The next version, which JITRO represents for the coding world, is tools that take a goal and figure out the execution themselves.

When you look at where this is heading, you have to ask, what happens to the person whose only job was figuring out how to execute a task? Not the person who sets the strategy, not the person who owns the outcome, but the person in the middle who just figured out the steps in between. That role is going to change totally fast, you know, and the people who will stay ahead aren't the ones who are best at executing prompts. They're the ones who get good at framing outcomes, knowing what good actually looks like, setting a goal that actually means something, reviewing an agent's reasoning, and knowing whether it's right.

These are human skills. They don't get automated, but they do get more valuable. Here's a concrete example. Let's say, for example, you run an agency, and you want your client's website to generate more leads.

Right now, you might use AI to write the copy and generate ideas to build pages faster, but you're still defining every task. With a goal-driven AI agent, the JITRO model, you'd set the objective, more qualified leads from this page, right? The agent identifies what's blocking that. Maybe this form is buried.

Maybe the headline is weak. Maybe the page loads slow on mobile. Maybe it flags things, proposes changes, and waits for your sign-off. You're still in control, but you're operating at a high level now.

You're not managing tasks anymore. You're managing outcomes. And a better one, right? And it's a better one.

Let's talk about the trust piece here as well, because it's the honest part of the conversation. The reason most people don't fully hand off things to AI agents right now, coding or otherwise, is that they don't know what the agent is going to do. They've seen it go off track. They've seen it confidently produce the wrong thing.

They've learned to double-check everything. JITRO's design acknowledges that. Keeping humans in the loop for goal approval and direction review isn't a limitation. It's what makes the whole thing usable in the real world.

Alex C. Shabanov at Testing Catalog, who first reported on this, noted that what's different here isn't just the capability, it's the framing. The JOOLS team's own messaging says manually prompting your agents is so 2025. Signaling Google sees this as a generational shift, not just an iteration.

And it's worth noting what JOOLS already did before JITRO even ships, right? During the beta, JOOLS helped developers tackle tens of thousands of tasks, resulting in 140,000 code improvements shared publicly. It's now out of beta and available across free and paid tiers, integrated into Google AI Pro and Ultra subscriptions. The foundation is real.

The usage is real. JITRO is just the next layer on top. Now let's look at how this compares to what competitors are doing. So you've got GitHub Copilot, which is deep in Microsoft's ecosystem.

It's powerful for task completion, but it still operates on the task first model. You define what you want, it does it. Cursor has built a loyal following and it's excellent, but it's synchronous. So you have to wait for each output.

There's no background execution. OpenAI's Codex agent is moving in the agentic direction, but the public framing is still task based. Fix this, build that. What JITRO is reportedly building, goal-driven persistent workspace, asynchronous, is a different product category completely, right?

It's not just a better coding assistant, it's a different type of collaborator. And if Google ships this at Google I.O. in May, the conversation in the AI tool space is going to shift fast. Now here's a question I always ask when I see something like this.

What can you do right now to be ready? First of all, understand the difference between prompting and goal setting. Most people are still in prompt mode. Do this task, start thinking in terms of outcomes instead, right?

So for example, I want X to happen. Here's what good looks like, here's what matters. That mental shift works with every AI tool you use today. It will matter more as tools get more capable.

Second, start paying attention to how the tools you use handle reasoning transparency. The tools that give you visibility into why they made a decision, those are the ones worth investing time into. JITRO is being designed around this principle. Reward tools that do it.

And third, if you're using JOOLs right now, get comfortable with reviewing a plan before approving changes. That workflow, review, approve, let it run, is the preview of how goal-driven agents will work. And fourth, think about which parts of your business are driven by clear measurable outcomes. Better conversion, faster turnaround, lower error rate, more leads.

These are the parts of goal-driven AI agents we'll be able to help with directly. So map those out. You'll be ready when the tools catch up. And the trajectory here is clear.

The prompt and wait model is version 1. Goal-driven persistent outcome agents are version 2. Google is building it, others will follow. And the people who treat this as just another feature update will spend 2026 still in the prompt loop.

The people who see it as a shift in what AI collaboration actually means and who learn how to set goals instead of just write prompts are going to operate at a completely different level. If you want to get ahead of this, for example, how to use goal-driven AI agents to get more leads, serve clients faster, and actually build workflows that run on outcomes instead of task lists, come join us in the AI Profit Board. And we've got a 30-day roadmap built around exactly this kind of shift. How to go from prompting AI tools to running AI agents on goals.

You get thought coaching calls every week with people who are already doing this, daily tutorials, and a community of 2,800 business owners, and a member map so you can connect with people near you who are building the same things. Link in the comment description or go to the aiprofitboard.com to check it out. The shift from tell the AI what to do to tell the AI what you want sounds simple, but it changes everything about how you work with these tools. Jitro is the clearest signal yet that this is where things are going.