Compute-hours

1\ \text{ZEQ} \;=\; H\ \text{Zeqonds of compute}, \qquad H = \frac{3600}{\tau_Z} = 4633.200000004633

One ZEQ is one CPU-hour, and the peg runs both ways: the consumer of compute burns D/H ZEQ for D Zeqonds of work, and the provider of that compute earns D/H ZEQ for the same D Zeqonds.

Symmetric by construction, not by convention

The burn side and the earn side are not two matching formulas that could drift apart. They are one function with two names:

/** ZEQ cost to CONSUME `z` Zeqonds of compute. cost = z / H. */
export function zeqForComputeZeqonds(z: number): number {
  if (!Number.isFinite(z) || z <= 0) return 0;
  return z / ZEQONDS_PER_ZEQ;
}

/** ZEQ EARNED for CONTRIBUTING `z` Zeqonds of sealed compute. The SAME rate as the burn. */
export const zeqEarnedForComputeZeqonds = zeqForComputeZeqonds;

shared/api-core/src/lib/zeqTimeMeter.ts. earn(z) === cost(z) bit-for-bit for every duration, because it is literally one function assigned twice.

H is derived, never typed. ZEQONDS_PER_HOUR = 3600 / TAU_ZQ, and the hour is only a human-facing scale — everything underneath is Zeqond-native. If the Zeqond ever moves, the peg moves with it.

The source comment on that line reads ≈ 4633.18. The evaluated value is 4633.200000004633; the comment is stale. The constant is right, the annotation is not, and the same 4633.18 has been copied into at least one design document. Use the derived value.

Exact, at planck resolution

Whole-ZEQ division would floor a sub-hour contributor to zero, so the earn/cost path also has a BigInt form that carries the fraction exactly. H is expanded as a rational so nothing rounds through a float:

\text{plancks} \;=\; \frac{mz \times 777{,}000{,}777 \times 10^{43}}{3.6\times10^{15}}

mz is millizeqonds — the framework's integer compute-time unit, as recorded in agent_sandbox_runs.duration_mz. The denominator is 1000 × 3600 × 10^9.

Measured against the repo's own functions:

Duration	Cost (ZEQ)	Earn (ZEQ)	Equal	Whole ZEQ
1 Zeqond	0.00021583	0.00021583	yes	0
60 Zeqonds	0.01295001	0.01295001	yes	0
4,633 Zeqonds	0.99995683	0.99995683	yes	0
4,633.2 Zeqonds	1	1	yes	1
50,000 Zeqonds	10.7916775	10.7916775	yes	10

The threshold that actually binds

A contributor must supply ⌈H⌉ = 4,634 Zeqonds of sealed compute inside one settlement window to earn a whole ZEQ. The settlement window is itself SETTLEMENT_WINDOW_Z = ZEQONDS_PER_HOUR — about an hour. Below that, the exact fraction still accrues in bi_accrued_quanta and rolls over; it does not round to zero.

Against that: the agent sandbox enforces a hard per-agent daily cap of 60,000 millizeqonds = 60 Zeqonds, plus 20 runs a day. So one agent's entire daily allowance is 1.3% of what a single whole coin costs. This is why the live network shows distributed: 0, nodes: 0 in every settlement window — see issuance. The peg is not the blocker; the sandbox cap is.

Seat tiers — one price, hours per cycle

ECON v5 (2026-09-04) replaced the published-prose ladder with one enforced number. GET /api/pricing/tiers returns the price block and the tier table; nothing on this page is quoted from prose any more.

Tier	Per seat per month	Hours per cycle	Zeqonds
Starter	$29	9.764	45,238
Builder	$79	26.599	123,239
Advanced	$199	67.003	310,438
Architect	$499	168.013	778,438

Hours per cycle = seat price ÷ ** $2.97 per compute-hour** (cost basis$ 1.98 × 1.5). The hours are bonded in the wallet for the 30-day cycle (3,335,904 Zeqonds), burn first as you compute, and expire at cycle end; the next payment tops the bond up. After expiry there are 7 days of grace (778,378 Zeqonds) before the plan mirror falls back to Free. The full statement is on Compute credits.

AI is strictly BYOK

Compute-hours meter the framework's own physics compute — the seven-step wizard, the solvers, the sealed sandbox runs. They do not meter, subsidise or convert into model inference. You attach your own provider credential; the platform stores it in the ZSC vault and never funds a token of inference from the pool.

Where compute-hours meet the coin

One bridge, one direction. 1 ZEQ coin = 1 compute-hour by the peg, and the only way a coin becomes hours is POST /api/credits/from-coin { zeq }: the coin is burned (issued supply falls) and the same number of hours is credited — with bond_tier it lands as a 30-day cycle bond instead. There is no credits-to-coin path: coins are only earned by contributed CPU (one coin per CPU-hour), never sold and never minted for a payment.

Constants on this page

Constant	Value	Source
`ZEQONDS_PER_HOUR` (H)	4633.200000004633	`zeqTimeMeter.ts` = 3600 / τ_Z
`ZEQONDS_PER_ZEQ`	= `ZEQONDS_PER_HOUR`	`zeqTimeMeter.ts` (the peg dial)
`TAU_ZQ` (τ_Z)	0.777000777 s	`zeq-kernel-constants.ts`
`ZEQ_COIN_QUANTA`	10⁴³ plancks	`zeqTimeMeter.ts`, pinned to `PLANCKS_PER_ZEQ`
`SETTLEMENT_WINDOW_Z`	4633.200000004633 Zeqonds	`nodeDistribution.ts`
`usd_per_hour`	2.97 = 1.98 × (1 + 0.5)	`domain_economy_config`, live `GET /api/pricing/tiers`
`CYCLE_ZEQONDS`	3,335,904 (30 days)	`cycleBondMath.ts`
`GRACE_ZEQONDS`	778,378 (7 days)	`cycleBondMath.ts`
Sandbox daily cap	60,000 mz = 60 Zeqonds, 20 runs	`agentSandbox.ts`

Symmetric by construction, not by convention​

Exact, at planck resolution​

The threshold that actually binds​

Seat tiers — one price, hours per cycle​

AI is strictly BYOK​

Where compute-hours meet the coin​

Constants on this page​

Read next​