Several hundred active contracts, and nobody knows the portfolio.
The pattern is the same in almost every mid-sized company. Contracts are scattered: some in the DMS, some as an attachment in the mailbox of the person who negotiated them, some as a scan on the network drive, some in a filing cabinet. There is an Excel list, but it is incomplete, because someone would have to maintain it who has no time for it.
The consequence is always the same chain. Nobody knows all the terms and notice periods. Automatic renewals happen unnoticed: a maintenance contract quietly runs on for another twelve months, because the deadline was three months before the end of the term and was in nobody’s calendar. A single case like that quickly costs a four- to five-figure amount.
And before a negotiation nobody knows which clauses the portfolio even contains. Where is there a price-indexation clause, where unlimited liability, which contracts have the same counterparty? The information is in the documents. It is simply not findable.
First know what exists. Then capture facts. Only last, switch on the deadlines.
The most common objection comes in the very first conversation: interpreting contracts is a lawyer’s job and does not belong in software. The objection is right, and it became the specification. The AI employee evaluates nothing. It states what the contract says and where it says it, every field with a source reference, and every deadline gets a name.
- Inventory of the storage locations: First an honest list of where contracts actually live today: DMS, mailboxes, network drives, filing cabinet. Including the sources nobody officially knows about.
- Define the field catalogue: The team defines what gets extracted and explicitly what does not. Evaluative fields like risk high or low stay out, because they fake a legal statement.
- New contracts first, then the backlog: From day one every new contract runs through the AI employee, so the backlog stops growing. The old portfolio follows in waves, starting with contracts that have recurring payments and automatic renewal.
- Deadline logic with owners: Deadlines go live last, always with a named responsible person per contract. A reminder without an addressee is not a reminder.
80 percent is done by the AI employee. The human decides at two points.
The AI employee picks up every new contract where it arrives and reads it, including a scan of the signed version. From every contract it extracts the fields of your catalogue: parties, subject matter, term, renewal mechanics, notice period, remuneration, and the named clauses. Every field carries the source reference with page and section. If a passage is illegible, it flags it instead of guessing a value.
From end of term and notice period it calculates the deadline and reminds the responsible person with the lead time you define. The human stays in the loop at two points: checking the extraction through the source links, and deciding at the deadline whether to terminate, renegotiate, or continue. The AI employee never gives an assessment of the clauses, not even hidden behind colors or scores.
Maintenance contract for production equipment, 18 pages, PDF from the DMS, with automatic renewal.
One field is flagged for a decision. The AI employee states that there is a renewal, a notice period, and an index clause, and calculates the deadline. Whether to terminate or renegotiate is decided by the human.
That was before, this is today.
This is how contract work ran before, and this is how it runs today with the AI employee. Conservatively calculated, the effort per contract drops by about three quarters, and the portfolio is searchable for the first time.
| Before | Today | |
|---|---|---|
| Effort per contract | 30 to 60 minutes by hand | A few minutes of review via the source links |
| Where contracts live | DMS, mailboxes, folders, filing cabinet | One searchable register, linked to the original |
| Notice periods | Incomplete Excel list | Extracted from the contract, deadline calculated |
| Automatic renewal | Noticed when the invoice arrives | Reminder with lead time to a named person |
| Clause question before a negotiation | Leafing through, result depends on who searches | A query across the portfolio, hits with source reference |
* A typical scenario from our project work, not a single customer project. Savings conservatively calculated: 30 to 60 minutes per contract before for retrieving, reading, retyping fields, maintaining the list, and entering the date, versus 5 to 10 minutes today for checking the extracted fields through the source links. Even in the worst case, 30 minutes before against 10 minutes today, about two thirds of the effort disappears.
How do you build an AI employee like this, technically?
The knowledge from this setup to take away, whether you build with us or on your own:
Reading: the old portfolio as scans, too
New contracts usually arrive as clean PDFs. The backlog consists of scans, often skewed and covered in stamps. Mistral OCR reads such pages reliably and keeps the page and paragraph structure you need later for the source reference. If a passage is illegible, it gets flagged rather than guessed.
Extraction: every field with a source reference
Claude from Anthropic and GPT from OpenAI find clauses even when they are named differently than expected, for example index clause instead of price-indexation clause. What matters is the output format: every field comes with page and section. A paraphrase without a source reference cannot be checked, and then you have to trust the model.
Deadlines: a rule set, not a prediction
The deadline is arithmetic: end of term minus notice period, taking the renewal mechanics into account. That belongs in fixed rules, not in a model, so anyone can recalculate it. Plus the second half: every contract gets a named responsible person, and the reminder goes to them with lead time, typically 90, 60, and 30 days ahead.
Integration: the contracts stay where they are
The AI employee connects to the DMS, the monitored mailbox, and the filing folder through the existing interfaces and with the existing access rights. There is no migration into a new platform. The register links to the original, it does not replace it.
UX: the interface decides adoption
The contract on the left, the extracted fields on the right, each with a link that jumps to exactly that spot in the document. Plus a calendar with the upcoming deadlines and the responsible person. And deliberately no traffic light and no risk score: a green light ends the thinking exactly where it should begin.
What does it cost in comparison?
Superkind charges per use case. The price grows with contract volume, not with headcount. Here is the honest comparison:
| Folders and an Excel list | CLM software | Superkind AI employee | |
|---|---|---|---|
| Cost | Hidden working time, a dedicated contract manager or in-house counsel costs 60,000 to 90,000 € per year | Often 20 to 50 € per user per month, plus a rollout project | Price per use case, a fraction of a full-time position |
| What is included | Only what someone types in by hand | The structure, you have to supply the data | Reading, extraction with source references, register, and deadlines |
| Scales with | More staff | Number of users | Contract volume, without new positions |
| Exceptions | Left unhandled | An empty mandatory field | Flagged and sent to a human |
| Rollout | Immediate, but never finished | Migrating the whole portfolio first | 2 to 3 weeks to the first productive version |
The honest comparison is the full cost of today’s state: the time spent searching, the price-indexation clauses nobody invokes, and the contracts that renew because a deadline was in nobody’s calendar.
What we learned about AI in contract work.
The biggest temptation in this use case is evaluation. A model that reads clauses can easily output a risk traffic light, and in a demo that looks impressive. We still do not build it. A red light that is wrong blocks a contract for no reason. A green one that is wrong ends the thinking exactly where it should have started. The useful boundary runs between what does it say and what does it mean.
The second lesson: the value is not created on the single contract, it is created across the portfolio. A human reads a maintenance contract in twenty minutes. The question of which of the three hundred contracts contain an index clause and which expire in the fourth quarter is answered by nobody. Not because it is hard, but because it means doing the same work three hundred times. That repetition is exactly the AI employee’s job.
What it is not suited for: Anyone with twenty active contracts needs a maintained list, not a register. If every contract is negotiated individually and every question ends up with the law firm anyway, the preparation is small and the assessment is the entire work. And if contracts only exist on paper in a filing cabinet, scanning is the first step.
