The covenant certificate that will not sign through a breach.

A personal attestation, computed in a spreadsheet nobody re-reads against the contract.

A compliance certificate is a personal certification, typically by the CFO or another responsible officer, that the covenant calculations are correct, and lenders can treat an incorrect certificate as a default in its own right. The calculation behind it runs against negotiated legal definitions: a Consolidated EBITDA with a bespoke add-back list, leverage and coverage ratios defined in the agreement, thresholds that step quarter by quarter. In most mid-market treasuries all of that lives in Excel, transcribed once from a 150-page agreement at signing and rekeyed from the trial balance every month.

The failure mode is drift, and it is well documented in the covenant data. Lincoln International's Senior Debt Index, which values several thousand private companies quarterly, reported covenant defaults rising for three consecutive quarters to 3.4% in Q2 2025, against a seven-year average of 4.4%, with covenant breaches rather than missed payments dominating the default count (Lincoln SDI, Q2 2025, Q3 2025). A technical breach that surfaces late does not stay technical: it arrives during the audit or a refinancing, on a certificate the CFO signed personally, and it can drag waiver negotiations and going-concern discussions in with it.

• the transcriptionThe analyst reads the agreement once and types what they understood into Excel. The contract and the model are never mechanically linked again.
• the driftAdd-backs get "interpreted" month by month: a cap is forgotten, a time window lapses, a recurring charge keeps its non-recurring label. Each cell edit is invisible.
• the discoveryTwelve months later someone else recomputes from the actual definitions and finds a covenant breached three quarters ago, signed through repeatedly.

The agreement is read once in a decade. The arithmetic runs every month. Those are different jobs.

The tempting AI fix is to hand the model the agreement and the trial balance every month and ask whether the company is compliant. That design is wrong on both sides of the boundary. On the reading side, a model that re-reads the contract monthly can re-interpret it monthly, which reintroduces exactly the drift the control was meant to kill, only faster and with more confidence. On the computing side, a leverage ratio is division. A system that can produce different EBITDA figures from identical inputs is not a compliance control; a re-run that does not reproduce the certificate is itself an audit finding.

There is also a subtler trap: the agreement you have is never complete. The exhibit this demo uses is an amendment that restates the definitions and covenants, but the base agreement's text is not in the filing. A model that answers anyway is guessing about a legal document. The correct output for "Consolidated EBITDA" in this exhibit is "not defined in this document", and an unconstrained model is the one system that will never say it. So the design splits the work: the model locates and quotes, once, under confirmation; code computes, forever, under hashes.

Extract once with citations. Confirm once with a name. Then deterministic forever.

Phase 1 runs once, at signing. The extraction stub locates each defined term in the real agreement text and must quote the clause verbatim with its section reference; the extraction script refuses to ship any quote it cannot literally find at a recorded character offset. Terms the document does not define are surfaced as abstentions with their occurrence counts. The treasurer confirms each extracted term, supplies the missing definitions manually (marked manual, never presented as extracted), and the confirmation freezes everything to the ledger with clause hashes. Phase 2 runs every month, and no model appears anywhere in it: code maps TB accounts to the frozen definitions, recomputes the three ratio covenants across all 24 months, projects the trajectory two ways, enforces the negotiated add-back cap, and drafts the certificate by substituting computed values into the template.

The clauses are real. The demo extracts from Amendment No. 3 to Manitowoc's Amended and Restated Credit Agreement (SEC EDGAR, January 2010): the Consolidated EBIT definition with its negotiated add-back list, the three ratio covenant schedules of Sections 6.07, 6.08 and 6.21, and the Section 5.01(c) certificate requirement. Clause (h) of the EBIT definition caps post-2010 non-recurring cash restructuring add-backs at $15,000,000 in aggregate, which is precisely the kind of negotiated detail a spreadsheet forgets and code cannot: the engine tracks cumulative claims against the cap on every run, whatever anyone decides to call "non-recurring".

