Zum Hauptinhalt springen

Zeq is ZeqVM — tap into the mathematical-physics virtual machine

ZeqVM is the framework's category: a virtual machine whose instruction set is physics. 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 don't write a frontend that calls our backend — you spin up your own state machine, your instance of the VM, with its own audit entangled state, its own ZEQ balance, its own pages, its own contracts. You compose it in a new mathematical language: 1,500+ catalogued operators across 64 domains, 241 named protocols, one operator synthesis — with an explicit numeric-accuracy bound on every computed result. The math keeps every transition honest. The state machine is what makes those transitions yours.

The order matters. Zeq is, first, ZeqVM — a hash-linked, Zeqond-stamped virtual machine where computation actually runs. A state machine is your instance of it, bound to your ZID. Sitting on top of the VM is a new mathematical language that spans quantum and classical regimes in one composable surface — Schrödinger sits next to Newton, the Dirac equation sits next to KE = ½mv², Big-O sits next to the Friedmann cosmology equation. The language is how you compose; the VM is what the language composes against.

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 a 1.287 Hz HulyaPulse clock and a 0.777-second Zeqond.

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 three minutes.

  • Install — pick your language; one command, one minute.
  • 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 — 241 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 timebase, the 0.777-second Zeqond.
  • 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