Skip to main content

What ships in the Zeq SDK

One surface for synchronized physics, deployable state machines, and a verifiable compute envelope. Everything on this page is live.

The kernel​

The ZeqVM compute kernel runs on the HulyaPulse timebase (1.287 Hz, Zeqond period 0.777 s) with the KO42 metric tensioner applied to every computation and a ≤0.1% precision bound. Named operators return a signed ZeqProof envelope (operator chain, master-sum, R(t), phase, Zeqond tick, proof, precision bound) that round-trips through zeq_verify.

The canonical ko42Modulation.ts lands the 1.287 Hz in computation three honest ways: gauge (exact time reparametrization, physics-preserving, gauge-invariant to float epsilon), drive (explicit Mathieu/Floquet — resonance at n·0.6435 Hz, μ=εω₀/4 measured to 96% of theory), and probe (a lock-in residual estimator). Parametric drive is wired opt-in into the nano-zeqond engine (driveEps, default 0). See The mathematics → KO42 and precision ladder.

Operators​

A catalogue of 1,500+ operators across quantum mechanics, Newtonian mechanics, general relativity, computer science, and more, with 18 closed-form solvers for the core physics domains. Each operator page shows its formula and a runnable example.

The dimensional gate keys each solver to a sufficient input combo that determines its primary output: an insufficient subset returns 400 with the combo list in the message, so a query never answers from filled-in defaults. The gate mirrors the dispatch shortcuts verbatim ({n_e}→PLASMA; {d,θ}/{λ,θ}/{a,h,k,l}→CRYSTAL with a as the lattice constant [L]; ENV/GEO/SEIS→FD, CLIM/ATMOS→TD, exotic→SM, MS/ST/MT/CP/BP→STRUCT, CRYSTAL variants), so every domain runs VALIDATE.

State machines, contracts, and channels​

