Self-host the query plane

The entire query plane — REST, MCP, search, verification — is one stateless worker. You can run the same code we run on your own machine in one command, with no account, no API key, no telemetry, and no network access required beyond what you choose.

The neutrality proof — three commands

This is the whole point of the architecture: nothing about the query plane is ours-in-principle. Any third party — a mirror, a lab, a skeptic — can stand up a byte-identical service and check that the answers don't depend on who is asking:

# 1 · get the code (no credentials, no sign-up)
git clone https://gitlab.audienceamp.ai/audienceamp/aiseedbank.git
cd aiseedbank/queryplane

# 2 · boot the plane (node ≥ 22.6, offline, zero npm installs)
node --experimental-strip-types selfhost.mjs --port 0
# → listening on http://127.0.0.1:<port>

# 3 · ask it something and check the signature chain yourself
curl http://127.0.0.1:<port>/api/v1/models/Qwen_Qwen3-0.6B

Command 2 boots selfhost.mjs, which mounts theliteral worker fetch handler — not a reimplementation — with the bundled signed fixture plane as its origin. Command 3 returns a record that the worker verified with a pinned minisign public key before serving. Compare its answers against the hosted instance: same signed bytes in, same answers out.

The no-credentials law

The query plane needs no credentials to run and collects none to serve: no API keys anywhere in the flow, no accounts, no per-client tracking (the rate limiter counts requests per IP address in a fixed window, nothing else; with a Workers KV binding the window is shared across isolates — approximately enforced, since KV has no atomic increment). The only "secret" in the system is the minisign signing key, which lives with the publishing pipeline and never on any server. What servers hold is the public key — fixtures/test-trust.pubby default for the fixture plane, or your own plane's key via theTRUST_PUBKEY environment variable.

Serving your own copy of the artifacts

Everything the worker reads is static, signed, and re-servable: the endpoints artifact, the index, the chunk shards. Point the boot at any directory laid out like a published plane:

node --experimental-strip-types selfhost.mjs --port 0 --origin /path/to/plane

That --origin seam is the same configuration staging uses — the worker never hardcodes where artifacts come from, only that they must verify. Swap the directory, swap the trust file, and you are fully sovereign: your artifacts, your key, same code.

There is also a measurement mode that reports (not asserts) how large an index this node can hold in memory:

node --experimental-strip-types selfhost.mjs --measure-search /path/to/plane
# → one JSON line: records, aggregateBytes, parsedHeapBytes,
#   bytesPerRecord, ceilingRecords (0.8 × 128 MiB budget)

And after deploying the plane anywhere, the same checkout carries the post-deploy check — nine PASS/FAIL legs including a vendored signature verification of the exact bytes the deployment serves:

node --experimental-strip-types probe-staging.mjs https://<deployment> \
  --plane https://<artifact-origin>

What self-hosting does not give you

The query plane is read-only. Hosting it does not publish models, sign artifacts, or federate anything — publishing stays with the signed pipeline. To help the weights move, seed a torrent or run a mirror instead:how to help →