Skip to main content

Pulse — the framework's voice and gateway

Pulse is the framework's user-facing surface. A floating bubble, bottom-right of any framework page (and any third-party page that embeds it). Click it and a four-tab workbench opens; every reply is computed by the kernel and writes a ZeqProof envelope to your machine's entangled state.

Naming rule. HulyaPulse is the framework's 1.287 Hz system clock (defined exactly: τ = 777,000,777 ns, f = 1/τ — see the Constants Charter). Pulse (capital P) is the user-facing entity that beats to the HulyaPulse rhythm — what was previously called "the Pulse." Lowercase pulse is just a generic verb; avoid it in branding.

The four-surface workbench (WB.3)​

When you tap Pulse on any framework page, the workbench mounts with four tabs. Each is an independent surface — its own scoped chat, its own mode-aware system prompt, its own toolset. The step-strip is the spine.

TabServer modePurpose
LEARNmode=learnKernel-aware Q&A. Ask anything about the framework, the constants, the operators, the math. The agent reads the SDK and the live agent-context to answer. No write tools — pure read.
SKILL (Step 5)mode=skillBrowse the skill catalogue, AI Generate new skills, attach a skill to your machine. Persists the skill .md to agent_files/skills/<id>.md.
PLAN (Step 6)mode=planSpec/plan canvas. The agent drafts a PRD and 10 state contracts when you mount it with skills attached. PRD edits persist to agent_files/prd.md. Locking the plan advances you to Step 7.
BUILD (Step 7)mode=buildBig BUILD & DEPLOY button. The agent emits <zeq-build-output page_slug="…">…</zeq-build-output> HTML. The compliance gate validates it, then publishes to state_machine_pages and serves at /s/<machine>/p/<page>/.

All four surfaces share the same per-machine chat history (multichat sidebar) and read from the same agent_files/ bag. Switching tabs swaps the mode and the toolset — it does not start a new conversation.

The step strip also exposes the standalone CLI as a fifth panel for no-AI exploration (see Zeq CLI).

Two modes (auth)​

Machine-bound (signed-in)​

data-zid="zeq07XXXXXXXX" — Pulse routes to /api/zeq/agent/page-chat bound to your machine. Replies stream back with the kernel's actual computed values (operators, R(t), phase, proof_digest). The owner's self-service path is exempt from the 503 wallet gate, so the four surfaces work without burning ZEQ while you build your own machine. Visitor chat on your published /s/<machine>/ page costs 25 ZEQ per turn against your wallet.

Guest (unauthed)​

data-zid="guest" — Pulse routes to /api/chat/free, backed by the framework's seeded Fireworks credential. Free-tier rate limits apply (~10 chats/day per visitor IP). The agent tells visitors to register if they want to run contracts or build pages. No charge to you.

The runtime decides the mode by reading data-zid: "wizard" and "guest" are placeholders → guest mode; anything else is treated as a real machine ID → page-chat mode.

Where it appears​

Inside the framework — auto-injected on every page​

/pulse-everywhere.js loads on every framework HTML page (portal, state admin, tally, transparency, SDK, apps, every machine page). It auto-detects the right data-zid:

  1. URL ?slug=… (per-machine admin pages, hosted /s/<machine>/)
  2. localStorage.zeq_user.machineSlug (the signed-in user's machine)
  3. "guest" fallback

Then it injects /apps/zeq-orb/ into a Shadow DOM mount so its CSS never leaks onto the host page. Closing the workbench restores the host's data-theme cleanly — see CLAUDE.md §9.9 for the hardening.

On user-uploaded /s/<machine>/ pages​

Hosted pages get Pulse only if the machine's inject_pulse_orb toggle is on (default OFF — opt-in only, per Phase L3). The framework default canvas ships Pulse unconditionally because the canvas is the Pulse — it's the only thing a brand-new machine has to interact with.

On any third-party site​

One-line snippet — see Embed Pulse:

<script src="https://YOUR-FRAMEWORK/embed/orb.js"
        data-zid="YOUR-MACHINE-ID"
        defer></script>

/embed/orb.js reads its own <script src> URL to determine the framework origin, so the snippet is host-portable across forks. Every fork's public origin is auto-detected via domain_genesis.public_base_url (see FORK.1) — operators don't set a domain env var.

What's inside​

The Pulse bundle ships with:

  • Shadow-DOM mount — orb-byok-shell.js mounts /apps/zeq-orb/ into an isolated DOM tree. Zero CSS bleed between host and panel.
  • Microphone + transcription — Web Speech API; falls back to typed input if HTTPS or mic permission is unavailable.
  • Per-machine multichat — localStorage.zeq_chats:<machineId> scoped, so signing in/out doesn't lose history.
  • Mode-aware system prompts — assembleSystemPrompt(mode) on the server picks the LEARN / SKILL / PLAN / BUILD directive plus the full kernel CKO envelope.
  • Compliance gate — every BUILD-mode reply runs through five validators (security, vocab, operator, numeric, API). Security violations block publish; the other four are advisory and surface warnings without blocking (per PH3.AUDIT.GATE).
  • Pyodide sandbox — the Python panel (Ω11.F) runs scripts server-side with row-level audit via agent_sandbox_runs.
  • .zeq Moments — HITE temporal-bound conversation persistence.
  • Local Gemma (via WebLLM) for offline Plus mode + BYOK fallback for hosted models.

The Pulse is also the framework's PWA-installable shell — see /pulse/ for the standalone full-screen experience.

Attributes (recap)​

AttributeDefaultWhat it does
data-zid (required)"guest"Machine ID to bind Pulse to. "guest" → free chat. "wizard" → free chat (used by the homepage register flow).
data-theme"dark""dark" or "light".
data-position"bottom-right""bottom-right" or "bottom-left".
data-accent#00ff88CSS colour for Pulse's glow.
data-originscript's own originFramework origin to load /pulse.js from. Useful for rotator failover.

Per-machine opt-in for hosted pages​

Owners control whether visitors to /s/<machine>/ pages see Pulse:

  • Toggle on /state/admin/ai/ → "Auto-inject into hosted pages."
  • Saves to state_machines.inject_pulse_orb (boolean, default FALSE).
  • Mirrored toggle for agent-rail.js (the agent picker strip).

Default is OFF because the framework will not silently mutate user-uploaded HTML. The default canvas is the only exception — it's a framework-owned page and ships with Pulse unconditionally.

Why it matters​

Pulse is how the framework "wakes up" any page it touches. A blank machine canvas with Pulse is more useful than 1,000 lines of boilerplate, because Pulse can build the page out from voice — Skill → Plan → Build → Deploy in four taps. It's also the framework's competitive moat against generic LLM chat interfaces: every reply lands as a verifiable transition on your entangled state, not an ephemeral message in some vendor's history.

Pulse is the gateway. Treat it like one.

  • Embed Pulse — the snippet, attributes, examples
  • Agents — hyperagent runs, ZeqProof fitness, ZIDs
  • BYOK — bringing your own LLM keys to Pulse
  • State machines — what Pulse writes to
  • ZEQ economy — what each Pulse turn costs (25 ZEQ machine-bound visitor turn; free for owner self-service; free for guest tier)
  • Universal source-audit — Pulse kicks off audit conversations