Skip to content
All Kauzio productsKauzio Lumi
KauzioKauzioLUMI
Kauzio Lumi · For builders

Decision intelligence API other devs plug into their apps

The decision layer,one endpoint away.

Lumi puts the whole Kauzio platform behind one clean API. Plain JSON in, plain JSON out. Send any choice your users are about to make. Get back the answer, the case for and against, a score for how hard it is to undo, and a signed receipt your users can check. 50 calls free every month, no card needed. Paid plans get higher limits and priority support.

Start freeSee pricing

50 calls free · Priority support on paid plans · No card to start

Kauzio Lumi

See it in motion

From an API key to a signed verdict in 30 seconds.

The real Lumi UI, the real flow. 6 steps a new developer goes through, exactly as they’ll see it.

kauzio.com/lumi/register?plan=free
Lumi Free · 50 calls/mo

Create your Lumi account

Your name
••••••••••••

No card · 50 calls/mo free forever

Get an API key in 30 seconds. Build, prototype, ship. Upgrade when you outgrow the cap.

See it in action

One request in. A decision out.

Lumi is one REST endpoint. Here is the whole flow, end to end.

The request

Send a decision as plain JSON

POST the question your app needs answered, with whatever context you already have. One endpoint, any language, any framework.

bash
$ curl -X POST https://api.kauzio.com/v1/decide \
  -H "Authorization: Bearer kz_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "question": "Approve this £4,000 loan application?",
    "context": {
      "credit_score": 612,
      "debt_to_income": 0.41,
      "prior_defaults": 0
    }
  }'
The response

Get back a verdict you can act on

A clear verdict, a confidence score, the reasoning behind it, and a receipt_id. Drop it straight into your own logic or UI.

200 OK · application/json
{
  "verdict":     "approve_with_review",
  "confidence":  0.78,
  "reasoning":   "Score is below
                  threshold but no prior defaults.",
  "receipt_id":  "rcpt_9f3a21c8",
  "latency_ms":  341
}
The dashboard

Keys, usage and webhooks in one place

Manage API keys, watch live usage and latency, and wire up webhooks so your app reacts the moment a decision lands.

app.kauzio.com/lumi/dashboard

API keys

production

kz_live_4f8a…2c1
12,481 calls

staging

kz_test_9b3e…7d0
2,034 calls

14,515

Calls this month

361 ms

Avg latency

3

Active keys

Webhook

ACTIVE
POST https://yourapp.com/hooks/kauzio

Example request and response. Field values are illustrative.

What teams build on Lumi

One API. Any product that decides for its users.

Lumi is not tied to a sector. If your product makes a choice on a user's behalf, the decision layer drops straight in.

HR & recruitment techFinTech & lendingHealthtechLegalTech & complianceMarketplaces & platformsInternal enterprise tools

Not on this list? If your product makes a call a user has to live with, Lumi fits.

Kauzio Lumi

Decision intelligence.

One POST.

Drop signed verdicts and risk scores into your own product. Six checks behind one endpoint.

POST/v1/decide
{ verdict: "…" }
Signed receipt issued
Get an API key

Simple by design

One API call. Full decision analysis.

Send any decision as plain text. Get back a clear breakdown, flagged thinking traps, a suggested action and a score for how sure we are. All in one response.

Get your API key
Example request
curl -X POST \
  https://api.kauzio.com/api/public/v1/forge/decide \
  -H "Authorization: Bearer kz_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "decision_text": "Should we expand to the US market in Q3?",
    "context": "Two of our top three markets are still under-penetrated.",
    "domain": "strategy"
  }'
Response
{
  "question": "Should we expand to the US market in Q3?",
  "answer": "Not yet. Two of your top three markets are still under-penetrated. Recommend a Q4 pilot with a 90-day proof window.",
  "data_context_loaded": true,
  "source": "kauzio_brain",
  "latency_ms": 312
}

API reference

Key endpoints

A selection of the most powerful endpoints in the Kauzio API.

POST
/api/public/v1/forge/decide

Send a question. Get back the answer, a risk score, how hard it is to undo, the case for and against, and a signed receipt. All in one call.

POST
/api/public/v1/forge/oppose

Get the strongest case against a decision across six checks: sales at risk, profit hit, how customers react, extra work, cost to undo, and how sure we are.

GET
/api/public/v1/forge/calibration

See how close past answers got to what actually happened, by sector.

POST
/api/public/v1/forge/certificate/issue

Get a signed receipt for an existing decision_id. Returns a public verify link.

GET
/public/v1/verify/{certificate_id}

Check any signed receipt by its ID. No API key needed.

View full API reference

Platform features

Built for production

Everything you need to ship the decision layer into a real app, from keys to webhooks to signed proof.

API Keys & Rate Limiting

Generate multiple API keys per project, set rate limits, and monitor usage per key, all from the Lumi developer dashboard.

Webhooks

Get notified when decisions, simulations and receipts complete. Every message is signed, so you can confirm it came from Kauzio.

See your usage

Track calls per day and per month against your keys. See your plan cap in the dashboard and a full log for each key.

Signed receipts

Every /decide call comes back with a signed receipt and a public verify link. Anyone can check the call later. No API key needed.

Plain JSON, no SDK

Every endpoint is a simple JSON POST. Hosted on European infrastructure. No client library to install, curl works fine.

