Artificial Intelligence

Engineering Intelligence

Most AI in production still drafts and recommends. A human decides and executes. We build what is on the other side of that line.

PerceivePredict, optimize, reason

DecideAgainst real state

ActAnswer for the outcome

Grounded in a decision. Gated by deterministic control. Operated as infrastructure as it scales.

// Reference architecture

A section through the system.

Built bottom up, because that is the order it goes in. State before intelligence, intelligence before decision, and a control plane every action crosses on its way out. The geometry is the argument: there is no path from decide to act that routes around it.

Fig. 01Decision system, vertical section Probabilistic below, deterministic at the gate

Actattributable, reversible, recorded

Identityscoped per agent

Authoritywhat it may trigger

Policyevaluated outside the model

Limitshard, not soft coded

Evidenceappend only, actor and outcome

Control plane

Decideone named decision, one named uncertainty

Perceivevision, fusion, extraction

Predictsequence, gradient boosted

Reasonscoped to ambiguity

Optimizesolvers, math programming

Plansearch, hierarchical planners

State bus

Semanticsone agreed meaning

Contextscoped to the decision

Historyauthoritative event log

Lineageinput to output

Freshnessstale is excluded

Accessscoped at the data layer

One governed path

ERP

MES / SCADA

EHR

Ledger

Flow runs upward · one governed read · every action crosses the gate Dashed edge, the outcome written back to history

A production decision may combine several kinds of computation. The uncertainty determines which ones belong.

// Grounded in a decision

The unit of work is a decision, not a model.

Every production call resolves to a named decision and uncertainty type. A typed contract enforced at runtime makes the computation class a derivation, not an opinion.

Fig. 02decisions/supply/reallocate.yaml Enforced at call time

decision: supply.reallocate
blocks:   "next month's allocation"

# the uncertainty selects the method,
# not the other way round
uncertainty:
  type:        stochastic
  estimand:    P(stockout | 30d)
  requires:    calibrated_interval
  resolves_to: prediction   # not an LLM

inputs:
  - path:     state.supplier.lead_time
    max_age:  6h
    on_stale: abstain
  - path:     state.inventory.on_hand
    max_age:  15m
    on_stale: abstain
  - path:     contract.single_source
    via:      reason

# the block most teams never write
abstain_when:
  - interval.width > 0.25
  - any(input.stale)

emits:
  allocation_split -> allocation.shift

The system can abstain when its evidence is weak, stale or contradictory.

// Gated by deterministic control

Confidence is not a permission.

Competence and permission are independent. A model being more certain is never a reason to let it do more. This ledger is sorted by confidence.

Fig. 03Authorization ledger, one capability allocation.shift · policy v18

Model confidence

99.9%

99.4%

96.8%

88.1%

71.2%

Share of volume requested

asked for 74%

asked for 62%

asked for 41%, over by one

asked for 27%

asked for 33%

Verdict

Refused

Allowed

Confidence informs the request. Policy determines whether the action is allowed.

What that buys you

Replace the model with something more capable and this ledger does not change. If swapping one needs a security review, capability and authority were coupled, and that coupling is the defect.

// Operated as infrastructure

Degraded is a state, not an incident.

An autonomous system occupies states over time. What matters is what moves it between them. Here are sixteen weeks of drift and the state it produced.

Fig. 04One model, sixteen weeks in production Drift above, resulting state below

Retrain threshold

Shadow Live Retraining

W00W04W08W12W16

Not acting Partial traffic Live Degraded

Triggerdrift > threshold

Policy responseremove live traffic

Recoveryretrain → shadow

At week eleven, a predefined response moved the model off live traffic before the drift became an incident.

// The Machine Estate

Humans and machines, operating the same systems.

People and machines now read the same enterprise state and act on the same business processes. That shared operating environment is the machine estate.

Fig. 05lock trace · allocation-2026-04 09:00 to 10:00, one hour

One record, one morning allocation-2026-04 holding nobody

Holds it

j.okaforplanner supply-plannerv2.4.1 pricing-agentv1.9.0 m.reyesapprover forecast-svcv4.2.7 ops-deskon call

Waiting for itQueue

supply-plannermachine

waited 7m

m.reyeshuman

waited 12m, behind two machines

pricing-agentmachine

waited 2m

ops-deskhuman

waited 14m

09:0009:1509:3009:4510:00

Human operator Machine operator Striped bar, waiting for the record

Recordallocation-2026-04

Current holdernobody

Actor classunassigned

Controlexclusive write

People and software share the same queue, so identity, authority and coordination must apply to both.

The operating condition is simple: every actor is named, every action is bounded, and every collision has a deterministic outcome.

// Where we enter

We have no stack to defend.

The composition follows the problem. Some engagements start at state and never reach a model. Others start at a model and end up rewriting how state is resolved.

decision workspacescope / supply.reallocate

Evidence is unreliable

Ground

State · semantics · provenance · integration

Uncertainty is unresolved

Compute

Perception · prediction · optimization · learning

Action needs judgment

Decide

Reasoning · simulation · policy · authority

Production needs control

Operate

Evaluation · observability · limits · drift response

The honest version

Sometimes the answer is a rule, not a model, and we will say so before you have paid for anything. This is production discipline: evaluation, on call and regression practice already run across 200+ engineers, applied to systems that make decisions.

Capability gets smarter. Authority stays explicit.

Nobody engineering today knows where the frontier stops, and you do not need a position on the destination to build for the journey. Bring us the problem and we engineer the intelligence around it: what decision is blocked, what class of computation it actually calls for, and what would have to be true before a system is allowed to make it.

>_ Bring us the problem How we work