Judgment governs.
Every action carries its terms.
The terms a deployment declares, held against the record of what the machine did.
It bounds what can happen next, writes the bound as a contract, and reaches the decision on the machine.
The bound is written with the deployment, and read against the record.
The bound
It bounds the range the record has narrowed
A record says what happened. Run it forward and it also says how little can happen next.
- The range
- What the machine can still reach, narrowed by the trail the record already holds. The longer the trail, the smaller the range.
- The terms
- The bound a deployment declares: what an action may do, on what authority, at what cost.
- The hold
- Work that leaves the terms does not run.
- The answer
- When someone asks afterwards, the rule and the record answer together.
The narrowing is deterministic: the same record leaves the same range. Krisis is where the bound on that range is declared.
The contract
One contract answers which model, at what cost, by whose authority
The terms are written with the deployment, and read against the record it keeps.
- The action
- What each action may do, and what it may not.
- The model
- Which model answers a request.
- The cost
- What that answer costs.
- The authority
- Who may move an agent, and with what authority.
- The record
- What the machine did, read beside what it was allowed to do.
One contract answers all five, so the same request is read the same way twice. A bound is worth what the record can prove about it, so the two are bought together.
The judgement
The decision is made where the work runs
A decision that waits for a round trip is a report. The layer answers on the machine.
- The read
- A request is classed, and its class decides what may happen to it.
- The machine
- The classifier is small enough to run on a 32-bit part with no operating system, beside the work it governs.
- The check
- The same arithmetic is written four ways: compiled, hand-written for the part, in hardware, and as the plain reference the other three are held to.
- The number
- 0.915 quantised accuracy on a 64-32-10 network.
A decision small enough to sit on the machine, and an arithmetic that can be checked against a reference written from it.
Two holders
The acts that cannot be undone
- The class
- Which acts need two holders. Declared with the deployment.
- The window
- How long a second holder may still agree.
- The hold
- The act waits while the class holds it.
- The release
- It starts when a second holder agrees inside the window.
- The record
- Both agreements sit beside the act on one record.
Two different holders, one window, one record. A second agreement by the same holder is not a second key.
The buyer
The operator who has to answer for it
- A regulated operator
- A deployment that must account for which model answered, at what cost, and on whose authority.
- An enterprise operator
- A fleet where an agent can move a machine, and the terms of that move have to be readable later.
- What it is bought with
- A bound is only as good as the trail behind it, so the layer is bought with the record.
What the buyer wants is an answer that survives an audit, which is why the price lands on the layer that holds the record.
Contact
Declare what the work may do
If a deployment has to bound what a model may do and answer for it later, we should talk.
Bring the rules a deployment already declares, and we will show you where they meet the record.