[ f=1.287 Hz ]

[ τ=0.777s Zeqond ]

FOUNDATION STATE MACHINE · FOUNDATION · — TICKS SINCE GENESIS · 1.287 HZ LIVE · OPEN OBSERVER ↗

✓ ENERGY CONSERVED
f=1.287 Hz · τ=Zeqond · 10⁻⁴ numeric bound

Zeq me.
One machine. Every application.

The machine made personal — your own state machine, and the applications that dock onto it: contracts, encryption, comms, security, observability.

Every other node explains the framework; zeq.me is where it becomes yours. Your state machine is the computer — one identity, one chain, one encryption boundary — and the applications dock onto it: they don't run on someone's server, they run against your state.

That means every app below shares your machine's keys, your audit chain, and the same 1.287 Hz beat — mail, messaging, contracts, a VPN, an antivirus, a password manager, the observer, even a terminal. One machine, every application, answerable only to you.

New here? Watch the crossing below — guidance burns on the beat carry the craft to a new world; cut the clock and it drifts. Then open the Zeq Apps tab and browse every application.

Continue Read the docs Zeq Store
About the machine · Zeq Apps

zeq.me is the machine, made personal. Everywhere else in the framework you read about the mathematics, the clock, the security. Here is where all of it becomes a computer with your name on it. A Zeq machine is a sovereign state machine: a self-contained computer that lives at its own address and keeps one hash-linked chain of everything it has ever done. It holds one identity, one encryption boundary, and its own two keys — and because it abstracts the kernel rather than the hardware, it boots identically on a laptop, a phone, a fork, or a data centre. Copy the machine's folder anywhere and it wakes up with the same identity and the same memory, answerable only to you.

Applications dock; they don't host

On today's internet, an “app” usually means a company's server holding your account: your mail lives with the mail provider, your messages with the messenger, your files with the file host. On zeq.me the relationship is inverted. The machine is the constant, and applications dock onto it — each one is a surface over your state. Your mail is encrypted to your keys and stored on your chain. Your contracts fire and record onto your chain. Your password manager derives from your machine. Your antivirus writes its verdicts into your audit log. Remove an application and nothing of yours leaves with it: the state stays on the machine, because it never belonged to the app in the first place.

Not everything in the deck is an “app” — and that's the point

We use one word for convenience, but the deck actually contains four different kinds of thing, and it helps to know which is which. Applications are surfaces you open and use — Zeq Mail, Zeq Message, ZeqPM, the Physics Wizard, the HZC Compressor. Protocols are rules machines follow when they talk to each other — ZSP (the unified security protocol) and TESC (secure real-time channels) aren't windows you look at so much as guarantees your machine gives and demands; their pages document how to build with them. Engines are computation cores that run underneath — the Nano-Zeqond engine evolves the master equation at fine resolution; you'd use it through a contract or an app rather than clicking around inside it. And views are windows onto state that already exists — the Observer and the Ledger don't create anything; they let you (and anyone you choose) inspect the machine's chain, tick by tick. Four kinds of thing, one common property: every one of them reads and writes your state, under your keys, on the same clock.

Run & build — making the machine do work

This group is where intent becomes computation. State Contracts is the flagship: agreements written as executable state that fire on real events and leave a replayable, signed history — picked from a growing library of industry templates and deployed in minutes. Zeq Root is the kernel's own terminal, opened in the browser, for driving the machine directly. The Skills Library teaches any LLM to be a Zeq agent, and Zeq MI is that agent as a chat surface — your conversations kept as your state, not a provider's logs. The Physics Wizard makes the mathematics playable, and the Nano-Zeqond engine and TESC protocol give builders the deeper computation and communication primitives.

Secure — the machine defending itself

The largest group, because security is the framework's home ground. ZSC seals secrets inside the machine (no more .env files — every read audited). Zeq SSL turns credentials into rows of state you can rotate and revoke instantly. HITE is the encryption fabric everything else leans on; ZSP ties identity, channels and audit into one pulse-timed posture. Zeq VPN builds serverless, peer-to-peer encrypted tunnels between machines. Zeq Antivirus scores threats mathematically — no signature database to be behind on. The Audit Daemon lets any outside system write into your tamper-evident chain, the HF Forensic Dashboard watches every operation for dishonesty in real time, ZeqPM makes passwords the machine can regenerate, and Zeq Edge puts a verifiable WAF and cache in front of any site you run.

