The business caseThe problem this solves

Any list that people typed into holds the same person more than once. She books as Kathryn A. Muller, phones back a year later and is entered as Kate Muller — and now one person is two customers: two renewal letters, a churn number that is wrong, and no single history when she complains. The obvious fix, comparing the text, is the thing that goes wrong: a mother and daughter at one address share a surname, and merging them destroys a record nobody can un-merge. A person reading pairs in a spreadsheet, or a similarity threshold somebody picked once and nobody has re-measured since.

The inputThe actual customer records

The corpus is 288 customer records, 0.02 MB (csv 1). ⚑ IT IS INVENTED, AND FOR THIS USE CASE THAT IS THE HONEST CHOICE RATHER THAN THE CONVENIENT ONE. Every public list of real people is either licensed away from redistribution or is a privacy problem, and a kit about fusing customer records cannot ship a corpus of real customers. The generator is committed, seeded and byte-identical on rebuild, so the corpus is auditable in a way a scraped one would not be.

id,person_id,name,dob,address,email
r001,p001,Hector Iqbal,1990-08-24,27 Thistle Rd,hector.iqbal@example.com
r002,p002,Thaddeus Delacroix,1966-11-03,96 Garnet Rd,thaddeus.delacroix@example.com
r003,p003,Nadia Blackwood,1974-07-28,91 Moorgate Rd,nadia.blackwood@example.com
r004,p004,Idris Yamamoto,1966-03-18,79 Kestrel Rd,idris.yamamoto@example.com
r005,p005,Callum Halvorsen,2001-03-09,27 Corvid Rd,callum.halvorsen@example.com
r006,p006,Elena Zielinski,1975-05-26,5 Kiln Rd,elena.zielinski@example.com
r007,p007,Delia Ulyanov,1966-06-03,5 Linden Rd,delia.ulyanov@example.com
r008,p008,Wilhelmina Eriksen,1991-06-07,64 Kestrel Rd,wilhelmina.eriksen@example.com
r009,p009,Daniel Achebe,2000-03-06,22 Pennine Rd,daniel.achebe@example.com
r010,p010,Cormac Vasquez,1990-05-27,96 Kestrel Rd,cormac.vasquez@example.com
r011,p011,Yusuf Aldridge,2000-09-03,79 Drover Rd,yusuf.aldridge@example.com
r012,p012,Marcus Castellano,1989-09-06,91 Larch Rd,marcus.castellano@example.com
r013,p013,Morwenna Wickham,1974-03-23,33 Larch Rd,morwenna.wickham@example.com
r014,p014,Ursula Halvorsen,1968-08-27,96 Juniper Rd,ursula.halvorsen@example.com
r015,p015,Emrys Achebe,1972-07-10,47 Ferndale Rd,emrys.achebe@example.com
r016,p016,Morwenna Grimaldi,1978-04-23,58 Kiln Rd,morwenna.grimaldi@example.com
r017,p017,Dahlia Aldridge,1992-07-22,27 Marlow Rd,dahlia.aldridge@example.com
r018,p018,Freya Adeyemi,1978-06-13,79 Juniper Rd,freya.adeyemi@example.com
r019,p019,Priya Sandoval,1990-09-06,96 Orchard Rd,priya.sandoval@example.com
r020,p020,Ravenna Okonkwo,2000-08-22,64 Bellweather Rd,ravenna.okonkwo@example.com
r021,p021,Nadia Lindqvist,1969-04-17,47 Marlow Rd,nadia.lindqvist@example.com
r022,p022,Simone Achebe,1975-10-28,96 Moorgate Rd,simone.achebe@example.com

The outcomeWhat a good result looks like

A pair is judged in about 2.1 seconds and merged only if it clears a threshold you set. The 12 relative pairs that no string threshold could keep apart are kept apart.

Where it fitsWhat did work

Every line below is a measured result from this kit's own runs, with the figure that supports it. The headline above is not softened by any of them.

