CELAUT

A Peer-to-Peer Architecture for Software Design and Distribution

Inspired by cellular automata — resilient global behaviour emerging from simple local rules.

Tap any underlined word for a plain-language explanation. Turn them off any time with the button in the corner.

Where it comes from

It starts with a handful of rules.

In the 1940s John von Neumann and Stanislaw Ulam introduced cellular automata: models that showed how complex behaviours could emerge from simple ones.

Nobody is directing this.

In 1970 John Horton Conway’s “Game of Life” became the classic example: a grid where each cell only ever looks at its neighbours, and yet the whole thing produces intricate, evolving structure.

That’s the whole design philosophy.

These ideas offer insight into how decentralized systems can achieve complexity without central control — the guiding philosophy behind Celaut. Simple rules at the node and service level, an adaptive system on top.

Decentralization · Simplicity · Determinism

The two primitives

A node

A computer or device that talks to peers and manages service execution. It provides hardware, decides whether to run work locally or pass it on, and never needs to understand what the software does.

A service

A deterministic software container built to do one job. It is sealed from the node that runs it: the node doesn’t inspect the program, and the program doesn’t know which machine it landed on.

Two atoms. Specification, execution, payment and reputation are all how they interact.

The network

Having nodes is not the difference.

Most decentralized networks have nodes, and most of them still depend on one powerful thing: the protocol everybody has to run. The rules are the centre, even when the machines are not.

Celaut has no protocol to agree on.

Nodes don’t have to settle on a communication protocol in advance — they declare the interfaces they support and the payment methods they accept on contact. Two nodes talk about whatever they happen to have in common; where they don’t overlap, they simply don’t talk.

So you change your node, not the network.

A new pricing policy, another payment method, a specification format nobody else parses yet — you implement it in your own node and it works with whoever already supports it. Nobody votes, nothing has to be migrated, and there is no hard fork to survive.

No shared protocol. No shared version. No permission.

What runs on it

A service is a sealed container.

Services in Celaut are deterministic software containers designed to perform a specific task. Nothing more elaborate than that.

Following the black box principle.

They operate independently of the nodes that execute them, focusing solely on their functionality. The node doesn’t need to understand the service, and the service doesn’t need to know anything about the node.

Isolated, every single time.

Each request runs as an isolated process — in its own virtual machine, with its own kernel and a hardware-enforced boundary — which abstracts away the execution environment and keeps the security barrier intact.

What goes in, what comes out. That’s the whole interface.

How a service is specified

BOX — the environment.

Architecture, filesystem, environment variables, entrypoint, configuration and resources. It specifies the entire file structure directly rather than relying on external images or repositories, which is what makes execution reproducible on any node.

API — the interface.

How to communicate with the service, the payment systems it accepts and the associated costs. It lets services be used without any central controller negotiating protocol on their behalf.

NET — the network scope.

By default a service is isolated: it can talk only to its parent, its children and the node running it. If it needs the outside world, the networks it will reach are named in its own specification — the node grants them, because it wants to run the service properly, and you get the guarantee that it can never reach anywhere else.

Three components. One portable service.

Together they create portable, reproducible services that deploy consistently across the network while maintaining security and determinism.

No third-party dependencies. Nothing left implicit.

Who decides what

A service asks for its children.

A service can request the execution of child services through its node. It states the resources each one needs and hands over a budget for them to spend. Not a machine, not a region — resources.

The node decides where they run.

It compares the cost of running the instance locally against the cost each of its peers quotes and picks the one it considers best. One child stays here; another lands on a peer.

The parent never finds out.

It doesn’t know whether a child ended up on this machine or somewhere else, and it doesn’t need to. All it watches is what its children consume and how fast they’re spending, so it can balance that.

That split is the whole trick.

Node operators deal with the physical side: hardware, capacity, price, placement. Service developers declare the resources they need and nothing about infrastructure. Neither has to do the other’s job — which is exactly what keeps both halves simple.

Two concerns. One clean line between them.

Why it holds

Same input. Same output.

Services are fully specified to aim at reproducible results across time and nodes. Given the same inputs, the same specification is meant to produce the same outputs, regardless of where or when it runs.

Not a guarantee in every case.

A service that reaches a network can’t be perfectly reproducible — the network answers differently. But a specification carries far more than a Docker definition does: the architecture, the whole filesystem, the entrypoint, the config. So this sits much closer to running a plain program than to pulling an image and hoping.

Which makes trust measurable.

Because the software can’t drift, a reputation proof recorded some time ago still says something true today — provided the service doesn’t reach out to a network, which is its default state.

And it travels.

Because nothing about the environment is left to the host, the same specification produces the same behaviour on a laptop, a spare server or a node you have never heard of. Where it runs stops being part of the answer.

Fully specified, so nothing is left to the machine.

How strangers cooperate

Reputation comes first.