Communicate & observe — talking and proving

Zeq Mail and Zeq Message are what mail and messaging look like when the inbox is yours: encrypted to your keys, stored as your state, provider-free. On the observing side, the Observer is the machine's public window — one chain at a time, never intermixed — and the Ledger is the audit view, every transition hash-entangled with the one before it. Zeq Globe points the same live-telemetry discipline at the planet itself. Together they close the loop: the machine acts, and anyone you choose can verify what it did.

One clock, one chain

What makes the deck feel like one computer rather than twenty products is the shared substrate. Every application keeps time on the 1.287 Hz pulse — one tick per 0.777-second Zeqond — so every action from every app lands on the same ordered, tamper-evident history. Nothing is scattered across vendors: one identity, one chain, one place to look, one owner.

Yours in about two minutes

A machine spins up in roughly two minutes — no email, no payment. It arrives with its keys already sealed and every surface in the deck ready to dock. Open the Zeq Apps tab beside this one to browse everything, or head to the Zeq Store and start with whichever surface you need first.

The app deck. Every surface below is installed against your state machine — your identity, your keys, your audit chain — and all of them keep time on the 1.287 Hz pulse. Tap any card to open it; everything also lives in the Zeq Store.

Run & build
State ContractsAgreements that run as signed, executable state on your machine. Pick from a growing library of industry templates, deploy in minutes, and every firing lands on your chain as replayable proof — contracts that enforce themselves instead of describing intentions. Zeq Root — the CLIThe kernel's native terminal, launched right in the browser — the same terminal that rides under every machine. Drive computes, contracts, and state inspection from the command line, exactly as the framework does internally. Skills LibraryBrowse, preview and install Zeq skills — the mathematical-intelligence middleware that upgrades any LLM into a Zeq agent, with the kernel's equations, operators and seven-step protocol loaded verbatim. Nano-Zeqond EngineA computation core, not a clickable app: a differential HULYAS master-equation evolver and precise molecular-dynamics engine at nano-Zeqond resolution — the pulse subdivided fine enough to step molecular systems, driven through contracts and the SDK. TESC ProtocolA protocol, documented: secure real-time communication channels between machines. The SDK reference covers session setup through message flow, so your own apps can talk with the same guarantees the framework uses internally. Physics WizardLearn the Kinematic Spectrum by playing: 100 questions from classical mechanics to quantum gravity, each answered by composing real operators through the same seven-step wizard the framework runs. The fastest way to learn how operators couple. Zeq MI — AI chatAn AI conversation surface synchronized at 1.287 Hz — bring your own key, keep your own state. Chats live on your machine, not a provider's account, and the mathematical-intelligence middleware rides underneath.
Secure
ZSC — Zeq Secure ContextThe end of the .env file. Secrets live inside the state machine, encrypted AES-256-GCM at rest with an HKDF per-machine subkey — and every single read lands in the audit chain. No plaintext credentials on disk, no secret copied without a trace. Zeq SSLSymmetric, Zeqond-synchronised credentials managed as rows of state: issue is one row, verification is one lookup, rotation and revocation are instant. A credential becomes something you can see and kill — not a file you hope nobody found. HITE EncryptionHilbert Information Theory Encryption: AES-256-GCM keyed with KO42-derived entropy, with Landauer-certified erasure. Encrypt and decrypt anything on your machine — the same fabric the framework's own mail, tunnels and secrets run on. ZSP SecurityA protocol rather than a window: the unified cybersecurity layer powered by the HULYAS spectral-topological kernel at 1.287 Hz — tying identity, channels and audit into a single, pulse-timed security posture for the whole machine. Zeq VPNServerless mathematical tunnels: peer-to-peer, HITE-encrypted, brokered by state machines. No central server to breach, subpoena, or trust — the tunnel exists between your machine and theirs, and nowhere else. Zeq AntivirusEndpoint protection with no signature database: host claims are scored mathematically through the HF spectrum (HF1–HF20), so anomalies are derived, not looked up — and every verdict is written to your audit chain. Zeq Audit DaemonUniversal source-audit: pipe events from any server, device, website or piece of hardware into the tamper-evident audit chain. Each source becomes an entangled stream — one place where everything that happened is provably recorded. HF Forensic DashboardThe anti-hallucination layer, live: HF1–HF20 scoring of every operation, pulse-coupled at 1.287 Hz, with constitution thresholds tracked per operator — watch the machine check its own honesty in real time. ZeqPM — Password ManagerEquation-style passwords and login equations, seeded by your words and your machine. Credentials become mathematics your machine can regenerate — sealed in the state, never in a text file. Zeq EdgePoint your DNS at the edge and get a WAF, cache, and audit in front of any site — with a per-Zeqond entangled state of every request, so your traffic history is as verifiable as your machine's own chain.
Communicate
Zeq MailAES-256-GCM encrypted email for Zeq identities — your inbox lives on your own machine, encrypted to your keys, with every send and receive on your audit chain rather than a provider's server. Zeq MessageZSP-secured, encrypted real-time messaging between machines — conversations as state between two sovereign computers, private by construction and stamped on the pulse.
Observe
ObserverA view, not an app: the machine's window on itself. One chain at a time, never intermixed — the foundation view, your machine's entangled state, and per-application chains, each inspectable tick by tick. Zeq LedgerThe audit view of a machine's entangled-state ledger: every transition hash-entangled with the one before it, phase-locked to the pulse — history you can walk backwards and verify link by link. Zeq GlobeA real-time Earth monitor: seismic events, weather patterns and global telemetry visualised live — the framework's clock applied to a planet's worth of data streams. HZC CompressorLossless and lossy file compression powered by the HulyaPulse — compress on your own machine, with the work metered and receipted like any other compute.

