Skip to content
Ioannis Ouzounis
All articles

AI

Nobody Reviews Their Own Work: What Translation Taught Me About AI Agents

Translation settled the self-review problem long ago: whoever writes the text never signs it off. AI agents need the same rule. Here's how I apply it, from the brief to the final sign-off.

7 min read

On this page

Translation has a rule that is older than any software in the industry: the person who translated a text doesn't get to approve it. A second linguist revises it first. ISO 17100, the international standard for translation services, makes that revision mandatory, and it has to be done by someone other than the translator.

The rule isn't there because translators are careless. It's there because authors are the worst possible readers of their own work. You read what you meant, not what you wrote. A skipped negation, a number copied from the wrong row, a term that was right for the last client and wrong for this one: the author's eye slides straight past them, because the author already knows what the sentence is supposed to say.

I worked inside that rule for a long time, first as a translator and later as the Greek language lead responsible for quality in critical markets. When I started coordinating AI agents, it was the first thing I brought with me.

The self-review problem, at machine speed

AI models have the author's blind spot, and then some.

Ask a model to check its own answer and it tends to agree with itself. It wrote the answer from a set of assumptions, and it checks the answer from the same assumptions. Studies of AI self-correction point the same way: without outside feedback, such as a failing test or a source to compare against, models struggle to find their own reasoning errors, and sometimes "correct" a right answer into a wrong one.

There's a second problem that any language lead will recognize. The most dangerous translation is not the clumsy one. It's the fluent one that's wrong, because it reads well and nobody stops to question it. AI output is fluent by default. A wrong answer arrives in exactly the same confident, well-formatted prose as a right one. Polish tells you nothing about correctness.

So "ask the AI to double-check" isn't a quality step. It's the same pair of eyes looking twice.

Four eyes, translated for agents

The fix is the same as in translation: separate the roles, and make sure whoever checks the work isn't whoever produced it. Here's how the parts of a translation project map onto the way I run agents:

In a translation projectIn an agent run
The brief, glossary and style guide every translator works fromOne written brief that every agent works from, approved before anything runs
A large job split across translators who share one glossarySeveral agents exploring the problem in parallel, each from a different angle
The reviser, a second linguist who checks against the sourceChallenger agents whose only job is to find what's wrong with each result
Translator queries to the client instead of guessesOpen questions and disagreements surfaced, not smoothed over
Quality scoring against agreed criteriaEach surviving option scored against criteria agreed with the requester
The language lead's sign-off before a critical releaseMy review and sign-off before anything reaches the client

Two details make this work.

First, the agents that explore never see each other's drafts. If they did, they would converge on the first plausible idea. That "first idea wins" habit is exactly what makes a single AI answer so limited. Independence is what creates breadth.

Second, the agents that challenge are briefed to break, not to improve. Ask a reviewer to "improve" a draft and you get a polished version of the same draft. Ask it to find where the draft fails the brief, and it starts looking for problems. That's the reviser's mindset: not "how would I have written this?" but "where is this wrong?"

What the challenge round looks for

In translation, a reviser checks accuracy, terminology, omissions and fitness for purpose. The challenge round checks the agent equivalents:

  • Invented facts. Every claim needs evidence: a source, a test run or a sample output. "The tool supports bulk export" is a claim until someone shows the documentation or runs the export.
  • Missing cases. The design works on the clean sample. What about the file with merged cells, the empty row, the date written three different ways?
  • Shaky assumptions. The request says the report must be ready by 10:00 every Monday. Does the design quietly assume that someone's laptop is switched on at 9:55?
  • Drift from the brief. The request said "no client data uploaded to new services". The clever option that does exactly that gets dropped, however clever it is.

Most ideas don't survive this round. That's the point. It's much cheaper to kill a weak option here than to discover the weakness after you've built it.

Why a person still signs it off

If agents can check agents, why does it still need me?

Because a second agent is a second pair of eyes, not a second mind with something at stake. Two models can agree with each other for the same wrong reason, from similar training and similar blind spots. Agreement between agents is not evidence. So the final check is against things that can't be talked into agreeing: the source documents, the test results, the sample output on a real file.

And because somebody has to answer for the result. In localization, the language lead's sign-off means "I checked this, and if it's wrong, it's on me." Nothing about AI removes the need for that. My rule is simple: nothing reaches a client that I haven't read, checked and can explain. Anything I couldn't verify is labeled as unverified.

That makes my review the bottleneck, by design. The agents can explore as widely as the problem needs, because exploring is cheap. What isn't cheap is a wrong answer that looks right, arriving in a client's inbox with my name on it.

Disagreement is information

One more habit from translation: a good translator who isn't sure what the client meant sends a query instead of guessing. The query is not a failure. It's the process working.

The same goes for agents. When two agents reach opposite conclusions, the disagreement usually marks the exact spot where the brief was ambiguous or the evidence is thin. Averaging the two answers, or quietly picking one, throws that information away. I'd rather show the requester both positions and the evidence behind each, and let them decide with the trade-off in plain view.

Three rules you can use today

You don't need a team of agents to borrow this. Even with a single AI assistant:

  1. Never ask the same conversation to check its own answer. Open a fresh one, paste in the original request and the output, and ask it to find errors, not to improve the text.
  2. Ask for evidence, not confidence. "Which row of the sample file shows that?" is a better question than "Are you sure?"
  3. Decide what would make you reject the answer before you read it. Otherwise a fluent answer will talk you into accepting it.

Translation learned this the expensive way, one corrected release at a time. AI work doesn't have to.

More on how I run a request, from the brief to the sign-off: AI agent orchestration.

About the author

Written by Ioannis Ouzounis, an independent AI and automation consultant. He coordinates teams of AI agents to explore, test and build solutions, and personally signs off on every result.

More about Ioannis

Keep reading

Is this costing your team?

If this post sounds like your week, put a number on it, then let's talk about removing that work.

I read and answer every message myself.