A score you can audit
The risk number comes from a fixed formula over the flagged clauses. The same contract gets the same score, and every point traces back to a quoted line.
Lex Claro · AI legal-tech case study
Every clause read, every risk scored, before anyone signs.
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
Measured against the market
Each term is compared with market standard. The reader sees a line like "payment terms 50% below market" and gets a drafted reply asking for better.
Signed means locked
Once a contract reaches Executed, the server makes it read-only. Every earlier version is kept, encrypted and hash-chained, so a later edit cannot hide.
Private before it is processed
Personal data is scrubbed from the text before it is sent for analysis, and an upload can be set to delete itself an hour later.
Talk to the document
Ask about a clause, have the assistant rewrite it in place, or open a live voice conversation with the contract itself.
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.
Review takes too long
A careful read of a long contract costs hours, and the queue of documents waiting for one never gets shorter.
Risk hides in the detail
Liability caps, renewals and payment terms sit deep in the document, phrased to be read past.
No benchmark for fair
Without knowing what the market accepts, a hard bargain looks the same as a bad one, and there is nothing concrete 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.
Accounts and documents, kept apart
Billing and identity live in one app and the legal work in the other, so either can change without putting the other at risk.
One pipeline, every time
OCR, credit check, duplicate check, privacy scrub, two analysis passes, then the score. In that order, for every document.
Built for a whole firm
Roles and invitations, clients with their aliases, numbered matters, and a conflict check that must be waived on the record before work goes ahead.
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 in each contract before any are judged
- 8
- Interface languages, from Dutch to Russian
- AES-256
- Encryption on reports and version history
- 1 hour
- The shortest auto-delete timer on an upload
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 an hour 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.