Zeq.dev is an open-source scientific computing framework — a deterministic physics kernel that binds NIST physical constants directly to the execution layer. Every computation is synchronized to a 1.287 Hz global clock and verified by the KO42 metric — eliminating floating-point drift across multi-domain simulations. It is not a simulation engine, not a physics calculator, and not an AI model. It is a generative mathematics compiler: you give it a problem, it assembles an equation that did not previously exist in that specific form, executes it, and returns a result verified to ≤0.1% against experimental data from NIST, NASA, and CERN. In practice: add ZEQ_API_KEY to your project's secrets, call POST /api/zeq/compute with a domain and inputs, and receive a full ZeqState envelope — operators applied, precision, phase, and the Zeqond timestamp — along with your result.

Any developer who needs verified physics in their project — simulation games, science apps, engineering tools, AI agents, educational platforms, or research code. You do not need a physics background. You supply the domain (e.g. quantum_mechanics) and the inputs (e.g. {"E": 13.6, "m": 9.11e-31}), and Zeq.dev selects the appropriate operators and returns a grounded result.

NumPy, SciPy, and Wolfram are libraries and lookup engines — they give you functions to apply to equations you already know. Zeq.dev does something fundamentally different: it is a generative mathematics compiler that assembles the equation from verified physics for you, executes it, and returns a result verified against NIST, NASA, and CERN experimental data. NumPy/SciPy also run in isolated reference frames — there is no shared clock binding results across domains. Zeq.dev is the first system where every computation across every physics domain is synchronized to a single mathematical clock: the 1.287 Hz HulyaPulse. Cross-domain results are composable because they share the same temporal foundation. Every result is reproducible at the exact same Zeqond timestamp. The shortest distinction: NumPy is a tool. Zeq.dev is middleware. You bring the problem; Zeq.dev brings the mathematics.

Yes. The 1.287 Hz HULYAS ZEQ Framework was published on Zenodo (DOI: 10.5281/zenodo.15825138) by Hammoudeh & Aydan Zeq in August 2025. Zenodo is operated by CERN. The paper has received 4,000+ downloads across 8 versions — exceptional for a physics preprint, where the median lifetime download count is approximately 150. The framework derives from a published mathematical proof. Every operator in the registry has a corresponding equation. Every computation carries its precision measurement.

Every Zeq.dev computation applies this equation: R(t) = S(t) × [1 + α × sin(2π × 1.287 × t)] Where R(t) is the grounded result, S(t) is your raw input signal, 1.287 Hz is the HulyaPulse frequency, and α = 0.00129 is the modulation constant (also written αK). The modulation grounds every result to the universal 1.287 Hz clock, ensuring cross-domain coherence. The precision is always ≤ 0.1%.

A Zeqond is a new temporal unit — exactly 0.777 seconds. It is derived from the 1.287 Hz HULYAS ZEQ Framework, not arbitrary convention. At 0.777 s, the Zeqond aligns perfectly with the 1.287 Hz HulyaPulse: one pulse every 0.777 s. Time and physics share the same clock. Every Zeq.dev response carries the current Zeqond count (zeqond) and phase (phase). Two calls at the same Zeqond always return the exact same result — phase-locked, reproducible, and auditable. The Zeqond count is simply: τ(t) = tunix / 0.777

1.287 Hz is the HulyaPulse frequency — the universal resonance frequency derived in the 1.287 Hz HULYAS ZEQ Framework paper. It is not an arbitrary constant. The proof in the Zenodo paper shows this frequency emerges from the mathematical structure of synchronized operator dynamics across quantum, relativistic, and classical regimes. The inverse of 1.287 Hz is approximately 0.777 seconds — which defines the Zeqond. The two constants are mathematically inseparable.

KO42 is the Metric Tensioner Prime Directive — the foundational operator that applies the master equation to every computation. It ensures cross-domain coherence: whether you call a quantum operator, a fluid dynamics operator, or an astrophysics operator, they all remain in the same mathematical reference frame. KO42 is always included in the operators list of every ZeqState response. You do not need to specify it — it is automatically applied. If KO42 is missing from a response, that result should be treated as invalid.

