Specify, don’t deploy
A service is a BOX (architecture, filesystem, environment, entrypoint, config), an API and a NET scope. Write that down and you are done — there is no deployment step to own.
Service developers
Then stop thinking about where it runs.
A Celaut service isn't a deployment — it's a specification. Describe the environment, the interface and the network scope, hand it to a single node, and the network takes it from there.
Tap any underlined word for a plain-language explanation. Turn them off any time with the button in the corner.
The idea
There is no server to provision, no image to push, no pipeline to keep green. A service in Celaut is a written description of what it needs to run.
BOX describes the execution environment — architecture, filesystem, environment variables, entrypoint, config. It specifies the entire file structure directly, rather than pointing at an external image, which is what keeps execution reproducible.
API defines how clients and other services talk to it, plus accepted payment methods and costs. NET names the external networks it will reach — by default a service is isolated, and anything wider is declared in the specification itself, so users know up front where it can go.
Portable, reproducible, free of third-party dependencies.Benefit 01
Celaut doesn’t ask you to adopt a framework, a runtime or an SDK. It asks for a filesystem and an entrypoint.
Services follow the black box principle: they operate independently of the details of the nodes that execute them, and nodes run them without needing to understand what they do.
The BOX declares the microarchitecture it targets, so nodes know whether they’re a match. Beyond that, your service can be run by anyone on any compatible node — that’s the whole contract.
No lock-in, because there’s nothing to be locked into.Benefit 02
You don’t publish to a store and you don’t wait for review. The developer only needs to send the service to one or more nodes.
Those nodes handle distributing the service among others. There is no central service registry — services spread peer-to-peer, so there’s no single point of failure and no gatekeeper deciding whether you’re allowed in.
Nodes can also upload the service to a reputation system, so users and other services can judge whether to use it, and when. Services can be declared on a blockchain registry — like the Sigma Reputation System on Ergo — to improve visibility and trust.
Nothing to sign up for. Nobody taking a cut.Benefit 03
A service can request the execution of other services — its child services — through the node running it. Complex workflows are built by composition, not by orchestration config.
Nodes manage service instances and decide whether to run them locally or distribute the load across peers. Dependencies are the node’s problem to solve — it ensures services can reach what they need across the network.
The parent service does not know where its dependencies are executed. Each child simply states the resources it requires. You write the composition; the network solves the placement.
No scheduler to configure. No topology to maintain.A service is a BOX (architecture, filesystem, environment, entrypoint, config), an API and a NET scope. Write that down and you are done — there is no deployment step to own.
The BOX describes the entire file structure the service needs, rather than pointing at external images or repositories. No third-party registry can go missing underneath you.
Services operate independently of the nodes that execute them. You never write against a node's environment, because you are never told what it is.
Given the same inputs a service always produces the same outputs, regardless of where or when it runs. Determinism is an architectural property here, not a provider promise.
A service can request the execution of child services through its node. The parent does not know where they run; each one just states the resources it needs.
Because a service is deterministic and isolated by default, a reputation proof recorded a while ago still says something true about it today.
There is no store to publish to and no review to wait for. A service is handed to one node, and the network carries it from there — by default off-chain, and optionally on it.
Celaut has no central service registry. Services spread across nodes peer-to-peer, so they can be found directly — and there is no gatekeeper deciding whether you are allowed in.
Services can also be declared on a blockchain that implements a registry — like the Sigma Reputation System on Ergo — when visibility and an auditable trail are worth more than staying entirely off-chain. It is an option, never a requirement.
Any language, any stack. What matters is the filesystem it needs and the command that starts it — not the framework you reached for.
Declare the environment, how callers talk to the service and what (if any) external network access it should be able to request.
One node is enough. It distributes the service to others and can publish it to a reputation system so users and other services can find it.
Nodes negotiate cost and decide where each instance executes. You are not in the loop, and you have no infrastructure to keep alive.
Today, shipping software means picking between hosting it yourself and asking people to run it themselves. Both options cost something. Celaut's claim is narrow and specific: it takes the advantages of each without their disadvantages — at the price of your control over the running service.
GainsUsers need no infrastructure and no configuration.
CostsYou can't prove the system hasn't changed, and users have to take your word that their request data isn't being misused.
GainsDeterministic — once downloaded, you can't change it under them — and their request data never reaches you.
CostsThey need capable hardware and have to survive the configuration, which is where most people give up.
GainsNo infrastructure to manage and nothing to configure, because the spec already covers the container, architecture, network needs and interface.
CostsYou give up control: you can't modify, throttle or extract data from a service once it's out there. That's the point.
Your service needs somewhere to run and someone to run it for. Both of those are people too.
They provide the hardware and execute whatever is requested, without needing to understand what your service does, in exchange for payment.
Rent your PC →They launch services on nodes and pay for the computational resources used — and can verify that what ran is exactly what the spec described.
For final users →The full architecture: nodes, services, specification, coordination through reputation and payment systems, and why any of it is necessary.
Read the paper →Unstoppable Skills is a registry where the problems are the protagonists: search for a skill, and find the services that cover it, their benchmarks and their reputation. It’s the shortest path from “what should I build” to “who needs it”.