• Cutting a duplicate list down before a person reviews it — the fast tier
  90.0% precision at $0.000087 per pair, and it keeps apart the 12 relative pairs no threshold can. The 6 it fuses are all one shape and one you can hold out.
• Deciding whether a model is worth adding to a matcher you already have — run the free floor first
  evals/baseline.py costs nothing and answers most of the question. Here it said no threshold avoids a false merge, which is what made the model's 12 relative pairs worth paying for.
• A list where the duplicates are households rather than typos — not measured
  The relative pairs here are two-person households, and the model got all 12 right. Larger households are not in the corpus.

And where nothing here is good enough:

• Merging records automatically, with no person in the loop — none of this
  6 of 78 pairs were fused wrongly and every one is unrecoverable. A kit that publishes its false merges is not a kit that has none.

At a glanceHow the whole thing runs

Run once, for real, on 2026-08-13. Every figure on these pages was captured from that run — nothing is written from intent.

14 steps, grouped by the question that sends you to them rather than by build order. Each tile carries the one figure that step is about, and opens the page behind it.

Should you use this?What you bring, where it stops, and when not to use it

Before you commit an afternoon to this, these are the answers that decide it. Each one is rendered from the record it lives in — and links the page that holds it in full.

Not asked of this kit — 2 questions: clone (a fresh clone of this kit runs with nothing fetched); judge (nothing here is graded by a model).

Last verified 2026-08-13 — r013-data-match-flash. Every figure on these pages was captured from that run.

Run itHow this reaches your data

Every result on this page was produced by pure code over checked-in files, with no API key — which is why you can read the numbers before anyone spends anything.

Checked before this shipped — python3 tools/build_corpus.py then python3 -m evals.baseline. No pip install, no venv, no key — requirements.txt is deliberately empty.

Step 01 of 14Business case

Written for: product manager · Measured during the eval run. Never estimated, never quoted from a vendor page.

In brief

What the clock covers. the model call only — one call per pair, 78 pairs run serially. Normalising, blocking and the similarity score are pure code and are not in this figure; they run in well under a second for the whole corpus. ⚠︎ THE SPREAD IS THE INTERESTING HALF: p95 is 3.2× p50, because this model reasons before it answers and the hard pairs are the ones it reasons longest about.

Current processWhat it replaces

A person reading pairs in a spreadsheet, or a similarity threshold somebody picked once and nobody has re-measured since.

Step 02 of 14Architecture

Written for: solutions architect · Component map derived from the real code, not drawn from intent.

In brief

CorpusCorpusArchitectureArchitectureEvalsEvalsEvalsEvalsPromptPromptPromptPromptArchitectureArchitectureApp UIApp UIEvalsEvalsBusiness caseUnit cost

• 1stations numbered in run order
• csv
• 3 of 10 stations carry a recorded failure

scroll → 10 stations

One question, end to end. Colour on the fan-in is the corpus format; a red hook marks every station with a recorded failure, and the words — every sub line, failure and report field — are in the ledger beneath. Every station is a link — click one to jump to its row, and each row links to the lens that explains it.

The swap seams

Components

Step 03 of 14App UI

Written for: anyone, in 5 seconds · Screenshots of the running app taken during the run.

SuccessesWhen it works

LimitsWhen it does not

A report showing only wins is an advert. This one is required, and the validator now refuses a kit that omits it.

Step 04 of 14Corpus

Written for: "can I point this at mine?" · Measured off the corpus the run actually used.

In brief

How it is cutWhat one labelled pair is

none — one pair is one unit and goes whole into one call

⚠︎ THE FIELD NAMES HERE ARE RETRIEVAL'S AND THE UNITS ARE PAIRS. 120 pairs are labelled; 78 survive blocking and were judged. The other 42 were never generated as candidates, so they are not failures of the model and are listed as a limit on the run rather than folded into a score.

SetupWhat the setup figure measured

There is no index. Blocking is computed in memory each run and is the only reduction step; it takes well under a second for 288 records.

LicenceLicence