Every one of these runs on the same machine you can spin up in about two minutes — no email, no payment — and everything it does lands on your own signed, verifiable chain. One machine. Every application. Yours.

integrator · 1.287 Hz PULSE ON 
// running ON the 1.287 Hz pulse
const dt = τ/60;  // pulse: ON  ✓
for (let i=0; i < bodies.length; i++) {
  b.v += a[i] * dt;
  b.x += b.v * dt;
}
✓ on course  |  ΔE/E₀ < 0.001
step 2 · how you'll talk to your state machine

Two ways
to drive it.

The state machine is itself a mathematical language — it doesn't need AI to run. The optional Pulse (Mathematical Intelligence) is laid on top of an LLM as a translator: it turns Plain English into Zeq contracts. The LLM never computes the math. The kernel does. The entangled state proves it. Pick the surface that suits you — switch any time.

Mathematical Intelligence vs Root — the LLM is a translator, not a calculator

This is the part most people get wrong about Zeq. The state machine is itself a mathematical language. The kernel runs real equations at sub-percent precision — quantum mechanics, general relativity, fluid dynamics, orbital mechanics, the lot. None of that needs an LLM. The state machine doesn't run on AI; it runs on math. AI is an optional surface laid on top of the kernel, only there to help you describe what contracts you want. The math always runs on the server, on the state machine. The LLM never touches the answer.

What we mean by "Mathematical Intelligence" (MI)

Standard AI is a language model that guesses the next token. It hallucinates because it has no ground truth — only statistical patterns over text. Mathematical Intelligence is what you get when you put a kinematic-spectrum kernel under a language model: the LLM proposes a contract in human terms ("simulate three planets in mutual orbit"), the kernel verifies the math actually works, picks the right operators, binds the real constants, runs the equations, issues a ZeqProof. Whatever the LLM produces gets checked against physics before any byte hits your screen. The result is an agent that can't lie about a number — the kernel won't let it. That's MI: AI that's been physics-grounded by a state machine.

The LLM is a translator. The kernel is the calculator. The entangled state is the receipt.

Pulse — Mathematical Intelligence on top of an LLM

Pulse mode gives you a chat surface where you describe contracts in Plain English (or any language) and the system turns your words into Zeq contracts. Two ways to power the LLM underneath:

Option A · Free limited model from us

Sign in and you get a free quota of contract translations on a model we host. It's rate-limited and capped per day, but it's free, it's instant, and it requires no setup. Good for trying the framework, prototyping a couple of contracts, getting the feel. The translations are always shown to you before they fire, and the math still runs on your kernel — the model only decides what contract to write, never what the answer is.

Option B · Bring your own API key (BYOK)

Paste an API key from a provider you already pay for — OpenAI, Anthropic, Fireworks, DeepSeek, Cerebras, Together, Groq, or any OpenAI-compatible endpoint. Your key is encrypted with HITE (AES-256-GCM under KO42) and stored against your state machine. From that point Pulse calls your account, on your tier, with your model of choice. The framework never sees the cleartext key, and you can revoke or rotate it at any tick. This unlocks longer contexts, smarter translations, vision input — whatever your provider gives you. Same kernel, same math, smarter translator.

