Reusable micro decision kernels for bounded, high-frequency decisions — grounded in your knowledge graph. Declare the answers; the kernel picks one with a calibrated confidence, or abstains when it cannot decide.
INPUT : LIVE STATE
SCOPE : BOUNDED
ABSTAIN: CALIBRATED
A generative model is charged for every token it might need — for a decision that needs none of them.
A decision on the request or control path is budgeted in microseconds to milliseconds. A general model spends them before it answers.
Wity Decisions
→ Set Power 0.91
Input — live state of the system
"raise the gain on the north-sector link"
Declared answers — bounded
What it's for
Pick the optimal option when new options keep getting added, and the properties of every option keep drifting over time.
Each prompt deserves a different model. Here is a router built from two kernels, step by step.
Step 01
Models, prices and capabilities can change every week, so the best model for a prompt keeps changing. Most apps either pin one model or hand the choice to a gateway's auto-router. Owning the choice usually means an LLM call just to pick a model, or rules that break each time something changes.
Gateway auto-routers, like OpenRouter's
their routing logic, their idea of 'best', no confidence you can act on
An LLM picks the model
an extra call, tokens and latency on every request, and a different answer each time
Hand-written rules
rewritten whenever a model is added or a price changes
Step 02
Before any model, there is one question: what kind of job is this prompt? Define it once.
Question
"which kind of job is this request?"
Step 03
List the jobs you handle, each in plain words. The kernel can only ever pick one of them, or abstain when none fits.
Question
"which kind of job is this request?"
Answers — declared
generate — make a new image from a text prompt
edit — change part of an existing image
background — cut out or replace the background
text-graphic — a logo, poster or graphic with words in it
Step 04
Capabilities, prices and speeds live in your catalogue, referenced rather than copied. Add a model there and the router knows about it, with no code change.
Question
"which kind of job is this request?"
Answers — declared
generate — make a new image from a text prompt
edit — change part of an existing image
background — cut out or replace the background
text-graphic — a logo, poster or graphic with words in it
Knowledge — by reference
→ model catalogue (capabilities, price, speed · updated live)
Step 05
Each prompt gets a job with a confidence, in milliseconds and without an LLM call. Prompts that fit no job are flagged instead of misrouted.
Input
Kernel
which kind of job?
{ prompt: "a watercolour fox in the snow" }
→ generate
0.88
{ prompt: "cut out my product, white background" }
→ background
0.97
{ prompt: "summarise this PDF" }
→ abstain
no job fits
Step 06
The job alone doesn't name a model; price and speed do. A second kernel reads the catalogue and the request's budget. Same prompt, different budget, different model.
Input
Kernel 1
which kind of job?
Kernel 2
which model, given price & speed now?
{ prompt: "a watercolour fox in the snow",
budget: "low" }
→ generate
0.88
→ flux-schnell
0.93
{ prompt: "a watercolour fox in the snow",
budget: "high" }
→ generate
0.88
→ luma-photon
0.86
{ prompt: "summarise this PDF",
budget: "low" }
→ abstain
no job fits
→ —
not asked
Step 07
Mark the odd result right or wrong. Each kernel fits its cutoffs to its own question, so a 0.8 comes to mean right about 80% of the time.
Input
Kernel said
judged
{ prompt: "a watercolour fox in the snow" }
→ generate
✓ right
{ prompt: "cut out my product, white background" }
→ background
✓ right
{ prompt: "make my logo pop" }
→ edit
✗ wrong → text-graphic
Question
"which kind of job is this request?"
Answers — declared
generate — make a new image from a text prompt
edit — change part of an existing image
background — cut out or replace the background
text-graphic — a logo, poster or graphic with words in it
Knowledge — by reference
→ model catalogue (capabilities, price, speed · updated live)
Calibration — this question only
cutoffs fitted from judged outcomes · 0.8 means right ~80% of the time
The thesis
General intelligence carries the whole world with it. For a decision over a known set of answers, that baggage shows up as cost, latency and confident wrong answer, or knowledge the decision never needed. Strip it out and the same decision gets faster, cheaper and more trustworthy.
A concrete case
Set the technology aside and staff the job with people. The question is always a choice: out of a known, fixed set of answers, which one fits this input? Two offices answer it very differently.
One clerk who knows everything
Extraordinarily well-read. Ask anything and they can, in principle, handle it. But to use what they know, they first write your whole request into a hundred-page notebook, page by page, before they answer. Slow, expensive, and — handed something outside their experience — they will still give you their best guess rather than admit the gap.
A clerk with one chart
A chart pinned to the wall and a fixed rack of bins. The chart — not the clerk — holds this domain's rules and exceptions. A letter arrives; the clerk reads it, drops it in the matching bin. If it fits no bin, it goes to the dead-letter tray for a human. The clerk carries no unnecessary knowledge of their own, needs none, and is honest about the edge of the chart.
Swap the letters for alarms on a live network, or a robot's next action from its state, and nothing changes: a known set of answers, chosen fast, at volume. The chart is the knowledge graph; the bins are the declared answers; the dead-letter tray is the abstain. Hand the same clerk a chart for another domain and they work that too — the clerk stays reusable, the chart supplies the domain. That is a decision kernel: a reusable clerk carrying no unnecessary knowledge, and a chart that supplies the domain exactly.
The category
Decision systems sit between two poles: open-ended reasoning that carries the world, and hard-coded rules that carry only what you wrote. Wity Decisions defines a third point — a reusable kernel that borrows a specific domain's knowledge instead of carrying its own.
| System | Knowledge / training basis | Runtime state | Decision scope | Intended strength |
|---|---|---|---|---|
| General LLMs | Broad world knowledge | Runtime context | Open-ended | General reasoning / generation |
| System One models | General intelligence trained for calibrated decisions | Structured state supplied at inference | Structured / bounded | Very fast general-purpose decisions |
| Traditional ML model | Task / domain training data | Structured features | Usually narrow | Prediction / classification |
| Rules / expert systems | Explicit domain rules | Explicit system state | Highly bounded | Deterministic decisions |
| Domain Decision Kernel the kernel | Specific domain knowledge + system-specific knowledge graph + learned patterns | Live state of the target system | Bounded | High-frequency decisions within a particular operational domain |
Positioning quadrant
Cost & latency against knowledge grounding.
Grounded · slow
GraphRAG / LLM over a KG
Grounds answers in a graph, but still pays generative inference on every call.
Grounded · fast
Domain Decision Kernel
Bounded selection grounded in a live domain graph — no generation, abstains at the edge.
Carried · slow
General LLMs
Carries the world in its weights and generates for every decision.
Carried · fast
Rules · classic ML · System One
Fast and bounded, but knowledge is hand-coded or baked in — not a live, reusable graph.
The move
Instead of asking a model to generate and then parsing whatever comes back, the application states the valid answers before inference — a list of options, an ordered rubric, a true/false statement. The kernel's only job is to pick among them and say how sure it is.
The whole class of "unparseable output" disappears. What remains is the honest failure mode — a wrong valid answer — which a calibrated probability lets the application catch and route.
With no meanings to reason over, a small local model cannot get there. So the kernel abstains rather than guess — the design, not a defect. Put the knowledge in the question and it resolves.
Same kernel, different worlds
The kernel is domain-agnostic; the knowledge graph is not. Point it at a different system and the same decision machinery answers a different class of question.
Choose the configuration from live state.
Given cell, link and service KPIs plus active alarms, select the next network configuration action — and abstain when the state doesn't match a known remedy. Runs on the element or at the edge, in the request path.
Map state estimates to bounded actions.
Given a state estimate, select from a bounded set of actions inside the control loop — and hand off to a safe state when the estimate is uncertain. Deterministic, local, no cloud round-trip.
Pick editing actions from the scene graph.
Given a snapshot of the scene graph and the user's intent, select the editing action to apply. A bounded vocabulary of edits, resolved against the current state of the timeline.
Select actions from state, objectives & constraints.
In a discrete-action game, choose the next action from the current game state, the objectives, and the constraints you declare — fast, cheap and repeatable across millions of ticks.
Under the hood
Most inputs don't need a model at all. So resolution is a ladder — each tier competent for a band of inputs, tried in order. The first proposal to clear its confidence threshold wins; nothing more is invoked than necessary.
exact name / alias match · the closed-vocabulary head
µsfuzzy + token overlap over names & descriptions · typos, paraphrase, shared roots
sub-mssentence-embedding meaning match (local MiniLM) · arbitrary phrasing with no shared words
~mszero-shot entailment (local NLI) · truth-of-a-statement · rubric judgment
10s of msdistilled SSM / encoder + classifier head (one pass) · domain knowledge carried in the weights
100s of msnothing above is confident — hand off, don't guess
terminalMost inputs don't need a model at all. A closed vocabulary is a grammar; a paraphrase is a fuzzy match. Only genuinely semantic inputs reach a small local model — nothing more is invoked than necessary.
Every tier proposes an answer with a probability, and clears a threshold before it's accepted. Confidence means what it says: answers assigned 0.8 are right about 80% of the time, checked per domain on your traffic.
When nothing clears the gate, the engine abstains and hands off. It is allowed to be unsure; it is not allowed to be confidently wrong at scale. Abstention is the design, not an error.
In the Wity stack
Wity Decisions is the platform's decision primitive — a headless, composable core alongside the Knowledge Graph and DIAL. It takes symbolic state — goals, relationships, constraints — and returns typed decisions: state, not output, which the Composition layer renders. It resolves intent into the Affordance layer, but it is not the Inference Bridge: its whole premise is avoiding general inference for bounded decisions.
Knowledge enters through two injected seams, never into the resolver: a World seam for candidate and relational provision — naturally backed by wity-system ↗ — and an enrichment seam for criterion meaning. The kernel stays pure and reusable; both seams plug in only where they are needed.
The three primitives
nominal — one of N declared options
the chosen option + a distribution + confidence
ordinal — a level on a declared rubric
the level + its ordinal position + confidence
dichotomous — the truth of a statement
P(true); certainty = max(p, 1 − p)
Status
Where a claim is measured, it says so; where it is not yet, it says that too. A reliability engine that fudged its own benchmarks would refute its own premise.
Built
Forthcoming
Measured so far, qualitatively: where the knowledge lives — in the question or nowhere — dominates model choice at this scale; small local models do not carry open-world knowledge, so the honest behaviour on such inputs is to abstain; and the abstain gate works — gibberish and degenerate questions that once produced confident wrong answers now abstain. The quantitative head-to-head is forthcoming: it needs labeled datasets still being assembled, and no comparative numbers are claimed that have not been measured.
FAQ
Still have questions? Explore the stack
Try it
Watch it pick one with a calibrated confidence — or abstain, honestly. Self-hosted, fast, and free of knowledge it doesn't need.
Self-hosted · No LLM in the hot path · Calibrated abstain