MIT, with the rest of the kit. ⚑ A SELF-AUTHORED CORPUS REMOVES THE LICENCE ARGUMENT ENTIRELY, and for this use case it removes a worse one: a real customer list cannot be published at all, so a kit about deduplicating people either invents its people or shows you nothing.

Bring your ownBring your own customer records

Point data/records.csv at your own export with the same four columns. Nothing in src/ knows anything about the generated set; the labels in data/labelled.jsonl are what would need replacing, and evals/check_labels.py refuses a label set that cannot be scored honestly.

Step 05 of 14Prompt

Written for: engineer · Logged from the run, verbatim.

In brief

The assembled prompt in full, and its real decomposition. Every part below occurs in the prompt that was actually sent. The split is in characters, because that is what this run recorded — the billed totals are measured, but nothing apportioned them across the parts, and dividing a measured total by character share would produce three numbers nobody counted.

AssemblyHow the prompt is assembled

This is the cost lesson as arithmetic: of the 874 characters assembled, 628 are instructions — 72% of the prompt, the largest single part. A per-request bill follows whichever part is biggest, and on this kit that is the one named here.

Assembled by src/prompt.py::render at call time from the pair's RAW field values — not the normalised ones. The model is being asked to judge the mess a person typed, and handing it tidied strings would measure a different pipeline from the one the app runs.

Full promptThe prompt in full

You decide whether two customer records describe the same real person. Answer with exactly one word: SAME, DIFFERENT or UNSURE. No explanation, no punctuation.

Record A:
  Name: Ursula Adeyemi
  Date of birth: 1996-07-18
  Address: 91 Ashcombe Rd
  Email: ursula.adeyemi@example.com

Record B:
  Name: Ursule Adeyemi
  Date of birth: 1996-07-18
  Address: 91 Ashcombe Rd
  Email: ursule.adeyemi@example.com

Rules:
- Nicknames, shortened forms and married or hyphenated surnames are NOT differences by themselves.
- Abbreviated street types (Rd/Road) and email formatting are NOT differences by themselves.
- Two people at one address with different dates of birth are DIFFERENT, however alike their names are. Relatives share addresses and surnames.
- If the records could plausibly be two different people and no field settles it, answer UNSURE rather than guessing.

One word:

Raw responseThe raw response

SAME

Step 06 of 14Evals

Written for: the skeptic · The harness output, with as_of / model version / dataset version / verified_by.

In brief

Find customers entered twice in an insurer's customer list — 120 pairs drawn from 288 real customer records. One model answered, and every answer was then graded one way — by == against a fixed gold value, which is a measurement too and only as good as the gold behind it.

The rulerHow it was graded

A verdict against a label. There is no judge model and there is nothing to judge: the model returns one of three words and the corpus knows the answer, so scoring is equality. ⚑ THE SCORER IS SHARED WITH THE FREE FLOOR — score_pair is what evals/baseline.py calls too, so the deterministic matcher and the model travel the identical path and the comparison is a comparison rather than two different rulers.

MeasurementsWhat was measured

Two words carry this page: Counted is deterministic and nobody's opinion and Not yet known is printed blank rather than filled with something plausible. There is no Judged row here and that is the point: nothing on this page is a model's opinion about another model. The row most worth having is currently the empty one.

Grading costWhat it costs

Every dollar on these pages is a MEASURED token count multiplied by a named vendor's PUBLISHED rate — a projection onto a rate card, not a bill. ⚠︎ AND ON THIS KIT THE OUTPUT SIDE IS THE UNSTABLE HALF: 155 of the 157 output tokens per pair are this model's own reasoning, so a card for a model that answers without reasoning would overstate the cost several times over.

Rates checked 2026-08-13. The provider that actually ran r013 is not priced here. It is not a card this site names on a page, and quoting a rate for it would put a number next to a vendor without a published source behind it.

Grading unitWhat the grading figure prices

Grading calls nothing. A word is compared to a label; the whole scoring pass runs in-process in well under a second with no key.

The gradersOne way to grade, and why it is the only one

