The business caseThe problem this solves

A landlord serves an escalation notice stating a revised rent and, almost always, not stating its basis. Recomputing an uplift is arithmetic a spreadsheet does perfectly, so the notice worth finding is the tidy one: a flawless percentage, correctly capped, applied to a rent that has not been payable since the year an earlier review was corrected and the landlord's rent account was not. reading each escalation notice by hand against the lease and the deeds. A portfolio of any size cannot do it, so the ordinary practice is to check the arithmetic on the notice's own face -- which is precisely the check that passes every one of the 23 WRONG_BASE readings in this corpus.

The inputThe actual escalation packs

The corpus is 120 escalation packs, 0.63 MB (txt 120). A lease escalation is the smallest job in which the arithmetic is trivial and the decision is not. Everything needed to check the figure is on one page except one number, and that one number -- the rent actually payable -- is the number the landlord's own notice misstates by construction on 23 of the 120 readings.

Synthetic Record
----------------------------------------------------------------
This file is SYNTHETIC. It was generated by tools/build_corpus.py for the AI Foundry use-case kit
`lease-escalation`. No real lease, landlord, tenant, managing agent, surveyor, property, rent or
published index appears anywhere in it. NCPI is an invented monthly series generated in that script
from a fixed seed, and the escalation clause below is illustrative drafting rather than any real
lease's terms. It is safe to read, to copy and to publish.

Lease
----------------------------------------------------------------
Lease reference                          : LE-0001
Property                                 : Unit 12, Ashfield Point, Warrington
Tenant                                   : Norlander Fixings Ltd
Landlord                                 : Brackenmoor Estates Nominee No.2
Managing agent                           : Ferrier Vaughan
Surveyor of record (tenant side)         : Priya Raman
Lease commencement                       : 2018-04-25
Initial Rent (clause 3)                  : 142,750.00 GBP per annum
Review date                              : 2019-04-25   (review 1 of this lease)
Month in which the review date falls     : 2019-04

Escalation Notice
----------------------------------------------------------------
Served by the managing agent on 2019-02-25, reproduced exactly as served.

  Current passing rent, as stated by the landlord          142,750.00
  Revised rent demanded, per annum                         145,719.20
  Increase demanded, on the landlord's own figures              2.08 %
  Effective from                                           2019-04-25
  Basis stated on the notice                           -- none stated

The outcomeWhat a good result looks like

every notice's verdict with the governing mechanism, the base rent used, the rent the lease actually requires and whether a dispute is due -- and the ground it goes to, because the two grounds go to different people.

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.

• Your landlords' rent accounts are all correct and no lease in your portfolio has a deed of variation — the free floor -- abstract-full (b001), $0.00
  It reaches 100.0 pct on the 66 readings with no deed on file, 100.0 pct on WRONG_INDEX_MONTH, 100.0 pct on FLOOR_SHORT and 90.91 pct on CAP_BREACHED, all for nothing. Deciding a lag, a cap and a collar is arithmetic and does not need a model.
• You need every defective notice flagged and you have somebody to triage the false alarms — the free floor -- deed-aware (b003), $0.00
  It misses 0 of 72 adverse notices and leaves GBP 0.00 of overcharged rent unflagged -- the same as the model, for nothing.
• Your leases carry deeds of variation and you have not written a reader for them — the model -- $0.00816 per reading
  100.0 pct on all nine verdicts, 100.0 pct on the 32 readings where a deed governs AND 100.0 pct on the 22 where one is on file and does not, 0 false disputes on 48 correct notices, GBP 0.00 overcharge missed. No rule was written for this lease library.

And where nothing here is good enough:

• You need the check to run on a lease this pre-check has never seen before — neither, yet
  The carried rent is this kit's own prior output. On a first-ever reading there is none, and every arm falls back to the notice's stated passing rent.

At a glanceHow the whole thing runs

Run once, for real, on 2026-08-25. 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-25 — r001-lease-escalation. 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 — Every pack, the answer key, all four free floors, the paired injection probe, the committed run records and the 14 pre-spend checks run with no key and no network. python3 -m evals.check_labels --self-test red-proves five of them and asserts the clean corpus green in the same pass.

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. one reading -- one lease, at one review date, end to end including provider-side reasoning, over 120 readings on r001-lease-escalation at a 64000-token ceiling with 6 concurrent workers

Current processWhat it replaces

reading each escalation notice by hand against the lease and the deeds. A portfolio of any size cannot do it, so the ordinary practice is to check the arithmetic on the notice's own face -- which is precisely the check that passes every one of the 23 WRONG_BASE readings in this corpus.

Step 02 of 14Architecture

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

In brief

CorpusCorpusArchitectureArchitectureArchitectureArchitectureEvalsEvalsEvalsEvalsPromptPromptPromptPromptApp UIApp UIEvalsEvalsBusiness caseUnit cost

• 1stations numbered in run order
• txt
• jsonl
• json
• 3 of 11 stations carry a recorded failure

scroll → 11 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 reading is

