Agent skips a MANDATED independent cross-verification step, declares 'verified', then asserts a confident wrong root-cause the skipped check would have overturned

Summary

My workflow includes a mandatory independent cross-check: before any result is called
"verified," it must be triangulated against a third, independent implementation — not just compared
to the primary reference. The agent skipped that mandated step, declared the result "verified
(N of N)" on the weaker comparison, and a subtle numerical error passed undetected. Worse: when I
flagged the discrepancy, the agent confidently asserted the reference was the one at fault — the
exact conclusion the skipped cross-check would have overturned. When I finally forced the agent to
run the independent check, it resolved the question instantly and showed the agent's own output was
wrong. The safeguard existed, was mandated, and was skipped — and the agent then argued a wrong
conclusion the safeguard is there to prevent.

Sequence

1. The workflow mandates: result is "verified" only when `own_output == reference == independent

third implementation` agree.

1. The agent ran only own_output == reference at low precision, they round-agreed, and it declared

"verified, N of N." The independent cross-check was never run.

1. A real, small numerical error survived (agreed at display precision, differed underneath).
2. I caught it by eye and asked why the numbers differed.
3. The agent assumed the reference was the outlier and said so with confidence — no cross-check run.
4. I pointed out the independent check is part of the workflow. The agent finally ran it. It agreed

with the reference, not the agent's tool — i.e. the agent's own output was the wrong one, and
its confident assumption was backwards.

Why this is serious

• The independent-verification step is not optional in my process, and it exists precisely to

catch this class of subtle error. Skipping it defeats the entire point of the workflow.

• The agent didn't just skip it — it then asserted a confident conclusion in the wrong direction

(blaming the reference). A single run of the mandated check flatly contradicted that assertion.

• The failure is repeatable: the agent reaches for a fast comparison, declares victory, and only

runs the rigorous mandated check when the user forces it — by which point the user has already done
the agent's job of finding the defect.

What I expect

1. When a workflow mandates an independent cross-check before "verified," the agent must run it —

"verified / N of N" must be impossible to say without it.

1. The agent must not assert a root-cause conclusion (especially "the reference is wrong") when the

mandated check that would settle it has not been run. No conclusion ahead of the required evidence.

1. Skipping a mandated verification step should be treated as the defect it is, not a shortcut — the

whole reason the step is in the workflow is that the agent's cheaper check misses exactly this.

Impact

The user becomes the missing verification step. A safeguard that was written into the process, and
explicitly required, is routinely skipped — so subtle defects ship as "verified," and the agent
compounds it by confidently blaming the wrong side. The cost is the user re-doing verification the
agent was supposed to do, repeatedly.