100%
Reproducible, same contract same score
Lex Claro · AI legal-tech case study
Read, scored, signed safely.
An AI workspace for legal documents, built for LexClaro. Upload a contract and every clause is read, scored for risk by a fixed formula and checked against market terms. Then it is negotiated, signed and locked.
- IndustryLegal technology
- UsersLaw firms, founders, freelancers
- In productionVersion 4.5
- ServicesProduct Design, Development, AI, Maintenance
Overview
LexClaro is a workspace for legal documents, founded by Roy van Hemert. CodeMyPixel is the technology team behind it. We designed and built the whole system, and we keep it running in production.
A contract goes in as a file and comes back as a marked-up document. Every clause is found and quoted. Every risk is flagged next to the words that caused it. One risk score sits on top, calculated by a fixed formula rather than a model's opinion. Then each term is measured against what the market treats as fair, so the reader knows what is risky and what to ask for instead.
The same workspace carries the contract the rest of the way: an editor laid out like the printed page, an assistant that can explain a clause or rewrite it, links for the other side to suggest changes, and a lifecycle that ends with the signed version locked on the server.
Know before you sign
LexClaro's own tutorial: uploading a contract, reading the risk report and working in the document.
Key capabilities
−50%
vs market standard
0
Edits after executed
Private
PII scrubbed before AI sees it
Ask
Chat, edit or speak, inside the doc
Contracts are written to be signed, not read. A founder with a supplier's terms, a freelancer with a client's NDA, a lawyer with a stack of leases: each has the same problem. The clause that matters is buried. Nobody can say whether the terms are normal for the market. And the conversation with the other side starts with nothing firmer than a feeling. A full legal review fixes that, at a price and a pace most documents never get. An AI summary is quicker, but a summary that cannot show its working is one more thing to trust blindly.
Hours
Lost on every manual review
p.31
Where the risky clause hides
Blind
No market data to push back with
We built LexClaro as two applications behind one sign-in. LexClaro owns the account: who you are, which plan you are on and how many credits are left, with payments through Stripe. LawClaro is where the documents live, and it re-reads the account on every page load, so a plan change or a top-up counts the moment it happens. Every contract goes through the same pipeline in the same order, and comes out with a report that shows its evidence.
Apart
Billing in one app, law in the other
Always
Same order, every document
Firm
Roles, matters, conflict checks
Upload, and every page is read
Before anything is read, the uploader chooses how long the file may live: five minutes, an hour, a day, or until they delete it. The file then goes straight from the browser to a private storage bucket, hashed on the way in, OCR pulls the text from every page, and the page count sets the credit cost.
Risks pinned to the paragraph
The report opens as the document itself, set out on A4 pages, with the risk index on one side and the findings on the other. Each flagged clause opens to a plain summary, the explanation, the exact words that triggered it and its references, with a button to ask about that clause.
A score that shows its working
Findings are weighted by severity and the total is normalised, so a contract with several critical problems cannot hide behind a long list of clauses that passed. The result is banded High, Medium or Low, and two people reading the same contract see the same number.
Fairness, as negotiating material
In the background, each term is set against market standards. The result reads like "payment terms 50% below market standard", and the assistant drafts the message to the other side asking for something better.
Edit it by asking
The assistant answers questions about the contract, and when asked to change it, applies structured edits to the document itself rather than pasting a new version into the chat. A redesign agent offers three styled versions with previews, and a live voice mode lets somebody talk the contract through.
Share it, then lock it
Links give the other side view, suggest or full access, with an optional expiry and their own AI permissions, and their suggestions wait for the owner to accept or reject. Every version is kept as a hash-chained snapshot, and one click checks that none has been altered. When the contract reaches Executed, the server locks it.
LexClaro's commercial numbers are LexClaro's to publish. What we can show is what the system does to every contract that goes into it: the clauses it finds and quotes, the languages it works in, how it protects what it reads, and how briefly it needs to keep it.
12-25
Clauses found and quoted per contract
8
Interface languages, Dutch to Russian
AES-256
Encryption on reports and history
5 min
Shortest auto-delete timer
Know before you sign
- Upload the contract
- Read every page
- Scrub personal data
- Find and score the clauses
- Compare with the market
- Negotiate, sign, lock
Interface & languages
- Both apps
- Next.js 16
- React 19
- TypeScript
- Tailwind CSS
- A4 editorWord-like pages, with clause badges beside risky paragraphs
- next-intlEN, NL, ES, DE, NO, FR, IT, RU
- PWAInstallable on desktop and phone
- Both apps
Accounts & billing
The LexClaro app: the source of truth for every account.
- LexClaro accountsSign-in, plans and team seats for both apps
- StripePayments and subscriptions
- Credit ledgerA team pool or a personal balance, mirrored between both apps
- Account syncLawClaro re-reads the account on every page load
Document pipeline
The same steps, in the same order, for every upload.
- Presigned uploadBrowser to private bucket, SHA-256 hashed on the way
- Mistral OCRText and page count from every page
- Duplicate checkThe same text reuses the earlier report
- PII scrubberPersonal data removed before the text goes for analysis
- Risk formulaSeverity-weighted, normalised, banded High, Medium, Low
- Fairness passEach term compared with market standards, in the background
Models
- gpt-5.4-miniTwo-pass analysis: find the clauses, then judge them
- gpt-5.4-nanoChat, and the edits made from it
- gpt-realtime-2.1Live voice conversation with the document
Collaboration
- YjsReal-time co-editing, with presence
- Firebase Realtime DatabaseCarries the edits, team chat, audit trail and push
- Share linksView, suggest or full access, with expiry and per-link AI rights
State & data
- PostgreSQLDocuments, reports, firms, clients and matters
- PrismaTyped data access and migrations
- AWS S3A private bucket, reached only through presigned URLs
- Version historyEncrypted snapshots, hash-chained with SHA-256
Trust & security
- AES-256-GCMReports and snapshots encrypted at rest
- Lifecycle lockExecuted contracts become read-only on the server
- Integrity checkWalks the hash chain and names the first altered version
- Conflict checksFuzzy and legal-form-aware; a conflict needs a recorded waiver
- Auto-deleteUploads removed on a timer set per document
Deployment
- VercelHosting, and scheduled jobs on Vercel Cron
- ResendTransactional email, with SMTP alongside
A risk score that does not drift
Solution:Ask a model for a number twice and it can give two. So the models only find and classify the clauses. The score is computed afterwards by our own formula, weighting each finding by severity and normalising the total, so identical findings always produce an identical score.
Client data and third-party models
Solution:A lawyer cannot send a client's name to a model they do not control. The text is scrubbed of personal data before it goes for analysis, reports and snapshots are encrypted with AES-256-GCM, and each upload can be set to delete itself on a timer.
Proving a signed contract was not touched
Solution:A locked flag is only as good as whoever can unset it. Executed contracts are read-only on the server, and every version is an encrypted snapshot chained to the one before it by SHA-256. A verification pass walks the chain and names the first version that does not match.
Two apps, one truth about the account
Solution:Plans and credits live in LexClaro, documents in LawClaro. Rather than syncing on a schedule and hoping, LawClaro re-reads the account on every page load, and every credit spent, from a team pool or a personal balance, is mirrored back to LexClaro as it happens.
Questions
LexClaro was founded by Roy van Hemert, and the product is his. CodeMyPixel is the technology team behind it. We designed and built both applications, the analysis pipeline and the infrastructure they run on, and we maintain them in production.
No. The models find the clauses, quote them and classify each finding. The score is calculated afterwards by a fixed formula, so the same findings always give the same number, and every finding behind it can be opened and read.
Personal data is scrubbed from the text before it is sent for analysis. Files sit in a private bucket reached only through short-lived links, reports and version history are encrypted at rest, and an upload can be set to delete itself as soon as five minutes later.
Not from the workspace. When a contract moves to Executed, the server makes it read-only. Its history is a chain of encrypted snapshots, and an integrity check reports the first version that does not match, if one ever fails to.
Lawyers and firms come first, with clients, matters and conflict checks built for them. But the same report works for a founder reading a supplier agreement or a freelancer reading a client's terms, because every flag is explained in plain language.
Too many documents, not enough readers?
Let's build the AI that reads them first.