TensorYard
A regulated number your auditor can replay — bit-for-bit, offline, trusting nothing.
A pure arithmetic engine runs the figure — never a language model — and seals it in a signed receipt. Your auditor replays it offline.
Walk a receipt with the engineer who seals them.
Bring
The computation under challenge — inputs, epoch, who signs.
Quote
G1 is free. We walk it, then we quote.
Sold to
The signatory who carries the liability. Production.
Ed25519
Every receipt cryptographically signed
Bit-for-bit
Replayed by your auditor, offline
0
Language models in the compute path
WORM
Hash-chained, append-only evidence ledger
An authority, not a spreadsheet.
A regulated number is only as good as your ability to reproduce it under challenge. TensorYard runs the computation on a pure arithmetic engine — deterministic by construction, no probability, no model — and emits a signed receipt that binds the inputs, the engine version, and the result into one tamper-evident record. An auditor takes that receipt to their own machine, off your network, and recomputes: an identical digest, or a mechanical rejection. There is no 'trust our platform' step, because there is nothing to trust — only arithmetic anyone can rerun.
Compute. Seal. Replay.
One regulated computation, three moves — and the last one belongs to your auditor, not to us.
01 — Compute
A pure arithmetic engine runs the regulated calculation — reserve derivation, standardized credit RWA, chain-ladder — pinned to a fixed runtime epoch. Same inputs always produce the same output, on any machine, any year.
02 — Seal
The result is canonically encoded, hashed into an RFC-6962 Merkle tree, Ed25519-signed, and appended to a hash-chained WORM ledger. The receipt binds inputs, engine version, and figure into one tamper-evident bundle.
03 — Replay
Your auditor takes the receipt to their own iron — offline, air-gapped if they wish — and recomputes. An identical digest verifies the number ; any drift is a mechanical REJECT. No access to us required, ever.
What a signed receipt actually binds.
The receipt is the product. It is not a log of what happened — it is a self-contained proof a third party can verify with no trust in us and no connection to our systems.
The inputs, canonically
Every input is canonically encoded, so the same data always hashes to the same value — no ambiguity of formatting, ordering, or precision to argue about later.
The engine epoch
The exact engine version is pinned to a runtime epoch and bound into the receipt. A computation from 2026 replays under 2026's engine, not whatever ships next year.
The Ed25519 signature
An Ed25519 signature over the Merkle root makes the receipt tamper-evident : change one input, one digit, one byte, and verification fails — cleanly, mechanically, offline.
Every guarantee kills a way the number goes wrong.
Deterministic, sealed, sovereign — and each property forecloses a specific way an audited figure quietly stops being defensible. The capability and the failure it kills, in one place.
Pure engines, not models
Regulated figures are computed by pure arithmetic engines, deterministic by construction — no probability, no model to retrain. So a figure is never defended by 'the model said so' : the reviewer reruns the math, they do not take it on faith.
Signed, replayable receipts
Every computation emits a self-contained receipt — canonical inputs, engine epoch, Ed25519 signature — that reproduces bit-for-bit on any machine. A result nobody can recompute, or one quietly edited after the fact, fails : the receipt replays, or a single moved byte breaks the signature.
WORM evidence ledger
Receipts append to a hash-chained, write-once ledger — the audit trail is the ledger itself. A record slipped into or out of history is caught : the order is provable, any rewrite detectable.
Mechanical rejection
There is no 'looks close enough'. A recomputation that does not match is REJECTED — including a stale-engine replay, since the pinned epoch turns engine drift into a mechanical failure, not a debate.
Offline, air-gap verify
Verification needs no network and no vendor — the auditor recomputes on their own iron, fully disconnected. Evidence you could only check by logging into us would be lock-in ; here the proof outlives the relationship.
Your keys, your perimeter
Run the engines and hold the signing keys inside your own environment. The regulated data — and the authority to sign the number — never leave your control.
Hosted, or entirely inside your perimeter.
Start hosted for a pilot ; bring the engines and the signing keys in-house when the regulator — or your data-residency rule — demands it.
Cloud
Fully managed for a design-partner pilot — the fastest way to put a signed receipt behind a regulated computation, nothing to provision.
Self-hosted
Run the engines and hold the signing keys inside your own environment. Your infrastructure, your control plane — the regulated data never leaves your network.
Air-gapped
Fully disconnected for the most sensitive reserving and risk work. Compute and verify where the data lives, because the proof does not need the internet.
The person who signs — and bears the liability.
The signatory whose name is on the regulatory opinion, and the teams who hand them a number that has to survive a challenge.
One deterministic philosophy, across the suite.
TensorYard shares the Maxor posture : deterministic math over black-box models, verifiable over trust-us, sovereign-deployable by default. It is the compute authority that sits beside Heisen and the grounding fabric in the evidence substrate behind every Maxor surface.
Explore the Maxor suiteAvailability
—
Status
Production
Deployment
Cloud · Self-hosted · Air-gap
Owner
Maxor Digital · IP held by Maxor Global LLC
Put a signed receipt behind the number.
A G1 call is free. Bring the figure you sign. We walk the compute, the receipt, and the offline replay — then we quote. Production. Sold to the signatory who carries the liability.
TensorYard, answered
TensorYard is a deterministic-compute authority for regulated numbers. A regulated computation is run by a pure arithmetic engine — never an LLM — and sealed in a signed receipt, so the number can be defended long after it was produced.
An independent auditor re-runs the same computation offline. If the recomputation produces an identical digest, the result is accepted; if it differs in any way, it is mechanically rejected. Verification does not depend on trusting Maxor — it depends on the math reproducing exactly.
Language models are non-deterministic: the same prompt can yield different outputs, and a result cannot be re-derived to an identical digest. Regulated numbers need pure, reproducible arithmetic that an auditor can recompute independently — which is exactly what TensorYard's engines provide.
Yes. TensorYard is in production. The compute → signed-receipt → offline-verify core is real and running, and its registry ships a focused set of regulated engines. It is sold to the signatory who carries the liability — a G1 call walks a receipt, then a quote.
It is for regulated environments where a number must be auditable and defensible — the value has to hold up to independent recomputation. It is sold to the signatory who carries the liability for that number, through Maxor's software and advisory engagement.