Journal · Entry 004 · October 2026

The Emerging Stack

Jev makes probabilistic judgment cheap. Pramaana Labs insists a percentage cannot replace a proof. The industry has not decided how to distribute verification between deterministic and probabilistic paths — our answer, and where Verified sits in the emerging stack.

Plate 004

Two product launches this autumn answered the same question with opposite instruments. In September, TypeSafe released Jev, the first of what it calls System One models: no prose, no chat, just typed questions about application state answered in milliseconds as bounded choices and calibrated probabilities, cheap enough to run on every step of a workflow. Around the same time, Pramaana Labs argued from the other end of the spectrum: regulatory and policy text formalized into machine-checkable specifications, run through provers and solvers, returning proofs and counterexamples rather than scores. “Confidence is not accountability,” their site argues — a percentage cannot replace a proof.

Both teams are serious, and they are pulling the same problem in opposite directions. That disagreement is worth more attention than either launch on its own, because it marks a question the industry has not settled: when machines do the work, what kind of computation checks it? Probabilistic judgment, now nearly free? Formal proof, now increasingly practical? The stack is still sorting itself out, and the sorting will not end with one of them winning.

Why the question exists

Agents have stopped merely producing text. They create purchase orders, reconcile transactions, update customer records, coordinate work across applications. The tooling around them still mostly measures model behavior — prompts, tokens, traces, evaluation scores — which explains how the application behaved and says nothing about whether the work happened. A customer-service agent can interpret a billing dispute perfectly and fail to commit the adjustment. The quality of an AI interaction and the correctness of a business outcome are different properties, and a business runs on the second one.

So something has to check the work. The question is what that something is made of.

What cheap judgment buys — and what it cannot

Jev’s class of model makes a real difference to the economics. When a bounded semantic question — does this document need review, is this transaction unusual, does this action look consistent with that policy — can be answered in milliseconds for a fraction of a cent, evaluation stops being a quality-assurance step that runs on samples and moves into the execution path itself: every consequential tool call can be assessed while it can still be stopped.

But consider what such an evaluator actually receives. A purchasing agent reports an order complete; the evaluator examines the execution history and finds it compliant. Perhaps the tool response it inspected was generated by the agent itself. Perhaps the ERP accepted the request and rejected the transaction a moment later. Perhaps the approval existed but came from someone without the authority to grant it. The evaluator may have reasoned flawlessly over inputs that were never sufficient to establish the outcome. Calibration measures how well a model knows what it was shown. It cannot measure whether what it was shown was true.

A highly accurate model can evaluate fabricated evidence. A signed statement can be false. There is no computational shortcut around where the evidence came from.

Pramaana’s critique of confidence scores is therefore right as far as it goes — and the same discipline applies to proofs. A prover establishes properties of what has been formalized and fed to it. If the formalization is wrong, or the facts beneath it were never authenticated, the proof is a perfectly rigorous statement about a world that doesn’t exist. Evaluation, evidence, verification and attestation are four different mechanisms. An evaluation assesses information against a criterion. Evidence ties a claim to an observed event, with provenance. Verification establishes whether defined requirements are met by that evidence. Attestation makes the result attributable to an issuer. None of the four substitutes for another, which is why neither pole of the current debate can be the whole answer.

Distributing the verdict

We wrote in Neo-Determinism that for two centuries we trusted machines because they repeated themselves, and that when the worker became probabilistic, the record had to become the predictable part. That is also our answer to the distribution question. Probabilistic computation belongs where interpretation is unavoidable: triaging claims, scoring risk, suggesting contracts from event data, explaining a verdict afterwards. The verdict itself must not be probabilistic: it is the deterministic evaluation of signed evidence against an explicit contract, replayable years later with the same result. The worker may be probabilistic. The judgment may be probabilistic. The verification must not be.

In practice the mechanisms arrange themselves by cost and by what each can establish:

