Every case starts with twenty minutes of digging.
Claims arrive through every channel at once: an email into the service mailbox with three phone photos, a phone note from a field technician, a web form with four fields and no serial number, occasionally a letter. Nothing arrives in the same structure twice. So every clerk builds the case their own way, and the next colleague cannot pick it up without asking.
Then the entitlement check begins, and it is almost entirely lookup work: find the purchase date in the ERP, match the serial number to a delivery note, open the PDF with the warranty terms that applied at the time of sale. Twenty to thirty minutes per case is realistic for that. Nothing has been decided afterwards, only the basis for a decision is on the table.
Everything downstream suffers. The 8D documentation stays on the pile because nobody wants to reconstruct a case a second time. Customers wait weeks for an answer and call to ask, which creates more work than the claim itself. And recurring defect patterns go unnoticed: three claims on the same batch sit in three mailboxes, and nobody compares them.
First separate what is decidable. Then automate.
The most common objection in the first conversation: goodwill is gut feeling and knowing the customer, no machine can decide that. True, and that is exactly why we do not build it for that. Goodwill is always decided by the human. The AI employee takes over the part that can be justified from a rule and a record.
- Start at the mailbox, not at the software: We go through a week of real incoming claims and see what is actually missing on arrival. Usually it is the serial number and a usable defect description.
- Turn the warranty terms into a decision table: Periods, product lines, and value thresholds are written down as explicit rules. Everything the rules cannot answer is marked as a judgment call and never guessed.
- Deliberately small start: Intake, case file, and the formal check first. Replacement handling, credit notes, and pattern reports come later.
- Go-live only after the team says okay: The service team tests against real cases and writes down what is wrong. That becomes our acceptance criteria. It goes live when the clerks say: the case file saves us the lookup work.
80 percent is done by the AI employee. The human decides at two points.
The AI employee reads whatever arrives, whether free-text email, phone note, or a photo of a type plate. It extracts customer, product, defect description, and any number it can find. The rest is resolved deterministically from the ERP: a delivery note number resolves to an order, a delivery date, a serial number, and a batch. Nothing is guessed, because a wrong serial number is worse than a missing one.
On that case file the formal check runs against the configured warranty terms: purchase date versus period, defect type versus covered defects, serial number versus the delivery record. The AI employee then writes a proposal with reasoning and evidence attached. The service lead decides goodwill, and a human releases the answer to the customer. In parallel the input for quality management is prepared, and every new case is matched against open and closed cases.
Email from a long-standing industrial customer: a drive component failed, purchased 14 months ago. Two photos of the housing, delivery note number in the signature, no serial number given.
One field is flagged for decision: formally the case is closed, the warranty ran out two months ago. Three failures from the same batch and a long customer relationship make this a goodwill question. Exactly this judgment stays with the service lead.
That was before, this is today.
This is how claims handling ran before, and this is how it runs with the AI employee. Conservatively calculated, that saves about three quarters of the effort per case, and the turnaround drops from weeks to days.
| Before | Today | |
|---|---|---|
| Intake | Every channel and every clerk different | One case structure, regardless of channel |
| Formal entitlement check | 20 to 30 minutes of lookup per case | Checked automatically, evidence attached |
| Goodwill decision | Gut feeling without the history at hand | Human decides, with case and batch context |
| 8D and QM documentation | Reconstructed later, often left undone | Created while the case is handled |
| Customer answer | Weeks of waiting, customers call to ask | Draft the same day, released by the human |
| Recurring defects | Noticed by chance or not at all | Flagged when the third case on a batch arrives |
* Typical scenario, not a measurement at a single customer. Savings conservatively calculated: before, about 20 minutes of formal entitlement checking plus about the same again for documentation, roughly 40 minutes per case. Today, about 5 minutes to review the finished case file plus about 5 minutes for the goodwill decision and the release, roughly 10 minutes. We calculate with the lower end of the 20 to 30 minute range; case file and 8D input are created automatically along the way.
How do you build an AI employee like this, technically?
The knowledge from this scenario to take away, whether you build with us or on your own:
Intake: language models read email and phone notes
Claims arrive as free text, not as a form. Language models like GPT from OpenAI or Claude from Anthropic read the email, the phone note, and the photo of a type plate, and extract customer, product, defect description, and every number that appears in the text. Each field carries its location in the source, so it stays traceable where it came from.
Enrichment: the ERP supplies the hard data
Purchase date, serial number, and batch are not estimated but resolved through the ERP: delivery note number to order, order to delivery date, delivery to serial number and production batch. This split between reading and looking up is the most important building block, because a guessed serial number is worse than a missing one.
Pattern detection: claims are quality data
Because every case has the same structure, cases can be compared on product, component, batch, and a normalized defect type. The AI employee matches every new claim against open and closed cases and flags it when a threshold is crossed, for example the third case on one batch within a defined window.
QM connection: the fact base for 8D
Defect type, affected product, batch, delivery reference, and customer impact are created while the case is handled and land structured in your QM tool. Quality management gets a prepared D1 to D3 instead of a reconstruction job. Root-cause analysis and corrective actions stay with the engineers who own them.
UX: the interface decides adoption
The case file shows a timeline from purchase through delivery to the claim, next to it the proposal with its reasoning and the evidence. Goodwill is a deliberate click with its own field for the justification, never a default. Exactly this turns skepticism into approval, because the team sees that nothing is taken out of its hands.
What does it cost in comparison?
Superkind charges per use case. The price grows with claim volume, not with headcount. Here is the honest comparison:
| Claims clerk | Ticket system | Superkind AI employee | |
|---|---|---|---|
| Cost | 55,000 to 75,000 € per year | 15 to 50 € per user per month | Price per use case, a fraction of a full-time position |
| What is included | The whole case, by hand | Queue, status, and assignment | Intake, case file, entitlement check, documentation, and pattern matching |
| Entitlement check | 20 to 30 minutes of lookup per case | Does not happen, the system only organizes | Checked against your terms, with evidence |
| Scales with | More staff | Number of users | Claim volume, without new positions |
| Exceptions | Human does everything | Ticket routed onward | Flagged and sent to a human |
| Rollout | Recruiting and onboarding | Configuration and training | 2 to 3 weeks to the first productive version |
The honest comparison is the full cost of manual handling: the lookup work per case, the QM documentation that never gets written, the customers who call, and the batch problem found half a year too late.
What we learned from claims projects.
The obvious value is speed: a case that used to take three weeks is answered in three days. The underestimated value is pattern detection. Manual handling treats every complaint as an isolated incident, because that is how it arrives and how it is filed. As soon as every case has the same structure, complaints become quality data. Three failures from one batch stop being three annoyed customers in three mailboxes and become a signal that reaches engineering while the batch is still in the field.
The second thing we see in every project: the resistance is never about the technology, it is about who decides. Service teams have spent years building a feel for which customer gets a yes, and they are right to defend it. The projects that work say early and clearly: goodwill is not on the automation list. They only make the human decision better, because history, batch evidence, and case value are already on the table.
What it is not suited for: With a handful of cases per month the lookup work is annoying but not your bottleneck, and pattern detection needs volume. If nobody can write the warranty terms down, there is no formal check to automate. And if serial numbers are not tracked, the basis for the case file is missing.
