Skip to main content
LIOP Architecture Diagram LIOP Architecture Diagram LIOP operates on a fundamentally different paradigm than traditional REST APIs or the Model Context Protocol (MCP). It abandons the client-server hub-and-spoke JSON-RPC model in favor of a decentralized, binary push model. By orchestrating Logic-on-Origin, LIOP eliminates data gravity constraints, allowing Agent logic to travel to the dataset rather than forcing the dataset to travel to the Agent.

​
Protocol Scope

LIOP comprises several foundational pillars:
  • LIOP Specification: The standardized implementation of Protobuf messages, libp2p routing, and WASI binary execution constraints.
  • LIOP SDKs: Official TypeScript and Rust libraries to integrate the mesh into existing applications.
  • LIOP Runtimes: The core engine (usually wasmtime) that performs the mathematical sandboxing.
Similar to MCP, LIOP is agnostic to the LLM model used beneath the hood. It strictly standardizes how the context and logical execution are securely exchanged.

​
Mesh Participants

In the LIOP Mesh, every node is a Peer, but they assume distinct roles based on their computational purpose:
  • Host System: The underlying operating system, database, or device that holds the proprietary raw data.
  • Data Node (Server): A specialized LIOP peer running adjacent to the Host System. It initializes the WASI sandbox and awaits remote modules. It protects the Host from malicious execution.
  • Agent Node (Client): Typically an Autonomous AI. It generates dynamic WebAssembly bytes (.wasm) mapped to an intent, and pushes these bytes into the Mesh to find corresponding Data Nodes.

​
System Layers

To minimize latency and enforce strict isolation, LIOP is structured into two technical layers, orchestrated through verifiable execution pipelines.
LIOP Topology ArchitectureLIOP Topology Architecture

​
1. Transport Layer (libp2p & QUIC)

The transport layer handles discovering peers and establishing unbreakable connections.
  • Network Protocol: Uses QUIC, which natively supports multiplexing without UDP head-of-line blocking, and TCP/WebSockets for Edge/Browser compatibility.
  • Cryptography: Initial handshakes utilize the Noise Protocol (Ed25519) combined with Symmetric Authenticated Envelopes (AES-256-GCM), deeply rooted in Post-Quantum Cryptography (ML-KEM-768 / Kyber).
  • Routing: Utilizes a highly optimized Kademlia Distributed Hash Table (DHT). Agent nodes do not need hardcoded IP addresses or centralized DNS; they merely ask the Mesh “Who can fulfill this request?”, and Kademlia routes the binary payload autonomously.

​
2. Data Layer (Protobuf & Tonic)

Once the transport layer connects the Agent and Data nodes, the Data Layer dictates the structure of the execution request.
  • Encoding: Abandons bulky JSON representations. All messages are tightly packed binary Protocol Buffers (.proto).
  • RPC Framework: Uses Tonic (gRPC) for lightning-fast bidirectional streaming.
  • Payload Structure: The Data Layer defines the LogicRequest and LogicResponse primitives, transmitting the WASM AST, capability identifiers, and cryptographic proofs (ZK-Receipts).

​
3. Verification & Isolation Layer (Execution)

The final boundary before touching bare metal.
  • Guardian AST Validation: Scans WebAssembly import trees looking for Host-Escape vulnerabilities before sandbox initialization.
  • Hardware Enclaves (TEEs): Optionally bootstraps the entire wasmtime engine inside an Intel SGX or AWS Nitro enclave, shielding the RAM from server administrators.
  • Zero-Knowledge Evidence: Optionally leverages zkVMs (like RISC Zero) so the server returns the requested insight mathematically sealed, guaranteeing the compute wasn’t tampered with.

​
Multi-Tier Sovereign Mesh Topology

In enterprise production deployments, the mesh topology is partitioned across three distinct security tiers with asymmetric boundary enforcement:
Multi-Tier Sovereign Mesh Topology

​
Tier 1: Data Sovereignty Enclaves

  • Cryptographic Isolation: Strict private network isolation via pnet Swarm Key (PSK) (/key/swarm/psk/1.0.0/). Any connection attempt from an unauthenticated peer without the symmetric PSK is aborted at the socket transport layer.
  • Nodes: Core Banking (The Bank, 1,500 synthetic accounts with $148M balance) and Healthcare EHR (The Vault, 2,500 patient records).
  • Policy: Enforces Differential Privacy (Laplace noise) and strict Cardinality limits (raw row-level data is permanently blocked from egressing).

