Give this page to your AI

Paste this URL — https://zeqsdk.com/sdk/sdks/mcp/agent/ — to any MCP-capable AI (Claude Desktop/Code, Cursor, Cline, Zed, OpenAI Agents SDK, …). Everything the model needs to become a Zeq agent is below, written for the model. No prior account, no human steps after the paste.

For the AI reading this

You are connecting to the Zeq MCP — a physics/maths engine that returns HMAC-signed, independently verifiable results. Follow the four steps in order. Every API key belongs to an account, so you authenticate first (it's free and takes one call). Then compute, then verify the ZeqProof so you can trust the number.

Connect — two transports

A. stdio (local). Install from the framework's own registry and run the bridge:

npm config set @zeq:registry https://zeqsdk.com/registry
npm install -g @zeq/mcp
ZEQ_ORIGIN=https://zeqsdk.com zeq-mcp        # add ZEQ_API_KEY=… once you have one

Point your MCP client's command at zeq-mcp. It forwards to the live endpoint, so it always exposes the current tool set.

B. HTTP (no install). Speak JSON-RPC 2.0 directly to POST https://zeqsdk.com/api/mcp:

{"jsonrpc":"2.0","id":1,"method":"tools/list"}
{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"<tool>","arguments":{…}}}

Public tools (zeq_pulse, zeq_list_operators, zeq_field_status) need no key. Everything else needs Authorization: Bearer zeq_ak_….

You have no key yet, so mint a demo key — the authenticated entry point:

curl -sX POST https://zeqsdk.com/api/demo-key/mint -H 'Content-Type: application/json' -d '{}'
# → { "key": "zeq_ak_demo_…", "computeBudget": 5, … }

If you mint repeatedly from one IP you'll get POW_REQUIRED with a Landauer (LZ1) proof-of-work challenge: find a solution so sha256(challenge + ":" + solution) has the required leading-zero bits, then POST again with { "pow": { "challenge", "solution" } }. The first mint per hour is free.

Step 2 — Spin up your own machine

Call zeq_spin_up with the demo key. It provisions your own ZeqVM state machine and returns your main zeq_ak_ key + recovery equation (shown once):

curl -sX POST https://zeqsdk.com/api/mcp \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer zeq_ak_demo_…' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call",
       "params":{"name":"zeq_spin_up","arguments":{"displayName":"my-agent"}}}'
# → structuredContent: { apiKey: "zeq_ak_…", zid, machineSlug, recoveryEquation, recoverySalt, … }

Save apiKey (and the recovery equation/salt — there is no password reset). Use this main key for every call from here on.

Step 3 — Compute real physics

curl -sX POST https://zeqsdk.com/api/mcp \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer zeq_ak_…' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call",
       "params":{"name":"zeq_compute","arguments":{
         "domain":"Newtonian Mechanics","operators":["NM19"],
         "inputs":{"mass":5,"acceleration":9.81}}}}'

structuredContent comes back with value (49.05), unit (N), operators (KO42, NM19), masterSum, zeqond, a zeqProof string, and a ready-made verify object.

Step 4 — Verify the ZeqProof (HMAC)

Every result is signed. The ZeqProof is an HMAC over the canonical tuple operator | result | zeqond (keyed server-side), so a result can't be forged or altered without detection. To check it, hand the compute response's structuredContent.verify object straight to zeq_verify (with your key):

# verify = { proof, operatorIds, value, unit, R_t, zeqond, keyPrefix }  (from step 3)
curl -sX POST https://zeqsdk.com/api/mcp \
  -H 'Content-Type: application/json' \
  -H 'Authorization: Bearer zeq_ak_…' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call",
       "params":{"name":"zeq_verify","arguments": <the verify object> }}'
# → valid: YES ✓   (re-computes the HMAC over operator|result|zeqond and compares)

If valid is YES, the number is authentic and the proof round-trips. This is the trust anchor — never present a Zeq value to a user as verified unless zeq_verify returned YES.

The full tool set (18)

Tool	What it does	Key
`zeq_spin_up`	Demo key → your own machine + main key	demo key
`zeq_compute`	Operators + inputs → signed value + `verify`	Bearer
`zeq_solve`	Master-equation trajectory (precision-bound explorer; `strict:true` tightens tolerance)	Bearer
`zeq_multibody`	N-body coupled master equation	Bearer
`zeq_verify`	Re-check a ZeqProof HMAC	Bearer
`zeq_contract_templates` / `_deploy` / `_list` / `_get` / `_fire` / `_generate`	State-contract lifecycle (build & run programmable triggers)	Bearer
`zeq_publish_page`	Publish a live HTML app to `/s/<machine>/p/<page>/`	Bearer
`zeq_observer`	Read the entangled-state proof-of-computation feed	Bearer
`zeq_pulse` · `zeq_list_operators` · `zeq_field_status`	Live state / catalogue / status	public
`zeq_lattice` · `zeq_shift`	Multi-node coherence · time projection	Bearer

Operating rules for the agent

Authenticate once (steps 1–2), reuse the main key.
Every physics claim you surface should be backed by a zeq_verify that returned YES.
zeq_compute is the textbook-precise, signed path for named operators. zeq_solve is the master-equation explorer; its errorPct is a tolerance/precision bound, not a fault.
One machine is enough — don't mint in a loop (it costs escalating Landauer proof-of-work).

See the full reference at MCP server.

Connect — two transports​

Step 1 — Get a key (free, no signup)​

Step 2 — Spin up your own machine​

Step 3 — Compute real physics​

Step 4 — Verify the ZeqProof (HMAC)​

The full tool set (18)​

Operating rules for the agent​