← AI Operations Tools

The Verification Quadrant

Based on the Templeton Ratio™

Before automating a task with AI, ask two questions: How hard is it to do? and How hard is it to check? The ratio between these two numbers - the Templeton Ratio - determines whether AI will save you time or double it.

2x2 verification quadrant showing Automate Now, AI Sweet Spot, Verification Trap, and Do Not Automate zones
Calculation Difficulty →
EasyHard
Hard to verify
Easy to verify

The Templeton Ratio

AI value is not determined by how impressive the output looks. It is determined by one number: how much cheaper it is to check than to produce.

# The Templeton Ratio
T = time_to_do / time_to_check
# T = 1 → no value (you are doing the work twice)
# T = 10 → 9x leverage per unit
# T = 100 → transformative (check 100 outputs in the time of 1)

The Verification Quadrant maps the two components of this ratio. Tasks in the AI Sweet Spot have high T - hard to calculate, easy to verify. This is the P vs NP intuition applied to operations. Generating a solution is expensive. Checking it is cheap. That asymmetry is where automation creates leverage.

The Verification Trap kills more AI pilots than technical failure. The task looks automatable because generation is easy. But "is this output correct?" requires human judgment that scales linearly with volume. T approaches 1. You end up paying for generation and review instead of just doing the work once.

How to Score a Task

Calculation Difficulty

How hard is it for a human to produce correct output?

Low (0.0 - 0.3)
Lookup, extraction, classification against a known taxonomy. Anyone trained on the format can do it reliably.
High (0.7 - 1.0)
Requires domain expertise, synthesis across sources, or creative judgment. Takes a skilled human meaningful time.

Verification Difficulty

How hard is it to determine whether the output is correct?

Low (0.0 - 0.3)
Binary pass/fail, compiles-or-not, diff against ground truth, spot-check values. A machine or a quick glance can verify.
High (0.7 - 1.0)
Requires reading carefully, expert judgment, or "is this good?" assessment. Verification takes nearly as long as doing the work.

Decision Rules

LOW / LOWAutomate for volume. Value comes from throughput, not skill replacement. Full autonomy is safe.
HIGH / LOWAutomate aggressively. This is where AI creates transformative ROI. Build quality gates on the cheap verification and scale.
LOW / HIGHDo not automate until you can make verification cheaper. Invest in rubrics, deterministic checks, or decomposition before deploying AI.
HIGH / HIGHDo not automate yet. No cheap feedback signal means no quality gates - unless you build one. See below.

* The Capital Value of Verifiers

The quadrant above describes the current state of a task. It is not permanent.

If you can build a verifier - a system that cheaply and reliably checks whether an output is correct - you shift that task downward on the diagram. What was "hard to verify" becomes "easy to verify." A task that sat in Do Not Automate moves into the AI Sweet Spot. A task stuck in the Verification Trap drops into Automate Now.

This is a legitimate capital investment. Building a high-quality verifier is often harder than building the generator. It requires deep domain knowledge, careful rubric design, and usually a blend of deterministic checks and calibrated scoring. It is not cheap to build. But the payoff is structural: once the verifier exists, every unit of AI output can be checked at near-zero marginal cost, and the entire task permanently moves quadrants.

# The investment math
verifier_cost = one-time capital expenditure
per_unit_savings = (old_verification_cost - new_verification_cost) * volume
payback_period = verifier_cost / per_unit_savings
# In Templeton Ratio terms
T_before = low (verification expensive, task stuck in red/amber)
T_after = high (verification cheap, task moves to blue/green)

The companies that are winning at AI are not the ones picking easy tasks. They are the ones building verifiers that increase their Templeton Ratio - making hard tasks easy to check, then running those tasks at scale.