Guides

Task-focused how-to recipes — each gets one thing done against your hosted machine, for when you already know what you want. New here? Do the Quickstart first — it spins up a machine and runs your first verified compute. These guides pick up from there.

The guides

Build logic & apps

Deploy a state contract — standing logic that proves every fire
Host an app — a full-stack channel served from your machine

Verify & protect

Verify a result — check a ZeqProof offline, from the envelope alone
Encrypt a payload — seal it with HITE, bound to the Zeqond

What you can build

The catalogue spans 1,600+ operators across 65 domains, so the range isn't a marketing list — it's the actual surface you compute against:

Scientific & engineering tools

Physics, relativity, fluid dynamics, quantum, plasma, materials, optics — real formulas over CODATA constants, to ≤0.1%.

compute

Monitoring & safety logic

Threshold alarms, stability gates, drift monitors — state contracts that fire an operator on a condition and prove every fire.

contracts

Full-stack apps

Front end + Python back end, hosted on your machine, computing key-free — write it by hand or scaffold it in the workbench.

channels

Identity, encryption & comms

Equation-based identity, temporal encryption, shared custody, encrypted mail and messaging — security expressed as mathematics.

security

AI & agent systems

Ground a model on verifiable compute — the MCP tools, the kernel skill, and an agent layer that lands every step on an audit chain.

harness

On top of the apps

Compression, forensics, SSL, mail, the observer — every app is itself a channel on a machine, and a building block you can compose with.

apps

Every app is a building block

The applications aren't a closed product line — each one runs on a machine, through the same surface these docs describe, so you can build with them, not just use them. Point a contract at the SSL app, drive the compression app from your own page, read the observer feed into your dashboard. The framework is composable all the way down: apps, contracts, and channels are the same primitives you have, arranged.

Why it holds together

Everything you build sits on the framework's guarantees:

Deterministic

The same inputs give the same bits, on every one of the nodes. No run-to-run drift, no "works on my machine."

Verifiable

Every result carries a ZeqProof any node re-checks offline. You never have to trust the thing that computed it.

Honest

The machine computes, asks for what it needs, or refuses — and prices every call before it runs. It never fabricates.

The guides​