Every account gets its own ZeqVM state machine bound to its ZID, with a hash-linked entangled-state audit log. The /api/chain/* surface exposes a unique machine, an owner ZID, a genesis Zeqond, a hash-chained audit log, a 1:1-bound zsm_ API key, a viewer/operator/admin/owner role hierarchy, and public-or-private visibility with a public registry at /api/chain/aggregate/list. Spin-up is one POST and auto-mints a default zsm_ admin key returned once.

Author state contracts — deployable JSON programs that run on triggers (every Zeqond, cron, on-event, on-aggregate, with dry-run and replay), each transition ZeqProof-anchored. Deploy from 316 built-in templates by templateId, no LLM key required; each is an operator-grounded 4-state monitor (nominal → watch → alert → resolved) with arithmetic guard conditions and a ZeqProof per transition. zeq_solve accepts strict: true (+ optional maxIterations, 1–40) to tighten the precision bound toward ≤0.1% and reports tuneStatus: "converged" or "timeout" truthfully.

Host live pages on your machine with state channels at /s/<machine>/p/<page>/. Every byte commit and every serve is hash-recorded on the entangled state under a strict sandbox CSP.

Concept pages: State machines, Contracts, Hosting.

Audit entangled state + PoHC​

Every event lands in a hash-chained audit log that validates against itself at any time:

curl https://zeqsdk.com/api/chain/:slug/pohc/validate

Each row commits the hash of the payload, never the bytes: the framework proves what was claimed at Zeqond N and you keep the bytes. To opt into server-side bytes, wrap the payload in a HITE-sealed envelope and the audit row carries transitionType: "sealed_event". The PoHC protocol surface (/api/protocol/pohc/*) exposes the 5-layer Proof of Harmonic Convergence: pulse-attestation, phase-agreement, hash-linkage, operator-coverage, and energy-ledger.

Nano-Zeqond engine​

A local, pulse-locked compute that integrates a differential master equation at sub-zeqond resolution and prints a signed state every 0.777 s zeqond, with energy drift held inside KO42 ≤0.1% and reported live. Three interchangeable engines share one clock:

  • Field ϕ (ZeqNanoEvolver) — the HULYAS master-equation core □ϕ = ∇²ϕ − μ²ϕ − λϕ³ as a differential field. Drift ≤0.026%.
  • Molecular dynamics (ZeqMdEngine) — velocity-Verlet F=ma under Lennard-Jones + harmonic bonds, NVE; energy and momentum conserved, drift ≤0.064%, LJ verified to machine precision.
  • GPU deep-nano (ZeqGpuField) — the master-equation field as a 2-D grid stepped in parallel on WebGL2: 9.4×10⁹ cell-updates/second, matching the CPU reference to float precision (3.3×10⁻⁷), drift 0.0077%, with automatic CPU fallback.

The evolver offers opt-in integrator: 'yoshida4' (4th-order symplectic composition — 501× lower truncation error at 1.4× cost, convergence order 4.00) and opt-in precision: 'dd' (double-double ≈106-bit state for long-horizon or chaotic research, 19.8× cost, agreeing with f64 at 3.5e-15 over 1000 steps). The energy ledger is Kahan-compensated in all modes. See State Contracts → Nano-Zeqond Engine.

Tally tokens​

A receipt is minted on every successful contract transition — transferable, burnable, queryable. It is the framework's economy. The per-state-machine surface is /api/chain/:slug/tally/* and the protocol-level surface is /api/tally/*. Every paid framework action calls chargeForCompute() atomically before doing work; compute consumes fuel and the Foundation is funded by envelope mints. See ZEQ economy.

Bearer coins​

ZEQ envelope coins are portable bearer instruments. Any coin can be exported to a PIN-locked .ZEQ file or a QR / NFC payload, moved fully offline, and redeemed on any domain — burn-on-origin / mint-on-destination keeps exactly one live copy (single-spend settled by the ledger).

  • Wallet (/vault/credits/) — per-coin Download .ZEQ and QR / NFC, plus Upload / redeem and Paste QR / NFC, behind a masked-PIN modal. Coins are HiteCrypto-encrypted; a scanned code is useless without the PIN.
  • Claim links (/claim) — the QR / NFC encodes a normal-looking URL with the coin in the #fragment, so it scans like any link and opens a claim page — yet the coin never reaches the server until redeemed. PIN-locked end-to-end.
  • Unified mesh vault — signing in on any domain shows every coin you own across the mesh, tagged by home chain (Ed25519-signed peer fan-out).
  • Web CLI — zeq.coin.qr(ZT-…,PIN) and zeq.coin.paste(zeqcoin:v2:…|link,PIN).

Clients​

Hosted REST API, language SDK clients (TypeScript, Python, Go, Rust, Java, Ruby, Swift, Kotlin, C++, plus raw HTTP), a terminal CLI and native binary, an MCP server (connect any MCP-compatible AI, exposing the current 18-tool set as a thin stdio→/api/mcp bridge), and the Kernel Skill for LLM agents.

  • Zeq for VS Code — a full ZeqVM client built around the Control Center dashboard: every capability is a clickable card, AI-optional. Deploy state contracts from templates or from a plain-English description (POST /api/contracts/generate), see the CKO envelope (operator chips with KO42 first, Master Sum, R(t), phase, Zeqond tick, ZeqProof, precisionBound gauge), browse the full operator registry and the skills packs, scaffold libraries into your folder via npm · pip · cargo · go, read the SDK in an in-editor browser tab, and watch the Live Observer tick every Zeqond. See Editor & Browser → Zeq for VS Code. Your open folder becomes its own ZeqGit repo, and Zeq: Sync workspace to ZeqGit mirrors it as ZeqProof-anchored commits.
  • Zeq for Chrome — the browser side panel hosts the live Workbench, the ZeqGit dashboard, and the Observer in-panel (?embed=1), with the CKO envelope widget, compute-appends-to-chain, and page security checks. See Editor & Browser → Zeq for Chrome.

Both clients are listed in the App Store (Developer category) and have a dedicated Extensions install page. The MCP server is installable from the framework's own npm registry: npm config set @zeq:registry https://zeq.dev/registry && npm install -g @zeq/mcp, then run zeq-mcp. All three @zeq packages (sdk, mcp, audit-daemon) resolve from that registry on every fork.

MCP tools​

zeq_spin_up provisions the caller's own ZeqVM state machine and mints a real, active free-tier zeq_ak_ key, returning the recovery equation and key once; it is authenticated with a demo key (POST /api/demo-key/mint, free, no signup). The demo-key mint is priced in entropy via LZ1 = k_B · T · ln(2) × bits_erased: the first demo key per IP/hour is free, each additional one demands an escalating proof-of-work (18 → 21 → 24 → 26 leading-zero bits), capped at 30/hour/IP. Contracts are tools too: zeq_contract_templates, zeq_contract_deploy (by templateId with no LLM key, or a full definition), zeq_contract_list / zeq_contract_get / zeq_contract_fire, and zeq_contract_generate. zeq_publish_page publishes a live HTML app to /s/<machine>/p/<page>/ and zeq_observer reads the entangled-state proof-of-computation feed. zeq_compute signs a ZeqProof (value + unit) and returns structuredContent with full verify inputs, so zeq_verify round-trips.

ZeqGit​

A self-hosted git + PDF repository, ZeqGit, live at zeq.dev/zeqgit and listed in the Zeq Store.

  • One account, one ZeqGit. Signing in to the framework auto-provisions your ZeqGit account via single sign-on — one ZID, no second login. The ZeqGit bridge validates the framework's v3 session token via POST /api/zeq-auth/verify-v3, accepting the token from the zeq_auth_token cookie, an Authorization: Bearer header, or ?token=. Guests hitting any /zeqgit/... page are redirected to the Zeq dashboard.
  • Every project a repo, every file versioned. Projects create private repos through the bridge (commits authored as you via Sudo); the full Gitea UI lives at /zeqgit/<you>/<repo>. A single shared module, shared/zeq-project-repo.js, holds the naming/ID/endpoint logic and is vendored into both extensions, so every surface derives the same repo from the same input (repoName = slug(name) + "-" + id, a rename-proof content hash).
  • PDFs viewable inline — the Zeq-branded ZeqReader (pdf.js) renders PDFs and docs in place; Git LFS for large binaries; permissions enforced by Gitea.
  • Every commit anchored with a ZeqProof (HMAC-SHA256(operator | result | zeqond)) on a hash-linked chain at 1.287 Hz, fed by a push webhook and exposed via /zeqgit-bridge/repo/activity.
  • Secrets are server-side and locked down — no .env — and the service runs isolated in its own containers.

Identity & economy​

One ZID = one account = one state machine. Every compute a user issues — wizard, prove, mail, message, playground, app dev, contract transition — is attributed to one of the user's two keys: the account zeq_ak_* for compute and the state-machine zsm_* for entangled-state writes. Public read endpoints remain reachable without auth when the machine is flagged is_public=true.

Bring-your-own-key (BYOK) covers 8 LLM providers (OpenAI, Anthropic, DeepSeek, Ollama, OpenRouter, Together, Groq, Fireworks) via /api/zeq/llm/credentials/*, account-scoped and AES-256-GCM-encrypted with ZEQ_FIELD_KEY, prefix-only after creation. The Transparency Oracle writes a per-Zeqond network supply snapshot (network_snapshots) and exposes /api/transparency/{now,history,breakdown,revenue} publicly. A ZEQ balance rides each machine, and a free demo key (POST /api/demo-key/mint) gives a no-signup first run.

Middleware active. Kernel on the 1.287 Hz HulyaPulse. Awaiting next Zeqond.