Verified compute  ·  2026

Verse.

Run code on a machine you don’t trust. Get a cryptographic receipt when an independent node re-runs it and gets the same answer.

Not “trust the cloud.” Check the re-run.

The precondition exp, ln, sin, cos

Re-running only proves something if the answer can’t drift.

IEEE-754 pins arithmetic, not exp, ln, sin, cos. Verse pins those too and publishes the evidence.

$ verse det check
✓ 255 conformance vectors identical · x86-64, arm64, wasm
How it’s proven →
Ancient Doric stone columns overgrown with infrared-white foliage
Plate I  ·  Columns, overgrown a mesh, not a chain

The network has no center.

Apps connect directly to the machines and capabilities they need.

Nobody else stores, executes, or approves the work.

One interface. Many capabilities.

Fig. 01  ·  Interference many machines, one result

Use compute, storage, models, tools, and verification without one provider.

Your app stays portable. Nodes stay independent.

Three things. That’s it.

I  ·  Space

What exists.

Signed records for capabilities, apps, work, and state.

II  ·  Capsule

What happens.

Portable WASM components with typed interfaces, permissions, and limits.

III  ·  Pact

What connects it.

A temporary signed agreement for access, execution, verification, and settlement.

How Verse runs an application six steps

One loop. Composed at any scale.

1 Discover find capabilities 2 Compose connect code + models 3 Agree permissions + price 4 Execute capsules run on nodes 5 Verify signed receipts 6 Settle pay + prune

Each operation runs where it fits. Apps compose those operations into something larger.

Scattered blocks
Plate II  ·  Scattered blocks

Apps move through the mesh.

Machines remain independent.

Roots in the wall
Plate III  ·  Roots in the wall

State stays where it belongs.

Only the nodes that need it store it.

A shaft of light on a stone altar in a dark temple

Plate IV  ·  Light on the altar

Portable logic. Native power.

WASM controls permissions.

Native hardware does the heavy work.

Built for agents.

Typed capabilities. Explicit permissions. Hard spending limits.

Agents can discover, combine, execute, and verify capabilities without root keys, unrestricted wallets, or access to whole machines.

Controlled by users.

Every action is bounded by a signed mandate. Natural language can propose, not authorize.

The living field one number, read many ways

The field finds its own shape.

Every served byte leaves heat, which decays. The mesh follows demand: data replicates, traffic finds the nearest copy, and price follows load. Nobody schedules it.

Caching, routing, replication, and price: one field, many readings.

Trust needs no ledger. Re-run work on a machine you don’t own and compare the result. One honest re-run settles it.

The re-run is the proof ↗

Nothing global unless it must be.

Left out

  • −  Native token
  • −  Global ledger
  • −  Permanent history
  • −  Central scheduler
  • −  Global contract VM
  • −  Network-wide consensus

Kept

  • +  Direct peer links
  • +  Portable WASM
  • +  Compute, storage, models
  • +  Signed Pacts + receipts
  • +  Pluggable payments
  • +  Data that expires
Two carved stone steles facing each other across a ruined grove

Plate V  ·  Two thrones

Only the participants coordinate.

Not every machine. Not every validator. Not forever.

One honest
re-run settles it.

No consensus, no majority to bribe, no chain. Just a signed receipt and a node willing to run it again.

One binary. MIT/Apache. No token. Zero proprietary blobs.

It is young and honest about it: the verifier set and mint are permissioned today. That is a trusted committee, not yet trustless refereed delegation. Read the threat model ↗

Verse © 2026