Architecture

Architecture

RootSpace is architected as a hybrid stack to achieve both maximum performance and rapid iteration. The engine is divided into a high-performance Rust Backend and an agile Node.js Dashboard/Integration Layer.

---

🏗️ System Components

1. Peer-to-Peer Backbone (libp2p)

The network layer is built entirely on rust-libp2p. It allows RootSpace nodes to dynamically discover each other, form a mesh network, and communicate without central relays.

• Multiplexing: We utilize yamux for lightweight stream multiplexing over a single TCP connection.
• Security: Noise protocol handshakes ensure all peer-to-peer traffic is encrypted and authenticated.

2. Execution Engine (wasmtime)

AI agents deployed to RootSpace do not run as native processes. Instead, they are compiled to WebAssembly (Wasm) and executed within a tightly controlled wasmtime runtime.

• Sandboxing: Memory boundaries and capability-based security ensure agents cannot break out of their execution context.
• WASI Support: Controlled access to the filesystem, network, and environment variables is provided through the WebAssembly System Interface.

3. State Management (rusqlite)

Each node maintains its local state (agent metadata, peer routing tables, and telemetry) via an embedded SQLite database.

4. Integration Layer (Node.js)

While the core operations happen in Rust, the user-facing APIs, telemetry aggregation, and web dashboards are served via a Node.js companion process. The Node layer communicates with the Rust engine through strict FFI bindings or local gRPC.

---

🔄 Node Lifecycle

1. Bootstrapping: The node starts, initializes its SQLite state, and loads its persistent identity keypair.
2. Discovery: The libp2p swarm begins mDNS/DHT discovery to find neighboring RootSpace nodes.
3. Execution: Incoming Wasm agent binaries are queued, validated, and spawned in isolated threads.
4. Telemetry: Resource usage (CPU/Memory per agent) is aggregated and exposed to the Node.js dashboard.