No guesswork. A pipeline you can audit.
Vern doesn't hand your contract to a model and hope. It runs fixed stages in a fixed order, records the exact document and playbook version it used, and anchors every finding to the characters it came from. Same input, same output, check it yourself.
However it reaches us, it becomes the same thing.
Parsing is a fallback, not a platform. DOCX is read properly so redlines can go back properly.
The primary contract format, parsed locally. Clause numbering and structure survive, and we keep a map from the extracted text back to the ranges in the file, which is what makes true tracked-change write-back possible.
Born-digital PDFs give up their text layer locally; the model reads the document natively as the semantic layer on top. No screenshot-and-guess.
A photographed or scanned contract goes through OCR before anything else. The vendor sits behind a small interface and runs on EU endpoints only.
The same contract is never analysed twice by accident.
Every lane ends the same way: the text is normalised and hashed, and that hash is the version. Upload the file your colleague already emailed in and it resolves to the version that exists, findings appear instantly and no credit is spent. Change one word and it's a new version, and a follow-up round.
Four stages, in this order, every time.
Not an agent deciding what to do next. Code decides the order; the model does the reading and the judging. Pick a stage.
The model reads the whole contract and returns every clause and defined term. Citations are enabled on this pass, which is what produces the character offsets each finding is later anchored to. Nothing is scored yet, this stage only establishes what exists and where.
8.1Neither party shall be liable to the other for any indirect or consequential loss howsoever arising, without limitation as to amount.
Defined terms are captured here too, so “Losses” means what clause 1 says it means, not what the model assumes.
Each clause is judged against your playbook position and, separately, against whether it would hold up under UK law. One pass, two independent answers, which is why they are free to disagree. Answers come back through an enforced schema, so a malformed score fails rather than quietly becoming a wrong number.
8.1 breaches your position and would not hold up. 5.2 breaches your position and is perfectly enforceable. Different problems, different responses.
Clauses are then read against each other. A liability cap you have negotiated hard for can be undone by an uncapped indemnity three paragraphs later, and neither clause looks dangerous alone. This pass is why the report tells you about the pair.
Score the clauses in isolation and this is invisible. It is the most common way a well-negotiated contract still leaks.
Finally the run produces an executive summary and a negotiation plan: what to fight for first, what to trade, what to let go, and the rationale the other side is likely to give you. Tiered, so you can hand tier 1 to someone and keep the rest in reserve.
With the rationale they are likely to give you for each, and what you can offer in exchange. Exportable as a memo for whoever is actually on the call.
First verdicts in seconds. Then they get better.
A fast triage pass streams preliminary verdicts into the screen almost immediately, so you can start reading. The deep pass follows and upgrades each finding in place, you never sit in front of a spinner, and you're never shown a number that turns out to be provisional without being told.
Nothing polls. Progress is an event stream every surface subscribes to, so the dashboard, the Word pane and the API client all see the same run advance at the same moment.
Every finding has a receipt.
This is the part a general-purpose chatbot cannot give you. Not because the model is worse, because nothing around it is recorded.
A finding stores the offsets it was drawn from. Click it and you land on the words in your document. There is no Vern finding that can't be traced to a sentence.
Findings are records, not a blob of text: classification, both scores, impact, suggested wording, fallback tiers. Queryable, exportable, diffable.
A run records the document version, the playbook version, the model and a hash of the prompts. Edit a position tomorrow and last month's review still says what it said.
Re-analysing produces a new run beside the old one, free of charge. Compare them. If a model upgrade changes a verdict, you can see exactly where.
Scores come back through enforced schemas rather than text we hope to read correctly. A malformed answer fails loudly instead of quietly becoming a wrong number.
Escalate to expert review and a qualified reviewer's revision sits over the AI run as an overlay. The original is never mutated, and every reviewer action is logged.
Then it's a negotiation,
not a report.
Everything below sits on the same record, so nothing has to be reconciled afterwards.
Run it on a contract you already know the answer to.
That's the honest test. Thirty minutes, your playbook, a contract you've already negotiated, and see whether we'd have caught it.