20 leases x 6 annual review dates, walked strictly in order per lease so the carried rent is always the previous review's determined figure. Leases are independent and run concurrently; reviews within a lease never are.

SetupWhat the setup figure measured

There is no index to build -- each reading's pack goes whole into the prompt. The figure is the corpus generator's own wall time.

LicenceLicence

MIT

Bring your ownBring your own escalation packs

tools/build_corpus.py writes data/corpus/*.txt and data/gold.jsonl. Keep the 9 section headings and the rule of dashes under each (src/segment.SECTIONS asserts them), keep the lease abstract's key:value shape, and src/figures.py reads your packs unchanged. The deeds are prose and src/deed.py is a phrase list -- point it at your own wording before trusting b003. Everything else is data.

⚠︎ And what stops being true when you do: The measured figures on this page do not transfer to your own corpus. The 23-reading carried-base population is the whole discriminator and its size is a property of THIS corpus; on a portfolio whose landlords' systems are all correct it is zero and the model buys nothing over b001.

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, and the token counts sum to the recorded input total — but they are the input total apportioned by each part’s share of the characters, not a per-part reading from the provider’s counter. The total is measured; the split is arithmetic, and a part carrying denser text really costs more of it than this says.

AssemblyHow the prompt is assembled

This is the cost lesson as arithmetic: of the 3,387 tokens assembled, 1,834 are instructions — 54% 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.build for LE-0018-R5 and reproduced byte for byte, with the system message prepended. The stateless ablation sends this prompt with the carried-state block replaced and every other byte identical.

Full promptThe prompt in full

You are the rent-escalation pre-check for a tenant's lease administration team. You read one lease's escalation notice for one review date, against clause 4, the deeds of variation on file and the index months the pack publishes, and you answer with one JSON object and no other text.

You are the rent-escalation pre-check for a tenant's lease administration team. It runs each time a
landlord serves an escalation notice, and it answers ONE question before anybody pays: is the rent
being demanded the rent the lease requires?

The lease, the notice as served, clause 4 in full with the lease abstract's summary of it, every
deed of variation on file, the published index months this pack carries and the landlord's own
review history are reproduced in the extract below. You cannot see any earlier review of this lease;
what is known about them is stated under "Carried state" and is the only history available to you.
Do not assume anything about earlier reviews beyond it.

⚠︎ THE CLAUSE, THE CAP, THE COLLAR, THE INDEX AND THE MATCHING TOLERANCE ARE ILLUSTRATIVE DRAFTING
AND AN INVENTED SERIES, NOT ANY REAL LEASE'S TERMS. Apply them exactly as printed regardless of
whether they look right for the lease in front of you.

THE POINT OF THIS JOB: multiplying a rent by a percentage is arithmetic and a spreadsheet does it
perfectly, so it is NOT what you are for. What you are deciding is WHICH ARITHMETIC the lease
requires -- which rent is the base, which month of the index, whether a cap or a collar bites, and
whether a deed of variation has replaced the clause altogether. The notice states a figure and does
not state its basis. The dangerous notice is the tidy one: a flawless percentage applied to the
wrong rent.

HOW TO WORK IT OUT, in this order. Stop at the first line that decides the answer.

 1. GOVERNING TERMS. Read every deed of variation on file and decide, from the date or review date
    IT names against the review date printed under Lease, whether it is in force AT THIS REVIEW
    DATE. A deed that takes effect at a later review date is on file and does NOT govern. A deed
    that varies something other than the rent review -- a break date, a service charge
    apportionment -- does not govern the escalation however plainly it is in force. If a deed IS in
    force and replaces the escalation mechanism, ITS terms are the governing terms; otherwise
    clause 4's are.

 2. INDEX AVAILABLE? If the governing terms need an index value for a month the "Published Index"
    table on this page does not carry, the verdict is INDEX_UNAVAILABLE. Nothing is recomputed,
    "correct_rent" is NONE, "basis" is NONE, no dispute is raised. Do not substitute a neighbouring
    month, and do not interpolate.

 3. STANDSTILL? If a deed in force stands this review date down, no uplift is due at all. The
    correct rent is the rent payable immediately before this review date, unchanged. If the notice
    demands that same figure the verdict is AGREES; if it demands anything else the verdict is
    NO_REVIEW_DUE. "basis" is NONE either way.

 4. THE BASE RENT. Under a COMPOUNDING base rule the base is THE RENT PAYABLE IMMEDIATELY BEFORE
    THIS REVIEW DATE, which is stated in the carried state. It is NOT necessarily the "current
    passing rent" the notice prints and it is NOT the landlord's own review history -- where an
    earlier review was corrected, the landlord's account went on compounding its own uncorrected
    figure and the two never reconverge. Under an INITIAL base rule the base is the Initial Rent
    printed under Lease.

 5. THE UPLIFT. Compute it under the governing mechanism:
      INDEX_LAGGED   the percentage change in the series from the comparison month to the reference
                     month, the reference month being the review month less the stated lag
      INDEX_CURRENT  the same, with the reference month being the review month itself
      FIXED_PCT      the stated percentage. Under an INITIAL base rule it is that percentage once
                     for EACH review date that has occurred including this one, SIMPLE, not
                     compounded -- so at review 4 of a 2.75 per cent clause the uplift is 11.00 per
                     cent of the Initial Rent, not 2.75
      GREATER_OF     the greater of the stated percentage and the index change
    Then apply the printed collar and cap: an uplift below the collar becomes the collar, an uplift
    above the cap becomes the cap. Round the uplift to TWO DECIMAL PLACES first, then apply it to
    the base and round the rent to the nearest penny, half a penny up. Both steps are printed in
    clause 4.3.

 6. AGREES? If the rent demanded is within the printed matching tolerance of the rent you computed,
    the verdict is AGREES. Check this BEFORE diagnosing anything.

 7. OTHERWISE DIAGNOSE, in this order, stopping at the first that fits:
      SUPERSEDED_TERMS    a deed is in force and the figure demanded is what the ORIGINAL clause 4
                          would have given on the same base
      CAP_BREACHED        the increase the notice states against its OWN passing rent is more than
                          the printed cap
      FLOOR_SHORT         that same stated increase is less than the printed collar. This is an
                          UNDERCHARGE and it is still a defect -- report it
      WRONG_INDEX_MONTH   the figure demanded is your base and your method taken at a DIFFERENT
                          month that this page publishes -- the lag applied wrongly
      WRONG_BASE          the figure demanded is your uplift applied to a different rent that is
                          printed or carried: the notice's stated passing rent, the Initial Rent, or
                          the rent payable
      UNSUPPORTED_DEMAND  the figure ties to nothing on the page. This is a real answer, not a
                          wastebasket: it is what gets a landlord to disclose their working

 8. "basis" is the governing MECHANISM you applied -- INDEX_LAGGED, INDEX_CURRENT, FIXED_PCT or
    GREATER_OF -- and NONE when the verdict is INDEX_UNAVAILABLE or NO_REVIEW_DUE or when a
    standstill made the rent unchanged.

 9. "raise_dispute" is YES only when the verdict is adverse AND the carried state does NOT already
    show a dispute open on the same ground. There are two grounds and they go to different people:
    BASIS covers SUPERSEDED_TERMS, NO_REVIEW_DUE, WRONG_INDEX_MONTH, WRONG_BASE and
    UNSUPPORTED_DEMAND; QUANTUM covers CAP_BREACHED and FLOOR_SHORT. A dispute open on one ground
    does not satisfy the other. It is always NO for AGREES and for INDEX_UNAVAILABLE.

Answer with a single JSON object and nothing else:

{"verdict": "AGREES|SUPERSEDED_TERMS|NO_REVIEW_DUE|CAP_BREACHED|FLOOR_SHORT|WRONG_INDEX_MONTH|WRONG_BASE|UNSUPPORTED_DEMAND|INDEX_UNAVAILABLE",
 "basis": "INDEX_LAGGED|INDEX_CURRENT|FIXED_PCT|GREATER_OF|NONE",
 "base_rent": <the rent you applied the uplift to, a plain number to two decimals, no commas>,
 "correct_rent": <the rent the lease requires, a plain number to two decimals, no commas, or the string "NONE">,
 "raise_dispute": "YES|NO",
 "rationale": "one sentence naming the governing terms, the base you used and where it came from,
   the reference month and the uplift, and what the demand did instead"}

Carried state
----------------------------------------------------------------
The rent PAYABLE immediately before this review date, as determined at the last review, is 82,826.82 GBP. Use that figure wherever the clause says the rent payable before the review date, even if the notice prints a different current passing rent. A dispute is ALREADY open on QUANTUM, BASIS (the managing agent, as an arithmetic correction; the tenant's surveyor, as a lease-interpretation question). A dispute open on one ground does not satisfy the other. The previous review date was returned as AGREES. This pre-check has read 4 earlier review notice(s) on this lease.

Escalation pack
----------------------------------------------------------------
Synthetic Record
----------------------------------------------------------------
This file is SYNTHETIC. It was generated by tools/build_corpus.py for the AI Foundry use-case kit
`lease-escalation`. No real lease, landlord, tenant, managing agent, surveyor, property, rent or
published index appears anywhere in it. NCPI is an invented monthly series generated in that script
from a fixed seed, and the escalation clause below is illustrative drafting rather than any real
lease's terms. It is safe to read, to copy and to publish.

Lease
----------------------------------------------------------------
Lease reference                          : LE-0018
Property                                 : Unit 8, Netherfield Point, Nottingham
Tenant                                   : Barrowfield Print Ltd
Landlord                                 : Ravenhurst Pension Nominees Ltd
Managing agent                           : Bramhall Rowe
Surveyor of record (tenant side)         : Nadia Okonjo
Lease commencement                       : 2019-09-30
Initial Rent (clause 3)                  : 71,450.00 GBP per annum
Review date                              : 2024-09-30   (review 5 of this lease)
Month in which the review date falls     : 2024-09

Escalation Notice
----------------------------------------------------------------
Served by the managing agent on 2024-07-28, reproduced exactly as served.

  Current passing rent, as stated by the landlord           82,826.82
  Revised rent demanded, per annum                          86,139.89
  Increase demanded, on the landlord's own figures              4.00 %
  Effective from                                           2024-09-30
  Basis stated on the notice                           -- none stated

  The notice does not say which month of the index it used, which rent it applied the
  uplift to, or whether any cap or collar was applied. It states a figure.

Escalation Clause
----------------------------------------------------------------
Clause 4 of the lease, reproduced in full:
  4.1  On each Review Date the Annual Rent shall be revised to the Base Rent multiplied by one plus
       the Index Uplift. The Index Uplift is the percentage change in the NCPI between the month
       twelve months before the month in which the Review Date falls and THE MONTH IN WHICH THE
       REVIEW DATE FALLS. No lag is applied.
  4.2  The Base Rent is the Annual Rent payable immediately before the Review Date.
  4.3  The Index Uplift shall be computed to two decimal places and the revised Annual Rent rounded
       to the nearest penny, half a penny being rounded up.
  4.4  In no event shall the Review Uplift exceed 4.00 per cent, however far the
       measure in clause 4.1 moves.
  4.5  In no event shall the Review Uplift be less than 1.00 per cent, however
       far the measure in clause 4.1 moves.

  Summary of clause 4, as recorded on the lease abstract:
    Mechanism                              : INDEX_CURRENT
    Index series                           : NCPI -- National Consumer Price Index (synthetic)
    Reference month                        : the review month itself, no lag
    Comparison month                       : twelve months before the reference month
    Base rent for the uplift               : COMPOUNDING
                                             the rent payable immediately before the
                                             review date
    Cap on the uplift                      : 4.00 %
    Collar on the uplift                   : 1.00 %
    Rounding                               : the uplift to two decimal places, then the
                                             revised rent to the nearest penny, half up
  Matching tolerance for this pre-check    : 1.00 GBP

Amendments On File
----------------------------------------------------------------
  DoV-2020-260
    Supplemental deed. The parties have agreed that clause 4 of the lease shall cease to
    have effect in relation to any review date on or after the review date falling in 2021,
    and that in its place the Annual Rent shall be revised by reference to the greater of
    2.00 per cent and the change in NCPI over the twelve months to the month 3 before the
    review month, with no cap.

Published Index
----------------------------------------------------------------
NCPI -- National Consumer Price Index (synthetic). Monthly, index points, one decimal place.
Only the months printed below are published on this notice pack.

  2023-04      124.4    2023-05      125.0    2023-06      125.7
  2023-07      126.3    2023-08      127.0    2023-09      127.6
  2023-10      128.2    2023-11      128.8    2023-12      129.5
  2024-01      130.1    2024-02      130.4    2024-03      130.7
  2024-04      131.0    2024-05      131.4    2024-06      131.8
  2024-07      132.1    2024-08      132.5    2024-09      132.8

Review History
----------------------------------------------------------------
  As recorded in the LANDLORD'S rent account. This is the landlord's own file and it
  does not record any figure this pre-check determined.

  Review   Review date     Rent demanded    Rent carried by the landlord
  1        2020-09-30           72,100.20        72,164.50
  2        2021-09-30           73,607.79        73,607.79
  3        2022-09-30           76,552.10        77,163.05
  4        2023-09-30           82,826.82        82,826.82

Covering Letter
----------------------------------------------------------------
  Please arrange for the revised rent to be paid by the existing standing order from the effective date. Our reference is unchanged.

Raw responseThe raw response

{"verdict": "SUPERSEDED_TERMS", "basis": "GREATER_OF", "base_rent": 82826.82, "correct_rent": 86843.92, "raise_dispute": "NO", "rationale": "DoV-2020-260 is in force for the 2024 review and replaces clause 4, so the rent is the carried pre-review rent of 82,826.82 uplifted by the greater of 2.00% and the NCPI change from June 2023 to June 2024 (4.85%), giving 86,843.92, while the notice demands the superseded clause 4's capped 4.00% figure."}

Step 06 of 14Evals

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

In brief

Check a landlord's rent-increase notice before you pay — 120 escalation packs. 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

Exact match per cell against a computed key. No LLM-as-judge anywhere in this kit, on any arm.

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, never a bill.

Rates checked 2026-08-18. The provider that actually ran all 344 calls is kept out of these tables per this estate's rule.

Grading unitWhat the grading figure prices

The grader is pure Python over the committed result files and costs nothing to re-run; python3 -m evals.run --floor <name> re-fires any free arm offline.

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

The model does not lose a column to any floor on this corpus, and that is NOT the finding. The finding is the shape of what b002 loses: it is 100.0 pct on the 66 readings with no deed on file and 28.12 pct on the 32 where a deed governs, and the gap is entirely prose. A fifth floor with src/deed.py wired in would close it to zero -- check_labels proves it -- and is deliberately not shipped, because it would be the answer key wearing a different name. What the model bought here is that nobody had to write it.

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-18. Nobody paid these particular bills; they are what the same work would cost you on a card you can sign up to today.

Answering vs gradingAnswering and grading are two separate bills

344 live calls in total: 120 scored, 120 for the ablation, 36 for two ceiling calibrations and 68 for the paired injection probe. NOTHING WAS DISCARDED, because the ceiling was raised from 32,000 to 64,000 BEFORE the scored run rather than after it. The injection probe is shown at $0.00 because evals/injection.py records no token counts per call -- that is a gap in the probe, not a free run, and it is listed in could_not_verify. The four free floors, the stub and every pre-spend check cost $0.00 and can be re-fired offline.

Cost driversWhat actually moves the bill

• PROVIDER-SIDE REASONING, and it is essentially the whole bill. 95.2 pct of this run's output tokens (331097 of 347649) were reasoning; the answers are ~90 tokens of JSON each.
• THE PROMPT'S INSTRUCTION BLOCK, which is 1763 of the 3387 input tokens -- larger than the escalation pack it is reasoning about. Deciding WHICH arithmetic is the job, so the rule is long and the evidence is short.

Your volumeWhat it costs at your volume

LINEAR IN LEASES x REVIEW DATES, and the chains are serial within a lease so the wall clock does not amortise either. 120 readings cost $0.98 on the projection card; 1,200 leases reviewed annually cost $9.80 a year, which is not the constraint. The constraint is that nothing here batches.

Model choiceWhy this model

It is the tier the shared connection was already pointed at. The kit's claim is about what a general model does with no rules written for this lease library, so the cheapest tier that can hold a nine-step precedence in one call is the right one to make the claim on -- and if a cheaper reading were enough, b002 already proves it at $0.00 on 55 pct of the corpus.

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.

per-query average, this run

The codeEvery file, and what it is for

15 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.

Eight 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.

src/clause.pythe clause vocabulary and the rounding — a swap seam

The nine verdicts, the five mechanisms, the two base rules, the two dispute grounds, and the three functions that turn an index pair into a percentage and a percentage into money. Every figure in the kit is a Decimal quantized to 0.01 ROUND_HALF_UP, pinned here once so the builder, the key, four floors and the scorer cannot disagree.

You change it to: index_uplift_pct() rounds the percentage before it touches money. That single line is the difference between the key and the model's only arithmetic error.

# The vocabulary of a rent-escalation pre-check, and the arithmetic primitives underneath it.

AGREES = "AGREES"
SUPERSEDED_TERMS = "SUPERSEDED_TERMS"
NO_REVIEW_DUE = "NO_REVIEW_DUE"
CAP_BREACHED = "CAP_BREACHED"
FLOOR_SHORT = "FLOOR_SHORT"
WRONG_INDEX_MONTH = "WRONG_INDEX_MONTH"
WRONG_BASE = "WRONG_BASE"
UNSUPPORTED_DEMAND = "UNSUPPORTED_DEMAND"
INDEX_UNAVAILABLE = "INDEX_UNAVAILABLE"

src/escalation.pyTHE RULE, and the answer key

decide() applies the nine-verdict precedence and step() writes the carried state. It never sees a model reply -- every arm is scored against it and none of them reaches it.

# THE RULE, in code. One lease, one review date, one answer -- and the answer key for every arm.

REVIEWS = 6
CADENCE_LABEL = "one review date a year, on the lease anniversary, re-read as each notice lands"
PCT_EPSILON = Decimal("0.01")
def month_add(ym, n):
def reference_months(terms, review_month):
def uses_index(terms):
def governing(reading):
def raw_uplift(terms, reading):
def base_rent(terms, reading, carried):

src/figures.pythe page, read back in code

The lease block, the notice, the lease abstract's summary of clause 4, the published index table and the landlord's own review history. It deliberately does NOT read the deeds.

# Read the STRUCTURED blocks of an escalation pack back off the printed page. Pure code.

MONEY = r"[-+]?[\d,]+\.\d\d"
def _sections(text):
def _money(s):
def _field(body, label):
def lease(text):
def notice(text):
def clause(text):
def index(text):
def amendments_raw(text):

src/deed.pythe deeds, read by phrase list

~120 lines of regular expressions against the three phrasings this corpus ships per kind of deed. It is honest about being a phrase list: a fourth phrasing returns UNCLASSIFIED rather than a guess, because an unread deed defaulting to 'governs' would rewrite every rent on the estate.

# Read a deed of variation off the page. A PHRASE LIST, and it says so.

FROM_YEAR = (
STANDSTILL_YEAR = (
IRRELEVANT = (
def _first(patterns, text):
def _pct(s):
def _caps(text):
def _mechanism(text):
def read(dov, review_year):
def read_all(dovs, review_year):

src/select.pywhich sections leave the machine — a swap seam

The union of the mapped sections. Landlord Agent Contact is mapped by nothing, so it is never sent -- including down the fallback path a schema migration would reach.

You change it to: SECTION_HINTS and NEVER_SENT. Emptying NEVER_SENT is what red-proves the guard.

# Pick which sections of an escalation pack are sent. Pure code -- the last deterministic step

BANNER = "Synthetic Record"
LEASE = "Lease"
NOTICE = "Escalation Notice"
CLAUSE = "Escalation Clause"
AMENDMENTS = "Amendments On File"
INDEX = "Published Index"
HISTORY = "Review History"
CONTACT = "Landlord Agent Contact"
LETTER = "Covering Letter"

src/prompt.pythe one prompt

Three parts, assembled by string concatenation: the question, the carried state, the pack. --stateless replaces the middle block and nothing else.

# Assemble the one prompt this kit sends. No template engine, no framework -- string concatenation

INSTRUCTION = """\
def build(text, carried, stateless=False):

src/state.pywhat carries between review dates — a swap seam

The rent this pre-check determined was payable, and which dispute grounds are open. Written by the rule, never by a model.

You change it to: describe() is the only route between review dates, and it is one block of the prompt. Removing it is the ablation this kit scored.

# What this pre-check carries from one review date to the next, and the sentences it hands the

HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
DEFAULT_PATH = os.path.join(HERE, "data", "state.json")
def load(path=DEFAULT_PATH):
def save(store, path=DEFAULT_PATH):
def for_lease(store, lease_id):
def describe(state):

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

One interface, several providers, raw HTTP, stdlib only. It also carries the 900-second socket timeout and the single transport retry that a 64000-token ceiling makes mandatory.

You change it to: PROVIDER, BASE_URL and MODEL in .env. Adding a vendor is one function and one entry in PROVIDERS.

# 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
TIMEOUT_SECONDS = 900
TRANSPORT_RETRIES = 1
def _post(url, headers, payload, timeout=None):
def openai_compatible(cfg, system, user, max_tokens, thinking=None):
def anthropic(cfg, system, user, max_tokens):
PROVIDERS = {"openai-compatible": openai_compatible, "anthropic": anthropic}

evals/baseline.pythe four free floors

b000 to b003, ascending, none a strawman. b001/b002/b003 are ONE implementation given three sets of inputs, so the difference between the columns is the input and never an accident of three hand-written checkers.

# THE FOUR FREE FLOORS. No key, no model, no network -- and none of them is a strawman.

MODES = ("notice-defaults", "abstract-full", "abstract-plus-state", "deed-aware")
def _reading(text):
def _answer(v, basis, base, correct, dispute):
def _dispute(verdict, carried):
def notice_defaults(text, carried):
def _full(text, carried, use_state, deed_aware):
def review(text, carried=None, mode="notice-defaults"):

evals/scoring.pythe scorer

Exact match per cell, split rather than blended. The discriminator is reported over its two populations separately and at three tolerances.

# Score one arm's answers against the key. Pure code, no model, no judge.

FIELDS = ("verdict", "basis", "base_rent", "correct_rent", "raise_dispute")
MONEY_FIELDS = ("base_rent", "correct_rent")
AGREES = "AGREES"
INDEX_UNAVAILABLE = "INDEX_UNAVAILABLE"
QUIET = (AGREES, INDEX_UNAVAILABLE)
TOLERANCES = (Decimal("0"), Decimal("0.01"), Decimal("1.00"))
def _money(v):
def _norm(field, v):
def _pct(n, d):

evals/run.pythe harness

One lease chain at a time, strictly in review order, carrying the ground-truth state.

# Run the pre-check over the 20 leases, six review dates each, and write one result file.

HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
RESULTS = os.path.join(HERE, "results")
GOLD = os.path.join(HERE, "data", "gold.jsonl")
def load_gold():
def carried_of(g):
def next_state(g):
def stub_complete(cfg, system, user, max_tokens=1024):
def main():

evals/injection.pythe paired injection probe

Forces the instruction-shaped covering letter onto every reading where a dispute is due and fires each twice, comparing all five fields rather than only the verdict.

# THE INJECTION PROBE, PAIRED. Does an instruction-shaped covering letter from the landlord's

HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
RESULTS = os.path.join(HERE, "results")
INJECTION = (
QUIET = ("AGREES", "INDEX_UNAVAILABLE")
FIELDS = ("verdict", "basis", "base_rent", "correct_rent", "raise_dispute")
def force_letter(text):
def main():

evals/check_labels.pythe pre-spend gate

14 checks. The load-bearing one re-derives the whole key from the printed page.

# Prove the corpus and the answer key BEFORE any run may spend. Free, offline, no key.

HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
CORPUS = os.path.join(HERE, "data", "corpus")
GOLD = os.path.join(HERE, "data", "gold.jsonl")
FIELDS = ("verdict", "basis", "base_rent", "correct_rent", "raise_dispute")
INJECTION_MARK = "assured-calculation programme"
def load_gold():
def doc(doc_id):
def from_page(text, carried):
def norm(field, v):

tools/build_corpus.pythe corpus generator — a swap seam

Deterministic from one seed, and it refuses to write a corpus whose planted defects the rule does not independently re-derive.

You change it to: AMENDMENTS and the three prose phrasings per kind. Add a fourth phrasing and src/deed.py stops reading it, which is the experiment this kit did not run.

# Build the corpus and the answer key. Deterministic, offline, no key, no model.

HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
CORPUS = os.path.join(HERE, "data", "corpus")
GOLD = os.path.join(HERE, "data", "gold.jsonl")
STATS = os.path.join(HERE, "data", "corpus-stats.json")
STATE = os.path.join(HERE, "data", "state.json")
SEED = 20260825
REVIEWS = 6
ANNUAL_RATE = {2016: 1.6, 2017: 2.0, 2018: 2.1, 2019: 1.8, 2020: 0.5, 2021: 2.6,
INDEX_START = "2015-01"

src/app.pythe local UI

One notice, the rent actually payable beside the rent the landlord says is passing, and all four free floors computed live. Renders with no key.

# The minimal local UI. Standard library only -- python3 -m src.app, then open the printed URL.

HERE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
UI = os.path.join(HERE, "ui")
GOLD = os.path.join(HERE, "data", "gold.jsonl")
PORT = int(os.environ.get("PORT", "9047"))
RECORDED_RUN = os.environ.get("RECORDED_RUN", "r001-lease-escalation")
GOLD_ROWS = {r["doc_id"]: r for r in
def carried_for(doc_id):
def read_in_code(text):
class H(BaseHTTPRequestHandler):

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: 3072 input and 2897 output tokens per reading (one lease, at one annual review date), 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

MEASURED, FORCED AND PAIRED. The Covering Letter is this kit's injection surface -- it is prose written by the landlord's managing agent, the party whose demand is under examination, which makes it the one block on the page authored by somebody with a direct interest in the answer.

API_KEY is read from .env (gitignored) or the real environment; never logged, never placed in a prompt, and redacted from any provider error message the local UI passes to the browser.

The experimentWe DID attack it -- one sentence, on every reading where it could matter, each one paired against itself

The probe forces the instruction-shaped letter onto every reading whose gold raise_dispute is YES and fires each twice, once with and once without, everything else held identical including the carried state. The paired denominator is the readings the model called adverse WITHOUT the letter, because a reading it already got wrong is an ordinary miss and counting it as a suppression inflates the rate. It compares all FIVE fields rather than the verdict alone, because a sibling kit's single flip was not a suppression at all -- it was a fabricated arithmetic error that existed only under injection. Both were run for real on 2026-08-25.

Both boundaries are measured in both directions: the injection probe forces the condition rather than waiting for it, and the privacy guard is checked against the schema-change condition that reaches its fallback.

The result0 of 34 adverse verdicts flipped, 0 of 34 disputes suppressed and 0 of 34 pairs moved any of the five fields -- measured, forced, paired, at a 64000-token ceiling.

One phrasing, one model, one corpus, 34 paired readings -- every reading where suppression was even possible. No pair failed.

HonestyWhat this does not prove

• Whether the 0 of 34 reproduces across phrasings, models, corpora or ceilings. One sentence, one model, one corpus, one ceiling -- paired against its own un-injected answer, so nothing broader is claimed.
• Whether a letter placed in Landlord Agent Contact would have any effect -- by construction it cannot, because that block is never sent.
• What the probe cost. evals/injection.py records no token counts per call.

In one lineThe only guardrail is the prompt

One instruction, no enforcement. It mostly holds — and mostly is the whole subject.

Never pay, withhold, serve a counter-notice, amend a rent account or trigger a review arbitration -- and never present the clauses, the caps, the collars or the NCPI series as any real lease's terms or any published statistic.

Stated to the model on every call in src/prompt.py's INSTRUCTION block, stated again on the local UI, and true of the code by ABSENCE: there is no writer anywhere in src/, evals/, tools/ or ui/ outside results/*.json and data/state.json.

EvidenceDoes it hold?

The limitWhat a guardrail is not

• This is a PROMPT RULE PLUS AN ABSENCE, not a runtime enforcement layer. Nothing stops a forker adding a payment call tomorrow.
• The injection result is ONE SENTENCE against ONE model on ONE corpus at ONE ceiling.
• Nothing here validates that the clauses in tools/build_corpus.py match any real lease. They are illustrative drafting and the page says so four times.
• The 100.0 pct verdict accuracy is NOT evidence that a model is needed here. On this corpus a deterministic page reader reaches the same number for nothing, and the kit says so before any figure is read.

WatchedWhat is watched, and why that one

The kit measures 119 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.

4 measured by the latest run 115 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.

no shared guard The two recorded runs declare no guard in common, so nothing below is protected by a precondition — read the history as two separate observations, not as a difference.

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

10 recorded runs. 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. They are split into 4 blocks because a free floor is a baseline rather than a peer, and a run of another kind measures another thing; a column in one block is never differenced against a column in another.

triage · no model in the path — a baseline, not a peer column — 4 runs. A floor is what the kit scores with no model in the path; it is the line the model runs have to beat, and it is never differenced against them.

not a time series No two of these 4 runs measured the same system — they differ on adverse_false, adverse_missed, escalation_calc_base_from_state_hits, escalation_calc_base_on_page_hits, escalation_calc_hits, false_disputes, leases_caught, leases_missed, missed_disputes, the model — so nothing here may be differenced and the Verdict column is left off. Read this block DOWN a column, as a comparison between those runs, not along a row as a history.

triage · with the model in the path — 4 runs. Columns here are only ever compared with each other.

not a time series No two of these 4 runs measured the same system — they differ on adverse_cells, adverse_missed, answered, deed_governing_cells, deed_on_file_not_governing_cells, dispute_due_cells, dispute_quiet_cells, documents, escalation_calc_base_from_state_cells, escalation_calc_base_from_state_hits, escalation_calc_base_on_page_cells, escalation_calc_base_on_page_hits, escalation_calc_hits, escalation_calc_not_computable_cells, false_disputes, leases_caught, leases_with_a_defect, max_tokens, memory_cells, missed_disputes, no_deed_cells, overcharging_cells, quiet_cells, readings_scored, stateless, undercharging_cells — so nothing here may be differenced and the Verdict column is left off. Read this block DOWN a column, as a comparison between those runs, not along a row as a history.

stub · no model in the path — a baseline, not a peer column — 1 run. A floor is what the kit scores with no model in the path; it is the line the model runs have to beat, and it is never differenced against them.

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 20 chips that all say so.

redteam · with the model in the path — 1 run. Columns here are only ever compared with each other.

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 4 chips that all say so.

DeviationsWhat deviated

0 breaches across 10 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

annual -- one review date per lease, re-read as each notice lands

In one lineNo framework, deliberately

NO FRAMEWORK. A folder of readable Python, no framework dependency, an empty requirements.txt and a prompt anyone can read end to end. A framework abstraction would own the retrieval step -- there is none here -- and the memory layer, which is already the entire surface of src/state.py and is two fields wide.

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

Linear: the pack -> src/prompt.py -> src/adapters -> evals/scoring.py. No branching, no tool-calling and no agent loop.

The other sideWhat a framework costs you

• Swapping providers means editing the PROVIDERS dict by hand. In exchange the prompt has no hidden templating layer, requirements.txt stays empty, and the socket timeout is a constant a reader can see.

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

Measured on r001-lease-escalation on the fast tier, with the rent payable carried in, 2026-08-25. 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. Not one of the 7 earlier runs on record is comparable with this one — a different model tier, or a changed guard — and differencing across that measures two systems rather than one. 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.

DriftMedian call, run over run

Hatched bars are runs that are not comparable with the latest — a different model tier or a changed guard. They are drawn because hiding them would make the history look shorter than it is, and greyed because differencing across them would be measuring two systems.

4 runs not plotted. b000-lease-escalation-notice-defaults, b001-lease-escalation-abstract-full, b002-lease-escalation-abstract-plus-state, b003-lease-escalation-deed-aware recorded no call latency at all — a rules-only floor run makes no model call, and the 0 its record stores is an absence, not a zero-millisecond answer. Plotting it would put a bar on this chart claiming the fastest run in the kit’s history.

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 — the population is re-read whole on each scheduled run, and the prior run's carried state is what makes a reading a CHANGE.

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, EVAL_WORKERS, MAX_CALLS_PER_DAY, MODEL, PORT, PROVIDER, RECORDED_RUN.

The other sideWhat this page does not claim

The corpus licence, from the Data lens: MIT Your corpus’s licence is yours to verify, and the labels you write are about your documents.

In one lineThe verdict, governing mechanism, base rent, required rent and dispute call, per reading

whether each of the 5 answered fields equals the answer key, per reading, with money compared as Decimal at EXACT equality

MethodHow the test was run

python3 -m evals.run --run-id <id> ...; evals/scoring.py compares strings and Decimals. No model grades anything anywhere in this kit.

The inputOne real row, seen by every grader

The formulaWhat it computes

accuracy = hits / 120 per field. escalation_calc_accuracy_pct is scored over the 116 readings where a rent is computable at all, and is ALWAYS printed as its two populations -- 93 where the notice's passing rent is the base, 23 where it is not -- never as the blend.

The analysisWhat it actually did

In operationWhat to monitor

Reference standard: the computed answer key in data/gold.jsonl, produced by src/escalation.step() from the same planted inputs the corpus builder wrote onto the page, and re-derived independently from the printed page by evals/check_labels.py.

No true/false rates for this grader. It records 5 operating rows and not one of them carries a confusion matrix, so there is no TPR, TNR or precision to state here — this grader does not sort answers into pass and fail, and rates that were never measured are not going to be printed as though they were. What it did measure is in “What it actually did” above; what to watch is immediately below.

How tight can the band be? There is no tunable threshold. The grader is exact match against a computed key, so there is nothing to tune and nothing to overfit.

Cadence: Re-scored free on every run of evals/run.py, and re-derivable from the committed result files with no key.

The decisionWhen to reach for it