Running a node

What a node is, from the machine's point of view

A UniNet node is one process you install on hardware you already administer. It publishes capacity you declare, accepts workloads bounded by that declaration, runs them as containers, and holds an identity that the network scores for reliability. It does not ask for shell access to the box, and it does not take over the host.

That distinction is the point of the design. The usual ask from a network that wants your hardware is broad — an account, an agent with wide privileges, and a workload whose shape you discover after it lands. A node instead gives a tenant a container with declared limits and gives you an operator identity that is a key you hold rather than an account somebody issues to you.

What sits on the machine

   YOUR MACHINE — host OS, your root, your remote access, your other tenants
              │
              │  one process, installed by you
              ▼
        uninet node
              │
              ├──────────► operator identity
              │            a keypair you hold; reliability is
              │            scored against it, not against a listing
              │
              ├──────────► published capacity
              │            cpu · memory · storage
              │            allocated shared or dedicated, your choice
              │
              ├──────────► reservations
              │            atomic; a request that does not fit here
              │            can be placed on another suitable node
              │
              ├──────────► workload containers
              │            declared resource limits
              │            start · stop · remove, locally
              │
              └──────────► metering and settlement
                           delivered capacity, addressed back to
                           the operator identity that delivered it

The questions operators actually open with

| Question | Answer | | --- | --- | | What runs on my machine? | The node process, plus the workloads scheduled to it — hosted chains and containerized jobs, each declaring the resources it may consume. | | Can it be isolated? | Workloads run as containers with resource limits and lifecycle operations. The boundary is the kernel's. You, holding root, are above it rather than outside it. | | How much of the box does it take? | What you publish, and no more. A reservation is bounded by the capacity declaration it was placed against. | | Shared or dedicated? | Your decision per machine. It is the lever that sets how much of a box is committed to one tenant. | | Who measures reliability? | The network records it against your operator identity rather than inside one marketplace's database, so the record travels with the identity. | | What if a tenant walks away? | A reservation covers declared resources for a declared period, and lifecycle control sits on your node. Abandoned capacity is reclaimed locally rather than litigated. |

Isolation, stated precisely

Isolation is container-level. Resource limits bound what a workload consumes; the container boundary bounds what it reaches. Co-tenants are outside each other's boundary. The host operator is not — see the threat model for the full statement of who sits where. This matters to you in a direction operators sometimes miss: a tenant evaluating your hardware is being told plainly that you can observe their workload, and the network makes no claim to the contrary on your behalf.

Everything the host already does stays with the host. The operating system, the patch cadence, the hypervisor, the network operations, and any tenants you already serve are untouched by the node process.

Capacity is published, not surrendered

Capacity enters the network as a declaration: CPU, memory, storage, and whether each pool is allocated shared or dedicated. Consumers query across nodes and reserve atomically, and a reservation that cannot be satisfied on a given node can be placed on another suitable one rather than failing outright. From your side the consequence is simple. Nothing is committed that you did not declare, and the declaration is the contract the reservation is checked against.

Reliability and settlement

Delivery is scored against the operator identity. Because the score is held at network level, it is not the property of whichever application scheduled the work, and it follows you across whatever is scheduled to you next. Payment for delivered capacity is a signed transfer at the network layer, denominated in UNE and addressed to that same identity.

What a delivered unit is worth is a separate and unfinished question. This documentation publishes no rate card, no yield figure, no percentage return and no earnings estimate, because the parameters that would produce one are not settled, and a number printed before they are is a number operators would plan against and be wrong about. Understand also what the network is today: capacity discovery is a protocol primitive, not a queue of paying jobs waiting to be claimed. There is no live consumer demand on the network. Publishing capacity does not by itself produce a tenant.

Size a first deployment as a technical pilot on a machine you can spare. If you need contracted revenue from the hardware this quarter, this is not that yet.

Onboarding

There is no self-serve operator portal, and joining is a technical conversation rather than a signup form. That conversation is short and covers what hardware you can commit and for how long, whether the machine can carry the node process alongside what it already runs, what isolation your existing tenants require of you, and whether you want capacity published as shared, dedicated, or both. Deciding that UniNet is not worth your rack this quarter is a legitimate outcome of that call.

How this composes

An operator identity is one of the identity types the network defines, alongside personal and agent identities — see identity. Consumers reaching a service you host do so through addressing that is decoupled from your machine, described under private networking, which is why hosting a service does not require publishing where it physically runs. Spending authority on the consumer side is bounded by delegated authority, which is what makes an automated counterparty something other than an unbounded one. Per-subsystem grades for everything named here are on build status.