GuardianDB now includes Guardian Compute, a decentralized edge computing layer built on top of its local-first, peer-to-peer data model. This enables nodes to delegate the execution of business logic, compiled to WebAssembly, to other peers in the network. A compute-aware scheduler routes each task to the peer with the highest available idle capacity, while results flow back through the database’s normal replication mechanism.
The basic workflow is seamless. A requesting node publishes a task as a binary artifact, while executor nodes continuously advertise their available resources, such as CPU and memory. The scheduler evaluates this information, selects the most suitable candidate, and dispatches the request. The executor downloads the code, runs it inside an isolated environment, and returns both the results and execution metrics, which are then stored and replicated across the network.
Guardian Compute reuses the database’s existing infrastructure, including secure transport, node identities, file distribution, and reactive triggers. What this feature adds is a WebAssembly sandbox, telemetry, a distributed scheduler, and an auditable task registry. To access these capabilities, developers simply enable the appropriate compile-time features. They can also enable optional Edge AI support, allowing complex machine learning models to run with GPU acceleration.
The system is built upon a set of robust concepts. Each task is treated as an isolated module that receives opaque input data, ensuring the executor runs exactly the requested code through the use of cryptographic identifiers. Execution takes place inside a secure sandbox with strict limits on memory, execution time, and CPU usage, completely isolated from both the network and the host machine’s filesystem. Nodes advertise their available resources using capability vectors, while the owner of each node always retains full control over which tasks to accept and which additional resources to contribute.
Task routing supports several execution models. Direct delegation allows clients to specify exactly which machine should execute a task. Dynamic scheduling lets the network automatically select the best executor and transparently fail over if the chosen node becomes unavailable. For more expensive workloads, the system can perform a real-time bidding process that confirms executor availability before dispatching the task. Large computations can also be partitioned across multiple nodes for parallel execution, while a redundant execution mode provides additional reliability in untrusted networks.
To simplify development, Guardian Compute includes an SDK that hides the underlying complexity, allowing developers to write compute functions in modern programming languages with minimal effort. For artificial intelligence workloads, nodes can host pre-approved machine learning models. In this case, the scheduler is intelligent enough to route inference requests only to machines that already have the required model available, reducing network traffic and improving response times.
Another powerful capability is the integration of reactive triggers with the task registry. The system can be configured to automatically launch a computation whenever specific data is synchronized across the network, such as generating a thumbnail immediately after an image is uploaded. Execution is coordinated so that only a single node performs the work, preventing every node in the network from processing the same task simultaneously.
The entire platform is built around a strong security model. The isolated execution environment protects executor machines from faulty or malicious code. Trust in the returned results, however, remains the responsibility of the task requester, making private, permissioned networks the recommended deployment model. Participation in the ecosystem is collaborative and does not rely on cryptocurrencies or tokens, instead operating on a reciprocal resource-sharing model.
The project’s core infrastructure is already fully tested, covering code isolation, telemetry, fault tolerance, Edge AI support, and trigger-based execution. Expected use cases range from running large language models on edge devices, decentralized media processing, and distributed data analytics, to fault-tolerant automation workflows that continue operating despite individual server failures.