The gate is a comparison against a frozen threshold, so it is written as one.

Here is the deterministic core from the shipped engine: the covenant state check that drives the badges, the watermark and the Sign button, and the clause (h) cap check that runs regardless of classification. Compliance under Section 6.08 means strictly below the threshold, because the covenant text says "less than", and the tolerance band is the sign gate's own margin, stated on screen:

// clause (h): the aggregate cap is enforced in code, whatever anyone calls
// "non-recurring". Returns the add-back actually allowed for this window.
function capAllowed(claimWindow, claimedBefore) {
  return Math.min(claimWindow, Math.max(0, CAP_H - claimedBefore));
}

function covState(c, val) {                    // c.thr frozen from the clause
  var breached = c.dir === "max" ? val >= c.thr : val <= c.thr;
  var head = c.dir === "max" ? c.thr - val : val - c.thr;
  return { breached: breached, headroom: head,
           inTolerance: !breached && head < c.tol };
}
// the Sign button is enabled only when gate.reasons is empty:
// any covenant breached OR inside tolerance appends a reason, and the
// first reason's clause is quoted verbatim next to the dead button.

$2,400,000 of "non-recurring" restructuring is the difference between a certificate and a default.

The synthetic borrower carries $127,500,000 of debt against LTM EBITDA that erodes every month. In March 2026 it recorded a $2,400,000 restructuring charge, the third restructuring in as many years, and treasury proposes adding it back under clause (h). The demo's headroom switch makes the dispute a physical object:

The forward view is computed twice from the same frozen definitions: a linear projection (OLS over the last six LTM points) and a seasonal one (same month prior year plus the mean YoY delta), with debt held flat. Both cross the 3.50x line at the 2026-10 LTM point, four months after the June close the visitor is standing on. The quarterly consequence is the point of the demo: the September 30 test is projected at 3.459x, compliant but with 0.041x of headroom, thin enough that the sign gate would already refuse it; by December 31 the projection is 3.622x, breached. A spreadsheet whose add-backs had drifted would have signed both. The engine shows the crossing in June, quantifies what the September certificate would be signed against, and will not draft its way past December at all.

The clauses are real. The breach is engineered. The discipline transfers.

The computed results, from the engine, every run: total leverage 3.310x with the disputed add-back and 3.530x without it, against the frozen <3.50x threshold; interest coverage 3.535x against >3.00x; senior secured leverage 2.064x against <3.00x; projected breach at 2026-10 on both projection methods, four months ahead of the close being certified; the full 24-month recompute across all eight add-back combinations in single-digit milliseconds, timed live in the page. The ledger replays to identical hashes, and the Tamper button demonstrates the chain locating its own corruption.

The limits, stated flatly. This is one real agreement, and bespoke private-credit definitions vary far more than any single document can show. The exhibit is an amendment; the base agreement's definitions are genuinely absent, which the app handles by abstaining and logging manual definitions rather than by pretending. The GAAP-to-covenant bridge is simplified (a handful of add-backs, no pro-forma adjustments, no equity cure mechanics even though the real document has cure rights), debt is held flat, and the trial balances are synthetic and labelled, shaped so the dispute changes the answer. Clause extraction here is a deterministic stub standing in for a model, so the run reproduces exactly; in production the extraction is a first draft for the treasurer's confirmation rather than legal interpretation, and the app says so on screen. What transfers is the architecture: quote-or-abstain extraction, a named confirmation that freezes terms, computation that cannot drift, and a certificate that can refuse its own signature.

Flip the add-back. Watch the Sign button die.

The switch is the first thing you can click. Turn the restructuring add-back off and the gauge crosses the covenant line, the certificate watermarks itself, and Section 6.08 is quoted next to the disabled button. Click any certificate figure for its clause and TB lines, sign as the CFO while it is still legal, then tamper with the ledger and watch the chain break at the exact entry.