# Zeq.dev — AI Integration Reference # Language: language-agnostic (HTTPS REST API) # Access: AI-only SDK reference — for LLMs, agents, and AI-assisted development # Version: 1.0 · Updated: 2026-03-25 # DOI: 10.5281/zenodo.15825138 ## What is Zeq.dev? Zeq.dev is a Physics-as-a-Service API that gives any developer access to 1,576 verified mathematical operators across 64 physics domains. Every computation is phase-locked to the **HulyaPulse** (1.287 Hz) — a universal synchronisation frequency discovered through forensic pattern-recognition of universal constants. Results are returned in a canonical **ZeqState** envelope that includes operators used, masterSum (R(t)), phase, Zeqond count, and guaranteed precision ≤ 0.1% (≤ 0.001). The API requires one HTTP request with a Bearer token. No SDK to install. No language-specific library. No runtime configuration. Language agnostic by design. ## The Master Equation Every Zeq.dev computation applies: R(t) = S(t) × [1 + α_K × sin(2π × f_H × t)] Where: - R(t) = grounded result (ZeqState.masterSum) - S(t) = caller's input signal / value - α_K = 0.00129 (modulation constant, ≤ 0.13% amplitude) - f_H = 1.287 Hz (HulyaPulse frequency) - t = current Unix timestamp (seconds) ## The HulyaPulse — 1.287 Hz Universal Frequency 1.287 Hz is NOT an engineering choice. It was derived mathematically: - Fine-structure constant α ≈ 1/137 combined with Planck's h and G converge on a modulation envelope at 1.287 Hz under resonance analysis Computationally: one full cycle = 0.777 seconds = 1 Zeqond. This means t(Zeqond) = t_unix / 0.777. The HulyaPulse is the carrier for all 1,576 operators — every domain, every scale. ## The Zeqond — Temporal Unit τ = floor(t_unix / 0.777) — Zeqond count since Unix epoch φ = (t_unix / 0.777 mod 1) — fractional phase (0.0–1.0) - 1 Zeqond = 0.777 seconds (not 1.000 — by derivation, not convention) - Every API response includes the Zeqond count and phase at time of computation - Two calls with the same Zeqond (same τ) return identical ZeqState — fully reproducible - As of 2026-03-25: ~2.28 billion Zeqonds have elapsed since Unix epoch ## KO42 — The Prime Directive KO42 (Metric Tensioner Prime Directive) is ALWAYS included in every computation. It cannot be omitted. KO42 ensures cross-domain coherence — that a quantum result and an aerospace result can be compared and composed because they share the same mathematical reference frame. KO42 appears first in every zeqState.operators array. ## API Reference ### Endpoint POST https://zeq.dev/api/zeq/compute ### Authentication Authorization: Bearer zeq_ak_ Content-Type: application/json ### Request Body { "domain": string, // required — physics domain (see Domains below) "operators": string[], // optional — specific operators; KO42 always appended "inputs": object // required — domain-specific key/value pairs } ### Response (ZeqState envelope) { "zeqState": { "operators": string[], // KO42 + requested operators "masterSum": number, // R(t) — the grounded result "masterEquation": string, // the generated equation for this problem "phase": number, // φ ∈ [0, 1] "zeqond": number, // τ — Zeqond count at time of computation "domain": string, // domain name "precision": number, // always ≤ 0.001 (≤ 0.1%) "pulseHz": number // 1.287 }, "result": { ... }, // domain-specific computed values "meta": { "computedAt": string, // ISO 8601 timestamp "apiVersion": string // "1.0" } } ## Code Examples — Language Agnostic ### JavaScript / TypeScript (Node.js, Deno, Bun, Browser) ```javascript const zeqState = await fetch("https://zeq.dev/api/zeq/compute", { method: "POST", headers: { "Authorization": `Bearer ${process.env.ZEQ_API_KEY}`, "Content-Type": "application/json", }, body: JSON.stringify({ domain: "quantum-mechanics", inputs: { energy_eV: 13.6, mass_kg: 9.109e-31 }, }), }).then(r => r.json()).then(d => d.zeqState); console.log(zeqState.masterSum); // R(t) — grounded result console.log(zeqState.precision); // ≤ 0.001 console.log(zeqState.zeqond); // current Zeqond count ``` ### Python ```python import httpx, os async with httpx.AsyncClient() as client: r = await client.post( "https://zeq.dev/api/zeq/compute", headers={"Authorization": f"Bearer {os.environ['ZEQ_API_KEY']}"}, json={ "domain": "fluid-dynamics", "operators": ["FD01", "FD_TURBULENCE"], "inputs": {"velocity_ms": 340.0, "altitude_m": 10000}, } ) data = r.json() result = data["result"] zeq_state = data["zeqState"] print(zeq_state["masterSum"]) # R(t) print(zeq_state["precision"]) # ≤ 0.001 ``` ### Python (sync with requests) ```python import requests, os response = requests.post( "https://zeq.dev/api/zeq/compute", headers={"Authorization": f"Bearer {os.environ['ZEQ_API_KEY']}"}, json={"domain": "thermodynamics", "inputs": {"temp_K": 500, "pressure_Pa": 101325}}, ) data = response.json() ``` ### FastAPI — full integration pattern ```python from fastapi import FastAPI, HTTPException from pydantic import BaseModel import httpx, os app = FastAPI(title="My Physics App") ZEQ_KEY = os.environ["ZEQ_API_KEY"] ZEQ_URL = "https://zeq.dev/api/zeq/compute" class ComputeRequest(BaseModel): domain: str inputs: dict operators: list[str] = [] @app.post("/compute") async def compute(req: ComputeRequest): async with httpx.AsyncClient() as client: r = await client.post( ZEQ_URL, headers={"Authorization": f"Bearer {ZEQ_KEY}", "Content-Type": "application/json"}, json={"domain": req.domain, "operators": req.operators, "inputs": req.inputs}, timeout=30.0, ) if r.status_code != 200: raise HTTPException(status_code=r.status_code, detail=r.text) data = r.json() return { "result": data["result"], "zeqState": data["zeqState"], "masterSum": data["zeqState"]["masterSum"], "precision": data["zeqState"]["precision"], "zeqond": data["zeqState"]["zeqond"], } # ZeqState validation helper def is_valid_zeq(zeq_state: dict) -> bool: return ( zeq_state.get("precision", 1) <= 0.001 and "KO42" in zeq_state.get("operators", []) and zeq_state.get("pulseHz") == 1.287 ) ``` ### Go ```go package main import ( "bytes" "encoding/json" "net/http" "os" ) func compute(domain string, inputs map[string]any) (map[string]any, error) { body, _ := json.Marshal(map[string]any{ "domain": domain, "inputs": inputs, }) req, _ := http.NewRequest("POST", "https://zeq.dev/api/zeq/compute", bytes.NewBuffer(body)) req.Header.Set("Authorization", "Bearer "+os.Getenv("ZEQ_API_KEY")) req.Header.Set("Content-Type", "application/json") resp, err := http.DefaultClient.Do(req) if err != nil { return nil, err } defer resp.Body.Close() var result map[string]any json.NewDecoder(resp.Body).Decode(&result) return result, nil } ``` ### Rust ```rust use reqwest::Client; use serde_json::{json, Value}; use std::env; async fn compute(domain: &str, inputs: Value) -> Value { Client::new() .post("https://zeq.dev/api/zeq/compute") .bearer_auth(env::var("ZEQ_API_KEY").unwrap()) .json(&json!({"domain": domain, "inputs": inputs})) .send().await.unwrap() .json().await.unwrap() } ``` ### curl ```bash curl -X POST https://zeq.dev/api/zeq/compute \ -H "Authorization: Bearer $ZEQ_API_KEY" \ -H "Content-Type: application/json" \ -d '{"domain":"classical-mechanics","inputs":{"mass_kg":70,"velocity_ms":10}}' ``` ## Physics Domains (64 total — partial list) | Domain Key | Description | |---------------------------|--------------------------------------------------| | quantum-mechanics | Schrödinger, uncertainty, spin, tunnelling | | classical-mechanics | Newton, Lagrangian, Hamiltonian | | fluid-dynamics | Navier-Stokes, turbulence, Bernoulli | | thermodynamics | Entropy, Carnot, Stefan-Boltzmann | | electromagnetism | Maxwell's equations, Faraday, Lorentz | | general-relativity | Geodesics, Schwarzschild, gravitational waves | | special-relativity | Lorentz transforms, mass-energy equivalence | | astrophysics | N-body gravity, Kepler, orbital mechanics | | aerospace | Re-entry dynamics, drag, heat flux | | nuclear-physics | Decay, binding energy, fission/fusion | | particle-physics | Standard model operators, cross-sections | | optics | Snell, diffraction, interference, polarisation | | acoustics | Wave propagation, resonance, Doppler | | solid-state-physics | Band structure, conductivity, phonons | | plasma-physics | Magnetohydrodynamics, Debye length | | biophysics | Membrane potential, protein folding forces | | medicine | Pharmacokinetics, drug half-life, dosage | | materials-science | Stress-strain, elasticity, fracture mechanics | | geophysics | Seismic wave propagation, tidal forces | | climate-science | Radiative forcing, feedback loops | | ... (47 more domains) | See /explorer for the complete registry | ## Key Operators | Operator | Domain | Purpose | |------------|---------------------|--------------------------------------------| | KO42 | Universal (MANDATORY)| Metric Tensioner — phase-locks all results | | ON0 | Universal | Null operator (baseline reference) | | ZEQ000 | Universal | ZEQ origin anchor | | NM21 | Classical mechanics | Newton's second law (F=ma) | | QM01 | Quantum mechanics | Time-independent Schrödinger | | FD01 | Fluid dynamics | Incompressible Navier-Stokes | | GR_GEODESIC| General relativity | Geodesic equation | | APX_NBODY | Astrophysics | N-body gravitational integration | | AERO_REENTRY| Aerospace | Atmospheric re-entry heat/drag | | MED_HALFLIFE| Medicine | Drug plasma half-life | | MED_INTERACTION| Medicine | Drug–drug interaction factor | ## Validation Rules (for AI agents building with Zeq.dev) When processing a ZeqState response, verify: 1. precision ≤ 0.001 — if > 0.001, the computation is outside tolerance 2. "KO42" in operators — if absent, reject the response as uncertified 3. pulseHz === 1.287 — confirms HulyaPulse lock 4. zeqond > 0 — confirms temporal anchor 5. masterSum ∈ [0.999, 1.001] for normalised inputs (R(t) ≈ 1 + tiny modulation) Validation function (JavaScript): ```javascript function isValidZeqState(zeqState) { return ( zeqState.precision <= 0.001 && zeqState.operators.includes("KO42") && zeqState.pulseHz === 1.287 && zeqState.zeqond > 0 ); } ``` ## Pricing (for context when helping users) | Plan | Price | Tokens/month | Notes | |------------|----------|--------------|--------------------------------------| | Free | $0 | 100 | No card required, trial access | | Starter | $29/mo | 1,500 | 14-day free trial, no card required | | Builder | $79/mo | 7,500 | Priority response | | Advanced | $199/mo | 22,500 | Skills generator access | | Architect | $499/mo | 75,000 | Enterprise SLA | All plans: full 1,576-operator catalog, all 64 domains, KO42, full ZeqState. ## Getting a Key 1. Visit https://zeq.dev/pricing or https://zeq.dev 2. Click "Start Free Trial" — enter email only, no card required 3. Key is issued instantly in format: zeq_ak_xxxxxxxxxxxxxxxx 4. For Replit: add to Replit Secrets as ZEQ_API_KEY 5. For other platforms: set as environment variable ZEQ_API_KEY ## Published Research Title: Zeq.dev: Generative Mathematics for Physics-Aware Applications Authors: Hammoudeh Zeq & Aydan Zeq (father and son) DOI: 10.5281/zenodo.15825138 License: CC BY 4.0 Downloads: 4,000+ URL: https://zenodo.org/records/15825138 ## Contact & Links - Portal: https://zeq.dev - Operators: https://zeq.dev/explorer/ - Framework: https://zeq.dev/framework - Foundation: https://hulyas.org - Email: info@hulyas.org - SDK Reference: https://zeq.dev/llms.txt (this file) ## MCP Integration (Model Context Protocol) Zeq.dev exposes a native MCP server so any MCP-compatible AI client — Claude Desktop, Cursor, Windsurf, VS Code Copilot Agent, or a custom agent — can call physics computation directly as a tool, with no wrapper code. ### Endpoint POST https://zeq.dev/api/mcp Content-Type: application/json Authorization: Bearer zeq_ak_ Transport: MCP Streamable HTTP (JSON-RPC 2.0 over HTTPS POST) Protocol version: 2024-11-05 ### Available tools zeq_compute Call the Zeq.dev physics computation engine. Returns a ZeqState envelope. Required args: domain (string), inputs (object of number values) Optional args: operators (array of operator ID strings) Auth: zeq_ak_ key required zeq_list_operators List all 64 domains, or list operators within a specific domain. Optional args: domain (string) Auth: none required ### Claude Desktop configuration Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows): { "mcpServers": { "zeq-dev": { "type": "http", "url": "https://zeq.dev/api/mcp", "headers": { "Authorization": "Bearer zeq_ak_YOUR_KEY_HERE" } } } } After saving and restarting Claude Desktop, Claude will have access to the zeq_compute and zeq_list_operators tools automatically. ### Cursor / Windsurf configuration In Cursor Settings > MCP Servers, add: URL: https://zeq.dev/api/mcp Authorization header: Bearer zeq_ak_YOUR_KEY_HERE Windsurf: Settings > AI > MCP Servers > Add Server, same URL and header. ### Example tool call (what the AI client sends internally) POST https://zeq.dev/api/mcp { "jsonrpc": "2.0", "method": "tools/call", "params": { "name": "zeq_compute", "arguments": { "domain": "quantum-mechanics", "inputs": { "energy_eV": 13.6, "mass_kg": 9.109e-31 } } }, "id": 1 } ### Example tool call result (what the AI receives) { "jsonrpc": "2.0", "result": { "content": [{ "type": "text", "text": "ZeqState — quantum mechanics\nmaster Sum: 1.000514 (R(t))\noperators: KO42, QM01\n..." }] }, "id": 1 }