Follow-up tracking

Send the result back once a decision plays out. Kauzio learns. Every result makes the next call sharper, for you and every other builder.

Works with any stack

Plain JSON in, plain JSON out. REST API works with any language or framework today. Python, Node.js, and Go SDKs are on the roadmap.

Sign any AI output

Time-stamp and sign the output of any AI model. A signed record of what your AI said and when.

Real answers, not made up

Every claim ties to your real data. When the data is not there, Kauzio says so instead of making something up.

In the terminal

One API key. The whole of Kauzio behind it.

One key. Three signed endpoints. Eight webhook events. Drop a verdict, a risk score and a tamper-proof certificate into anything you build, and close the loop when the outcome comes in.

POST /v1/decide{"question": "Should we open a second shop?"}→ 200 OK{"verdict": "proceed","confidence": 0.82,"receipt_id": "kz_a14f..."kz_a14f
One POST · signed receipt back · verifiable forever

One API. Every product you build.

Your code. One verdict away.

Lumi sits behind one REST endpoint. Drop a verdict, a risk score and a signed certificate into anything you ship: web, mobile, server, SaaS, AI agent, e-commerce, you name it.

Web app

browser → API

Mobile · iOS · Android

on-device call

Backend service

server-side decision

CLI · ops scripts

curl or SDK

AI agent

tool-call from LLM

E-commerce store

checkout, returns

SaaS product

embedded inside

Slack · Discord bot

chat-driven calls

Analytics pipeline

near-real-time scoring

One API key. Pay per call, free to start. Every response ships a tamper-proof signed receipt you can verify with /v1/verify.

inside / lumi

One POST in. One signed verdict out. Calibration on the way back.

Lumi runs the full decision loop server-side. Your app posts the question, gets a signed verdict, then patches the outcome back. Every outcome you report sharpens the coefficients on the next call.

01 / request

// your app asks Lumi

POST /api/public/v1/
     forge/decide

{
  "decision": "Raise prices
                8% in Q3?",
  "context": { ... }
}
02 / engine
→ brain.queryreasoning
→ oppose.runsix axes
→ simulatemonte carlo
→ risk.scorereversibility
→ certificate.signhmac-sha-256
03 / response

// signed, verifiable, ~280ms

200 OK

{
  "verdict": "go",
  "risk": 0.18,
  "reversibility": 0.62,
  "cert_id":
    "KZ-2026-001234",
  "verify_url":
    "/v1/verify/..."
}
feedback loop
04your app acts
PATCH /decisions/
  KZ-2026-001234

{ "outcome":
  "margin +2.4%" }
05 / webhookdecision.calibrated
06 / calibration

coefficients +0.034

next /decide is sharper, for you and for the platform.

memory is a first-class field, not an afterthought.

Inside Kauzio Lumi

Production decision intelligence at API-call scale.

Four endpoints, seven webhook events, signed certificates. Drop the entire decision tool into anything you ship.

API Keys

kz_live_* keys, scopes, rate limits

7 Webhook Events

HMAC-signed, retried, logged

Signed decision certificates with public verify

Tamper-evident, hashed at signing, public verify endpoint, no auth

/brain/query

Grounded AI Q&A over user data

/consequence/simulate

Full cascade in one API call

/opposition/challenge

Six-axis opposition across revenue risk, margin impact, demand elasticity, operational friction, reversal cost and uncertainty level.

Usage Meter

Daily + monthly limits, updated on each call

Delivery Logs

Every webhook attempt, status, retries

Priority email support

Faster response on paid plans

Lumi Forge API

Build on the same sector causal graph and decision primitives that power Kauzio.

Per-sector calibration

We publish how accurate Kauzio is in your sector. Updated nightly.

Cross-business patterns

Anonymised peer outcomes from other Kauzio businesses in your sector and size band.

Forge API

The four calls that run the engine.

Forge is how you call Kauzio from your code. Decide, push back, check the track record, sign it. Plain JSON in, plain JSON out.

forge.decide

POST /api/public/v1/forge/decide

Send a question. Get back the answer, a risk score, how hard it is to undo, the case for and against, and a signed receipt with a public verify link. All in one call.

POST /api/public/v1/forge/decide
{
  "question": "Should we raise prices by 8%?",
  "sector": "hospitality",
  "context": "Margin 0.18, footfall +12% last 30d."
}

forge.oppose

POST /api/public/v1/forge/oppose

The strongest case against any decision, across six checks, with evidence for each.

POST /api/public/v1/forge/oppose
{
  "decision": "Raise prices by 8% across all venues.",
  "context": "Margin trending +4% YoY."
}

forge.calibration

GET /api/public/v1/forge/calibration

See how close past answers got to what actually happened, by sector.

GET /api/public/v1/forge/calibration

forge.certificate / issue

POST /api/public/v1/forge/certificate/issue

Get a signed receipt for an existing decision_id. Returns a public verify link.

POST /api/public/v1/forge/certificate/issue
{
  "decision_id": "dec_8f3..."
}

Every Forge call is signed and has per-key rate limits. Results you send back help Kauzio learn. Patterns stay anonymous across businesses.

Pricing

Pay per call. Free to start.

Free · Indie · Studio · Enterprise.

50 calls free

See API pricing

Free tier available · Cancel any time