Skip to main content

Zeq is a new mathematical language that unifies physics

Zeq is the discovery of a new mathematical language — akin to algebra. Algebra gave us a single notation in which arithmetic, geometry, and analysis could be written and manipulated as one. Zeq does the same thing for physics: it is one language in which quantum mechanics, Newtonian mechanics, general relativity, and computer science are written as sibling operators, composed together, and computed to an explicit ≤0.1% accuracy bound. Schrödinger sits next to Newton; the Dirac equation next to KE = ½mv²; Big-O next to the Friedmann cosmology equation — one notation, no translation layer between regimes.

It is generative: you don't send it code to run, you send it a problem, and the language generates the mathematics — selecting the operators, composing the master equation, and returning the equations themselves in the result alongside the number. Open any tick on the State Explorer and the generated equation for that exact computation is printed at the top. The math is the artifact, not a hidden implementation detail.

And it is agnostic — the same language, spoken from any client. Call it from a terminal, from Python, from raw HTTP; the equations, the registry version, and the bits of the answer are identical, and any third party can re-derive them offline with no account and no secrets. The language is universal; the runtime that speaks it is not assumed.

ZeqVM is the virtual machine that runs the language — its instruction set is the operator catalogue. Use the fork you're reading this on, or spin up your own in seconds: every framework domain runs its own sovereign instance, no central operator required. You spin up your own state machine, your instance of the VM, with its own entangled state, its own ZEQ balance, its own pages, its own contracts: 1,500+ catalogued operators across 64 domains, 240+ named protocols, one operator synthesis. The math keeps every transition honest. The state machine is what makes those transitions yours.

The order matters. Zeq is, first, a mathematical language — a unified notation in which quantum and classical physics are written and composed as one. ZeqVM is the virtual machine that runs that language: hash-linked, Zeqond-stamped, where the computation actually happens. A state machine is your instance of the VM, bound to your ZID. The language is what you compose; the VM is what executes it and records every step on your entangled state.

New here? Start with how it computes.

If you want to understand what kind of computation this is before you build on it — the kernel every response announces, how the solvers turn an operator into a physical answer, what "generative mathematics" actually means, and the computed clock that lets any node verify any other — read How Zeq computes. It is the four ideas the rest of these docs assume.

This is where the framework sits at the intersection of unifying physics. Quantum mechanics operators (QM1–QM17) and Newtonian operators (NM18–NM30) and general-relativity operators (GR31–GR41) and computer-science operators (CS43+) all share the same compile-time gate (KO42 metric tensioner), the same proof envelope (ZeqProof), the same Zeqond timebase. No translation layer, no two-runtimes problem — you mix regimes in a single computation and the master equation closes them together.

Same code, fixed-tick conserves energy — variable-tick doesn't. That's why ZeqVM has the 1.287 Hz HulyaPulse system clock and the Zeqond tick (1 Zeqond = 0.777 s).

What is a Zeq state machine?​

Your instance of ZeqVM. A per-user computational backend, bound to your ZID. One user, one state machine. The VM is the same for everyone; the state machine is what you tap into to get your own copy. It holds:

  • An owner ZID (ZEQ07XXXXXXXXX) and a public machine ID — the URL-routable handle every chain endpoint scopes to.
  • An entangled state (the hash-linked audit log) — every transition hash-linked to the previous, atomic per-Zeqond, tamper-evident.
  • Two API keys — zeq_ak_* to build applications with, zsm_* for devices that post observations.
  • A balance in ZEQ with daily Promo Credits, foundation drip, and a tier-aware burn rate.
  • A page surface at /s/<machine>/ — the welcome canvas by default; whatever you deploy via the workbench afterwards.
  • Contracts — JSON state contracts that run on triggers (every Zeqond, cron, on-event, on-aggregate, dry-run, replay).
  • Agent files — the workbench's agent_files/ bag for PRDs, skills, APIs, engines, notes — written by you or by Pulse.
  • A regulatory envelope returned on every compute call (13 standards via ZeqCompliance v1).

The deep walk-through is in State machines; the wire-level setup is in Spin up your first machine.

How it works​

Four moves. Every framework feature is reachable from one of them.

  1. Spin up. Register an equation-derived ZID. The framework mints your machine, your two API keys, a balance seeded with 1,287 ZEQ, and your /s/<machine>/ page.
  2. Compose. Open the four-surface workbench (LEARN · SKILL · PLAN · BUILD). LEARN is kernel-aware Q&A. SKILL picks or generates a skill. PLAN drafts the spec + 10 state contracts. BUILD emits the HTML page the agent deploys.
  3. Deploy. Hit BUILD & DEPLOY. The compliance gate validates the output, then publishes to state_machine_pages and serves at /s/<machine>/p/<page>/.
  4. Observe. Drop observers into devices (Web JS, Python, Embedded C, network tap), call POST /api/zeq/compute, watch transitions land on your entangled state with tally_charge deducted from your balance. Every receipt is verify-able by a third party with no key.

