MCP tools

The machine speaks JSON-RPC 2.0 (MCP Streamable HTTP) on /api/mcp and exposes 57 tools. Two of them reach everything else: zeq_api_catalog is the map and zeq_http is the door.

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Tool	What it does
`zeq_protect`	ZeqPulseGuard — the PROTECT solver: a sealed protection heartbeat.
`zeq_api_catalog`	THE MAP - search the FULL public API surface of this Zeq node (851 public endpoints; admin routes are not exposed).
`zeq_http`	THE DOOR - call ANY public /api/* endpoint on this node directly (the full 851-endpoint public surface, not just the curated tools).
`zeq_spin_up`	Spin up your own ZeqVM state machine and get a REAL, account-backed API key.
`zeq_contract_generate`	Draft a state contract from a plain-English description.
`zeq_contract_templates`	List the 321 built-in state-contract templates (id + name) across every industry category.
`zeq_contract_deploy`	Deploy a state contract to your machine.
`zeq_contract_list`	List the state contracts on your machine — id, name, current state, and fire count.
`zeq_contract_get`	Get one contract's full state + definition by id.
`zeq_contract_fire`	Fire a contract's next transition now.
`zeq_observer`	Read the live entangled-state chain — your proof-of-computation feed.
`zeq_publish_page`	Publish a live HTML page/app to your machine — instantly hosted at /s/<machine>/p/<pageSlug>/ and added to your machine launcher.
`zeq_mail_html`	Build an HTML email and deliver it straight to YOUR OWN Zeq Mail inbox (<zid>@<your node's mail domain>), where you can review it and forward it on
`zeq_compute`	Compute physics results using the Zeq.dev HulyaSync framework.
`zeq_list_operators`	List available Zeq.dev physics operators for a given domain, or list all 67 domains.
`zeq_paper_search`	Search the scientific literature across arXiv, OpenAlex, Crossref and Europe PMC in one call.
`zeq_paper_fetch`	Fetch one scientific record by canonical id — 'arxiv:1706.03762', 'doi:10.1038/s41586-021-03819-2', 'pmid:34265844'.
`zeq_domain_match`	Given a paper (canonical id) or any text, return which of the 67 Zeq operator domains it plausibly falls in, with the exact vocabulary terms that fired as evide
`zeq_science_domains`	List the 67 Zeq operator domains and which literature sources serve each.
`zeq_find_operator`	Find operators by name, id, equation or description — ONE call instead of paging through domains.
`zeq_pulse`	Get the current ZeqPulse state — live Zeqond counter, HulyaPulse phase φ, and R(t) value.
`zeq_verify`	Verify a ZeqProof HMAC returned by zeq_compute.
`zeq_lattice`	Compute a ZeqLattice — a multi-node coherence grid.
`zeq_shift`	Compute a ZeqShift — a deterministic forward time-series projection of R(t) across up to 64 Zeqond steps.
`zeq_field_status`	Query the ZeqField security system status — cipher algorithm, key source, and protocol versions.
`zeq_solve`	Integrates the geodesic in the KO42-tensioned metric ds² = gμν dxμ dxν + α·sin(2π·1.287·t)·dt² and returns the trajectory φ(t), the register dump, the HULYAS fu
`zeq_multibody`	Run the vector master equation: N coupled φ_i(t) trajectories with pairwise inverse-square coupling.
`zeq_evolve`	Run ZeqEvolve — deterministic Nano-Zeqond MOLECULAR DYNAMICS: velocity-Verlet (2nd-order symplectic) integration of a Lennard-Jones system (NM19) with optional
`zeq_action`	Run ZeqAction — a least-action, HIGH-ORDER SYMPLECTIC integrator (Störmer-Verlet → Yoshida triple-jump, order 4/6/8, fixed dt, Kahan-compensated).
`zeq_heat`	ZeqHeat — 2-D heat/diffusion ∂T/∂t=α(∂²T/∂x²+∂²T/∂y²) on a grid (the default).
`zeq_lorenz`	ZeqLorenz — the Lorenz attractor (RK4), deterministic chaos.
`zeq_wave`	ZeqWave — 2-D MEMBRANE wave ∂²u/∂t²=c²(∂²u/∂x²+∂²u/∂y²) by leapfrog (the default), reality-checked by EXACT discrete-energy conservation (drift ~1e-13) and agai
`zeq_flow`	ZeqFlow — 2-D incompressible Navier–Stokes (Stam stable fluids): advect + diffuse + pressure PROJECTION so ∇·u→0.
`zeq_fracture`	ZeqFracture — 2-D bond-based peridynamic CRACK PROPAGATION (mode-I SENT, the default): a seeded edge notch either holds below a critical far-field strain, or th
`zeq_react`	ZeqReact — reaction–diffusion (biology).
`zeq_epi`	ZeqEpi — SIR/SEIR epidemic dynamics (RK4).
`zeq_quant`	ZeqQuant — European option price by Monte-Carlo, verified against the closed-form Black–Scholes.
`zeq_zeta`	ZeqZeta — locate Riemann zeta nontrivial zeros on the ½-line (Riemann–Siegel) and VERIFY the count against N(T)=θ(T)/π+1 up to height T.
`zeq_sat`	ZeqSAT — DPLL 3-SAT solver on a seeded random instance at ratio α=m/n (hardness peaks ≈4.26).
`zeq_gauge`	ZeqGauge — 2-D compact U(1) lattice gauge theory (Metropolis).
`zeq_fea`	ZeqFEA — 2-D plane-stress finite-element cantilever (Q4, matrix-free element-by-element Jacobi-preconditioned CG — memory O(dof), so LARGE meshes run: up to ~90
`zeq_grid`	ZeqGrid — DC power-flow on an N-bus network (B·θ=P).
`zeq_device`	ZeqDevice — 2-D device ELECTROSTATICS (the default): the potential + field in a semiconductor cross-section under an electrode, solving ∇²φ=0 by matrix-free Jac
`zeq_opt`	ZeqOpt — nonlinear optimization: minimise a test function (sphere, rosenbrock, rastrigin, beale) by Nelder–Mead or gradient descent, checked against the KNOWN g
`zeq_climate`	ZeqClimate — 2-D shallow-water equations (Lax–Friedrichs), a droplet radiating gravity waves.
`zeq_unified`	ZeqUnifiedComposer -- compose MULTIPLE operators in ONE call.
`zeq_dock`	ZeqDock — rigid-body molecular docking: minimise a Lennard-Jones + Coulomb score over the ligand's 6 DOF against a receptor pocket, from seeded restarts.
`zeq_buckling`	ZeqBuckling — the Euler critical buckling load of a compressed column/strut: the axial load P_cr at which a slender member collapses (columns, struts, landing g
`zeq_acoustic`	ZeqAcoustic — the resonant modes of a 1-D acoustic resonator (Helmholtz −p″=k²p): the standing-wave frequencies of an organ pipe, wind instrument, exhaust/HVAC
`zeq_schrodinger`	ZeqSchrodinger — the time-independent Schrödinger eigenvalue problem Ĥψ=Eψ, Ĥ=−(ℏ²/2m)d²/dx²+V(x): the quantum bound-state ENERGY LEVELS behind atoms, quantum w
`zeq_tumor`	ZeqTumor — Fisher–KPP growth front ∂u/∂t=D u_xx+r u(1−u): a population/tumor/gene that grows AND spreads, invading as a travelling front (oncology, invasion bio
`zeq_lotka`	ZeqLotka — predator–prey / ecosystem dynamics (Lotka–Volterra).
`zeq_kalman`	ZeqKalman — optimal state estimation (the Kalman filter): track a constant-velocity target from noisy position measurements (GPS/radar/robotics/sensor-fusion/na
`zeq_auto`	ZeqAuto — FRICTIONLESS: send a natural-language `query` + `constants` and the right solver is auto-selected, run, and sealed.
`zeq_stream`	ZeqStream — hosted, ticking solver channels.
`zeq_closedform`	ZeqClosedForm — the CLOSED-FORM master-equation solver, the analytic counterpart to the open-form RK4 (/api/solve).
`zeq_reactor`	ZeqReactor — recursive, sealed, environment-driven compute loops.

`zeq_protect`

ZeqPulseGuard — the PROTECT solver: a sealed protection heartbeat. Computes ZEQ-PROTECT-001 |sin(5ϕ)|/f_pulse and ZEQ-PROTECT-002 0.5+0.3·sin(t/30) from the live Zeqond phase, maps a liveness signal to a branch (healthy→bounded harmonic guard; down→hyperbolic alarm), applies the Zeq proper-time modulation R(t)=S(t)[1+α·sin(2π·1.287·t)], and returns guardState OK/DEGRADED/BREACH. Give t (unix seconds) or phase (radians), and health (up|slow|down) or liveness [0,1] or an HTTP status. Requires zeq_ak_ key.

Input schema

Field	Type	Required	Description
`t`	number	no	unix seconds
`phase`	number	no	phase in radians
`health`	string	no	up \| slow \| down
`liveness`	number	no	0..1
`status`	number	no	HTTP status (200=up)

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_protect",
           "arguments": {
             "t": 1,
             "phase": 1,
             "health": "up",
             "liveness": 1,
             "status": 1
           }
         }
       }'

`zeq_api_catalog`

THE MAP - search the FULL public API surface of this Zeq node (851 public endpoints; admin routes are not exposed). Filter by q (substring across path+description), method, auth. Use this to discover endpoints, then call them with zeq_http.

Input schema

Field	Type	Required	Description
`q`	string	no	Substring filter across path + description (e.g. 'tally envelopes', 'observer', 'state-machines').
`method`	string	no	Filter: GET \| POST \| PUT \| PATCH \| DELETE.
`auth`	string	no	Filter: public \| user \| key \| admin.
`limit`	number	no	Max entries returned (default 40, max 200).

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_api_catalog",
           "arguments": {
             "q": "example",
             "method": "GET",
             "auth": "public",
             "limit": 10
           }
         }
       }'

`zeq_http`

THE DOOR - call ANY public /api/* endpoint on this node directly (the full 851-endpoint public surface, not just the curated tools). Supports GET/POST/PUT/PATCH/DELETE and the new HTTP QUERY method (RFC 10008, June 2026): the safe, idempotent GET-with-a-body for complex data grabs - pass method QUERY with a JSON body and the node merges it into query params per the RFC semantics. Your Authorization bearer key is forwarded. Admin routes and /api/mcp itself are blocked. Discover endpoints with zeq_api_catalog first.

Input schema

Field	Type	Required	Description
`method`	string	yes	GET \| POST \| PUT \| PATCH \| DELETE \| QUERY (RFC 10008: safe GET-with-body - use for complex searches)
`path`	string	yes	Endpoint path starting /api/ (e.g. /api/zeq/pulse, /api/mesh, /api/chain/state-machines/foundation).
`query`	object	no	Optional query params as a flat object.
`body`	object	no	Optional JSON body for non-GET requests.

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_http",
           "arguments": {
             "method": "GET",
             "path": "example",
             "query": {},
             "body": {}
           }
         }
       }'

`zeq_spin_up`

Spin up your own ZeqVM state machine and get a REAL, account-backed API key. REQUIRES authentication: pass a demo key as Authorization: Bearer zeq_ak_demo_… — if you have no key yet, first POST /api/demo-key/mint (free, no signup) to get one, then call this with it. Provisions a fresh machine (unique ZID), seeds its audit chain, and mints an active zeq_ak_ compute key on the free tier. Returns your ZID, recovery equation + salt (SHOWN ONCE — save them, there is no password reset), the machine slug, and the API key (SHOWN ONCE). Put the returned apiKey in your connector's Authorization header and every subsequent zeq_compute / zeq_solve / contract call runs on YOUR machine. (Every API key belongs to an account — there is no keyless minting.)

Input schema

Field	Type	Required	Description
`displayName`	string	no	Optional label for your machine (e.g. your agent's name). Defaults to 'mcp-agent'.

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_spin_up",
           "arguments": {
             "displayName": "example"
           }
         }
       }'

`zeq_contract_generate`

Draft a state contract from a plain-English description. The framework turns your intent into an operator-grounded contract definition on YOUR machine. Returns the definition — pass it to zeq_contract_deploy. Requires your zeq_ak_ key (from zeq_spin_up).

Input schema

Field	Type	Required	Description
`query`	string	yes	8-600 chars: what the contract should do, its states, and transition conditions.

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_contract_generate",
           "arguments": {
             "query": "speed of sound in air at 20 C"
           }
         }
       }'

`zeq_contract_templates`

List the 321 built-in state-contract templates (id + name) across every industry category. Deploy any with zeq_contract_deploy { templateId } — no LLM credential needed. Requires your zeq_ak_ key.

This tool takes no input fields (or publishes none).

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_contract_templates",
           "arguments": {}
         }
       }'

`zeq_contract_deploy`

Deploy a state contract to your machine. Every transition is ZeqProof-anchored on the entangled-state chain and visible in the Observer. Pass EITHER templateId (from zeq_contract_templates — works with no LLM credential) OR a full definition object (must include a version; from zeq_contract_generate). Requires your zeq_ak_ key.

Input schema

Field	Type	Required	Description
`templateId`	string	no	Built-in template id to deploy (see zeq_contract_templates).
`definition`	object	no	A full custom contract definition (states, transitions, operators, conditions, version).

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_contract_deploy",
           "arguments": {
             "templateId": "example",
             "definition": {}
           }
         }
       }'

`zeq_contract_list`

List the state contracts on your machine — id, name, current state, and fire count. Requires your zeq_ak_ key.

This tool takes no input fields (or publishes none).

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_contract_list",
           "arguments": {}
         }
       }'

`zeq_contract_get`

Get one contract's full state + definition by id. Requires your zeq_ak_ key.

Input schema

Field	Type	Required	Description
`id`	string	yes	Contract id (from zeq_contract_list).

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_contract_get",
           "arguments": {
             "id": "01J8ZQ2H9VMR4K"
           }
         }
       }'

`zeq_contract_fire`

Fire a contract's next transition now. Returns a ZeqProof receipt; guarded transitions report their reason instead of firing. Requires your zeq_ak_ key.

Input schema

Field	Type	Required	Description
`id`	string	yes	Contract id to advance.

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_contract_fire",
           "arguments": {
             "id": "01J8ZQ2H9VMR4K"
           }
         }
       }'

`zeq_observer`

Read the live entangled-state chain — your proof-of-computation feed. With no key it returns the global recent feed; with your zeq_ak_ key it focuses on YOUR machine's state. Each entry links to the Explorer.

Input schema

Field	Type	Required	Description
`limit`	number	no	How many entries (1-50, default 15).

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_observer",
           "arguments": {
             "limit": 10
           }
         }
       }'

`zeq_publish_page`

Publish a live HTML page/app to your machine — instantly hosted at /s/<machine>/p/<pageSlug>/ and added to your machine launcher. Pass title and full html (optional pageSlug). Owner-authenticated. Requires your zeq_ak_ key (from zeq_spin_up).

Input schema

Field	Type	Required	Description
`title`	string	yes	Page title.
`html`	string	yes	Full HTML markup of the page/app.
`pageSlug`	string	no	URL slug (a-z0-9-, defaults to 'app').

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_publish_page",
           "arguments": {
             "title": "example",
             "html": "example",
             "pageSlug": "your-machine"
           }
         }
       }'

`zeq_mail_html`

Build an HTML email and deliver it straight to YOUR OWN Zeq Mail inbox (<zid>@<your node's mail domain>), where you can review it and forward it on to anyone. This does NOT send to third parties — it only ever delivers to the mailbox of the identity making the call, so an agent cannot be talked into mailing strangers. Use it to draft newsletters, announcements and campaigns: compose the markup, deliver it here, open Zeq Mail, then hit Forward. Write email HTML, not web-page HTML — table layout, all CSS inline, absolute https:// links, max 600px wide. Scripts, forms and iframes are stripped on arrival. Owner-authenticated: requires your zeq_ak_ key (from zeq_spin_up).

Input schema

Field	Type	Required	Description
`subject`	string	yes	Subject line of the email.
`html`	string	yes	The email body as HTML (fragment or full document).
`text`	string	no	Optional plain-text alternative. Generated from the HTML if omitted — always sent, because an empty text part reads blank in text-only clients.
`from`	string	no	Optional display name to attribute the draft to, e.g. 'Campaign Builder'. Cosmetic only; delivery is always to your own mailbox.

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_mail_html",
           "arguments": {
             "subject": "example",
             "html": "example",
             "text": "hello from the Zeq SDK",
             "from": "ZEQ7B3K9QX2M7T4V8N1C6H0DZ"
           }
         }
       }'

`zeq_compute`

Compute physics results using the Zeq.dev HulyaSync framework. Applies 1,600+ catalogued operators across 67 domains (19 closed-form solvers; coverage map published). Every result is phase-stamped to the HulyaPulse (1.287 Hz system clock) and returned as a ZeqState envelope with masterSum R(t), phase φ, Zeqond τ, and an explicit numeric-accuracy bound. KO42 is always included. Response includes a zeqProof HMAC for tamper-evident verification. Requires a valid zeq_ak_ API key in the Authorization header.

Input schema

Field	Type	Required	Description
`domain`	string	yes	Physics domain to compute in. Examples: quantum-mechanics, classical-mechanics, thermodynamics, fluid-dynamics, aerospace, electromagnetism, astrophysics, biomedical, materials-science. 67 domains are available — use zeq_list_operators to see all.
`inputs`	object<string, number>	yes	Key-value pairs of numeric domain inputs — use the keys the solver actually reads. Example for quantum-mechanics (particle in a box): {"n": 1, "L": 1e-10, "m": 9.109e-31} → E_n eigenvalue. Unrecognized keys are rejected by the dimensional gate (value: NaN), so match the domain's documented inputs. Values must be finite numbers.
`operators`	array<string>	no	Optional list of specific operator IDs to apply (e.g. ['QM01', 'QM03']). KO42 is always added automatically. If omitted, the domain default operator is used. Use zeq_list_operators to discover available IDs per domain.
`folder`	string	no	Optional folder name to file this computation under (e.g. 'Orbital Mechanics'). Computations sharing a folder group together: each folder becomes a tab in the state explorer and a directory in the user's ZeqGit 'computations' repo (open in Zeq Studio). Reuse the same name to keep adding to it; omit for the 'unfiled' catch-all. When a user is running several related computes, ask if they want to name a folder.

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_compute",
           "arguments": {
             "domain": "Acoustics",
             "inputs": {
               "mass": 70,
               "r": 1
             },
             "operators": [
               "KO42"
             ],
             "folder": "example"
           }
         }
       }'

`zeq_list_operators`

List available Zeq.dev physics operators for a given domain, or list all 67 domains. Use this to discover operator IDs before calling zeq_compute. No API key required.

Input schema

Field	Type	Required	Description
`domain`	string	no	Domain to list operators for. Omit or pass empty string to list all 67 domains.

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_list_operators",
           "arguments": {
             "domain": "Acoustics"
           }
         }
       }'

`zeq_paper_search`

Search the scientific literature across arXiv, OpenAlex, Crossref and Europe PMC in one call. Returns deduplicated results with a canonical id (arxiv:… / doi:… / pmid:…), title, authors, date, venue and abstract snippet. Use this INSTEAD of answering a literature question from memory — a citation you did not look up is a guess. No API key required.

Input schema

Field	Type	Required	Description
`q`	string	yes	Search query, e.g. 'AlphaFold protein structure prediction'.
`sources`	array<string>	no	Optional subset of: arxiv, openalex, crossref, europepmc, semanticscholar, biorxiv. Defaults to the four that work without a key.
`limit`	number	no	Max results, 1-50. Default 20.

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_paper_search",
           "arguments": {
             "q": "example",
             "sources": [
               "example"
             ],
             "limit": 10
           }
         }
       }'

`zeq_paper_fetch`

Fetch one scientific record by canonical id — 'arxiv:1706.03762', 'doi:10.1038/s41586-021-03819-2', 'pmid:34265844'. Returns the full record including abstract where the source provides one. Use this to verify a citation before repeating it. No API key required.

Input schema

Field	Type	Required	Description
`id`	string	yes	Canonical id in 'scheme:local' form. Schemes: arxiv, doi, pmid, openalex, s2, biorxiv.

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_paper_fetch",
           "arguments": {
             "id": "01J8ZQ2H9VMR4K"
           }
         }
       }'

`zeq_domain_match`

Given a paper (canonical id) or any text, return which of the 67 Zeq operator domains it plausibly falls in, with the exact vocabulary terms that fired as evidence. Use this to ask 'could the framework compute this?' before claiming it can. IMPORTANT: this is deterministic term overlap, NOT a solvability proof — 258 of 1,612 operators (16%) have their own equation evaluated, so a domain match means 'worth testing with zeq_solve', never 'solvable'.

Input schema

Field	Type	Required	Description
`id`	string	no	Canonical id — arxiv:1706.03762, doi:10.1038/…, pmid:…
`text`	string	no	Raw text to classify, if you have no id.
`limit`	number	no	Max domains to return, 1-12. Default 5.

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_domain_match",
           "arguments": {
             "id": "01J8ZQ2H9VMR4K",
             "text": "hello from the Zeq SDK",
             "limit": 10
           }
         }
       }'

`zeq_science_domains`

List the 67 Zeq operator domains and which literature sources serve each. Use before zeq_paper_search to scope a search: applied/industry domains (ENERGY, FIN, ENG, MAT) are served by Crossref + OpenAlex, physics and CS by arXiv, biomedical by Europe PMC. Scoping measurably improves precision. No API key required.

This tool takes no input fields (or publishes none).

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_science_domains",
           "arguments": {}
         }
       }'

`zeq_find_operator`

Find operators by name, id, equation or description — ONE call instead of paging through domains. Returns id, domain, PREFIX (what zeq_compute takes), tier, equation and the domain's accepted input keys. No API key required.

Input schema

Field	Type	Required	Description
`term`	string	yes	Search term, e.g. 'schwarzschild', 'kinetic', 'QM9', 'entropy'.
`limit`	number	no	Max matches (default 12, max 40).

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_find_operator",
           "arguments": {
             "term": "example",
             "limit": 10
           }
         }
       }'

`zeq_pulse`

Get the current ZeqPulse state — live Zeqond counter, HulyaPulse phase φ, and R(t) value. No API key required. Use this to read the real-time 1.287 Hz heartbeat of the Zeq.dev framework and synchronize agent operations to the HulyaPulse clock.

This tool takes no input fields (or publishes none).

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_pulse",
           "arguments": {}
         }
       }'

`zeq_verify`

Verify a ZeqProof HMAC returned by zeq_compute. Confirms the response (including the physics value, for v2 receipts) reached you unmodified — integrity, not independent re-derivation of the physics. Pass the proof string along with operatorIds, R_t, zeqond, value, unit, and the keyPrefix from the original response. Returns valid: true/false. Requires API key.

Input schema

Field	Type	Required	Description
`proof`	string	yes	The 64-character hex zeqProof HMAC from the compute response (field: zeqProof).
`operatorIds`	array<string>	yes	Operator IDs array from the original zeqState.operators field.
`R_t`	number	yes	The masterSum value from the original zeqState.masterSum field.
`zeqond`	number	yes	The zeqond value from the original zeqState.zeqond field.
`keyPrefix`	string	no	Optional keyPrefix from the original response. Defaults to the API key user ID prefix.
`value`	number	no	The physics value from the original response (required for v2 receipts, which sign the value).
`unit`	string	no	The unit string from the original response (v2 receipts).

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_verify",
           "arguments": {
             "proof": "example",
             "operatorIds": [
               "example"
             ],
             "R_t": 1,
             "zeqond": 1,
             "keyPrefix": "example",
             "value": 1,
             "unit": "example"
           }
         }
       }'

`zeq_lattice`

Compute a ZeqLattice — a multi-node coherence grid. Pass an array of 2–5 node specs, each with optional { domain, inputs }. All nodes share one Date.now() timestamp but run at staggered HulyaPulse phases. Returns per-node R_t, coherenceScore (0–1), and lattice equation. Counts as N compute tokens (one per node). Requires API key.

Input schema

Field	Type	Required	Description
`nodes`	array<object>	yes	Array of 2–5 node specifications, each with optional domain and inputs.
`nodes[].domain`	string	no	Physics domain for this node (same options as zeq_compute).
`nodes[].inputs`	object<string, number>	no	Numeric key-value physics inputs for this node.

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_lattice",
           "arguments": {
             "nodes": [
               {
                 "domain": "Acoustics",
                 "inputs": {
                   "mass": 70,
                   "r": 1
                 }
               }
             ]
           }
         }
       }'

`zeq_shift`

Compute a ZeqShift — a deterministic forward time-series projection of R(t) across up to 64 Zeqond steps. Each step advances by 0.777 s (one Zeqond) and returns t (absolute seconds), phase φ, zeqond τ, R_t, and delta (R_t change from previous step; 0 for step 0). Counts as N compute tokens (one per step). Requires API key.

Input schema

Field	Type	Required	Description
`steps`	number	no	Number of Zeqond steps to project forward (1–64, default 16).
`domain`	string	no	Physics domain (optional, defaults to Quantum Mechanics).
`inputs`	object<string, number>	no	Numeric key-value physics inputs for S(t) computation.

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_shift",
           "arguments": {
             "steps": 1,
             "domain": "Acoustics",
             "inputs": {
               "mass": 70,
               "r": 1
             }
           }
         }
       }'

`zeq_field_status`

Query the ZeqField security system status — cipher algorithm, key source, and protocol versions. Returns whether ZEQ_FIELD_KEY is configured, current PBKDF2 parameters, and ZeqProof HMAC settings. No API key required.

This tool takes no input fields (or publishes none).

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_field_status",
           "arguments": {}
         }
       }'

`zeq_solve`

Integrates the geodesic in the KO42-tensioned metric ds² = gμν dxμ dxν + α·sin(2π·1.287·t)·dt² and returns the trajectory φ(t), the register dump, the HULYAS functional energy E = P_φ · Z(M,R,δ,C,X), and the term-by-term diagnostic. The base metric carries the REAL physics selected by the operators (7-step SELECT→BIND): NM19/NM24 → free-fall −g; NM21 (+ real position in metres) → radial gravity −GM/x²; NM30 → SHM −ω²x; GR33–38 add the weak-field g₀₀ factor √(1−2GM/xc²) (relativity, in the metric). The KO42 metric tension rides on top for every domain — the unification — so R(t)=S(t)[1+α·sin] reduces to textbook mechanics within the α≈1.29e-3 band and its Zeqond-average recovers S(t) exactly. errorPct is a TOLERANCE CEILING (≤0.1% confirms 'computed within physical law'), not an error rate. Use REAL numbers and REAL positions. (zeq_compute is the exact static closed-form path.) Requires zeq_ak_ API key.

Input schema

Field	Type	Required	Description
`prompt`	string	yes	Label only — never read by math. Max 500 chars.
`mass`	number	no	Object mass in kg. Default 1.0.
`location`	string	no	Categorical: earth \| mars \| moon \| jupiter \| sun.
`medium`	string	no	Categorical: air \| water \| vacuum.
`object`	string	no	Free-form object label — not read by math.
`alpha`	number	no	KO42.1 amplitude. Default 1.0.
`beta`	number	no	KO42.2 amplitude. Default 0.0.
`koSettings`	object<string, number>	no	Operator weights, keyed by operator ID (e.g. { KO42: 1.0, NM21: 0.5, GR35: 0.3 }).
`tMax`	number	no	Simulation horizon in seconds. Clamped to [0.1, 30]. Default 5.0.
`position`	number	no	Real starting position/radius in METRES for gravity mode (a=−GM/x²). Real numbers only — not toy units.
`dt`	number	no	Integrator timestep. Clamped to [0.001, 0.1]. Default 0.01.
`useOperatorModules`	boolean	no	Use operator-specific physics values (SDK formula path).
`normalizeOperators`	boolean	no	Default true: normalise operator values by reference scale.
`coreOnly`	boolean	no	Restrict coupling to the 8 Core Operator Families.
`referenceMode`	string — one of "free-fall", "shm", "gravity", "model"	no	Base-metric law: free-fall (−g), shm (−ω²x), gravity (−GM/x², needs `position`), or model. Operators (NM19/NM21/NM24/NM30, GR33–38) also select it automatically.
`strict`	boolean	no	ALWAYS ON (2026-08-10 — same rule as the REST route since 2026-08-01): every solve autotunes β + operator weights to drive the precision bound vs the chosen referenceMode to ≤ 0.1 %, and REFUSES to seal anything still outside it. This flag is accepted and ignored; there is no opt-out. Honest — returns tuneStatus 'converged' (tolerance met) or a refusal (never a faked pass).
`maxIterations`	number	no	Strict-mode autotune budget (1–40). Default 40.
`folder`	string	no	Optional folder name to file this solve under. Computations sharing a folder group into a tab in the state explorer and a directory in the user's ZeqGit 'computations' repo (open in Zeq Studio). Reuse the name to append; omit for the 'unfiled' catch-all.

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_solve",
           "arguments": {
             "prompt": "example",
             "mass": 70,
             "location": "earth",
             "medium": "air",
             "object": "example",
             "alpha": 1,
             "beta": 1,
             "koSettings": {
               "key": 1
             }
           }
         }
       }'

`zeq_multibody`

Run the vector master equation: N coupled φ_i(t) trajectories with pairwise inverse-square coupling. Each body gets its own register dump; every pair returns mean/final force magnitude + separation statistics. Use for Sun-Earth-Moon-style three-body experiments. Strictly mathematical — math reads only the numerical/categorical fields. Requires zeq_ak_ API key.

Input schema

Field	Type	Required	Description
`prompt`	string	yes	Label only — never read by math.
`bodies`	array<object>	yes	Array of body specs (2–16 bodies).
`bodies[].mass`	number	yes	Body mass in kg.
`bodies[].location`	string	no	earth \| mars \| moon \| jupiter \| sun.
`bodies[].medium`	string	no	air \| water \| vacuum.
`bodies[].object`	string	no	Free-form label.
`bodies[].phi0`	number	no	Optional explicit initial φ.
`bodies[].dphi0`	number	no	Optional explicit initial dφ/dt.
`bodies[].position`	number	no	Real 1-D position in METRES. If every body has one, runs REAL Newtonian gravity (G, real r) instead of the dimensionless φ-field.
`alpha`	number	no	—
`beta`	number	no	—
`koSettings`	object<string, number>	no	Operator weights shared across all bodies.
`tMax`	number	no	—
`dt`	number	no	—
`pairwiseCoupling`	number	no	γ in the pairwise term. Default 0.05.
`pairwiseSoftening`	number	no	ε² softening. Default 1e-6.
`useOperatorModules`	boolean	no	—
`normalizeOperators`	boolean	no	—
`coreOnly`	boolean	no	—
`folder`	string	no	Optional folder name to file this multibody run under. Computations sharing a folder group into a tab in the state explorer and a directory in the user's ZeqGit 'computations' repo (open in Zeq Studio). Reuse the name to append; omit for 'unfiled'.

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_multibody",
           "arguments": {
             "prompt": "example",
             "bodies": [
               {
                 "mass": 70,
                 "location": "earth",
                 "medium": "air",
                 "object": "example",
                 "phi0": 1,
                 "dphi0": 1,
                 "position": 1
               }
             ],
             "alpha": 1,
             "beta": 1,
             "koSettings": {
               "key": 1
             },
             "tMax": 1,
             "dt": 1,
             "pairwiseCoupling": 1
           }
         }
       }'

`zeq_evolve`

Run ZeqEvolve — deterministic Nano-Zeqond MOLECULAR DYNAMICS: velocity-Verlet (2nd-order symplectic) integration of a Lennard-Jones system (NM19) with optional harmonic bonds (NM30) in the NVE ensemble. Presets: lj-liquid, lj-gas, crystal, polymer. Returns the energy-conservation drift (the ≤0.1% reality check), temperature, virial pressure and total momentum, plus a ZEQOND_RECEIPT of the real fields it produced. Same inputs reproduce the same run (seeded). Real physics for materials/soft-matter/biology sandboxes. Requires zeq_ak_ API key.

Input schema

Field	Type	Required	Description
`preset`	string	no	lj-liquid \| lj-gas \| crystal \| polymer. Default lj-liquid.
`N`	number	no	Particle count (2–2000). Default from preset.
`rho`	number	no	Number density N/area (reduced units).
`T0`	number	no	Initial temperature (reduced units).
`steps`	number	no	Velocity-Verlet steps (10–200000). Default 2000.
`dtSim`	number	no	MD time step, reduced units. Default 0.003 (VV-stable).
`eps`	number	no	Lennard-Jones ε. Default 1.
`sig`	number	no	Lennard-Jones σ. Default 1.
`rc`	number	no	Cutoff in units of σ. Default 2.5.
`kBond`	number	no	Harmonic bond stiffness (polymer). Default 30.
`r0Bond`	number	no	Bond rest length. Default 1.
`seed`	number	no	Seed for reproducibility. Omit → deterministic seed derived from the inputs.
`sample`	number	no	Energy samples in the returned series (2–500). Default 40.
`folder`	string	no	Optional folder to file this run under (groups in the explorer + ZeqGit).

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_evolve",
           "arguments": {
             "preset": "lj-liquid",
             "N": 10,
             "rho": 1,
             "T0": 1,
             "steps": 1,
             "dtSim": 1,
             "eps": 1,
             "sig": 1
           }
         }
       }'

`zeq_action`

Run ZeqAction — a least-action, HIGH-ORDER SYMPLECTIC integrator (Störmer-Verlet → Yoshida triple-jump, order 4/6/8, fixed dt, Kahan-compensated). Structure-preserving, so energy has NO secular drift. Systems: kepler (orbit), oscillator (anharmonic), pendulum. It ALSO runs classical RK4 on the same system and returns both drifts, proving the difference — symplectic stays bounded, RK4 drifts (the orbit decays). The reality check for long-horizon dynamics. Requires zeq_ak_ API key.

Input schema

Field	Type	Required	Description
`system`	string	no	kepler \| oscillator \| pendulum. Default kepler.
`order`	number	no	Symplectic composition order: 2 \| 4 \| 6 \| 8. Default 4.
`steps`	number	no	Integration steps (10–2,000,000). Default 20000.
`dt`	number	no	Fixed time step (symplecticity needs it constant). Default 0.01.
`eccentricity`	number	no	Kepler orbit eccentricity 0–0.98. Default 0.6.
`mu`	number	no	Kepler gravitational parameter. Default 1.
`omega`	number	no	Oscillator frequency. Default 1.
`lambda`	number	no	Oscillator quartic anharmonicity. Default 1.
`q0`	number	no	Initial coordinate (oscillator/pendulum).
`p0`	number	no	Initial momentum (oscillator/pendulum).
`compare`	boolean	no	Also run RK4 to show the drift difference. Default true.
`sample`	number	no	Series points returned (2–500). Default 60.
`folder`	string	no	Optional folder to file this run under.

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_action",
           "arguments": {
             "system": "kepler",
             "order": 1,
             "steps": 1,
             "dt": 1,
             "eccentricity": 1,
             "mu": 1,
             "omega": 1,
             "lambda": 1
           }
         }
       }'

`zeq_heat`

ZeqHeat — 2-D heat/diffusion ∂T/∂t=α(∂²T/∂x²+∂²T/∂y²) on a grid (the default). method 'explicit' (FTCS, conditionally stable — blows up past the 2-D CFL r=α·dt·(1/dx²+1/dy²)=½) or 'implicit' (ADI Peaceman–Rachford, UNCONDITIONALLY stable). Compared to the exact 2-D Fourier-mode decay. Fills temperature_field + heat_flux_vector. Pass dim:1 (or L, or the 1-D mode) for the original 1-D bar. Requires zeq_ak_ key.

Input schema

Field	Type	Required	Description
`method`	string	no	explicit \| implicit (default)
`nx`	number	no	grid points in x (8–128)
`ny`	number	no	grid points in y (8–128)
`kx`	number	no	Fourier mode in x
`ky`	number	no	Fourier mode in y
`alpha`	number	no	—
`dt`	number	no	—
`steps`	number	no	—
`dim`	number	no	1 for the 1-D bar
`mode`	number	no	1-D Fourier mode (selects the 1-D bar)
`folder`	string	no	—

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_heat",
           "arguments": {
             "method": "explicit",
             "nx": 1,
             "ny": 1,
             "kx": 1,
             "ky": 1,
             "alpha": 1,
             "dt": 1,
             "steps": 1
           }
         }
       }'

`zeq_lorenz`

ZeqLorenz — the Lorenz attractor (RK4), deterministic chaos. Checks the exact phase-volume contraction −(σ+1+β) and measures the Lyapunov exponent (butterfly effect) from a twin trajectory. Bounded strange attractor, reproduced bit-for-bit. Requires zeq_ak_ key.

Input schema

Field	Type	Required	Description
`sigma`	number	no	—
`rho`	number	no	—
`beta`	number	no	—
`dt`	number	no	—
`steps`	number	no	—
`delta`	number	no	twin separation for the Lyapunov estimate
`folder`	string	no	—

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_lorenz",
           "arguments": {
             "sigma": 1,
             "rho": 1,
             "beta": 1,
             "dt": 1,
             "steps": 1,
             "delta": 1,
             "folder": "example"
           }
         }
       }'

`zeq_wave`

ZeqWave — 2-D MEMBRANE wave ∂²u/∂t²=c²(∂²u/∂x²+∂²u/∂y²) by leapfrog (the default), reality-checked by EXACT discrete-energy conservation (drift ~1e-13) and against the standing mode ω=cπ√(kx²/Lx²+ky²/Ly²). 2-D Courant C=c·dt·√(1/dx²+1/dy²)≤1 or it explodes. Pass mode:'maxwell' for 1-D Maxwell (Yee FDTD), or dim:1 / mode_k for the 1-D scalar wave. Fills displacement/velocity (or E,B in maxwell). Requires zeq_ak_ key.

Input schema

Field	Type	Required	Description
`mode`	string	no	membrane (default) \| maxwell \| wave1d
`nx`	number	no	grid x (16–128)
`ny`	number	no	grid y (16–128)
`kx`	number	no	2-D mode in x
`ky`	number	no	2-D mode in y
`c`	number	no	—
`dt`	number	no	—
`courant`	number	no	target 2-D Courant (default 0.5)
`steps`	number	no	—
`dim`	number	no	1 for the 1-D scalar wave
`mode_k`	number	no	1-D Fourier mode (selects 1-D)
`eps`	number	no	—
`mu`	number	no	—
`folder`	string	no	—

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_wave",
           "arguments": {
             "mode": "example",
             "nx": 1,
             "ny": 1,
             "kx": 1,
             "ky": 1,
             "c": 1,
             "dt": 1,
             "courant": 1
           }
         }
       }'

`zeq_flow`

ZeqFlow — 2-D incompressible Navier–Stokes (Stam stable fluids): advect + diffuse + pressure PROJECTION so ∇·u→0. Reports divergence before/after projection. Fills velocity/pressure/viscosity. Requires zeq_ak_ key.

Input schema

Field	Type	Required	Description
`N`	number	no	grid size (8–160)
`steps`	number	no	—
`dt`	number	no	—
`visc`	number	no	—
`iters`	number	no	Poisson iterations
`folder`	string	no	—

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_flow",
           "arguments": {
             "N": 10,
             "steps": 1,
             "dt": 1,
             "visc": 1,
             "iters": 1,
             "folder": "example"
           }
         }
       }'

`zeq_fracture`

ZeqFracture — 2-D bond-based peridynamic CRACK PROPAGATION (mode-I SENT, the default): a seeded edge notch either holds below a critical far-field strain, or the crack initiates at the tip and runs across the specimen above it (unstable fracture). Reports crack tip, advance, whether it spanned, critical strain. Fills the material+boundary receipt tier: stress, strain, damage, elasticity, boundary_traction, contact. Pass mode:"bar" (or an N) for the 1-D cohesive bar. Requires zeq_ak_ key.

Input schema

Field	Type	Required	Description
`mode`	string	no	"2d" (default, crack propagation) \| "bar" (1-D)
`nx`	number	no	2-D grid width (16–64)
`ny`	number	no	2-D grid height (8–40)
`notchFrac`	number	no	2-D starter-notch length as a fraction of width (0.1–0.6)
`horizonM`	number	no	peridynamic horizon in grid spacings (2–4)
`N`	number	no	1-D bar node count (selects mode:bar)
`E`	number	no	—
`strain`	number	no	max applied far-field strain
`s0`	number	no	critical bond stretch
`sf`	number	no	1-D full-failure stretch
`loadSteps`	number	no	—
`relaxIters`	number	no	—
`folder`	string	no	—

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_fracture",
           "arguments": {
             "mode": "example",
             "nx": 1,
             "ny": 1,
             "notchFrac": 1,
             "horizonM": 1,
             "N": 10,
             "E": 1,
             "strain": 1
           }
         }
       }'

`zeq_react`

ZeqReact — reaction–diffusion (biology). model 'gray-scott' (Turing morphogenesis: spots/stripes/worms self-organise) or 'fitzhugh-nagumo' (excitable media: cardiac/neural travelling & spiral waves). 2-D grid, explicit. Stability D·dt/dx²≤¼ or it blows up. Fills the chemical/biological receipt tier (concentration + reaction rate). Requires zeq_ak_ key.

Input schema

Field	Type	Required	Description
`model`	string	no	gray-scott \| fitzhugh-nagumo
`N`	number	no	grid size (16–400)
`steps`	number	no	—
`dt`	number	no	—
`Du`	number	no	—
`Dv`	number	no	—
`F`	number	no	Gray-Scott feed
`k`	number	no	Gray-Scott kill
`epsilon`	number	no	—
`a`	number	no	—
`b`	number	no	—
`I`	number	no	FitzHugh-Nagumo stimulus
`folder`	string	no	—

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_react",
           "arguments": {
             "model": "gray-scott",
             "N": 10,
             "steps": 1,
             "dt": 1,
             "Du": 1,
             "Dv": 1,
             "F": 1,
             "k": 1
           }
         }
       }'

`zeq_epi`

ZeqEpi — SIR/SEIR epidemic dynamics (RK4). Reality check: population conserved. Reports R₀, peak infected, peak day, final size (Kermack–McKendrick). Public-health domain. Requires zeq_ak_ key.

Input schema

Field	Type	Required	Description
`model`	string	no	sir \| seir
`beta`	number	no	—
`gamma`	number	no	—
`sigma`	number	no	—
`N`	number	no	—
`I0`	number	no	—
`days`	number	no	—
`folder`	string	no	—

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_epi",
           "arguments": {
             "model": "sir",
             "beta": 1,
             "gamma": 1,
             "sigma": 1,
             "N": 10,
             "I0": 1,
             "days": 1,
             "folder": "example"
           }
         }
       }'

`zeq_quant`

ZeqQuant — European option price by Monte-Carlo, verified against the closed-form Black–Scholes. Reports price, standard error, delta. Quant-finance domain. Requires zeq_ak_ key.

Input schema

Field	Type	Required	Description
`type`	string	no	call \| put
`S0`	number	no	—
`K`	number	no	—
`r`	number	no	—
`sigma`	number	no	—
`T`	number	no	—
`paths`	number	no	—
`folder`	string	no	—

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_quant",
           "arguments": {
             "type": "call",
             "S0": 1,
             "K": 1,
             "r": 1,
             "sigma": 1,
             "T": 1,
             "paths": 1,
             "folder": "example"
           }
         }
       }'

`zeq_zeta`

ZeqZeta — locate Riemann zeta nontrivial zeros on the ½-line (Riemann–Siegel) and VERIFY the count against N(T)=θ(T)/π+1 up to height T. Verifies RH in range; does NOT prove it. Number-theory domain. Requires zeq_ak_ key.

Input schema

Field	Type	Required	Description
`T`	number	no	height up to which to verify (15–2000)
`dt`	number	no	—
`folder`	string	no	—

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_zeta",
           "arguments": {
             "T": 1,
             "dt": 1,
             "folder": "example"
           }
         }
       }'

`zeq_sat`

ZeqSAT — DPLL 3-SAT solver on a seeded random instance at ratio α=m/n (hardness peaks ≈4.26). Certifies SAT assignments; reports decisions/propagations (the NP-hard scaling). Solves instances; does NOT resolve P vs NP. Requires zeq_ak_ key.

Input schema

Field	Type	Required	Description
`n`	number	no	variables (3–120)
`alpha`	number	no	clause/variable ratio
`m`	number	no	—
`seed`	number	no	—
`folder`	string	no	—

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_sat",
           "arguments": {
             "n": 10,
             "alpha": 1,
             "m": 1,
             "seed": 1,
             "folder": "example"
           }
         }
       }'

`zeq_gauge`

ZeqGauge — 2-D compact U(1) lattice gauge theory (Metropolis). Mean plaquette verified against the EXACT Bessel result I₁(β)/I₀(β). The method used to study Yang–Mills numerically; does NOT prove the mass-gap theorem. Requires zeq_ak_ key.

Input schema

Field	Type	Required	Description
`L`	number	no	lattice size (4–64)
`beta`	number	no	—
`sweeps`	number	no	—
`seed`	number	no	—
`folder`	string	no	—

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_gauge",
           "arguments": {
             "L": 1,
             "beta": 1,
             "sweeps": 1,
             "seed": 1,
             "folder": "example"
           }
         }
       }'

`zeq_fea`

ZeqFEA — 2-D plane-stress finite-element cantilever (Q4, matrix-free element-by-element Jacobi-preconditioned CG — memory O(dof), so LARGE meshes run: up to ~9000 elements). Tip deflection vs Euler–Bernoulli beam theory; refine the mesh and the ratio CONVERGES to ~1.00 (coarse 24×6 is ~0.94, refined 120×30 is ~1.00). Reports von Mises stress, CG residual. Fills stress/strain/displacement/elasticity. Structural-engineering domain. Requires zeq_ak_ key.

Input schema

Field	Type	Required	Description
`nx`	number	no	elements along length (4–220, default 120)
`ny`	number	no	elements through depth (2–80, default 30)
`Lx`	number	no	—
`Ly`	number	no	—
`E`	number	no	—
`P`	number	no	—
`folder`	string	no	—

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_fea",
           "arguments": {
             "nx": 1,
             "ny": 1,
             "Lx": 1,
             "Ly": 1,
             "E": 1,
             "P": 1,
             "folder": "example"
           }
         }
       }'

`zeq_grid`

ZeqGrid — DC power-flow on an N-bus network (B·θ=P). Reality check: Kirchhoff's current law + power balance. Reports bus angles, line flows, max loading. Power-systems domain. Requires zeq_ak_ key.

Input schema

Field	Type	Required	Description
`N`	number	no	buses (3–300)
`chords`	number	no	—
`reactance`	number	no	—
`seed`	number	no	—
`folder`	string	no	—

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_grid",
           "arguments": {
             "N": 10,
             "chords": 1,
             "reactance": 1,
             "seed": 1,
             "folder": "example"
           }
         }
       }'

`zeq_device`

ZeqDevice — 2-D device ELECTROSTATICS (the default): the potential + field in a semiconductor cross-section under an electrode, solving ∇²φ=0 by matrix-free Jacobi-preconditioned CG, verified against the EXACT analytic solution (a sinh Fourier mode) to ~0.004% — the peak |E| sets breakdown (MOSFET/HEMT/diode design). Pass dim:1 (or Na/Nd) for the 1-D PN junction (built-in voltage V_bi=V_T·ln(NaNd/ni²) vs Poisson). Fills potential + E-field. Requires zeq_ak_ key.

Input schema

Field	Type	Required	Description
`nx`	number	no	2-D grid x (16–220)
`ny`	number	no	2-D grid y (16–220)
`Lx`	number	no	—
`Ly`	number	no	—
`V`	number	no	electrode voltage
`kx`	number	no	electrode mode
`dim`	number	no	1 for the PN junction
`Na`	number	no	1-D acceptor doping (m⁻³) — selects PN junction
`Nd`	number	no	1-D donor doping (m⁻³)
`ni`	number	no	—
`T`	number	no	—
`folder`	string	no	—

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_device",
           "arguments": {
             "nx": 1,
             "ny": 1,
             "Lx": 1,
             "Ly": 1,
             "V": 1,
             "kx": 1,
             "dim": 1,
             "Na": 1
           }
         }
       }'

`zeq_opt`

ZeqOpt — nonlinear optimization: minimise a test function (sphere, rosenbrock, rastrigin, beale) by Nelder–Mead or gradient descent, checked against the KNOWN global minimum. Operations-research / ML / design domain. Requires zeq_ak_ key.

Input schema

Field	Type	Required	Description
`fn`	string	no	sphere \| rosenbrock \| rastrigin \| beale
`method`	string	no	nelder-mead \| gradient
`dim`	number	no	—
`maxIter`	number	no	—
`folder`	string	no	—

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_opt",
           "arguments": {
             "fn": "sphere",
             "method": "nelder-mead",
             "dim": 1,
             "maxIter": 1,
             "folder": "example"
           }
         }
       }'

`zeq_climate`

ZeqClimate — 2-D shallow-water equations (Lax–Friedrichs), a droplet radiating gravity waves. Reality check: total mass conserved; CFL √(gH)dt/dx≤1. Fills velocity + height. Climate / geophysics / oceanography domain. Requires zeq_ak_ key.

Input schema

Field	Type	Required	Description
`N`	number	no	—
`steps`	number	no	—
`g`	number	no	—
`H`	number	no	—
`dt`	number	no	—
`folder`	string	no	—

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_climate",
           "arguments": {
             "N": 10,
             "steps": 1,
             "g": 1,
             "H": 1,
             "dt": 1,
             "folder": "example"
           }
         }
       }'

`zeq_unified`

ZeqUnifiedComposer -- compose MULTIPLE operators in ONE call. Give an operator chain (KO42 is auto-prepended) plus numeric inputs; each operator is evaluated formula-as-data (no eval) and composed: Strategy A (algebraic product under the KO42 frame), B (sequential Zeqond timeline, RK4 for ODE operators), or C (single-operator fallback). Operators may be ids (GR37, NM19, NM21, QM9, ORBIT_PERIOD, NM23/24/26, GR35/36/41, QM10) or {id, equation, unit?, kind?} objects for ANY formula-as-data expression. Returns the composed value, the method, per-operator intermediates and the compiled expression, sealed like every solver. Requires zeq_ak_ key.

Input schema

Field	Type	Required	Description
`operators`	array<any>	no	operator ids and/or {id, equation, unit?, kind?} objects; KO42 auto-prepended
`inputs`	object	no	numeric inputs used by the operator equations (mass, m, v, r, a, ...)
`consts`	object	no	optional overrides: t, alpha, f_H, T_Z
`folder`	string	no	—

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_unified",
           "arguments": {
             "operators": [
               {}
             ],
             "inputs": {
               "mass": 70,
               "r": 1
             },
             "consts": {
               "t": 1
             },
             "folder": "example"
           }
         }
       }'

`zeq_dock`

ZeqDock — rigid-body molecular docking: minimise a Lennard-Jones + Coulomb score over the ligand's 6 DOF against a receptor pocket, from seeded restarts. Reports binding energy + pose. Drug-discovery / comp-chem domain. Requires zeq_ak_ key.

Input schema

Field	Type	Required	Description
`restarts`	number	no	—
`iters`	number	no	—
`seed`	number	no	—
`folder`	string	no	—

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_dock",
           "arguments": {
             "restarts": 1,
             "iters": 1,
             "seed": 1,
             "folder": "example"
           }
         }
       }'

`zeq_buckling`

ZeqBuckling — the Euler critical buckling load of a compressed column/strut: the axial load P_cr at which a slender member collapses (columns, struts, landing gear, rocket interstages, scaffolding). Solves the beam-column buckling generalised eigenproblem K φ=P·K_g φ from Hermitian Euler–Bernoulli beam finite elements (Cholesky reduction + Jacobi), the smallest positive P being P_cr. Checked against EULER's exact P_cr=π²·EI/(K·L)² for the end condition — pinned-pinned K=1, fixed-fixed K=0.5, fixed-free K=2, fixed-pinned K≈0.699. RMS error vs Euler is the seal (a coarse mesh seals observable-differential). Requires zeq_ak_ key.

Input schema

Field	Type	Required	Description
`ends`	string	no	"pinned-pinned" (default), "fixed-fixed", "fixed-free", "fixed-pinned"
`EI`	number	no	flexural rigidity E·I (N·m²)
`E`	number	no	Young's modulus (Pa)
`I`	number	no	second moment of area (m⁴)
`L`	number	no	column length (m)
`ne`	number	no	elements (4–80)
`folder`	string	no	—

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_buckling",
           "arguments": {
             "ends": "example",
             "EI": 1,
             "E": 1,
             "I": 1,
             "L": 1,
             "ne": 1,
             "folder": "example"
           }
         }
       }'

`zeq_acoustic`

ZeqAcoustic — the resonant modes of a 1-D acoustic resonator (Helmholtz −p″=k²p): the standing-wave frequencies of an organ pipe, wind instrument, exhaust/HVAC duct or muffler. Each end is OPEN (pressure-release) or CLOSED (rigid); a finite-volume + half-cell-mass discretisation gives a symmetric tridiagonal solved by Sturm bisection, and the frequencies f=kc/2π are checked against the EXACT closed forms — open–open n·c/2L, open–closed (2n−1)·c/4L, closed–closed n·c/2L. RMS error vs exact is the seal (a coarse grid seals observable-differential). Reports the fundamental + overtones in Hz. Requires zeq_ak_ key.

Input schema

Field	Type	Required	Description
`ends`	string	no	"open-open" (default), "open-closed", or "closed-closed"
`L`	number	no	resonator length (m)
`c`	number	no	sound speed (m/s), default 343
`N`	number	no	cells (64–6000)
`modes`	number	no	resonances to return (1–16)
`folder`	string	no	—

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_acoustic",
           "arguments": {
             "ends": "example",
             "L": 1,
             "c": 1,
             "N": 10,
             "modes": 1,
             "folder": "example"
           }
         }
       }'

`zeq_schrodinger`

ZeqSchrodinger — the time-independent Schrödinger eigenvalue problem Ĥψ=Eψ, Ĥ=−(ℏ²/2m)d²/dx²+V(x): the quantum bound-state ENERGY LEVELS behind atoms, quantum wells/dots, molecular vibration and the qubit. A finite-difference tridiagonal Hamiltonian is diagonalised by Sturm-sequence bisection (robust, deterministic) and its lowest levels are checked against the EXACT analytic spectrum — harmonic oscillator Eₙ=ℏω(n+½), infinite square well Eₙ=n²π²ℏ²/2mL². The RMS error vs exact is the seal (life-or-death: too coarse a grid or too small a box gives WRONG levels and seals observable-differential). Natural units ℏ=m=1. Requires zeq_ak_ key.

Input schema

Field	Type	Required	Description
`potential`	string	no	"harmonic" (default) or "square-well"
`N`	number	no	grid points (64–4000)
`levels`	number	no	eigenvalues to return (1–12)
`omega`	number	no	harmonic frequency ω
`L`	number	no	square-well width
`folder`	string	no	—

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_schrodinger",
           "arguments": {
             "potential": "example",
             "N": 10,
             "levels": 1,
             "omega": 1,
             "L": 1,
             "folder": "example"
           }
         }
       }'

`zeq_tumor`

ZeqTumor — Fisher–KPP growth front ∂u/∂t=D u_xx+r u(1−u): a population/tumor/gene that grows AND spreads, invading as a travelling front (oncology, invasion biology, gene spread, spatial epidemics). Reality checks: the density stays in [0,1] (the seal — a stable scheme holds it, an unstable one past CFL D·dt/dx²≤½ violates it and explodes), and the front advances at the EXACT Ablowitz–Zeppetella speed c=5√(rD/6) (verified to ~0.2%). Reports front speed, boundedness, pointwise error vs the exact wave. Requires zeq_ak_ key.

Input schema

Field	Type	Required	Description
`D`	number	no	diffusion (spread rate)
`r`	number	no	growth rate
`nx`	number	no	grid points (50–2000)
`L`	number	no	domain length
`x0`	number	no	initial front position
`dt`	number	no	—
`steps`	number	no	—
`folder`	string	no	—

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_tumor",
           "arguments": {
             "D": 1,
             "r": 1,
             "nx": 1,
             "L": 1,
             "x0": 1,
             "dt": 1,
             "steps": 1,
             "folder": "example"
           }
         }
       }'

`zeq_lotka`

ZeqLotka — predator–prey / ecosystem dynamics (Lotka–Volterra). dx/dt=αx−βxy, dy/dt=δxy−γy. Reality check: the first integral H=δx−γ·ln x+βy−α·ln y is conserved on every orbit — RK4 (default) holds it to ~1e-9 (the seal), forward-Euler drifts and the populations spiral to a FALSE extinction/explosion (the life-or-death). Reports the boom-bust extremes, cycle period, and coexistence fixed point (γ/δ, α/β). Fisheries, pest control, conservation biology. method 'rk4'|'symplectic'|'euler'. Requires zeq_ak_ key.

Input schema

Field	Type	Required	Description
`method`	string	no	rk4 (default) \| symplectic \| euler
`alpha`	number	no	prey growth
`beta`	number	no	predation rate
`delta`	number	no	predator growth from prey
`gamma`	number	no	predator death
`x0`	number	no	initial prey
`y0`	number	no	initial predator
`dt`	number	no	—
`steps`	number	no	—
`folder`	string	no	—

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_lotka",
           "arguments": {
             "method": "tools/call",
             "alpha": 1,
             "beta": 1,
             "delta": 1,
             "gamma": 1,
             "x0": 1,
             "y0": 1,
             "dt": 1
           }
         }
       }'

`zeq_kalman`

ZeqKalman — optimal state estimation (the Kalman filter): track a constant-velocity target from noisy position measurements (GPS/radar/robotics/sensor-fusion/navigation). Reality checks: the error covariance converges to the steady-state Riccati/DARE solution (the seal, → machine precision); empirical RMSE → √P∞ (optimality); innovation variance ≈ HP⁻Hᵀ+R (whiteness); the Joseph-form update keeps the covariance positive-definite (a naive update diverges). Deterministic (seeded). State-estimation / control domain. Requires zeq_ak_ key.

Input schema

Field	Type	Required	Description
`steps`	number	no	filter steps (50–20000)
`dt`	number	no	—
`sigmaA`	number	no	process (acceleration) noise σ
`sigmaZ`	number	no	measurement noise σ
`seed`	number	no	—
`v0`	number	no	true target velocity
`folder`	string	no	—

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_kalman",
           "arguments": {
             "steps": 1,
             "dt": 1,
             "sigmaA": 1,
             "sigmaZ": 1,
             "seed": 1,
             "v0": 1,
             "folder": "example"
           }
         }
       }'

`zeq_auto`

ZeqAuto — FRICTIONLESS: send a natural-language query + constants and the right solver is auto-selected, run, and sealed. Covers molecular dynamics, orbits, heat, chaos, waves/EM, fluids, fracture, reaction-diffusion, epidemics, option pricing, Riemann zeros, SAT, lattice gauge, FEA, power flow, semiconductors, optimization, shallow-water, docking. No operators or endpoint to pick. Requires zeq_ak_ key.

Input schema

Field	Type	Required	Description
`query`	string	yes	e.g. 'simulate a Lennard-Jones liquid', 'price a call S0=100 K=100 sigma=0.2', 'shallow-water tsunami', 'SIR epidemic R0=3'
`constants`	object	no	solver parameters (S0, K, sigma, preset, steps, beta, gamma, …)
`solver`	string	no	optional: force a specific solver key
`folder`	string	no	—

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_auto",
           "arguments": {
             "query": "speed of sound in air at 20 C",
             "constants": {},
             "solver": "example",
             "folder": "example"
           }
         }
       }'

`zeq_stream`

ZeqStream — hosted, ticking solver channels. A channel is a solver wrapped as a live endpoint with its OWN key that a game/sensor/instrument ticks. action=create makes one (returns its key, shown once); action=tick advances ONE Zeqond and seals an envelope + receipt; action=get/list/close manage it. Each seal is one credit-compute; tickIntervalZeqonds sets the fair cadence (≈111197 ≈ a 24-hour tick). Requires zeq_ak_ key.

Input schema

Field	Type	Required	Description
`action`	string	yes	create \| tick \| get \| list \| close \| link \| secure. link = a keyless signed pull URL (no API key/.env). secure = open a ZeqSSH AES-256-GCM encrypted line (returns a one-time sessionSecret).
`solver`	string	no	create: solver key (lorenz, quant, evolve, heat, …) — or use query
`query`	string	no	create: natural-language, auto-classified like zeq_auto
`constants`	object	no	create: base constants merged into every tick
`label`	string	no	—
`autotick`	boolean	no	create: server advances it every cadence (spends credits)
`tickIntervalZeqonds`	number	no	create: Zeqonds between seals; ~111197 ≈ 24h
`ttlSeconds`	number	no	link: how long the keyless URL stays valid (default 30d)
`channel`	string	no	tick/get/close/link/secure: the channel id
`inputs`	object	no	tick: values merged over the channel constants

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_stream",
           "arguments": {
             "action": "create",
             "solver": "example",
             "query": "speed of sound in air at 20 C",
             "constants": {},
             "label": "example",
             "autotick": true,
             "tickIntervalZeqonds": 1,
             "ttlSeconds": 1
           }
         }
       }'

`zeq_closedform`

ZeqClosedForm — the CLOSED-FORM master-equation solver, the analytic counterpart to the open-form RK4 (/api/solve). Compiles polynomial couplings a+bϕ+dϕ³ into effective (μ²_eff,λ_eff,F_eff) and writes the EXACT branch solution of ϕ̈=μ²_eff·ϕ+λ_eff·ϕ³+F_eff (÷ KO42 tensioner): free / uniform-accel / harmonic / hyperbolic / driven, and Duffing ϕ₀·cn(Ωt,k) via AGM (hardening & softening). KO42 enters first-order in α on the linear branches. Ships an independent RK4 closed-vs-open cross-check. ϕ² / √ / exp shapes are REFUSED by name, never approximated. Give effective coeffs directly (mu2_eff,lambda_eff,F_eff) OR couplings [{a,b,c,d}] / [{samples:[[x,y],...]}]; phi0/phidot0 (else equilibrium launch), t, ko42, alpha. Requires zeq_ak_ key.

Input schema

Field	Type	Required	Description
`mu2_eff`	number	no	effective μ² (skip compile)
`lambda_eff`	number	no	effective λ (cubic)
`F_eff`	number	no	effective constant forcing
`couplings`	array<any>	no	couplings to compile: {a,b,c,d} cubics or {samples:[[x,y],...]} (≥4 pts; c≠0 → refused QUADRATIC)
`mu2`	number	no	—
`lambda`	number	no	—
`Jext`	number	no	—
`phi42`	number	no	—
`phi0`	number	no	—
`phidot0`	number	no	—
`t`	number	no	evaluation time
`ko42`	boolean	no	apply the KO42 tensioner (default true)
`alpha`	number	no	KO42.1 amplitude (default 1e-3)
`mode`	string	no	auto \| manual
`beta`	number	no	manual-mode tensioner amplitude
`folder`	string	no	—

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_closedform",
           "arguments": {
             "mu2_eff": 1,
             "lambda_eff": 1,
             "F_eff": 1,
             "couplings": [
               {}
             ],
             "mu2": 1,
             "lambda": 1,
             "Jext": 1,
             "phi42": 1
           }
         }
       }'

`zeq_reactor`

ZeqReactor — recursive, sealed, environment-driven compute loops. Where zeq_stream BROADCASTS one sealed envelope, a reactor CLOSES THE LOOP: the sealed output of step n plus a live environment observation become the inputs for step n+1 — xₙ₊₁ = seal(Solver(T(xₙ, uₙ))), each step hash-linked to the previous. action=create builds one from a transition contract (a solver + initialInput + a transition.inputs map whose values are literals or dot-paths over {output, env, step}, e.g. sigmaZ:'env.noise', v0:'output.rmse'); action=step advances one step (a credit-compute, sealed + receipt), optional inline env; action=observe pushes an environment reading and steps immediately if the contract's trigger is 'on-observe'; action=state/trajectory/telemetry/get read it (owner-scoped); action=close stops it. Any of the 26 solvers can drive a reactor. Field-carry makes a stateful digital twin — set transition.inputs.initialState:'output.finalDensity' (e.g. a tumour front that keeps advancing). Each step is reality-gated: a step that fails its ≤0.1% check seals observable-differential and the onUnverified guard can halt the loop, so a blown-up state can never seed the next. Requires zeq_ak_ key (step/observe burn credit, tied to your ZID).

Input schema

Field	Type	Required	Description
`action`	string	yes	create \| list \| step \| observe \| state \| trajectory \| telemetry \| secure \| get \| close. secure = open a keyless ZeqSSH encrypted line to consume sealed states (no API key).
`solver`	string	no	create: solver key (kalman, lorenz, tumor, heat, …) or 'auto'
`initialInput`	object	no	create: x₀ base inputs, e.g. { steps: 60, sigmaZ: 0.5 }
`transition`	object	no	create: { inputs: { nextKey: 'env.x' \| 'output.y' \| literal } }
`trigger`	object	no	create: { mode: 'on-request' \| 'on-observe' }
`guards`	object	no	create: { maxSteps, creditBudget, until, onUnverified: 'halt'\|'continue' }
`contract`	object	no	create: a full contract object (overrides solver/initialInput/transition/trigger/guards)
`reactor`	string	no	step/observe/state/trajectory/telemetry/get/close: the reactor id
`env`	object	no	step/observe: the environment observation uₙ, e.g. { noise: 0.8 }
`folder`	string	no	create: seal folder for this reactor's steps

curl -sS -X POST https://zeq.me/api/mcp \
  -H "Authorization: Bearer $ZEQ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
         "jsonrpc": "2.0",
         "id": 1,
         "method": "tools/call",
         "params": {
           "name": "zeq_reactor",
           "arguments": {
             "action": "create",
             "solver": "example",
             "initialInput": {},
             "transition": {},
             "trigger": {},
             "guards": {},
             "contract": {},
             "reactor": "example"
           }
         }
       }'

Generated from x-mcp-tools in https://zeq.me/openapi.json by scripts/generate-reference.mjs.

zeq_protect​

zeq_api_catalog​

zeq_http​

zeq_spin_up​

zeq_contract_generate​

zeq_contract_templates​

zeq_contract_deploy​

zeq_contract_list​

zeq_contract_get​

zeq_contract_fire​

zeq_observer​

zeq_publish_page​

zeq_mail_html​

zeq_compute​

zeq_list_operators​

zeq_paper_search​

zeq_paper_fetch​

zeq_domain_match​

zeq_science_domains​

zeq_find_operator​

zeq_pulse​

zeq_verify​

zeq_lattice​

zeq_shift​

zeq_field_status​

zeq_solve​

zeq_multibody​

zeq_evolve​

zeq_action​

zeq_heat​

zeq_lorenz​

zeq_wave​

zeq_flow​

zeq_fracture​

zeq_react​

zeq_epi​

zeq_quant​

zeq_zeta​

zeq_sat​

zeq_gauge​

zeq_fea​

zeq_grid​

zeq_device​

zeq_opt​

zeq_climate​

zeq_unified​

zeq_dock​

zeq_buckling​

zeq_acoustic​

zeq_schrodinger​

zeq_tumor​

zeq_lotka​

zeq_kalman​

zeq_auto​

zeq_stream​

zeq_closedform​

zeq_reactor​

`zeq_protect`

`zeq_api_catalog`

`zeq_http`

`zeq_spin_up`

`zeq_contract_generate`

`zeq_contract_templates`

`zeq_contract_deploy`

`zeq_contract_list`

`zeq_contract_get`

`zeq_contract_fire`

`zeq_observer`

`zeq_publish_page`

`zeq_mail_html`

`zeq_compute`

`zeq_list_operators`

`zeq_paper_search`

`zeq_paper_fetch`

`zeq_domain_match`

`zeq_science_domains`

`zeq_find_operator`

`zeq_pulse`

`zeq_verify`

`zeq_lattice`

`zeq_shift`

`zeq_field_status`

`zeq_solve`

`zeq_multibody`

`zeq_evolve`

`zeq_action`

`zeq_heat`

`zeq_lorenz`

`zeq_wave`

`zeq_flow`

`zeq_fracture`

`zeq_react`

`zeq_epi`

`zeq_quant`

`zeq_zeta`

`zeq_sat`

`zeq_gauge`

`zeq_fea`

`zeq_grid`

`zeq_device`

`zeq_opt`

`zeq_climate`

`zeq_unified`

`zeq_dock`

`zeq_buckling`

`zeq_acoustic`

`zeq_schrodinger`

`zeq_tumor`

`zeq_lotka`

`zeq_kalman`

`zeq_auto`

`zeq_stream`

`zeq_closedform`

`zeq_reactor`