The operator registry contains 1,500+ catalogued operators across 65 physics domains, including quantum mechanics, thermodynamics, fluid dynamics, electromagnetism, astrophysics, nuclear physics, biomedical physics, aerospace, classical mechanics, general relativity, and more. Each operator has a unique ID, equation, domain assignment, and group classification (Core, Extended, Applied, Industry, or Frontier). You can browse the full registry in the Operator Explorer.

Create your machine at /auth/ — no credit card required — then mint a key in the Vault (Secrets → developer API key). You receive the full key exactly once; copy it immediately. The key does not expire and does not change when you subscribe. What a key can spend is your compute-hours: one free hour every 30 days, plus whatever you buy or earn.

All Zeq.dev API keys start with zeq_ak_ followed by 32 random characters. The prefix makes the key instantly identifiable in code, logs, and secret managers — so it is obvious where it belongs and difficult to accidentally expose alongside unrelated credentials.

Add it to your project's Secrets (the padlock icon in the left sidebar). Set the key name to ZEQ_API_KEY and paste your zeq_ak_… key as the value. Your code then accesses it via: process.env.ZEQ_API_KEY (Node.js) or os.environ["ZEQ_API_KEY"] (Python). Your key never lives in source code — it is injected at runtime by 's secrets system. Restart your process after setting the variable.

The full key is shown exactly once — immediately after you mint it, or after your subscription completes — in the portal. After you leave that page, only the masked prefix (zeq_ak_••••••••) is displayed. If you lose your key, go to your portal and use the key rotation feature to generate a new one. The old key is immediately invalidated. The new key is revealed once.

Every account gets one free compute-hour every 30 days — no credit card, no trial, nothing to claim, and it never expires into a lockout. You get the complete operator library across 65 physics domains and a real zeq_ak_ key, usable immediately. Beyond the free hour, buy hours at $2.97 or earn ZEQ by sharing your CPU (one coin per CPU-hour, and a coin burns into an hour). There is no other free compute beyond the small per-IP try budget.

No. There is no trial and nothing expires: your key stays valid, and it is your compute-hours that run out, not your access. Out of hours, a call returns 402 INSUFFICIENT_FUEL — top up at /pricing/, or earn ZEQ by sharing your CPU, and the same key keeps working.

Every tier pays the same price for an hour of compute — $2.97 (cost $1.98 + the Foundation's 50% margin) — so hours per cycle are simply the tier price ÷ the price of an hour, bonded for the cycle and burned as you compute: Starter — $29/mo · about 9.8 compute-hours a cycle Builder — $79/mo · about 26.6 hours Advanced — $199/mo · about 67 hours Architect — $499/mo · about 168 hours (live numbers at /pricing/) Enterprise — custom pricing, dedicated deployment All plans include access to the full operator library and every tier pays the same $2.97 an hour. Plans differ by how many hours the cycle bonds, and by machine, app and disk limits. See Pricing for details.

Compute is metered per Zeqond, not per call: a request to POST /api/zeq/compute is charged for the Zeqonds it actually ran, never less than one Zeqond (1/4,633 of an hour). It is drawn from this cycle's bonded hours first, then from hours you bought. There are no daily allowances and nothing resets at midnight. Your hours and this cycle's bond are shown in the Vault and at GET /api/tally/credits/:zid.

Yes. Cancel from your developer portal at any time. Your subscription remains active until the end of the current billing period. No questions asked, no retroactive charges.

Zeq.dev implements the Model Context Protocol (MCP) — a standard for connecting AI clients (like Claude Desktop, Cursor, or Windsurf) to external tools. Once connected, your AI client gains two native tools: zeq_compute (to run physics computations) and zeq_list_operators (to browse the operator library). Your AI can call them autonomously — no wrapper code needed. See MCP for full setup instructions and ready-to-paste config blocks.

The zeq_list_operators tool is public — it works without an API key and returns the full list of 65 physics domains and their operators. The zeq_compute tool requires a valid zeq_ak_ API key passed in the Authorization header. Without a key, compute requests return a 401 Unauthorized response.

Currently tested and documented: Claude Desktop, Cursor, and Windsurf. Any MCP-compatible client using JSON-RPC 2.0 over HTTPS (protocol v2024-11-05) will also work. See the MCP page for ready-to-paste configs for each client.

The full machine-readable API reference is at /llms.txt — structured for direct ingestion by LLMs and AI tools. It covers all endpoints, authentication, request/response schemas, and the ZeqState envelope definition.