Trust is never assumed between parties. Nodes don’t trust other nodes; you don’t inherently trust a service or the node running it; a node doesn’t have to trust the service it executes. The one direction that does hold is the other way round — a service can trust its node, because whoever decided to run it picked that node. So nothing starts with a handshake; it starts with a lookup: reputation is records on ledgers, opinions rather than verdicts, weighed by each actor against the sources it already trusts.

Then you pay for a promise of resources.

Only once the record checks out does anything move. The requester pays up front, and what they buy is a promise: this much compute, for this long. Payment mechanisms sit outside the core architecture, so no particular ledger is baked in.

The node’s guarantee is its reputation.

Nothing forces it to honour that right. What holds it is that the outcome is written back to the ledger — and a node whose record says it took payment and under-delivered stops getting chosen. Each party has a standing interest in the next stranger liking what they read.

Check · pay · deliver · record. Then round again.

The rules it holds to

None of that was a feature list.

A network with no protocol to agree on, services sealed from the machines that run them, networks named up front, payment before execution — every one of those is a consequence. Three commitments produce them, and they hold each other up.

Decentralization.

No single point of control or failure. Nodes communicate and coordinate dynamically, with nothing in the middle to ask permission from — which is why there was no protocol to agree on in the first place.

Simplicity.

Minimalist rules that reduce complexity, so each component stays small enough to be understood and maintained on its own. A service is a container, an interface and a network scope, and that is the whole of it.

Determinism.

Services are specified completely enough to reproduce their results across time and across machines. Same inputs, same outputs, wherever and whenever they run — which is what makes a reputation recorded a year ago still worth reading today.

Drop any one of the three and the other two stop being worth much.

Common misreadings

What Celaut is not

The architecture sits close enough to several familiar things to be mistaken for them. It is worth being precise about the differences.

Not a single network

Celaut defines a flexible architecture, not one predetermined network. Predominant networks may well emerge, but the system supports many peer-to-peer constructions rather than dictating a singular one.

Not a complete protocol stack

It provides core principles for building computation distribution stacks, not a full opinionated stack. Current implementations lean on components like gRPC and Ergo, and those are interchangeable choices.

Not a blockchain project

Celaut has no native cryptocurrency and no DAOs. It does incorporate blockchain technologies where they earn their place — recording reputation, settling payment between strangers — without adopting the broader ecosystem around them.

The software

What exists today

The architecture is a specification, and anyone can implement a node against it. One implementation runs the network today; a second, for Android, is in alpha.

Nodo

Running

The reference implementation, in Python3 and Rust. It executes services, negotiates cost with peers, settles payment on Ergo or Bitcoin, provisions addresses and tokens, and resolves dependencies wherever they run. Installable on Linux with one command, and on Windows 11 through an official installer that provisions its own isolated Linux environment.

Chatui

Alpha

An Android app to use Celaut services without intermediaries: a light client that reaches services through a plain chat interface, with an Ergo wallet built in. It is in alpha — pre-release APKs are published on GitHub and development is active, so expect rough edges.

Nothing here is a placeholder for something that already works elsewhere. What runs, runs; what does not, says so.

Where it is already running

Real-world impact and applications

The architecture is not a thought experiment. It is in use at two different distances — as the layer itself, and as the foundation under something with its own reason to exist.

The architecture, switched on The layer itself

Neither of these is an application built on Celaut. They are what Celaut is, once nodes are actually running.

DePIN

Anyone can run a Celaut node and become part of a decentralized physical infrastructure network. Each node discovers peers, executes and orchestrates services, and manages their dependencies — turning ordinary computers into shared, censorship-resistant compute. This is the network, not a product on it.

Unstoppable Skills

A fully on-chain, serverless registry where the problems are the protagonists. Instead of hunting for services, agents search for a skill and discover the services that cover it, with real benchmarks and reputation-based ranking. It is how the paradigm’s reputation layer is actually reached — on Ergo, with native skin-in-the-game: nobody spams without risking reputation.

Built on top of it Independent project

One step further out: a product with its own purpose and its own users, which happens to be assembled from Celaut services. It would still make sense if it were rebuilt on something else — that is exactly what makes it evidence.

Game of Prompts

A competitive platform where creators design game-services that evaluate the robots playing them, and players write solver-services that try to maximise their score.

The services follow the Celaut paradigm, and the whole system uses the Ergo blockchain to record results and transfer prizes.

Pick your way in

Which one are you?

As users, we can play three types of roles in the ecosystem. Each has its own way in.

Role 01

Node maintainers

Similar to miners in blockchain systems, node maintainers provide computational resources to the network. They execute services requested by users in exchange for payment, without needing to understand the specific functionality of those services.

  • Provide hardware resources
  • Execute services on request
  • Receive compensation for resources

Role 02

Service developers

Developers create services that can run on any compatible node in the network. They focus on building functionality without worrying about the underlying infrastructure details.

  • Design service specifications
  • Build deterministic applications
  • Distribute services to nodes

Role 03

Service users

End users launch services on nodes, paying for the computational resources used.

  • Request service execution
  • Pay for computational resources
  • Consume service outputs