For agents and developers

Three executable paths into the public testnet: consume inference, run an executor node, audit. Everything below uses the live network parameters published in network.json (chain ember-s23-staging). The website chat described in the guide is a human showcase; this page is the real interface.

Machine-readable resources: llms.txt · openapi.yaml (OpenAPI 3.1, chain id and snapshot height embedded) · network.json · this page as Markdown · MCP endpoint https://relay.emberinfer.org/mcp.

Path 1 — Consume inference

1a. MCP tools (fastest, no install)

A remote MCP server runs at https://relay.emberinfer.org/mcp (JSON-RPC over HTTPS, same backend and same address-based auth as the website). Tools:

Identity is an Ed25519 key you generate; your address is hex(sha256(public_key)). The inference tool takes address, pubkey and signature (base64) inside its arguments and verifies a signature over the plain string ember-web/mcp-inference/v1\n<address>\n<model>\n<sha256hex(canonical messages JSON)>\n<max_tokens>. Canonical messages JSON means compact separators, sorted keys, UTF-8 with non-ASCII unescaped — in Python: json.dumps(messages, separators=(",", ":"), sort_keys=True, ensure_ascii=False).

Funding inference: inference spends website credit, the same prepaid balance the chat page uses. Get test Spark with faucet_claim, then transfer some to the website account d34487a050b0deb094ca4f4e3834b8416212e55a6ffa18bd4eafcd3ca8c7ba3a with a self-signed chain transfer (see 1d) broadcast through the public RPC — the backend credits your address automatically when the transfer finalizes. Unused credit can be withdrawn through a website session (see openapi.yaml).

Building a product on Ember inference? Partnerships and coordination: emberinfer@proton.me.

Sizing requests: the on-chain freeze bound grows with input tokens and max_tokens, and the chain rejects a freeze whose bound exceeds the assigned executor's remaining stake exposure (stake exposure limit, surfaced by gateways as HTTP 402). On the current testnet, keep max_tokens at 64 or below and inputs short; if you still hit it, retry (assignment is per-request) or shorten the request.

1b. Website chat (humans)

emberinfer.org/chat — browser-local key, faucet, prepaid credit, streamed answers with traces. Start with the guide; it states plainly what the page is and is not (a showcase, not an agent).

1c. Your own gateway (spend directly from your account)

The public gateway settles from a single operator consumer account — that is why the website and MCP use prepaid credit. To spend from your own account, run your own gateway from the same release: install with --role gateway and configure it from the template config/gateway.env.example (README, “Use it / Call a gateway”), register your consumer account in its auth file, then call it exactly like the README shows:

curl -fsS "$EMBER_GATEWAY_URL/v1/chat/completions" \
  -H "Authorization: Bearer $EMBER_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"model":"ember-qwen2.5-1.5b-s22-cpu-v1","messages":[{"role":"user","content":"Say OK"}],"max_tokens":16}'

The gateway freezes from your account, the scheduler assigns a node, and settlement lands on-chain under your address. Point the gateway at the public seed and RPC from the table in Path 2.

1d. Raw chain operations

The ledger is a CometBFT application. Reads need no auth: GET http://relay.emberinfer.org:39657/abci_query?path="/state", /account/<address>, /hold/<request_id> (values are base64 JSON). Faucet, direct:

curl -fsS http://relay.emberinfer.org:39095/testnet/faucet -H 'Content-Type: application/json' \
  -d '{"account":"<your-address-hex>"}'

Transfers are JSON envelopes signed with Ed25519 over ember/chain-tx/v1\x00 + the envelope JSON with signature: null, broadcast via broadcast_tx_commit on the same RPC. The exact byte format, the session login used by the website API, and every backend endpoint are specified in openapi.yaml.

Path 2 — Run an executor node

Nodes connect outbound to the seed — no inbound public port is needed. Serving is paid from the executor share of settled fees (80% executor / 15% auditor / 5% consumer refund, with scarcity multipliers up to 2× when coverage is below target; see PRICING.md). Registration stakes the on-chain minimum. Commands below follow the project Quickstart; verify the release first (SIGNING.md, signing key fingerprint d3b07085781f2d4d75de6caefa6e1dc9cd4eadeec10326b2b0c20eb03254eabb).

# 1. Download ember-0.2.0-linux-{amd64,arm64}.tar.gz + SHA256SUMS(.sig)
#    from https://github.com/emberinfer/Ember/releases/download/v0.2.0 and verify per SIGNING.md, then:
tar -xzf ember-0.2.0-linux-amd64.tar.gz && cd ember-0.2.0-linux-amd64
./install-release.sh --role node --prefix "$HOME/ember" --python python3.12

# 2. Fetch the model (weights are never distributed by the network;
#    they are verified against the on-chain manifest hash)
"$HOME/ember/venv/bin/python" - <<'PY'
from huggingface_hub import snapshot_download
snapshot_download("Qwen/Qwen2.5-1.5B-Instruct", revision="989aa7980e4cf806f80c7fef2b1adb7bc71aa306",
                  local_dir="~/models/Qwen2.5-1.5B-Instruct",
                  allow_patterns=["*.json", "*.txt", "*.safetensors"])
PY

Set the fields of the installed config/node.env to this network's published parameters (all from network.json):

# 3. Identity, funding, start
"$HOME/ember/bin/ember-node" id --state-dir "$HOME/ember/var/node"   # prints your address
curl -fsS http://relay.emberinfer.org:39095/testnet/faucet -H 'Content-Type: application/json' \
  -d '{"account":"<your-address>"}'                                  # faucet funds the stake
"$HOME/ember/bin/ember-role" node "$HOME/ember/config/node.env"        # stakes, registers, serves
curl -fsS http://127.0.0.1:19192/readyz                                # readiness (loopback only)

External CPU serving is slow for long requests; start with short ones. Registrations expire by height (default TTL 200000 blocks) and renew while you serve. To exit: stop the process and disable restarts, wait for registration expiry and outstanding holds to finish, then recover stake with ember-node exit --action status|unbond|claim (full procedure in the Quickstart).

Deploying nodes at scale or for an organization? Partnerships and coordination: emberinfer@proton.me.

Path 3 — Audit

Auditors replay committed token prefixes of sampled requests under the signed profile policy and sign verdicts; a rejection needs confirmation by a different assigned auditor, and disagreement cannot slash. Auditing is a node role: install as in Path 2 and set EMBER_AUDIT_ROLE=true in the generated config before the first join (Quickstart, “Network parameters”), then fund, register and run the same way. Removing the role takes effect at registration expiry. Auditors are paid from the 15% auditor share of the settled fees of the requests they audit. Cross-runtime verdicts are observe-only in the current build.

Note what auditing sees: in Phase 0 an assigned auditor can see the plaintext of the requests it replays. Audit only if that is acceptable for your participation; users are told the same on the chat page and in the guide.

Interested in auditing as an organization? Partnerships and coordination: emberinfer@proton.me.

Limitations

• Testnet only; Spark here is valueless test credit and carries over to no other network.
• Validators: single operator, static membership. No third-party security audit has taken place.
• Gateway account custody is centralized in the current build (one consumer account per gateway); the prepaid website model exists because of it.
• Privacy Phase 0 as above; no confidential-inference or hardware-attestation claim is made.
• Abuse controls: per-account and per-source faucet limits, gateway rate limits, bounded holds with height expiry.

Deeper reading: public network & trust model · pricing · audit design · disclaimer. Markdown mirror of this page: /agents.md.