UniNet
Contact

Infrastructure for autonomous software.

Identity, authority, private networking, execution and payments - as properties of one substrate.

Read the architectureExplore the docs

AI gave software intelligence. UniNet gives software the infrastructure to act independently.

Every layer beneath an agent still assumes a human is holding the account.

A two-part comparison. Human-mediated: six stacked accounts - human, application, cloud, database, payment provider and identity provider - with a trust boundary cutting the link between every pair: five separate relationships, each owned and revocable by a different provider, and each assuming a human who can log in, accept terms and be held accountable. Autonomous: the same capability as three - the agent's identity; UniNet, one substrate rather than six accounts; and execution, assets, payments and settlement - joined by one unbroken rail with no handoff between them. This describes the model UniNet is built around; the build status page carries the state of each subsystem.

Five properties

One network. Not six integrations.

Sovereign Identity

An identity the software holds the key to. Agents carry a human supervisor on record.

In developmentIdentity

Programmable Authority

Delegated by signature. Revoked with cascade.

AvailableAuthority

Private Execution

Reachable without publishing the machine behind it.

AvailableNetworking

Native Economy

Software that can own and move value.

AvailablePayments

Sovereign Coordination

Organizations that encode their rules into infrastructure.

AvailableGovernance

Multi-chain Interoperable Architecture

Reference design

An agent that pays its own way.

A budget, not a credit card. An identity, not an account.

A reference design: an autonomous agent buying decentralized compute travels one rail through four phases. Identity: 01 create an agent identity; 02 receive delegated authority, scoped to specific rights and with an expiry. Discover: 03 search available compute across nodes; 04 evaluate providers; 05 select a provider; 06 reserve compute atomically. Execute: 07 send the workload privately over UNP; 08 execute it in an isolated container; 09 receive the result. Settle: 10 verify the transaction against recorded state; 11 pay the provider by signed transfer from the agent wallet; 12 record the interaction. Each step uses a primitive the network has today; the agent that runs them end to end is described here, not shipped.

Who it is for

Built for software that acts on its own.

Agent infrastructure

Autonomous software that authenticates, holds permissions, reaches services privately and pays for what it uses.
For agents

Decentralized infrastructure

Compute, storage and network protocols that would rather not rebuild identity, routing and payments.
For protocols

Privacy-sensitive systems

Applications that cannot expose their topology or their user relationships.
Private networking

For operators

Host chains and isolated workloads on your hardware.

Run a node

For developers

One node replaces the provider stack.

One interface. Identity, permissions, private addressing, execution and payments resolve against the same network.

Read the docsQuickstart

The UniNet principle

Software should be able to operate independently.

Identity it controls. Authority that can be programmed. Infrastructure that can be verified.

Talk to the teamRead the manifesto