​
Tier 2: Consortium P2P & Perimeter Gateways

  • Border LIO Gateway (BLG): Acts as a cryptographic firewall and reverse proxy. Bridges external client queries into Tier 1 enclaves across an asymmetric network boundary using RFC 6749 OAuth 2.1 client credentials.
  • High-Frequency Trading (The Oracle): Real-time HFT market matching engine simulating L2 orderbooks and stochastic volatility models (Heston + Jump Diffusion).
  • Nexus: Decentralized service discovery directory and OIDC authentication provider.

​
Tier 3: Public Backbone & Edge IoT

  • Edge Industrial Nodes (Edge IoT): Deployed directly on edge industrial hardware under hostile WAN profiles (simulated 250ms ± 50ms latency with 2% packet loss). Computes anomaly detection in-situ, transmitting only critical aggregated telemetry.
  • P2P Circuit Relays (Relay): High-throughput public relays implementing AutoNAT and Circuit Relay v2 for traversal of corporate firewalls.
  • Client SDK, Web Playground & Studio: Interactive execution consoles operating over intercontinental WAN links (:16000 Studio / :16002 Playground).

​
Canonical Network Ports

The LIOP multi-tier topology standardizes specific network ports across services and development harnesses:

​
Interceptor Demarcation & Defense-in-Depth

Within this multi-tier architecture, interceptors follow strict topological demarcation per NIST SP 800-207 Zero-Trust standards:
  • Perimeter Ingress (GatewayInterceptor): Runs strictly at the DMZ boundary (e.g. Nexus Gateway) to filter malformed or hostile RPC calls (SQLi, Path Traversal, Prompt Injection) with HTTP 403 and error code -32099. It is strictly prohibited inside Tier 1 Enclaves to prevent false-positive rejections on legitimate analytical code and preserve genuine Zero-Trust sandbox evaluation.
  • Enclave Compute Isolation (The Shield): Runs inside Tier 1 Enclaves (The Bank, The Vault), containing injected code via a 6-layer defense pipeline (Guardian AST allowlist, WASI/V8 sandbox with 25 poisoned globals and fuel limits, Taint IFC, Egress PII Shield, Aggregation-First policy, and ZK-Receipts).
  • Universal Out-of-Band Observability (LogInterceptor & AuditInterceptor): Deployed across all tiers (Nexus, BLG, Enclaves) executing asynchronously out-of-band (0 ms host delay) to feed external SIEM analyzers, Prometheus, and SOC 2 / HIPAA compliance ledgers.
LIOP Interceptor Topology (Light)LIOP Interceptor Topology (Dark)

LIOP Interceptor Topology: Demarcation between Ingress Admission and Enclave Isolation

​
The Logic-on-Origin Journey

Animated Logic-on-Origin FlowAnimated Logic-on-Origin Flow
Here is the exact lifecycle of a LIOP execution, reflecting a 1:1 parity between our Architectural Models, Rust Backend, and Node.js SDK:

​
1. The Client Emitter (TypeScript Client)

  • WebAssembly Compilation: The LLM’s dynamic logic is evaluated and transformed into a .wasm binary stream.
  • Client AST Sentinel (GuardianTS): Before network emission, a pre-flight heuristic inspection blocks illegal bounds or malicious footprints from polluting the protocol.
  • Post-Quantum Key Exchange: The SDK generates a Kyber768 secret, mathematically defeating Harvest Now, Decrypt Later attacks.
  • Payload Encryption: The .wasm intent is hermetically sealed within an AES-256-GCM envelope using random generation nonces.

​
2. The Kademlia Transit (Zero-Trust Mesh)

  • Libp2p Transport: Packets traverse the decentralized mesh using ultra-low latency TCP/QUIC bounds.
  • Multiplexed Secure Streams: Yamux orchestrates thousands of parallel requests simultaneously, while raw connection traffic is armored via Noise protocol handshakes.

​
3. The Origin Ingestion (Rust Server)

  • Transport Terminator: The Data Node unwraps the Kyber secret and applies AES-256-GCM decryption natively, extracting the core payload.
  • AST Guardian: The Rust wasmparser inspects the incoming Abstract Syntax Tree. Any unauthorized host imports halt execution prior to instantiation.
  • Wasmtime / WASI Sandboxing: Bytecode Alliance’s engine boots a constrained memory boundary. The logic processes host data locally without moving records across the network.

​
4. Mathematical Return (ZK-Receipt)

  • Mathematical Proof: Optionally, a zkVM generates a cryptographic Journal and seal (ZK-Receipt) of the execution.
  • Result Streaming: Compact aggregated results return through gRPC streams, accompanied by cryptographic verification proofs.
This architecture combines in-situ computational efficiency with auditable, multi-layered Zero-Trust isolation.