System · Build & Ship
Filling in a celldoes not buy youthe layer.
Everybody draws the coverage matrix and reads it along the rows. Read it down the columns instead and something uncomfortable shows up: a layer that covers three decisions out of forty is not a layer of your system, it is a pilot that happened on three decisions — and every row it appears in has been counting a depth it never had.
Deterministic and offline. Inspects nothing, connects to nothing.
Grades the map you draw — never people.
Instant download. Python engine, workbook, two playbooks, worked map.
01
Four layers, across the top of the matrix
Your decisions go down the side. Each cell is full, partial, or none.
A declared rule exists
Something written down says what is and is not allowed here, in a form a machine could check rather than a paragraph a person interprets.
The input is bounded
The contract for the call can refuse an out-of-range value before anything runs.
The output is checked
The proposed result is validated against what is already known, before it commits.
A human is reached on failure
When a check says no, a named person sees it inside a window that still matters.
02
Three readings, and they disagree
The one everybody takes, the one that is the verdict, and the one nobody takes.
The fill rate
How much of the matrix has something in it. Everybody takes this reading and it means the least: an average across both axes hides a hole in either. The shipped map is 63% filled and reads BLIND SPOTS.
Down the columns
How much of the map each layer really reaches. In the shipped map the output-checking layer reaches 13%. That is not a layer. It is marked NOMINAL and stops counting.
Which means D-01 has every cell full and still reads THIN
Four of four cells marked, and a depth of three, because one of those four layers is nominal across the whole map. That follows to its conclusion: while any layer is nominal, no decision can read FOUR-LAYER — you do not have four layers of validation anywhere, you have three plus a pilot. The verifier asserts that across the whole space, and asserts it becomes reachable the moment that layer crosses the threshold.
03
Click the cells and watch the columns decide
Give the output-checking layer real coverage and decisions start reaching FOUR-LAYER. Take it away and they all fall back.
Click any cell to cycle it. Watch the column reading underneath change what the rows are worth — give output_checked real coverage and decisions start reaching FOUR-LAYER.
| Decision | declared_rule | input_bounded | output_checked | human_on_failure | depth | verdict |
|---|---|---|---|---|---|---|
| D-01 Refund over threshold | 3 | THIN | ||||
| D-02 Discount approval | 3 | THIN | ||||
| D-03 Vendor payout release | 3 | THIN | ||||
| D-04 Account tier change | 1 | THIN | ||||
| D-05 Support macro send | 0 | UNVALIDATED | ||||
| D-06 Bulk data export | 0 | UNVALIDATED | ||||
| D-07 Contract clause extraction | 3 | THIN | ||||
| D-08 Lead routing | 1 | THIN |
Reading down the columns
A declared rule existsfull on 6 of 8
75% · IN PLACE
The input is boundedfull on 4 of 8
50% · IN PLACE
The output is checkedfull on 1 of 8
13% · NOMINAL
A human is reached on failurefull on 4 of 8
50% · IN PLACE
A layer under 25% is a pilot, not a layer. It stops counting toward any decision’s depth — so nothing reads FOUR-LAYER until every layer is real. 1 filled cell(s) currently buy no depth.
Map verdict
BLIND SPOTS
0 four-layer · 6 thin · 2 unvalidated, of 8. Fill rate 47% full, 63% with anything — context only, neither decides. Thinnest layer: output_checked at 13%. Fix first: D-06.
Filling in a cell does not buy you the layer. Same arithmetic as the shipped engine and workbook; it grades decisions, never people.
04
What the engine prints
This is the shipped engine’s complete output on the shipped map.
VALIDATION-LAYER COVERAGE MAP
==========================================================================
READING DOWN THE COLUMNS - how much of the map each layer reaches
A declared rule exists 75% IN PLACE
full on 6 of 8, partial on 1
The input is bounded 50% IN PLACE
full on 4 of 8, partial on 2
The output is checked 13% NOMINAL <-- below the threshold
full on 1 of 8, partial on 1
A human is reached on failure 50% IN PLACE
full on 4 of 8, partial on 1
A layer under 25% is a pilot, not a layer. It stops counting
toward any decision's depth, so no decision can read FOUR-LAYER
until every layer is real.
--------------------------------------------------------------------------
READING ALONG THE ROWS - how many layers actually cover each decision
D-01 Refund over threshold (Payments)
declared_rule=full input_bounded=full output_checked=full human_on_failure=full
depth 3 of 4 THIN (1 cell(s) discounted as nominal)
every cell is full and this still is not four-layer: output_checked is nominal
D-02 Discount approval (Sales)
declared_rule=full input_bounded=full output_checked=partial human_on_failure=full
depth 3 of 4 THIN
D-03 Vendor payout release (Finance)
declared_rule=full input_bounded=full output_checked=none human_on_failure=full
depth 3 of 4 THIN
D-04 Account tier change (Billing)
declared_rule=full input_bounded=partial output_checked=none human_on_failure=none
depth 1 of 4 THIN
D-05 Support macro send (Support)
declared_rule=partial input_bounded=none output_checked=none human_on_failure=none
depth 0 of 4 UNVALIDATED
D-06 Bulk data export (Data)
declared_rule=none input_bounded=none output_checked=none human_on_failure=none
depth 0 of 4 UNVALIDATED
D-07 Contract clause extraction (Legal Ops)
declared_rule=full input_bounded=full output_checked=none human_on_failure=full
depth 3 of 4 THIN
D-08 Lead routing (Marketing)
declared_rule=full input_bounded=partial output_checked=none human_on_failure=partial
depth 1 of 4 THIN
--------------------------------------------------------------------------
MAP VERDICT: BLIND SPOTS
0 four-layer / 6 thin / 2 unvalidated (of 8 decisions)
fill rate 47% full, 63% with anything -- context only, neither decides
1 nominal layer(s); 1 filled cell(s) discounted because of them
thinnest layer: output_checked at 13%
fix first: D-06
Grades the map you draw. Not legal, security, or compliance advice.D-01 and D-06 are the pair worth reading twice. D-01 has all four cells marked full and still reads THIN, because the output-checking layer sits at 13% and is marked NOMINAL — a full cell in a nominal layer buys no depth. D-06 has nothing marked at all and reads UNVALIDATED, the fix-first decision. Between them sits the map’s real state: a 63% fill rate that reads BLIND SPOTS, because a row that looks complete is not the same as a row that is covered.
05
What is inside
Six files, all editable, none requiring an account.
Map engine
Zero-dependency Python. Prints the column reading first, then the rows, so you see which layers count before you read what they are worth. No network access.
Workbook that reproduces it
Four tabs and 83 live formulas, with the column reading on its own tab feeding the row depths. No macros, no array formulas.
Mapping Playbook
How to find the decisions nobody would have listed, which is the failure mode this format invites, and how to fill a matrix in ninety minutes without a workshop.
Coverage Runbook
What each verdict means, how to read the column view, and why the cheapest next move is usually widening a thin layer rather than deepening a thin decision.
Worked 8-decision map
Including the row where every cell is full and the verdict still is not four-layer.
Editable layers and threshold
The four layers and the nominal cut-off in files you own — the engine checks the bands still match the number of layers you declared.
06
Who it is for, and what it will not do
It is for whoever has to decide what to build next, with a finite budget.
Built for
- Teams with several validation efforts under way and no shared picture of what they add up to.
- Anyone who has been told “we have guardrails” and wants to know which decisions actually have them.
- Architects choosing between deepening one decision and widening one layer, who want the answer to be defensible.
It will not
- Tell you which decisions you left off the map. That is the failure mode this format invites, and the playbook opens on it.
- Verify a cell you marked full really is. It reads what you draw, the same way every time.
- Insist you need four layers everywhere. Some decisions genuinely do not, and the runbook says which.
- Build anything. It tells you where the thinnest layer is and what filling it would be worth.
This System grades the map you draw. It is a working aid, not legal, security, or compliance advice, and it is not an audit or a certification. It never scores, ranks, or assesses people. It cannot tell you which decisions you left off the map — MAP COVERED means what you drew came back covered, not that you drew everything.
07
What sits either side of it
Three neighbours that go deep on one thing. This one goes wide.
AI Agent Go-Live Readiness Gate
$79
Whether one agent is ready to launch, on five controls. This is the view above that: which decisions have which layers at all.
AI Agent & Connector Access Auditor
$99
What an agent is permitted to reach. Useful for finding the decisions that belong on this map in the first place.
Agent Reliability Harness
$149
Whether behaviour holds across runs. A map that reads covered still says nothing about consistency.
08
Questions people actually ask
Short answers first, with the caveat after it rather than in front of it.
One matrix. Your decisions down the side, four validation layers across the top — a declared rule exists, the input is bounded, the output is checked, a human is reached on failure — and each cell marked full, partial, or none. That is the whole input. It reads that matrix three ways and only one of the readings is a verdict.
Because an average across both axes hides a hole in either. A matrix can be two-thirds full and still contain a decision that nothing checks at all, or a layer that reaches almost nothing. The shipped map is 63% filled and reads BLIND SPOTS. The fill rate is printed for context and labelled as such in the engine, the workbook and the demo.
It is the column reading. A layer that covers three decisions out of forty is not a layer of your system — it is a pilot that happened on three decisions, and every row it appears in is counting a depth it does not have. Below the threshold (25% by default, editable) the layer is marked NOMINAL and stops counting toward any decision's depth. In the shipped map, D-01 has all four cells full and still reads THIN, because the output-checking layer reaches 13%.
Correct, and that is deliberate rather than a side effect. If one of your four layers is not really a layer, you do not have four layers of validation anywhere — you have three, plus a pilot. The verifier asserts this across the whole space: while any layer is nominal, the FOUR-LAYER count is zero, and it becomes reachable the moment that layer crosses the threshold.
The four layers are the lane. A declared rule is what the Domain Ontology Readiness Survey grades; a bounded input is the Tool-Input Schema Turnstile; a checked output is the Agent Action Admissibility Engine; a human on failure is the Validation-Failure Backstop. This map is the view from above — it tells you which of those four you are missing, and for which decisions, before you decide what to build.
Which decisions you left off the map. It reads what you draw, the same way every time, and a map of the decisions you remembered is not a map of your decisions — the playbook spends its first section on that, because it is the failure mode this format invites. It also cannot tell you a cell you marked full really is. It grades decisions, never people, and is a working aid rather than legal, security, or compliance advice.
See what your validation actually adds up to.
One matrix, three readings, and the column view nobody takes. Deterministic, offline, and clear that a map of the decisions you remembered is not a map of your decisions.
This System grades the map you draw. A working aid, not legal, security, or compliance advice. It cannot see the decisions you left out, and it never scores or ranks people.
Sold by RedHub AI LLC · Secured by Stripe · redhub.ai