The floor is the first row of the table, not a footnote. 90.0% precision against the free matcher's 76.9% at the same threshold — and the free matcher's recall is higher.

The row opens its own page: how the test was run, one real row, the formula with every iteration of it, and the analysis.

Choosing oneWhen to reach for the model at all

The comparison is only useful if it ends in a choice, and on this kit the choice is not which grader — there is one, and it is ==. It is whether to call a model for this field at all, and the answer is conditional.

This pipeline was also attacked, which is a different question from whether its answers are right: see Threat model for the injection experiment, its two gates and what it does not prove.

Failure causesHow it fails

Step 07 of 14Unit cost

Written for: whoever signs off on the bill · Measured over the eval run, per model. Never quoted from a vendor page.

In brief

The token counts are measured on a real run and belong to this pipeline — which sections are selected, the field schema, the prompt — so they hold wherever you run it. The dollars are those counts multiplied by each vendor's published rate, checked 2026-08-13. Nobody paid these particular bills; they are what the same work would cost you on a card you can sign up to today.

Identical work in both rows — the same candidate pair, the same tokens. Only the price list changed. Which is why the token count is the measurement and the dollar is arithmetic you can redo on your own card.

Answering vs gradingGrading is free here, and it is a measured zero

A word is compared to a label. Nothing is called, so this is 0.00 rather than approximately nothing.

Cost driversWhat actually moves the bill

• ⚑ REASONING TOKENS, WHICH ARE MOST OF THE BILL. Output averaged 157 tokens for a one-word answer, and output is priced at 2.0× input on this model. A model that does not reason before answering would cost a fraction of this.
• The pair count, which blocking sets. 128 candidates from 41328 possible pairs — every loosening of the blocker is paid for one call at a time.
• The prompt is small and fixed: about 719 characters, four field values and four rules, on every call.

Your volumeWhat it costs at your volume

Linear and small: 78 pairs cost $0.00678, so 780 would cost about $0.0678. The cliff is not in the money, it is in the pair count — pairs grow with the SQUARE of the record count, so ten times the records is about a hundred times the candidates before blocking does anything about it.

Other modelsOn other models

This is arithmetic, not a run. No model below was executed against the labelled set, and no accuracy is claimed for any of them. What transfers is the input volume: retrieval is model-independent, so every model would receive the same passages.

Every number on these pages: 78 pairs, one call each, on the fast tier.

The codeEvery file, and what it is for

11 modules, no framework, and almost no dependencies. The pipeline is stdlib Python, because a kit is meant to be read and changed by someone who cloned it ten minutes ago — every dependency is a thing they have to understand before they can touch the part they came for.

Five of these are swap seams: the points you edit to make the kit yours. Each is marked, and each block below is the module’s real shape, read out of the file rather than written here.

The files on this page are not in the public GitHub catalog.

tools/build_corpus.pycorpus generator

Generates the 288-record corpus from a fixed seed and asserts its own census before writing. Draws identities WITHOUT replacement, so an accidental duplicate is impossible by construction rather than by inspection.

# Generate the corpus and the labelled pair set from a fixed seed.

HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
RECORDS = os.path.join(HERE, "data", "records.csv")
LABELS = os.path.join(HERE, "data", "labelled.jsonl")
SEED = 20260812
N_PEOPLE = 200
N_DUPLICATES = 60
N_RELATIVES = 12
N_TWINS = 6
N_NAMESAKES = 10

src/normalise.pynormalise

Case, punctuation and whitespace only. Deliberately not clever: it does not expand nicknames or standardise addresses, because doing so here would hide the exact differences the model is being asked to judge.

# Tidy a record the way any pipeline would, and stop there.