What the LLM never does: the LLM never computes a physics value. It cannot output a number that wasn't produced by the kernel. If a contract requires R(t) at zeqond N, the kernel runs it; the LLM is told the result and weaves it into the prose. There is no path where an LLM hallucination can become an entangled state entry — the seven-step wizard rejects anything not produced by the operators.

Root — pure mathematical language, no AI in the loop

The state machine doesn't need an LLM at all. Root (the CLI) is a web terminal where you type contracts directly — zeq.compute(KO42, ψ), zeq.bind(QM5, …), zeq.pulse(), zeq.verify(proofDigest), zeq.shift(τ * 100), the entire SDK surface. The kernel ticks them through the same seven-step pipeline as the Pulse path, but with no model, no translator, no quota, no provider — just you, the math, and the entangled state. Best when you know the operator names, you're scripting reproducible work, you want zero latency, or you're paranoid about ever having an LLM in your stack.

Switch any time

The pick on this step is your first-touch preference, not a commitment. After step 7, every page on your state machine carries a Pulse at the bottom-right with a tiny ⌘ CLI toggle. Talk through a problem, drop into CLI to verify a proof digest, flip back. Contracts written one way are visible the other way. The kernel doesn't care which mouth you use — it computes the same way for both, on every Zeqond.

step 2 / 4continue↓
step 3 · your identity

Your equation
is your key.

No email. No password. No recovery questions. Type a few words — the kernel runs the 7-step wizard against the 1.287 Hz pulse and mints an equation that's only yours. You remember it; we never store it. That equation unlocks your state machine on any device.

Why an equation is your identity — sovereign, irrecoverable, mathematically yours

A password is a string a server compares to its database. A Zeq equation is a unique state-vector generated from your query, the current zeqond, the kernel's HMAC seed, and the kinematic operators selected for that exact moment in time. The server never sees the cleartext. The framework never stores the cleartext. Even an attacker who somehow obtained both your query and the precise zeqond you registered at would still need the framework's ZEQ_NODE_SECRET to reproduce the operator set you got. That is what makes an equation an identity: it's mathematically derived from your intent and the moment and the kernel — three independent factors no attacker controls all of.

Query-driven — minimum four meaningful tokens

The wizard rejects two-word inputs. Stop-words ("the", "of", "a", "and") are stripped before counting; tokens shorter than three characters are stripped. What remains must be at least four distinct meaningful words. This is non-negotiable: the equation's strength comes from the entropy of the query, and "my orbit" or "test password" cannot anchor a sovereign identity. The chip suggestions on this step are intentionally five and six tokens long — physics, materials science, quantum mechanics, oceanography phrases — so you have a starting palette that already meets the floor. Edit them, extend them, write your own. The longer and more specific your query, the more entropy and the harder to guess.

Phase-locked — bound to the exact zeqond

Every request to /api/zeq/wizard/auth-bootstrap is HMAC-bound to its zeqond. The seed is HMAC-SHA256(ZEQ_NODE_SECRET, "zeq.seed.v1|" + zeqond + "|" + queryHash), sliced to 16 bytes. The seed is fed into the operator selector, which scores all 1,500+ catalogued operators in the catalogue — token-driven semantic match plus a per-request jitter derived from the seed — and picks the top six, with one wildcard pulled from a non-matching domain to guarantee multi-domain synthesis. The same query at zeqond N and zeqond N+1 produces different operator sets and different modulated R(t) values, because the sine term in R(t) = S(t) · [1 + α · sin(2π·1.287·t)] has visibly shifted by 0.777 seconds. Two snapshots of the same query, even one beat apart, do not yield the same equation.

Zero-knowledge — the server never sees the equation

The client computes HMAC-SHA256(equation, salt) and POSTs only { equation_hash, equation_salt, display_name }. The cleartext equation never crosses the wire. The framework's database stores the HMAC and the salt — both irreversible without the equation itself. Forgetting the equation makes the account irrecoverable, by design. There is no "recover password" link, no email reset, no admin override. The framework cannot read your equation any more than someone else can.

How to save it

