Skip to content

Celaut#

Overview#

View on GitHub → Celaut Project

Celaut is a decentralized, peer-to-peer runtime for deploying and coordinating autonomous services and AI agents. Inspired by cellular automata, Celaut decouples what a service does from who runs it and where it executes. This enables a permissionless digital economy where services compete based on verifiable reputation and performance, rather than central control or advertising.

Recent updates#

  • Feb 11 and Feb 17: Celaut Node was back in beta testing on Linux sudo and Windows WSL.
  • Apr 1: Docker was replaced with microVMs, install scripts were improved, and a doctor command was added.
  • Apr 9: Celaut Node was being tested with Game of Prompts before an open competition launch.
  • May 8: Nodo v1 shipped a Windows 11 WSL installer. The README now marks local execution and packaging as beta on Linux and Windows, local networking and trustless networking as alpha, and macOS as unsupported.
  • Jul 17: Nodo v2 refreshed the Windows 11 WSL release assets. Follow-up source fixes added iproute2, systemd startup, and nodo.service to the release root filesystem; confirm the current release assets before reinstalling an older WSL image.
  • Aug 14: Nodo published guest-kernel-v2, a pinned guest kernel plus BusyBox userspace for its Cloud Hypervisor microVM path. Install scripts select it through GUEST_KERNEL_VERSION; treat this component release separately from the Nodo v2 application release.
  • Aug 8 to Aug 14: Nodo exposed peer payment contracts in its CLI/TUI, replaced UUID-style peer identities with signed public-key identities, and then switched those signatures to Ergo-compatible Schnorr proofs over Blake2b256. These changes break compatibility with older peers and remain pre-production.
  • Aug 11 to Aug 18: the old gas model was replaced by per-resource CPU, memory, disk, and network prices. Nodo accounts internally in integer monetary units (MU), while each payment contract declares the MU conversion rate; Ergo is currently the only implemented settlement system. Follow-up fixes aligned quotes with allocated resources and converted balances correctly between peers with different rates.
  • Aug 17: operator views gained separate peer/client pages, payment and reputation-event histories, counterparties for recorded transactions, and a switch for automatic peer-deposit refills.

Background#

Celaut draws from the legacy of cellular automata developed by John von Neumann and popularized by Conway’s Game of Life. It applies this model to software design: services operate as independent, auditable containers that evolve and interact within a distributed network based on demand, trust, and reputational feedback. There is no execution history directory; anyone is free to submit opinions about any service, putting their own reputation on the line by doing so.

The Need for Celaut#

Today's options for using intelligent or cloud services are limited:

  1. Centralized Platforms

    • Convenient but opaque and censorable
    • No guarantees on behavior, security, or long-term integrity

  2. Self-Hosting Open Source

    • Transparent but resource-intensive and impractical for most users

Celaut introduces a third path:

  • Nodes are decentralized and can dynamically allocate tasks.
  • Services are deterministic and isolated inside virtual containers.
  • Trust and payment are handled via Ergo smart contracts and the Reputation System.
  • No central service registry, no vendor lock-in.

Example: Decentralized Trading Bots#

With Celaut:

  • Trading bots run as portable services with on-chain reputation.
  • Users select them based on past performance and trustworthiness.
  • Resource use is accounted for by the node and payments are settled through Ergo contracts.
  • Developers cannot modify deployed bots post-factum, ensuring integrity.

This creates a transparent ecosystem where bot performance and trust are the sole indicators of value.

System Architecture#

Nodes (Nodo Implementation)#

  • Execute services in containerized sandboxes
  • Handle communication, scheduling, and per-resource metering
  • Publish metadata such as compute cost, architecture support, and uptime
  • Install on Linux with the stable branch install script, or use the Windows installer from the current v2 release.

Services#

The experimental Celaut Skills registry indexes problems separately from services that claim to solve them. Its public repository describes on-chain skill, benchmark, result, coverage, service-data, and service-metadata records on Ergo, with competing assertions weighted by reputation. Treat registry entries and benchmarks as claims to evaluate, not as automatic service endorsements.

  • Stateless and deterministic containers
  • May spawn sub-services, forming dynamic, reactive graphs
  • Can be hosted, delegated, or migrated across trusted nodes

Economic Layer on Ergo#

  • Reputation System
    • Tracks the performance and endorsements of nodes and services based on freely submitted opinions; there is no execution history directory, and anyone may provide feedback at the cost of their own reputation
    • Stored on-chain using immutable reputation tokens
    • Used by clients to decide service selection and delegation paths
  • Payments
    • Handled via Ergo smart contracts
    • Pay-per-use or subscription models
    • Payment contracts advertise how their settlement unit converts to the node's internal MU accounting unit

Resource Pricing and Incentives#

  • Nodes advertise separate CPU, memory, disk, network, build, tunnel, and resource-modification prices.
  • Prices, balances, and charges use integer MU internally. MU has no intrinsic value; each payment contract declares its own mu_per_unit conversion rate.
  • Ergo is currently the only implemented settlement system and defaults to one MU per nanoERG, but operators can change that rate. Clients and peers must read the advertised contract rate rather than assume a fixed peg.
  • Deposit tokens are UUID identifiers for payment requests, not Ergo tokens.
  • Nodes can pay peers for delegated execution; cross-peer balances are converted through the matching payment-contract rates.
  • Load balancing is guided by resource price, capacity, uptime, and reputation.
  • Each node has its own balance, service delegation, and pricing policies

Reputation System Integration#

Reputation is foundational in Celaut. It enables trust in service orchestration without requiring a consensus layer.

  • Each node and service accumulates on-chain reputation proofs
  • Reputation reflects peer endorsements and client opinions about services
  • Smart contracts enforce immutability of trust data
  • Reputation influences pricing, visibility, and delegation priority

The system is described in detail in the Reputation System documentation.

Real-World Use Cases#

  • Distributed analytics bots for on-chain/off-chain data
  • Autonomous trading agents with verifiable records
  • Serverless hosting of decentralized APIs
  • Economic simulation engines for DAOs
  • AI model marketplaces that reward trust and performance

How Celaut Works in Practice#

  1. A user needs a specific automated task, such as running a DeFi strategy.
  2. They select a service with strong Reputation System proofs.
  3. The task is deployed to a Celaut node, which meters the resources it consumes. Users normally operate their own trusted node and may disable incoming execution requests.
  4. If optimal, the node delegates execution to a lower-cost peer.
  5. The user receives results and optionally updates their trust evaluation.

Celaut is Not a Blockchain#

Celaut is an orchestration layer that runs on top of blockchains like Ergo. It does not compete with consensus platforms but extends their functionality.

Component On Ergo (On-Chain) On Celaut (Off-Chain)
Service Execution ❌ ✅
Node Management ❌ ✅
Resource metering ❌ ✅ (within nodes)
Payments & Licensing ✅ (settled on Ergo) ❌
Reputation System ✅ (reputation tokens and contracts) ✅ (used in service orchestration)
Service Metadata ✅ (optional, for transparency) ✅ (mandatory for operations)
Delegation Decisions ❌ ✅ (based on cost and reputation)

Further Resources#