What is an operator
ZeroSignal doesn't run the AI models its users talk to. They're served by operators — independent parties who run inference hardware and sell its output on an open network. If you have GPUs and a model to serve, you can be one.
This is the operator's side of the docs. If you're a user trying to understand who serves the models and why you don't have to trust them — rather than run a node yourself — see The operator network.
What an operator does
An operator runs the node software in front of an AI backend, and registers on-chain from the operator dashboard with their owner wallet (the node software doesn't self-register — you create the on-chain records, then point the node at them). Once registered, the node:
- Advertises the models it serves, their prices, and its capabilities, so users' clients can discover it.
- Answers inference requests — it receives an encrypted prompt, runs the model, and streams back an encrypted reply.
- Gets paid per request, in dollars (USDC), settled on-chain against a price the user agreed to up front.
- Relays other operators' traffic, helping protect every user's network identity. Relaying is mandatory — every node is a relay — and earns no direct payout; it's part of being a good citizen on the network.
There's no application and no gatekeeper: the registry is a smart contract, so anyone can register and any user can transact with any operator. You set your own models, prices, and policies — How the network works covers the economics and trust model behind all of this.
Operators and nodes
One operator is an on-chain identity — an owner address that gets paid and a stake that backs it. Under that identity you run one or more nodes, and each node is a single running endpoint with its own URL and signing key.
Users' clients route to a node, not to the operator as a whole. That split lets you:
- Run several machines under one operator identity and one payout address.
- Bring a node up in staging to test it without taking production traffic.
- Take a node down for maintenance while your other nodes keep serving.
The economics, stake, and reputation accrue to the operator; reachability, latency, and throughput are tracked per node.
What you need
| You need | Why |
|---|---|
| Inference hardware | Capable of serving the model(s) you want to offer, plus a backend that runs them. |
| A public HTTPS endpoint | The node software listens on it, reachable by users' clients (and by other operators, since you'll also relay). |
| An Algorand account | For your operator identity and payouts. |
| A USDC stake | Locked in the protocol to register — $250 (see Staking & economics). |
| The node software | Distributed as prebuilt binaries under the Functional Source License (FSL-1.1-ALv2); registers your operator and nodes, advertises your catalog, and speaks the wire protocol. |
What's covered here
Get oriented
- How the network works — the economics and the trust model from an operator's point of view.
- Quick start — the fastest path from zero to serving a first request.
Running a node
The concept, configuration, and on-chain pages below are complete — they describe the protocol your node has to speak, which is fixed regardless of how the software ships. Two things are still settling and are flagged where they come up: the exact node-software CLI command and flag names (the commands in the CLI reference are real but may be renamed), and the byte-level wire-protocol specification (the concept pages cover behavior, not the JSON layout). Confidential compute (TEE) is partially shipped — see the status note on that page.