Skip to main content

HulyaPulse and Zeqond

HulyaPulse — the 1.287 Hz system clock​

The HulyaPulse is the framework's 1.287 Hz system clock. Every protocol, every operator, every CKO is phase-locked to it.

The Zeqond is fixed exactly — the way the SI second is fixed by a count of caesium transitions:

1 Zeqond = τ = 777,000,777 ns   (exact)
f = 1/τ ≈ 1.287 Hz              (f·τ = 1 exactly in ℚ)

τ is the framework's time unit, and everything else is exact arithmetic on it — the phase, the modulation, the audit cadence, all derived from this one integer.

On the table

Is 1.287 Hz a constant of nature? We make no such claim. What we claim is what we can show: it is exact, it is shared by every computation, and it is load-bearing — the whole framework is built on it, and f·τ = 1 holds exactly. Whether a shared computational time base like this also reflects something in the physics is an open question we put on the table, not a conclusion we assert. Nothing hidden: read the constant, run the code, and judge for yourself.

Zeqond — the framework's native time unit​

The Zeqond is the period of the HulyaPulse: T_Z = τ = 0.777 s (display; 777,000,777 ns exactly). This is the page's one definitional anchor — everywhere else, durations are stated in Zeqonds and millizeqonds (1 mz = τ/1000).

Within one Zeqond:

  • Every operator evaluates exactly once.
  • Every composition is bounded by KO42.
  • Every CKO is signed and verifiable.

Across Zeqonds:

  • State is carried forward through the master equation's wave term.
  • Phase evolves deterministically by exact integer arithmetic on the millisecond clock: zeqond = floor(unix_ms / 777), phase = (unix_ms mod 777) / 777 ∈ [0,1), and phi_current = 2π · phase. This is the canonical formula the pulse and the audit chain share — computed, never received, so it never drifts and two nodes always agree on the tick.

Why 0.777 and not 1.0​

Fixing the tick at τ instead of one SI second has two effects:

  1. Phase math becomes exact. Multiples of τ produce phase values that live on a rational lattice (f·τ = 1 exactly). Common operations (averaging, quadrature, spectral decomposition) compose without drift.
  2. Unix time remains usable. We don't replace Unix time — we bridge it. ZTB1 is a lossless conversion. Any Unix timestamp can be mapped to a Zeqond count and back.

Practically, an agent running on the framework announces its phase every few messages or after any math step:

[Zeq tick] Zeqond 2292305743 — phase 0.412

This is the telemetry the Zeq skill emits by convention. It is a deterministic unit conversion of Unix time — computed, not received; there is no synchronization event.

Using it from the SDK​

You rarely need to touch the clock directly — the SDK computes it for you. When you do:

import { zeqond } from "@zeq/sdk";

zeqond.now();           // current Zeqond count
zeqond.phase();         // current phase in [0, 1)
zeqond.toUnix(z);       // convert Zeqond count to Unix seconds
zeqond.fromUnix(t);     // convert Unix seconds to Zeqond count

Every SDK response includes a zeqond_at field recording the exact Zeqond when the computation was executed on the hosted API. That value is part of the CKO signature.

Hosted clock service​

The paid hosted API runs the authoritative HulyaPulse at our edge. Clients can self-host a Zeqond service (it's a single loop — see Operate → Self-hosting), but hosted customers get:

  • Signed Zeqond attestations. A signed tuple (zeqond_count, t_unix, phi, sig) you can include in downstream CKOs.
  • Consistent server time. The hosted edge derives the Zeqond from the same integer-ns formula on a time-synchronised host, so a signed attestation reflects the server's wall clock at execution. (There is no separate "atomic-reference drift" measurement — the Zeqond is a deterministic unit conversion of Unix time, not an independent oscillator that could drift.)
  • Network-agnostic phase. Because phase is a pure function of the timestamp, two clients that agree on the Unix time for a Zeqond compute the same phase for it.

If you self-host for offline work, that's fine — the framework runs standalone. For multi-party attestation, use the hosted service.