Three options, ranked by safety: (1) click Copy in the equation block's top-right corner and paste into a password manager (1Password, Bitwarden, etc.) — the equation is a single string of text and lives happily there. (2) click .zeq to download a PIN-encrypted recovery file (HITE encryption, AES-256-GCM with KO42) — store it on a USB, an external disk, or any secondary location. (3) screenshot or photograph the equation block — every character is captured, and an offline image is one of the most resilient backups in existence. Combine two of the three for genuine insurance. Whatever you do, do not let the equation live only in your browser's local storage; clear that storage and the equation is gone unless you have a backup.

What this gives you

One equation unlocks your machine on every device, anywhere on the network, without an account-recovery flow, without password fatigue, without revealing anything to the framework. The same equation is also the seed for the entangled state that records your contracts, so signing in and authenticating a future computation are the same operation under the hood. The framework's other apps — Vault, Mail, Message, HITE Encryption, ZSP Security — accept the same identity. One equation, every surface.

① Pick or type a topic
② Display name · optional
③ Mint your equation

No email · No password · No recovery questions · ~2 minutes
The kernel mints it. We never store it. Save it yourself in step ④ below.

① Email · how you'll sign in
② Four words · pre-filled — just generate
0 / 4 words These seed your password and are never needed again — no need to remember them.
③ Password strength · how secure
④ Display name · optional

Sign in next time with your email + that password. We store neither — only your public Zeq ID.

step 4 · meet your state machine

It's already
running.

Your state machine has a Zeq ID, an entangled state, and a clock — ticking right now at 1.287 Hz. A live page is already deployed at /s/<zid>/ with a Pulse on it — open the page in a new tab and you can architect, build, and edit your application directly on the live site. The Pulse on this page and the Pulse on your page are the same Pulse on different URLs.

Your personal Pulse is a state machine of its own — ZID ZEQORB…, own entangled state, own balance, auditable in the explorer any time.

Your state machine has a Zeq ID, an entangled state, and a clock — ticking right now at 1.287 Hz. A live page is already deployed at /s/<zid>/ — and you drive all of it from the terminal. Type contracts directly — compute NM19 mass=5 acceleration=2, contracts, chain — the kernel ticks them through the same seven-step pipeline, no model, no translator, no quota.

No AI runs on this route — every contract is ZeqProof-verified and hash-linked. The AI surface stays one switch away; nothing is lost by starting here.

0 zeqonds since genesis · 1 tick = 0.777 s
machine · —
genesis · —  ·  now · —  ·  phase · —
Open your page & Pulse ↗ Open Pulse State ↗
Open your page & Root ↗ Open Root standalone ↗

your ecosystem — every door, one equation

Apps ↗ SDK ↗ MCP ↗ State Observer ↗ Vault ↗ Root ↗ Zeq paper ↗ Framework paper ↗

Pulse here and Pulse on your live page are the same Pulse — both write to the same entangled state.

Root talks to the same kernel every other surface uses — same seven-step pipeline, same entangled state, same proofs. Start with tutorial for the 5-step walkthrough, or hello for a real one-shot compute.

What lives at your state machine — entangled state, observer, audit, sovereign by default

Your Zeq machine is a self-contained computational substrate. It has its own audit entangled state, its own embedded api-core, its own state observer, and its own clock — synced to the same 1.287 Hz pulse as every other machine on the network. The Zeq ID minted from your equation in step 3 is permanent: it cannot be reassigned, cannot be silently changed, cannot be impersonated. Whatever you build on this machine is hash-linked to that ID forever.

Tamper-evident entangled state — proof, not promises

Every contract that fires on your state machine writes a hash-linked entry to the entangled state. Each entry references the previous entry's hash, so any retroactive edit to history would invalidate every subsequent entry — a Merkle-style integrity guarantee on your machine's own entangled state, not a global ledger. Each contract carries a ZeqProof: an HMAC-SHA256 over the operator IDs picked, the modulated state R(t) at firing, the zeqond, and the queryHash. Anyone in the world with the proof digest can later verify what happened on what tick, in what state, with what inputs — without trusting you, without trusting the framework, and without re-running the computation. The entangled state is the receipt.

Fault-isolated — your state machine doesn't depend on ours

