KTIMA is a local-only screener for Cyprus land opportunities. It is a 15-stage Python pipeline that produces an evidence dossier per parcel, with a map terminal on top. Orchestrated coding agents built almost all of it, and the process was recorded in enough detail that the working doctrine can point to specific incidents. Item 11 of that doctrine is written in capitals: VERIFY EVERY SUBAGENT.

What does “verify every subagent” actually require?

The rule closes with one instruction: “Re-derive the headline claim yourself before accepting any agent result.” An agent's own summary does not count, and neither does its explanation of why it is right. You produce the conclusion yourself and then compare.

The justification was measured over the 30 Jul session. In that session, agents produced genuinely excellent work and several confident-but-wrong conclusions. Independent checks caught:

The rule covers every subagent, including the ones whose earlier output was good. A session that produced both strong work and wrong conclusions gives no basis for trusting some results unchecked.

What happened when seven agents ran in parallel?

In one pass with seven parallel agents, every headline was re-verified by hand before it was accepted or acted on. Two agent conclusions were wrong in ways that would have made the product worse. Separately, one agent caught a flaw in my own verification.

How would one agent's rename have put a wrong location on 19 properties?

The agent working on Greek place names proposed rendering cadastral_community_en for all 54 rows. Nineteen of those rows name a different village. Applied verbatim, the proposal would have put a wrong location on 19 properties.

In general, a change stated as one rule across a whole table can be right for most rows and wrong for a subset. Agreeing that the rule sounds reasonable will not expose that. Comparing the proposed value against the expected value for each row will.

How did an agent find a bug in the orchestrator's own verifier?

The audit agent found that one of my verifiers compared values like this:

(a-b).abs() > 1e-9

NaN > 1e-9 is False. So when a row was blank, the comparison did not flag it, and the row passed silently. The check I was using to judge correctness let missing data through as agreement.

In general, ordered comparisons involving NaN evaluate to False in floating-point arithmetic. Any tolerance check of the form “flag if the difference is large” will therefore treat missing values as matches unless it handles them as failures explicitly. My verdict at the time: “That is the single most useful thing any of the seven produced.”

Why does verification have to run in both directions?

In that pass, my checks caught agent conclusions that were wrong, and an agent caught a flaw in my check. If the orchestrator's verifiers are treated as correct by default, a flaw like the NaN comparison stays in place. It keeps passing blank rows, and the green results it reports carry no information about those rows.

Two of the recorded catches share a property. The frontend diff would have broken the dev server silently, and the verifier passed blank rows silently. Neither would have raised an error at the point where it went wrong.

How should you apply doctrine 11 in practice?

KTIMA was built almost entirely by orchestrated coding agents. Doctrine 11 governs the step between an agent's result and the product: nothing goes in on the agent's word alone. The orchestrator's own checks do not get that exemption either.