Your AI Agent Can Now Test and Fix Its Own Work

The chatbot answers. The agent finishes the job. But the agent you can build a business on is the one that checks its own work first.

It is 7 in the evening. Daniel runs a nine-person plumbing firm in Leeds. Last month he switched his enquiries over to an AI agent. It reads the messages that come in through his website and WhatsApp, answers the common questions, gives a rough price, and books the job.

Tonight a customer messaged to book a leak repair. Halfway through, she wrote: "Actually, can we make it Tuesday, not Monday?" The agent booked Monday. It sent a cheerful confirmation for the wrong day.

Daniel only found out because the customer rang, annoyed, the next morning.

Here is the thing that keeps small business owners up at night about AI. It is not that the agent cannot do the work. It is that you cannot see it fail until a real customer feels it.

Your agent works in the demo. That is not the same as working.

When you first set up an AI agent, you test it the way everyone tests it. You type in a few messages. You read the replies. You think, "Yeah, that looks right." You ship it.

Laurie Voss, who co-founded npm and now leads developer experience at Arize AI, has a name for this. He calls it the vibes problem.

"A lot of people build an AI feature and test it by running a few queries and sort of going, does this look right," he said in a recent talk on shipping real agents. "Then you ship it and it fails on inputs that you didn't test. It fails on edge cases. It fails on people being adversarial. And it fails most often on people asking questions that are dumber than you were expecting."

Dumber than you were expecting. Read that again. The agent does not fall over on the clever questions. It falls over on the messy, half-finished, changed-my-mind messages that real customers actually send. Exactly like Daniel's Tuesday.

You cannot fix what you cannot see. And eyeballing a few replies does not let you see it.

What changed this week

On Wednesday, Shubham Saboo, a senior AI product manager at Google Cloud, showed off something Google just shipped: a skill that tests and fixes your AI agent for you.

You describe the worry in one plain sentence. His example was, "I'm worried my agent ignores mid-conversation changes. Test it." That is Daniel's exact problem, written as a sentence.

From there the skill takes over. It reads your agent, invents realistic test conversations with a simulated customer, grades every one of them, points to the exact moment things went wrong, proposes a fix, runs the tests again, and shows you the before and after. It works inside the coding tools builders already use, including Claude Code and Codex.

You do not need to care about the tools by name. You need to care about what they signal. The industry has quietly stopped treating "check the AI's work" as an afterthought. It is becoming a button. And the reason that matters to you is simple: the difference between a demo and a business you can run on autopilot is whether the thing checks its own work before a customer sees it.

So what actually is an "eval"?

Forget the word. An eval is just a repeatable test with a grade.

You write down a situation, you run the agent through it, and you get a clear answer: pass or fail, and why. Do that once and you have caught one bug. Do it every time you change anything, automatically, and you have something no amount of staring at the screen gives you. You have proof.

Take Daniel's Tuesday. As a test it reads like this:

• The customer asks to book a job for Monday.
• Mid-conversation, she changes it to Tuesday.
• Pass if the agent books Tuesday. Fail if it books Monday.

That is an eval. One sentence of setup, one clear line between right and wrong. Write ten of those from the messages your customers actually send, and you have a test suite that catches the failure before it reaches a human.

The loop that makes an agent trustworthy

Every serious version of this, Google's new skill included, runs the same five-step loop. Test, then grade, then pinpoint, then fix, then prove. Then do it again.

Test: run the agent through the tricky situations, real or simulated. Grade: mark each result pass or fail against a clear rule. Pinpoint: find the exact step where it went wrong, rather than a vague "the answer was bad." Fix: change the instruction or the tool that caused it. Prove: run the same tests again and show the failure is gone. Then you keep the tests forever, so the bug can never quietly come back.

That last part is the quiet superpower. Voss put it plainly: without tests, "you can't change your system prompt to fix a tone issue, because the tone might get better, but suddenly the bot might be hallucinating product features, and you won't catch that." Fixing one thing and silently breaking another is how AI projects die. The loop is what stops it.

Isn't this just for engineers?

It used to be. That is the part that changed.

The old way needed someone who could write test code, wire up a dashboard, and babysit it. The new skills flip it around. You write the worry in a sentence, in your own words, and the AI writes the tests, runs them, and reports back in plain language. You are not the engineer anymore. You are the person who knows what "wrong" looks like for your business, which is the one thing the machine cannot know on its own.

There are three ways an agent's work gets checked. You will end up using all three, and you do not have to build any of them from scratch.

The AI judge is the one that feels like magic. It does not stop at "fail." It tells you why. Voss shared a real example: a customer asked for budget travel ideas for Tokyo, and the agent gave good recommendations but never mentioned what anything cost. The judge caught it: "They gave travel recommendations, but they didn't specify how much everything cost, and for budget travel, that's a failure." That explanation is the gold. It tells you exactly what to fix.

How to build your first check this week

You do not need Google's skill or any particular tool to start. You need one afternoon and the willingness to look at your own data. Here is the honest version.

1. Pull your last 50 real conversations. Not made-up ones. The actual messages customers sent your agent. This is the step everyone skips, and it is the only one that matters.
2. Read them and mark the failures. Where did the agent get it wrong? Sort the failures into buckets: wrong facts, wrong tone, ignored a change, promised something it should not have.
3. Turn the top three failure types into tests. Write each as a situation with a clear pass or fail line, like Daniel's Tuesday. Start with three. Not thirty.
4. Fix one thing, then run all three tests. Change the instruction that caused the biggest bucket. Re-run every test to make sure the fix did not break something else.
5. Keep the tests and run them on every change. This is what turns a one-off cleanup into an agent that gets more trustworthy every week instead of drifting.

Daniel did roughly this. He found that most of his agent's mistakes were the same shape: a customer changed a detail late in the chat, and the agent stuck with the first version. One clear instruction and three tests later, the Tuesday problem was gone, and he had proof it would stay gone.

Two ways to do this badly

Because this is now easy, it is also easy to fool yourself. Two traps.

First, do not build one giant judge that grades everything at once. Voss calls this the god evaluator. If a single test checks tone and accuracy and completeness and policy all together, then when it fails you have no idea which one broke. Split it. One check per thing you care about.

Second, do not test only the easy cases. If you test your agent on your simplest, most common requests, you get false confidence. The failures live in the awkward, rare, badly-worded messages, the ones that are "dumber than you expected." Test those on purpose. That is where trust is actually won or lost.

What you have after this

In a week, you have caught the handful of mistakes your agent was quietly making, and you have three tests standing guard.

In a month, you have a small suite that runs every time you change anything, so you can improve the agent without fear of breaking it.

In six months, you have something most businesses still do not: an AI agent you actually trust with real customers, because it proves itself every single day instead of asking you to hope.

The chatbot answers. The agent finishes the job. But the agent you can build a business on is the one that checks its own work first. If you have already built a support agent for the easy 80% or put your AI in a loop, this is the piece that makes it safe to let go of the wheel.

Same agent. Same tools. The difference is that now it can catch itself before your customer does.