MechanismSettlesCost
CodeExact properties: thresholds, signatures, invariantsFree, and deterministic
System One modelsBounded semantic judgments, with calibrated uncertaintyCents, falling
Reasoning modelsAmbiguous cases, unfamiliar situationsExpensive
PeopleAuthority, disputes, consequenceThe scarcest resource

The rule is to apply the least expensive mechanism that provides the required assurance, to escalate what it cannot settle, and — this is the part the industry has not internalized yet — to record the boundary. A probabilistic judgment enters the record as a judgment: which model, which version, what it was shown, what it concluded. It is never silently promoted to fact.

The stack

Separate the responsibilities and the architecture draws itself.

Figure 1

Diagram: five stacked layers with vendor examples — execution (OpenAI or Copilot agents, UiPath), judgment (TypeSafe's Jev, frontier LLM judges), evidence (read-only connectors beside SAP, Salesforce, LIMS), verification (Verified; Pramaana with formal provers), attestation (Verified Work Records) — bracketed as the hot path, one claim before it commits. Below them, records accumulate into the Ledger, the aggregates: ROI, no-touch share, coverage, comparisons. A dashed coral arrow runs from the ledger back up to judgment, labeled: aggregates train evaluators.
Five responsibilities and one feedback edge — with examples of who plays where today. The names are illustrations, not endorsements.Figure 1

These are responsibilities, not products; one actor may carry several. But the moment two collapse into one, the stack stops being trustworthy: an agent judging itself, an evaluator writing its own evidence. We made the longer version of this argument in Systems of Proof.

The stack also runs at two speeds, with opposite requirements. The hot path decides one claim, now, before it commits. It runs the hierarchy above, cheapest mechanism first, and it is allowed to be occasionally wrong, provided it is wrong in a recorded, correctable way. The aggregates are what the records become afterwards: what the automation returned, how much ran untouched, how much of the work the evidence could support, which vendor did better against the same definition of done. Those answers can take an hour to compute. What they must be is re-checkable — every number traces back to records any party can replay. Most dashboards blur the two speeds: hot-path telemetry, presented as if it were an aggregate.

The feedback edge in the diagram is the slowest loop and the most valuable one. Evaluators learn from labels, and for enterprise work good labels are rare. A verified Work Record is a dense one: claim, contract, evidence, verdict, and, when a dispute later overturns a judgment, the resolved outcome. With data rights handled explicitly, aggregates of such records could train the next generation of evaluators; cheaper evaluators widen hot-path coverage; wider coverage produces more records. The layer built to make work accountable may end up producing some of the intelligence that judges it.

Where Verified belongs

So: are we a System One company? No. Models like Jev slot into the judgment seat of this stack, and the protocol is deliberately indifferent to which one sits there — commercial, open-weight behind the firewall, frontier for the exceptions, eventually an evaluator trained on an organization’s own records. The record preserves which model judged and on what; swapping the model must never rewrite history. Are we Pramaana? Also no. We admire the rigor, and formal methods are an ingredient of our contract semantics — but our object is not the policy text, it is the work: a claim that something was done, verified against an explicit contract on evidence signed at the source. Verification, as we practice it, is less a prover than a bookkeeper with a security clearance.

Verified is the bottom of the stack: Work Contracts, evidence, verification, attestation, durable Work Records — built to stand regardless of whose intelligence did the work or judged it, and regardless of how the industry’s deterministic-versus-probabilistic argument resolves above us. If verification succeeds as infrastructure it will partly commoditize, the way databases and transport security did; that would be maturity, not defeat. Intelligence is becoming abundant. Judgment is becoming cheap. Verification must become infrastructure. How we are building it is on the Technology page.

Keep reading

All entries

Bring us a process

We take on a small number of design partners, including for regulated processes. We write the Work Contract with you and run the protocol on live work.

Used only to contact you about access (privacy). Investors and everyone else: hello@beverified.ai