Skip to main content

The lattice

The framework runs as a lattice of nodes — eighteen of them, each with its own Postgres, its own Redis and its own genesis, all running one byte-identical code genome. Every node serves the same API surface, and you don't have to take that on faith:

for h in zeq.me zeqsdk.com zeqproof.com zeq.dev zeqstate.com hulyas.org; do
  printf '%-16s ' "$h"; curl -s "https://$h/api/endpoints" | shasum -a 256
done

Measured 2026-09-03: 763 endpoints and one distinct digest across all six — 230bc03c9f673d33…. That parity is what lets a ZeqProof made on one node re-verify on another.

No consensus, no voting, no mining​

Nothing in this system takes a vote. There is no proposer, no round, no fork-choice rule and no miner. What replaces all of it is determinism plus content-addressing:

  • Determinism. The coin for a given tick is a pure function of that tick. Two honest nodes cannot disagree about arithmetic, so a vote would prove nothing:

    for h in zeq.me zeqproof.com; do curl -s "https://$h/api/mesh/issuance/at?z=2301711961"; echo; done
    # identical key, rate, amount and phase on both — only the node name differs

  • Content-addressing. Every shared row is hash-linked and named by its own material. A receiving node recomputes each row's hash rather than trusting the sender, and duplicates collapse on a unique key instead of being negotiated away. lib/meshPeers.ts puts it exactly: discovery only decides who to dial; convergence of what is true is determinism plus content-addressing over the log.

Your machine's clock ticks locally at the Zeqond rate and a contract fire waits on no quorum. That part of the old story was always true.

What travels, and what does not​

An earlier version of this page said "there is no global ledger… what travels between nodes is verification, not state", and that your machine's audit chain "isn't replicated or gossiped." The second half of that is wrong, and this is the correction.

State does travel. There is a shared append-only log — the WORM issuance spine — and it replicates continuously between all eighteen nodes. You can watch it from outside with no credentials:

curl -s https://zeq.me/api/worm/replication \
| python3 -c "
import sys,json
d=json.load(sys.stdin)
print(len(d['origins']),'peer origins applied on this node')
for o in sorted(d['origins'], key=lambda o:-o['applied_count'])[:3]:
    print(f\"  {o['origin_node_id']:<28} applied {o['applied_count']:>7}\")
"

On 2026-09-03 zeq.me held 17 peer origins, with applied row counts from 7 up to 153,209 for machine-zeqenvelope#fed. Those are federated rows, written on other nodes, verified and applied here. Calling that "not replicated" was a measurable falsehood.

Travels between nodesStays on the node that made it
issuance — the coin, one row per windowyour machines (state_machines)
pool_inflow / pool_outflow — treasury flowsyour envelopes and coins (tally_tokens)
machine_genesis — a machine's birth recordyour pages (state_machine_pages)
precision_daily — the daily precision sealyour vault secrets (ZSC)
anchor, tombstone, kernelyour plan, and your node session

The per-user economy events (mint, transfer, burn, xfer_debit, xfer_credit, wallet_delta) travel only if the originating machine opted in with network_member = true. No machine context means private — the code fails closed.

The proof that the shared half really is shared: snapshot.poolBalance is a projection of federated rows, and it collapses to one number fleet-wide.

for h in zeq.me zeqsdk.com zeqproof.com hulyafield.com zeqenvelope.com zeq.dev; do
  curl -s "https://$h/api/transparency/now" \
  | python3 -c "import sys,json;print(json.load(sys.stdin)['snapshot']['poolBalance'])"
done | sort -u
# one line — that is the invariant. 441076 when this page was measured.

The number advances as treasury carves land, so a figure quoted on one page and re-measured later will differ; the mesh page recorded 436469 earlier the same day. What must never differ is the count of distinct values across the fleet. If that sweep ever prints two lines, the projection has diverged and something is wrong.

The full mechanism — the two hash chains, how a receiver re-derives every row, and the dedup keys — is on the spine and replication.

A down node takes its private data with it

Because envelopes, coins, machines, pages and vault secrets never enter the wire, there is no read path around a node that is down. The mesh lets you find out where your state is — see your identity and your home node — not read it from somewhere else.

See the live nodes →

Explore​

How the fleet works

The named roster, and what a node actually is.

Your data across it

Finding your state, and moving it deliberately.

Naming & self-hosting

Names, transports, and joining as a peer.

The network APIs live in the reference.