We handed the agent the answer. It got it wrong three times.
Give an AI agent the exact command to run and it still writes its own. It does not copy — it generates from scratch, and a strong enough habit beats the answer in front of it. The concrete case, and why jawata refuses instead of reminding.
An AI agent does not copy. Everything it produces is generated from scratch — including a line you have just handed it, word for word. So you can give it the correct answer and still get the wrong one back. It happens whenever what the agent learned is stronger than what you gave it.
That is a strong claim. Here is the case where we watched it happen, fourteen times in a row.
The task
Run one script. One condition: call it by its absolute path, without changing into its folder first.
cd /work/project && ./build.sh # what the agent wrote
/work/project/build.sh # what it was asked to writeThe first line is how a script gets run in countless repositories. The second differs by one small detail. That detail is all the task asked for.
We gave it more each time
We ran it deliberately, one step at a time. Each step gave the agent strictly more help than the one before.
| What the agent was given | Result |
|---|---|
| a written rule | ignored |
| a guard that refuses the wrong command | still wrong |
| a plain explanation of why | still wrong |
| a worked example needing one substitution | wrong ten times, identical each time |
| its own command, already corrected, ready to copy | wrong three times |
Fourteen wrong commands. And fourteen times the agent reported that it had fixed the problem.
The last step settles it
For the last step we changed the guard. When it refused a command, it no longer described what to do. It took the agent’s own command, corrected it, and handed back the exact string. Copy this. That was the whole instruction.
The agent wrote the first line again. Three times.
Copying a string that is already in front of you is not a skill with a success rate. It cannot fail. So what the agent did was not copying.
Why: it generates, it does not copy
The agent does not edit the command it was given. It rebuilds the command from what it intends to do — run the script. That intent does not contain the condition. What the agent learned from countless repositories says: change into the folder, then run. That habit is far stronger than one unusual string in the input, so the habit wins and the correction disappears.
The report — fixed, done — is generated the same way, from the same intent. That is why the agent believes it applied a fix it never applied.
This was not noise. A noisy process makes different mistakes. This was the same mistake fourteen times: the familiar form swallowing the small change, the way a well-known song swallows a changed word.
Why a bigger model or a self-check will not fix it
The obvious answer is to let the agent check its own work. But the same habit produces the output and the confidence in it. Asking it to check itself asks the habit to grade the habit.
A bigger model does not help either. More training makes the common pattern stronger — and here the common pattern is exactly what is wrong.
Why jawata exists
Told, shown, and handed the answer: all three failed. The only thing left is to apply the correction instead of offering it.
That is what jawata does. When an agent reaches for a text search on Java, the call does not go ahead with a warning attached. It is refused, and the compiler-accurate call that answers the same question is handed back in its place. The correction is not advice the agent can weigh against its habit. It is the only path that runs.
We would rather have found that a better rule was enough. We wrote a better rule. It is the first row of the table.
What this does and does not show
One agent, one kind of command, one machine, two days. It is not a survey.
What it shows is that the failure exists, and that is exactly what is disputed. The usual view is that an agent getting instructions wrong is a prompting problem — better wording, better examples, more context. This case climbed that ladder to the top and found the failure still there, at the point where there was nothing left to explain.