Photo by Taylor Vick on Unsplash
Heisen
The deterministic compute substrate.
The engine layer beneath the entire Maxor suite. It classifies each request and decides where it runs — local engine first, frontier model only when it must. Compression-first, audit-ready, sovereign-deployable. We could have wrapped a frontier LLM and called it a product. We didn't.
0.1 · Command center
4,200+
Deterministic engines in the substrate
counted live · same figure as /architecture
55M
Home-trained v11 router parameters — not an LLM
98.6 % acc · under a millisecond
0
Of your data enters any training loop
impossible by design, not by promise
3
Deployment modes — cloud, local, air-gap
Canadian-resident cloud by default
Heisen, inside MaxorConnect.
Not a legacy render. Live mint surfaces — command center, assistant, pulse, chat.
0.2 · Assistant
0.3 · Pulse + chat
A substrate, not a wrapper.
Most AI products are a thin shell around someone else's model. Heisen is the opposite : a deterministic compute core that resolves what it can exactly, and escalates only when it genuinely must.
Deterministic engines
A library of pure, bounded, documented engines. When a figure is computable exactly, a model does not invent it — it writes around the function.
Confidence router
Every request is classified and routed — local engine first, frontier model only when the work demands it. Cost stays predictable.
Hallucination-aware
Outputs are checked against an internal coherence signal before they reach you. Information-theoretic, not another model guessing about the first.
How it answers
Next-token prediction for the number and the sentence
Engine computes the figure; a model always generates the sentence; a frontier model only on the residual
Same question tomorrow
A different paragraph
Same inputs → same outputs. Always.
Your data
Enters a training loop, or you take their word
Never. Impossible by construction.
The bill
Per token, every query
The figure is $0 on the engine; generation still uses a model
When the auditor asks
A prompt
A function, a digest, a verdict
Failure mode
Plausible and wrong
Flagged before it ships
Resolve. Route. Arbitrate. Verify. Escalate rarely.
Each layer only handles what the layer below couldn't. A frontier model is the expensive last resort, not the product.
Resolve
The deterministic engine substrate computes everything exactly computable — the figure, instant, auditable from first principles. Generation still uses a model; the model does not invent the number.
≈ 68 % of compute · $0 engine · generation still uses a model
Route
What genuinely needs judgment is classified and routed to a domain specialist — the right expertise, not one generic model for all of them.
Home-trained v11 router · 55M params · 98.6 % · < 1 ms
Arbitrate
On hard or multi-domain queries, a reasoning layer fuses the specialists and resolves conflicts — reasoning, not an average of guesses.
Domain specialists + judge · the residual
Verify
Every output passes a deterministic coherence check before it ships. Hallucinations are caught here, before they reach you.
Grounding screen · independence check · every run
Escalate rarely
A frontier model is the last resort, used only when confidence stays low — so cost and latency stay bounded.
≈ 4 % · last resort · never the default path
Most of the compute never touches a large model.
That's the whole point. The deterministic substrate settles roughly two-thirds of the figure at zero extra model cost — auditable math. Generation still uses a model; a frontier model is the rare exception.
Deterministic engines
≈ 68 % · $0 · audit-ready
Specialist + reasoning judge
the residual — domain depth + arbitration
Frontier
last resort · rare
Every output — wherever it resolves — passes the deterministic verifier before it reaches you.
From clinical trials to structural loads.
The same engine library, specialized per domain. This is research we run for ourselves and deliver under engagement — not a roadmap promise.
Pharmaceutical R&D
Trial math, endpoints, dose — computed, not guessed.
Structural & mechanical
Loads, spans, members — the function the PE can show.
Computational physics
Bounded solvers. Same inputs, same field.
Quantitative finance
Replayable numbers. A receipt, not a vibe.
Applied mathematics
Closed-form and numerical, documented bounds.
Software & code analysis
68 code-audit engines. Defects named, not described.
Energy & process systems
Balances, constraints, operating envelopes.
Materials science
Properties from first principles, not a paragraph.
Statistics & data analysis
Tests you can re-run. No silent drift.
Operations research
Feasible, optimal, or proven infeasible.
Scientific simulation
Deterministic kernels under the model, not instead of science.
Compliance & legal logic
Rules as engines. A path the auditor can walk.
What you actually walk away with.
Not a chatbot subscription. A verifiable compute layer you can deploy, audit, reproduce, and own the outputs of.
Verifiable answers
Every output traces to a function or a checked source, with an audit trail — and reproduces run-to-run.
Your data stays yours
Nothing you send enters a training loop. The architecture makes it impossible by design.
Deploy it your way
Cloud, on your hardware, or fully air-gapped. Canadian data residency by default.
Bounded cost
The figure resolves at $0 on the engine. Generation still uses a model. You pay a frontier model only on the residual that needs one.
Domain depth
The right expertise per question across 12 sectors — not one generic model stretched thin.
A hallucination guardrail
A deterministic coherence check sits in front of every answer. Bad output is caught before it ships.
The same brain in dev, in prod, on your hardware.
Same brain when our developers ship on Monday, when your team uses MaxorConnect on Tuesday, when the engine runs inside your perimeter on Friday night.
Math, not vibes.
Same inputs → same outputs. Always. Every engine is pure, bounded, documented. When the auditor asks how a number was produced, we show the function — not a prompt.
Your data stays yours.
The engines are domain-agnostic logic patterns. Your code, your data, your IP never enter the substrate or any training loop — impossible by design, not by promise.
Air-gap capable.
When the work can't leave your perimeter, Heisen runs entirely on your hardware. No prompts leave the box, no completions leave the box, no telemetry, no phone-home.
We build with what we sell.
Every engine first proves itself building our own products. If Heisen can't help us ship Heisen, it doesn't ship to you. The gate is mechanical, not aspirational.
Heisen at the core. The surfaces on top.
Every product we build and run in Canada shares this one substrate — the six surfaces above it, Heisen beneath. Nothing bolted on.
Cloud, your perimeter, or a disconnected site.
The same substrate, three postures — your call, every time.
Cloud
Canadian-resident
Hosted on Canadian-resident infrastructure. Fastest to start, fully managed, audit-ready out of the box.
On your hardware
Inside your environment
Run the substrate inside your own environment when residency or latency demands it — a compact on-prem appliance, no datacenter required. No third-party round-trip.
Air-gapped
Fully disconnected
Fully disconnected via the Maxor Sovereign Stack. Sovereign by construction, not by configuration.
Precision-critical work. Not a chatbot for the hallway.
If a plausible-but-wrong answer is unacceptable, this is the layer.
Put Heisen to work.
Schedule a demo, discuss deployment — cloud, local, or air-gapped — or get pricing. A senior lead responds within one business day.
Heisen, answered
Heisen is the deterministic engine substrate behind Maxor's AI — a foundation of 4,200+ deterministic engines that compute verifiable answers instead of just confident-sounding ones. It is the brain every Maxor product runs on, audit-ready by default.
An LLM predicts the next token; Heisen routes each task to a deterministic engine that produces the same, checkable answer every time. Most work never touches a cloud model — Heisen answers locally first and escalates to an LLM only when the task genuinely needs it, so cost and hallucination both stay low.
A deterministic engine gives the same output for the same input, every run, with a calculation you can audit. That is what "verifiable, not just confident" means — and why Heisen suits precision-critical work where a plausible-but-wrong answer isn't acceptable.
Yes — deployment is hybrid: in the cloud, on your own hardware, or fully air-gapped. When work can't leave your perimeter, Heisen runs entirely on the box, with no prompts or telemetry leaving it.
No. The engines Heisen uses are domain-agnostic logic — your data, code, and IP never enter the substrate or any training loop. Per-engagement contracts state it explicitly.