One real run on the reference data: evidence of drift stayed below the alarm at 20 while traffic was healthy, crossed it at row 152 during the small shift, before the large shift began, and the verdict changed from Trusted to Untrusted. By row 240 the evidence was > 1,000.

alarm 20

Reliability for production models

Don’t just detect drift.Decide.

Your model still returns a number when the world underneath it changes. Kirelta watches the data going in, and tells you when the answers coming out stop being trustworthy — with the evidence, and a recommendation you can act on.

Free plan · 2 models · no card

Untrusted
fraud-modelrecorded from engine 3.32.0
Flagged rate
100.0%
Drift alarm
Fired
Points assessed
80

Evidence of drift

Evidence of drift in this batch≫ 20

Evidence far past the alarm line at 20: the drift alarm fired. Evidence measured on this batch alone. Logarithmic scale.

Recommended action

Block it.

Behaviour has moved well outside the trained baseline.

The engine’s own call: BLOCK

Real engine output — not a mockupOpen the case
fit · assess · branch
3 calls
raw records leave your side
0
every verdict, hash-verified
Frozen
approval before it acts
Human

The problem isn’t detection. It’s the decision.

Most monitoring tools tell you something changed. Then they hand you a chart and leave. The engineer on call still has to work out whether it matters and what to do — usually at 3am.

Traditional monitoring

  • A metric crossed a threshold
  • Here is a dashboard of charts
  • You decide if it’s real
  • You decide if it matters
  • You decide what to do
  • Tests re-run on every batch, so false alarms pile up over time

Kirelta

  • A verdict: trusted, degraded, or untrusted
  • The evidence behind it, in plain fields
  • Which features carry the deviation
  • A recommended action
  • Whether it’s already recovering
  • One false-alarm budget for the whole run — not per batch

Three calls

Kirelta doesn’t need your model, your code, or your raw records. It needs the same feature vectors you already compute.

  1. 01 / FIT

    Show it healthy data

    Send rows from a window when the model was working. Kirelta learns that shape and picks its own monitor for it — you don’t choose an algorithm.

  2. 02 / ASSESS

    Send recent rows

    The batch you want a call on. Kirelta compares it to the baseline and answers with a verdict, an action, and the evidence.

  3. 03 / DECIDE

    Branch on the verdict

    Serve, flag, or hold. One if statement in the code you already have.

Read the API →

This is the screen

Not a mock-up and not an illustration: the app’s own components, drawing the reference case — real engine output, recorded from one verified run.

Independent evidence layers

  • Input trust

    Do the inputs still look like the baseline? 100.0% flagged, alarm fired.

    Drifted
  • Output stability

    Does the model still behave like itself? Send outputs to /fit and /assess and Kirelta watches the model’s own predictions too.

    Not watched
  • Baseline quality

    The reference this model was trained on looks clean.

    Sound
  • Alarm reliability

    The rows in this batch look independent, so the drift alarm reads normally.

    Sound
  • Baseline fit

    Your baseline had a clear shape, which is the condition these readings assume.

    Clear

These are separate questions, answered separately. A layer marked “not watched” is switched off — it is not evidence of anything, in either direction.

Which features moved
  • #236.1%
  • #134.2%
  • #029.7%

Share of the deviation each feature is responsible for. Sums to 100%.

Five questions, answered separately

Most tools give you one number. Kirelta reports each layer of evidence on its own — and says plainly when a layer is switched off, because a layer that never ran is not evidence of anything in either direction. It also tells you when the data you trained on may itself be suspect, which changes how every verdict from that baseline reads.

What we will and won’t claim

The drift alarm stays honest however long you watch. Its false-alarm probability is bounded across the entire run, not per batch. Tools that re-run a fresh test on every window accumulate false alarms the longer you watch — this is a real mathematical difference, and it’s why Kirelta can keep watching without becoming noise. We measured it rather than just asserting it: across 300 clean batches on a synthetic baseline, the alarm fired 0.7% of the time against the ≤ 5% bound — and caught a one-sigma shift in 60/60 batches. How this was measured

On its own, it cannot tell you your model’s accuracy dropped. Kirelta watches the inputs by default, not the outcomes — if the world changed in a way that leaves your input distribution untouched, the verdict above will not see it, and it will say so rather than invent a number. Send it your model’s predictions too and that changes: a second, independent signal checks whether the model’s own behaviour has moved, which is exactly how it catches a model that has quietly stopped behaving like itself while its inputs still look ordinary — the layer is optional and documented here.

The engine’s own documentation lists where it wins and where a simpler method beats it. We’d rather you trust the verdicts you do get.

See a real verdict before you sign up

The demo is the app itself, signed out, showing the reference case — the numbers you see are the numbers the engine produced.