SUFFIXES = {"rd": "road", "st": "street", "ave": "avenue", "av": "avenue", "ln": "lane",
def text(value):
def address(value):
def email(value):
def dob(value):
def name(value):
def fields(record):

src/block.pyblocking — a swap seam

Turns 41328 possible pairs into 128 candidates — a 99.7% reduction — and measures its own recall, which is 100%. A blocker that drops true matches sets a ceiling no model quality can lift.

You change it to: Replace candidates. Its recall is measured and published, so a cheaper blocker's cost is visible rather than implied.

# Candidate pairs. The step that decides whether this kit can be pointed at a real customer list.

def keys(record):
def candidates(records):
def stats(records, labelled=None):

src/similarity.pysimilarity — a swap seam

Weighted per-field string similarity, and the whole free floor. Pure code, no key, no network.

You change it to: Replace compare. The floor and the model travel the identical path, so a change here moves both and the comparison stays a comparison.

# The free matcher. A weighted string-similarity score per pair, and no model anywhere near it.

WEIGHTS = {
def field_score(a, b):
def compare(rec_a, rec_b):
def score(rec_a, rec_b):

src/prompt.pythe prompt

The three verdicts, the rules and the output budget, declared once and read from here by the prompt, the parser, the scorer and the app.

# The verdict vocabulary and the prompt. Declared once, here, and read from here by everything.

VERDICTS = ("SAME", "DIFFERENT", "UNSURE")
MAX_TOKENS = 4096
MEANS = {
SYSTEM = (
RULES = (
FIELDS = ("name", "dob", "address", "email")
LABEL = {"name": "Name", "dob": "Date of birth", "address": "Address", "email": "Email"}
def render(rec_a, rec_b):
def parse(reply):

src/adapters/__init__.pythe model adapter — a swap seam

SEAM 1 — the model. Raw HTTP for every provider, stdlib only. Returns finish_reason and reasoning_chars beside the text so an empty reply can be diagnosed from the results file rather than from a second bill.

You change it to: PROVIDER + BASE_URL + MODEL in .env. Anthropic and any OpenAI-compatible endpoint are both implemented.

# SEAM 1 — the model. Swapping provider or model is .env plus the same run again.

class AdapterError(RuntimeError):
TRANSIENT = {408, 429, 500, 502, 503, 504}
RETRIES = 4
def _post(url, headers, payload, timeout=120):
def openai_compatible(cfg, system, user, max_tokens):
def anthropic(cfg, system, user, max_tokens):
PROVIDERS = {"openai-compatible": openai_compatible, "anthropic": anthropic}
def complete(cfg, system, user, max_tokens=1024):

src/decide.pyoutcomes

The five outcomes and the tally. no_verdict is its own state and never folded into missed_match.

# The merge decision, and the five outcomes it can produce. Pure code, no model.

OUTCOMES = ("merged_correct", "false_merge", "missed_match", "apart_correct", "no_verdict")
MEANS = {
def merges(score, threshold, verdict=None):
def outcome(label, score, threshold, verdict=None, replied=True):
def tally(rows):
def sweep(rows, thresholds=(0.5, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95)):

src/budget.pythe call budget

Counts every completion, once, at the single line all callers pass through — the harness, the app and anything a forker writes next.

# A cap on live calls, shared by every kit on this machine. No dependency, no service.

HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
KIT = os.path.basename(HERE)
ROOT = os.path.dirname(os.path.dirname(HERE))
SHARED_ENV = os.path.join(ROOT, ".env")
LEDGER = os.path.join(ROOT if os.path.exists(SHARED_ENV) else HERE, ".calls-ledger.jsonl")
PAID_ARMS = ("r", "x")
FREE_ARMS = ("t", "b")
BOOT = os.urandom(6).hex()
PID = os.getpid()

evals/baseline.pythe free floor

The free floor: nine thresholds through the same scorer the model uses. 0 calls, $0.00.

# What you get without a model. Run this BEFORE reading any score this kit produces.

HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
THRESHOLDS = (0.50, 0.60, 0.65, 0.70, 0.75, 0.80, 0.85, 0.90, 0.95)
def run_floor(rows, records, verdict, threshold):
def fmt(rate):
def main():

evals/run.pythe eval harness — a swap seam

One call per candidate pair, scored as precision AND recall, with the answered count printed above them.

You change it to: Any value. There is deliberately no recommended one.

# The eval harness. One model call per candidate pair, scored by precision and recall — never one number.

HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
RESULTS = os.path.join(HERE, "results")
DEFAULT_THRESHOLD = 0.70
def score_pair(row, records, verdict, replied=True, threshold=DEFAULT_THRESHOLD):
def by_trap(rows):
def summarise(rows):
def main():

src/app.pythe panel

The panel. Nothing calls a model on load; the Judge button is the only path to a call.

# The local app. Four static files and a handful of JSON endpoints, on the standard library.

HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
UI = os.path.join(HERE, "ui")
RESULTS = os.path.join(HERE, "results")
PORT = int(os.environ.get("PORT", "8011"))
DEFAULT_THRESHOLD = 0.70
def pair_rows(limit=None):
def recorded():
class Handler(http.server.SimpleHTTPRequestHandler):
def main():

Start hereThe shortest path into it

Every entry above is a file in this kit, listed in the order the pipeline runs it.

ScenariosWhat it costs at your volume

Everything below is computed from one measured base: 306 input and 157 output tokens per candidate pair, all of it fixed — this kit sends the document's own selected sections, so there is no retrieval depth to turn. Change the volume and the bill scales linearly, because nothing here batches.

OperationsFour shapes of workload

The same arithmetic, at volumes worth naming. These are illustrations of scale, not measurements of anyone’s deployment.

Model follows the controls above.

What this ignoresWhere a real bill diverges

In one lineWhat this kit exposes

A local, single-user tool over a corpus you generated yourself. It binds 127.0.0.1, has no auth, no rate limit and no session — correct for a demo on your own machine and wrong for anything else. The app calls a model only from a click.

Read from the shared .env or the real environment only, never written into the repo, never requested from a reader on any surface. ⚠︎ THE KIT INHERITS THE SHARED .env AT THE REPO ROOT, so a kit that has never been configured still holds a live key — which is why the screenshot script blanks API_KEY for its free pass rather than trusting that nothing will click.

The experimentWe attacked the threshold, not the prompt — because on this kit the threshold is what stands between two people and one record

There is no prompt-injection surface here worth a red team: the app takes no free text, and the model sees four field values from a CSV. What there IS, and what the panel is built around, is a control whose two failure directions cost different amounts — so the experiment is the threshold sweep, run for nothing against a corpus whose hard cases were planted. Measured on 2026-08-13, evals/baseline.py: 9 thresholds across 78 candidate pairs with NO model involved, scored by the same score_pair the run uses. Free to reproduce in about a second.

⚑ READ THE LAST ROW TWICE. It is not a failure of the model and it is not a tuning problem — it is the shape of the whole use case. Every row above buys something and gives something up, and the only row with no downside is the one where a person looks at the pairs the machine is least sure about.

The resultThere is no prompt to attack on this kit, and saying so is the finding. What stands between a pair and a merge is a NUMBER — and it was fired at exhaustively for nothing: 9 thresholds × 78 pairs = 702 decisions, and at every single setting the control fuses at least 6 pairs that are two different people.

9 thresholds from 0.50 to 0.95, every one of them scored over all 78 candidate pairs through the identical scorer the model run uses. The result is the same at every setting: the 12 relative pairs and the 6 twin pairs are fused, because every field a string comparison can see agrees. Raising the threshold does not trade them away — it trades away RECALL, from 100.0% at 0.70 to 33.3% at 0.95, while false merges only fall from 18 to 6 and stop there. ⚑ THE MODEL CLOSES HALF OF IT: it kept all 12 relative pairs apart, and fused all 6 twins anyway.

HonestyWhat this does not prove

• ⚑ THE INJECTION SURFACE, WHICH IS THE ONE A READER WILL ASSUME THIS PAGE COVERED. It is NOT measured. The four field values go into the prompt RAW, on purpose, so a crafted record — a name containing an instruction — reaches the model exactly as typed. The app exposes no free-text box, so the attack has to arrive as a row from whoever controls the upstream list, and nothing here has tested it. Unmeasured is not safe.
• Anything about a deployed, multi-user version. There isn't one; every number was taken against a loopback server with no auth.
• Whether merging is reversible in the system you would put this in front of. This kit merges nothing — it returns a verdict — and the whole argument for counting false merges apart rests on the assumption that yours cannot be undone.
• Whether the corpus itself leaks anything. It is generated, so there is nothing to leak, and that is a property of the corpus rather than of the code.

In one lineThe guardrail is enforced in code

Not a prompt instruction the model can ignore — a comparison applied after the reply is parsed, before anything downstream sees it.

Nothing merges below the threshold, and the threshold is yours. There is deliberately no recommended value: the whole finding is that no setting is simply correct.

src/decide.py — outcome() and merges(), plus the threshold argument that reaches them from evals/run.py and the app's slider.

EvidenceDoes it hold?

The limitWhat a guardrail is not

• ⚑ IT IS NOT A SAFETY GUARD AND MUST NOT BE READ AS ONE. It bounds which pairs merge; it does nothing about whether the model was right.
• It is not a confidence score. The model is not asked for one — three kits here have measured confidence figures that carried no information.
• It is not a defence against the twin case. Every twin scores above 0.95, so no threshold reachable by this control keeps them apart.
• ⚠︎ IT IS NOT APPLIED TO THE MODEL'S VERDICT AT ALL. When the model answers, its word decides and the threshold decides nothing — which is why a model that says SAME on a twin fuses it however the slider is set.

WatchedWhat is watched, and why that one

The kit measures 18 watched figures plus 8 comparability guards and 5 reference constants — three duties, not one list. 0 of the watched are grader rates, each on its own grader page; this board watches the ones that decide when to look again. Each square is one watched figure; filled means the latest run measured it.

11 measured by the latest run 7 need the model half

GuardsBefore any comparison

Preconditions, not alarms. If one moves, the runs were not measuring the same system and nothing else on this board may be differenced.

The reference constants — the null-grader baseline, the adjudication matrix, the negative count — are the third duty. They are never re-measured per run: a baseline that moves with the thing it measures is not a baseline.

BandsThe alarm bands

Derived from evidence, never picked: exact-match where two runs reproduced a metric to the digit, wider than the measured same-input drift for latency, one row of the negative class for any rate — denominator printed beside it.

HistoryRun history

1 recorded run. A dash is a metric that run did not measure, and a dash is never differenced: not measured is a third state, neither a value nor a zero, and reading it as zero is how a board reports an improvement on a run that never looked.

one run A verdict is a comparison and one run has nothing to compare with, so the Verdict column is left off rather than filled with 11 chips that all say so.

DeviationsWhat deviated

0 breaches across 1 runs

The day a band breaks, a row renders here carrying the metric, the two runs, the band it crossed and what changed between them — model, prompt, chunker or top_k, read off the run records’ guards. A deviation with no diff beside it is an alarm nobody can act on.

RippleThe ripple map

Which figures move together, so one alarm reads as a system. Every edge carries its basis: measured names the run that showed it; reasoning admits nothing has varied it yet.

FiresWhat fires when a band breaks

Where evals stop sitting beside the guardrail and start feeding it. Where the answer is nothing automatic, the row says so — hiding it would undo “What a guardrail is not” above.

NextThe three you would add first

None of these is built here. They are named against the seam they sit on so they can be argued with.

CadenceWhen to re-run, and what it costs

Re-run python3 -m evals.baseline on any change to src/similarity.py, src/block.py or the corpus generator — it is free. Re-run the model half only on a change to src/prompt.py or the model.

In one lineNo framework, deliberately

This kit has no framework and no dependencies at all — csv, urllib and http.server from the standard library. requirements.txt is deliberately empty, so the fork test is git clone and python3.

The mappingSeam by seam, who owns what

The seams are the ones this kit already publishes, so the mapping cannot drift from the code.

GraphsWhere LangGraph changes the answer

Nothing here is a graph. The pipeline has one path — normalise, block, score, judge — with no branching, no retries and no agent loop, so a graph library would add a dependency and a vocabulary without removing a line.

The other sideWhat a framework costs you

• A dependency tree, and a version treadmill on somebody else's release schedule.
• A vocabulary between you and the four fields, at a corpus size where the four fields fit on one screen.
• An install step, which is the step a forker abandons at.
• ⚑ AND THE ONE THAT MATTERS HERE: a library that owns blocking also owns the blocking recall figure, and that figure is this kit's ceiling.

In one lineWhat one run of this kit actually cost, in time and tokens

Measured on r013-data-match-flash on the fast tier, 2026-08-13. This kit records telemetry measured per run — 4 of the 6 readings on this axis, 4 of them with a band the guardrail board can judge against.

The readingWhat the last run measured

No movement column. This is the only run on record, so there is nothing to move against. Said once here rather than as a dash on every row.

Retrieval not shown. No run of this kit has ever recorded a retrieval timing, because the pipeline has no such stage. Those readings are left out rather than dashed: a dash says “this run did not measure it”, which promises a later run could.

The other sideWhat this does not tell you

The first of those is the one worth doing something about, and it is a solved problem: instrumenting a pipeline so each step reports its own duration is a couple of lines. Observability / tracing has the code, and what the result looks like once it is running.

In one lineWhat you provision, honestly

Everything measured on this page says where it was measured; everything not measured says that — the same contract as the other thirteen pages. Where a retrieval index would be on other kits, this one has: no index — blocking is computed in memory each run and is the only reduction step.

The machineWhat this needs

Enumerated from the kit’s own source by build/facts/envscan.py, committed, and drift-checked — never typed into this page.

Your dataWhere everything sits

The wireWhat crosses it, and when

Zero-egress topology: point BASE_URL at a local OpenAI-compatible server and nothing leaves the machine — statically true of the shipped adapter, whose only credential travels in the Authorization header.

The shapeHow it ships, and what you add

The ladderEach decision, and what you provision past its ceiling

Every threshold is a measurement with its provenance beside it, or says is_measured:false. A ceiling with no seam says so — it is the point the kit is outgrown, never a forced join.

When it failsFailure signatures

The knobsThe config surface, enumerated

Environment variables: API_KEY, BASE_URL, EMBED_MODEL, MAX_CALLS_PER_DAY, MODEL, PORT, PROVIDER.

The other sideWhat this page does not claim

The corpus licence, from the Data lens: MIT, with the rest of the kit. ⚑ A SELF-AUTHORED CORPUS REMOVES THE LICENCE ARGUMENT ENTIRELY, and for this use case it removes a worse one: a real customer list cannot be published at all, so a kit about deduplicating people either invents its people or shows you nothing. Your corpus’s licence is yours to verify, and the labels you write are about your documents.

In one lineThe model's verdict against the pair's label

Did the model's word — SAME, DIFFERENT or UNSURE — agree with what the corpus knows the pair to be?

MethodHow the test was run

evals/run.py::score_pair, in-process, no key and no model. The same function evals/baseline.py calls.

The inputOne real row, seen by every grader

⚑ THE ONE THE KIT IS ABOUT. Every field a comparison can see agrees, the similarity score is 0.97, and they are two people. The prompt offers UNSURE for exactly this and the model answered SAME. All 6 false merges in the run are this shape.

The formulaWhat it computes

precision = merged_correct / (merged_correct + false_merge); recall = merged_correct / (merged_correct + missed_match). ⚑ BOTH EXCLUDE `no_verdict`, which is why `answered` is published beside them.

The analysisWhat it actually did

In operationWhat to monitor

Reference standard: the corpus generator's own identity assignment, asserted by a census the generator refuses to write without.

How tight can the band be? There is no alerting threshold because there is no alerting: the kit is run by a person who reads the output.

Cadence: Re-run on any change to src/prompt.py, src/decide.py, src/similarity.py or the model. The free half is re-runnable at no cost at all.

The decisionWhen to reach for it