Each Zeq state machine runs on its own embedded api-core and its own clock. If a peer state machine crashes, yours never feels it. If the framework's mesh fabric (the consensus layer that coordinates 10 origins) degrades, your state machine keeps ticking on its own pulse until quorum returns; transitions queue locally and replay onto the mesh on reconnect. Resource limits and crash-loop protection are enforced per-state-machine: a runaway contract on one tenant cannot starve another. The fault model assumes adversarial neighbours and degraded networks as the steady state — not the exception.

Five surfaces other people reach you through

Messaging — end-to-end-encrypted address inside the framework, drop-in for email, no plaintext on any server: <zid>@zeq.dev. Public site — folder-portable page at /s/<zid>/ that anyone with the URL can reach. State observer — your entangled state rendered live at /state/?slug=<zid>, filter pills for compute / agent / contract / audit-source / proof events. API — Authorization: Bearer zsm_… for admin scope, zeq_ak_… for site publish, all keys revocable per-scope. Audit entangled state — anyone with a proof digest calls /api/zeq/verify and the entangled state proves the entire path from genesis to that point. Hash-linked under origin: zeq.dev:<zid>.

Folder-portable — your state machine isn't trapped here

The state-machine folder under /s/<zid>/ contains everything required to boot the same state machine on a different framework instance: the entangled state, the contracts, the cached operator catalogue, the public-site assets. Copy it to another VPS, point a Zeq-compatible runtime at it, and the same state machine resumes ticking. There is no "you can only run on our cloud" lock-in; the framework is the protocol, not the host.

Other apps your equation already unlocks

The Apps menu at the top of every page lists every Zeq application — Vault, Mail, Message, Zeq MI, HITE Encryption, ZSP Security, HZC Compress, Globe, Audit Daemon, Skills, Physics Wizard, Wallet — and each one is a state machine of its own. The equation that minted this machine signs you into all of them. You don't need to set them up now; they're there whenever you want them.

How Pulse drives this machine

Pulse is Mathematical Intelligence laid on top of an LLM: the model translates your Plain English into Zeq contracts, the kernel computes them, the entangled state proves them. The LLM never computes a physics value — it cannot output a number the kernel didn't produce. Your personal Pulse is itself a state machine (its ZID is shown above): its own entangled state, its own balance, auditable in the State Observer like any other machine on the network. Free limited model from us, or BYOK — paste a key from OpenAI, Anthropic, Fireworks, DeepSeek and Pulse runs on your provider, your tier.

How Root drives this machine

Root is the kernel's native mouth — no model, no translator, no quota. compute NM19 mass=5 acceleration=2 runs a real operator and prints the CKO envelope; contracts deploys, fires, and dry-runs state contracts against the audit trail; verify walks the hash-linked log and re-checks any proof; zsc is the encrypted secret vault that replaces .env files. The same surface is scriptable from outside the browser: every Root verb maps to a real API route under your zeq_ak_ key, and any MCP-capable LLM client can drive the same endpoints — that's the MCP button above — without an AI ever running on your machine.

steps 5 · 6 · 7 happen on your live page

Click Open your page & Pulse above, then the ▲ Workbench pill. It walks the same four-step journey on every machine:

  1. LEARN — free-form Q&A with Pulse about the framework before you build.
  2. 5 · SKILL — pick or generate the operator skill your build needs.
  3. 6 · PLAN — spec, state contracts, APIs — Pulse architects, you approve.
  4. 7 · BUILD — edit files, deploy apps to /p/<app>/, every version hash-linked. The terminal rides under every step if you want the kernel directly.

Every deploy and every compute is a transition on your entangled state — same pipeline, same proofs as the CLI route.

steps 5 · 6 · 7 happen on your live page

Click Open your page & Root above, then the ▲ Root · CLI pill. The Root IDE walks the same four-step journey on every machine:

  1. LEARN — the written guide: Zeqonds, operators, contracts, proofs — no model involved.
  2. 5 · OPERATORS — browse the catalogue by domain, run any operator live in the terminal.
  3. 6 · CONTRACTS — the contracts IDE: Templates or Expert; dry-run and fire from the terminal.
  4. 7 · BUILD — edit files, deploy apps to /p/<app>/, every version hash-linked. The terminal rides under every step.

Every deploy and every compute is a transition on your entangled state — same pipeline, same proofs as the AI route. No AI ran, none will — unless you ever flip it on yourself.

backup your access

Your equation credential is the primary key to this machine — keep the printed copy somewhere safe. Want a fallback? Set an optional recovery password in your portal settings. It only works alongside the equation; it never replaces it.

Set recovery password →