CELAUT For developers

Service developers

Build it once.

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.

  • BOX · API · NET three components — that is the whole specification
  • No DevOps nodes handle execution; there is no cloud account to open
  • Deterministic same inputs, same outputs, on any node, at any time

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

The idea

You don’t deploy. You specify.

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.

Three components. That’s all of it.

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.

And how the world reaches it.

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

Whatever you wrote, it ships the same way.

Celaut doesn’t ask you to adopt a framework, a runtime or an SDK. It asks for a filesystem and an entrypoint.

The node doesn’t care either.

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.

So any compatible node will take it.

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

Hand it to one node.

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.

The network carries it from there.

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.

Discoverable, if you want it to be.

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

Services that call services.

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.

The node decides where they land.

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.

And you never find out where.

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.

What the architecture gives you

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.

Self-contained by construction

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.

A black box, on purpose

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.

Reproducible, not “best effort”

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.

Composition without orchestration

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.

Reputation you can accumulate

Because a service is deterministic and isolated by default, a reputation proof recorded a while ago still says something true about it today.

How a service actually spreads

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.

Peer-to-peer by default

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.

On a registry, if it earns its place

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.

From code to running on the network

  1. Write the service

    Any language, any stack. What matters is the filesystem it needs and the command that starts it — not the framework you reached for.

  2. Specify BOX, API and NET

    Declare the environment, how callers talk to the service and what (if any) external network access it should be able to request.

  3. Send it to a node

    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.

  4. Let the network run it

    Nodes negotiate cost and decide where each instance executes. You are not in the loop, and you have no infrastructure to keep alive.

The trade you’re actually making

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.

A hosted web 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.

Source code they run themselves

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.

A Celaut service

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.

The rest of the network

Your service needs somewhere to run and someone to run it for. Both of those are people too.

Node maintainers

They provide the hardware and execute whatever is requested, without needing to understand what your service does, in exchange for payment.

Rent your PC →

Final users

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 paradigm

The full architecture: nodes, services, specification, coordination through reputation and payment systems, and why any of it is necessary.

Read the paper →

Start from the problems.

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”.

↑ Top