Every decision, with its reasoning attached.
Krino scores every incoming event against rules your own team wrote, in milliseconds, and puts anything suspicious in front of your analysts as a case. You see exactly which rule contributed what — so you can answer an auditor, a disputing customer and a regulator with more than a number.
Why does changing one rule take weeks?
Fraud patterns change in a week. If changing a rule waits on a software release, that week is a loss.
Rules live in the codebase
The risk team spots a pattern, explains it to an engineer, joins the backlog and waits for a release. The gap between noticing and stopping is measured in weeks.
The score is a black box
The vendor returns a number. When a customer asks why they were declined, or an auditor asks for the reasoning, that number is all you have.
Your data leaves
Transaction and customer records land in someone else's cloud. Under most regulatory regimes that is a file of its own.
How a transaction moves through Krino.
Event arrives
A payment, a login attempt, a signup — one API call, in your own data model with your own field names.
Signals are derived
Email, phone, IP and device signals come from lists held inside your infrastructure. Nothing is queried outside.
Rules run
The scenario's rules are evaluated together and each adds its score. Around 34 ms.
A decision returns
Approve, review, block-and-review or decline — with the contribution of every rule in the same response.
From detection to filing, in one product.
Rule engine
Your risk team builds rules on screen: compose the conditions, set the score, publish. Velocity rules, lists, fuzzy matching and threshold-based outcomes included.
Device intelligence
Browser fingerprinting, datacenter and VPN egress detection, disposable email providers, phone line type. All offline, no extra contract.
Sanctions screening
Name screening against consolidated sanctions and PEP lists. Tolerates accent, spelling and transliteration differences — refreshed on a schedule.
Case management
Decisions about the same customer collect into one file, route to a queue, get annotated, and record when they were reported to a regulator.
AI assistant
Ask about decisions, rules and cases in plain language and get the answer as a table and a chart. Runs on your own model provider: it reads, it does not write.
What if I moved the threshold?
Krino re-reads past decisions at new thresholds and shows how many would have landed differently. Not a forecast — a replay of decisions already made. The same screen shows how often each rule fired and how often it actually changed the outcome; a rule that fires constantly but is never decisive is adding noise to every score.
Nor do you have to wait after publishing a new version: a screen streams decisions as they are recorded — outcome, score, scenario, customer and the case opened, if one was. The first minute tells you now what the dashboard will say in half an hour: whether the thresholds held, which rule fires more often than you expected, and whether the volume landing in the queue is a number your team can carry.
Why Krino?
| Typical approach | Krino | |
|---|---|---|
| Changing a rule | Engineer plus a release, days to weeks | Risk team, on screen, immediately |
| Data model | The vendor's schema; your fields don't fit | You define your own tables and fields |
| Where data lives | The vendor's cloud, often another jurisdiction | Your own servers — nothing leaves |
| Decision rationale | A score comes back; the detail is closed | Which rule, how many points — one by one |
| Device intelligence | Separate product, separate contract | Included |
| Sanctions screening | Separate product, usually priced per query | Included, matched locally |
| Investigation workflow | Spreadsheets, email, a separate ticket tool | In the product, with an audit trail |
| Testing before release | Hope | Shadow mode against live traffic, or against last month's transactions |
| Record of a rule change | Versions kept, the difference visible to nobody | Two versions side by side — sentences, not JSON |
| Publish approval | Whoever changed it publishes it | Second approval: the requester cannot approve their own request |
Two endpoints. One afternoon.
You send the transaction, you get the decision. The reasoning comes back in the same response.
POST /api/decisions
{
"object_type": "card_payment",
"scenario_id": "019f8e68-…",
"trigger_object": {
"object_id": "tx-88214",
"updated_at": "2026-08-06 10:00:00",
"basket_total": 12500.00,
"customer_no": "4471",
"client_ip": "203.0.113.45"
}
}{
"decision": {
"outcome": "BlockAndReview",
"score": 92
},
"rule_executions": [
{ "rule_name": "Disposable email",
"outcome": "hit", "score": 40 },
{ "rule_name": "Datacenter IP",
"outcome": "hit", "score": 30 }
],
"execution_time_ms": 34
}Ask for the rule detail and the response also carries where the time went: reading data, counting velocity windows, running the rules. When an integration slows down you do not have to go hunting in dashboards for the step that grew — a dashboard gives you a percentile, and a percentile cannot be asked about one transaction.
When you would rather not wait on the decision, send events separately and receive the outcome over a signed webhook. Details in the documentation.
One plan, one price.
No per-transaction fee, no module-by-module upsell. It installs on your own infrastructure; the licence is a flat monthly figure.
Pay annually and save 20%
Unlimited rules, scenarios and users. Onboarding support and version upgrades included.
See what's includedEverything included
- Rule and scenario engine
- Device intelligence
- Sanctions and PEP screening
- Case management
- Shadow test runs
- Scheduled runs
- Webhooks and API
- Version upgrades
How much are you losing a month?
Put your own numbers in. Nothing is converted — whatever currency you enter is the currency you get back.
Krino costs $1,499/mo. One plan, no per-transaction fee, and it does not grow with your volume. Pricing →
Let's see it on your data.
The best demo is the one built from last month's transactions. Leave your details and we'll come back within two working days to set it up on an anonymised sample.