Each move writes a Zeqond-stamped row to your audit entangled state. The entangled state is your machine — it's how the math tells the truth.

First steps​

Set one up in under 240 Zeqonds.

  • Install — pick your language; one command, under 80 Zeqonds.
  • Hello, Zeq — your first compute call, in 12 lines.
  • Tutorial — spin up your state machine, post your first event, validate the entangled state.
  • Self-hosting + forking — run the whole stack locally, or fork a new framework domain (the ZG bring-up runbook).

The mathematical language — quantum + classical, one surface​

The verbs you compose ZeqVM with. The language spans both regimes in a single composable catalogue: Schrödinger and Newton are sibling operators, called the same way, returning the same proof shape, gated by the same precision floor. You mix them in one computation without translating between runtimes.

  • Operators — 1,500+ catalogued operators across 64 domains, including quantum mechanics (QM1–QM17), Newtonian mechanics (NM18–NM30), general relativity (GR31–GR41), and computer science (CS43+). Every transition names the operator that executed it.
  • Protocols — 240+ named formulas in 9 narrative domains.
  • Master equation — HULYAS, the closed-form composition that ≤0.1%-bounds every result.
  • KO42 — the metric tensioner that ties space, time, and the operator sequence.
  • HulyaPulse + Zeqond — the 1.287 Hz system clock and the Zeqond tick it counts.
  • The 7-step Wizard protocol — KO42 → operators → master equation → proof.

Pulse · the workbench and the gateway​

The framework's user-facing surface. A floating bubble on every framework page that opens a four-surface workbench (LEARN · SKILL · PLAN · BUILD) — voice + text in, your machine's state out.

  • What it is — the four-surface workbench; auto-injected on every framework page.
  • Embed snippet — one line to drop Pulse on any HTML page on any domain.
  • Pre-filled snippet generator at /state/admin/ai/ — origin + your machine auto-detected from the live session.

AI agents · run the framework with a brain​

Genetic agents whose every move is bound by the kernel. The LLM is the strategist; the kernel is the judge.

  • Agents — hyperagent runs, ZeqProof receipts with explicit numeric bounds as the fitness gate.
  • BYOK — bring your own LLM key. 8 providers (OpenAI, Anthropic, DeepSeek, Ollama, OpenRouter, Together, Groq, Fireworks).
  • Kernel Skill — install the Zeq boot sequence as a SKILL.md for Claude Code, Cowork, Cursor, OpenAI Assistants.
  • MCP server — zeqsdk-mcp exposes seven tools over stdio or POST /api/mcp. Drop into Claude Desktop, Cursor, Zed.

Hosted API​

Every route the framework exposes.

ZEQ economy deep dives​

The math behind the balance, the version cutover, the precision floor, and the daily allowance.

  • Migration window — three-state machine that moves an entangled state from v1_handpicked → v2_math, owner-gated, cutover-irrevocable, audit-emitted.
  • Zeqali precision — 1 ZEQ = 10¹⁸ Zeqali. Integer-only on-chain arithmetic, BigInt-safe wire format, mass-conservation by construction.
  • Daily Promo Credits — golden-ratio tier multipliers (1 / 9 / 15 / 24 / 38), per-Zeqond-day grant, spent before standing balance.

Secrets · ZSC (Zeq Secure Context)​

The framework's encrypted secret store — replaces .env with AES-256-GCM at rest, audit-chained reads, ZID-permission gates, and auto-rotation on the 1.287 Hz cadence.

  • ZSC Secure Context — what ZSC is, the read lifecycle, vault-first env-fallback contract.
  • Audit Trail — the four transition_type rows, proof_digest formula, entangled-state-verification SQL.
  • Admin API — 9 endpoints: list, info, set, rotate, grant, revoke, audit, delete, probe-permission.
  • Bootstrap & operations — KMS adapters (env / AWS / GCP), master-key rotation, recovery procedures.
  • Context CLI — 8 pulse > context … subcommands.

SDK clients​

Same wire calls, every language.

Extend the framework​

Teach the kernel new math, register external data sources, plug both into a state machine. Every operator in the catalogue went through the same protocol — yours travels the same path.

  • Custom operators — the 5-step DERIVE → VERIFY → REGISTER protocol, gated at ≤0.1% precision against your reference cases.
  • Custom protocols — external APIs, AES-256-GCM at rest, rate-limited, retry queue, entangled-state-logged. Plus hyperagents — full state machines you spawn with their own ZID + balance.
  • Wiring to a state machine — how the resolver picks built-in vs. derived vs. owner-scoped operators, and how each machine ends up with its own effective catalogue.
  • Worked example: thermal router — end-to-end build: derive one operator, register one API, deploy one contract.

How the substrate works​

The internals — read these when you want to know why a guarantee holds.

Help​

Papers