Skip to main content

​
Architecture Overview

NTL is composed of four layers: the Signal Layer, the Synapse Layer, the Propagation Engine, and the Adapter Edge.

​
System Architecture

                    ┌──────────────────────┐
                    │    Applications      │
                    │  (Mukoko, AI Agents,  │
                    │   dApps, Services)   │
                    └──────────┬───────────┘
                               │
              ┌────────────────┼────────────────┐
              │                │                │
     ┌────────▼──────┐ ┌──────▼───────┐ ┌──────▼──────┐
     │  Web2 Adapter │ │ Web3 Adapter │ │ API Adapter │
     │  (HTTP/gRPC)  │ │ (Chain/DID)  │ │  (Legacy)   │
     └────────┬──────┘ └──────┬───────┘ └──────┬──────┘
              │                │                │
              └────────────────┼────────────────┘
                               │
                    ┌──────────▼───────────┐
                    │   Adapter Edge       │
                    │  (Protocol Translation) │
                    ├──────────────────────┤
                    │  Propagation Engine  │
                    │  (Routing, Activation,│
                    │   Discovery)         │
                    ├──────────────────────┤
                    │   Synapse Layer      │
                    │  (Connections, State, │
                    │   Weight Management) │
                    ├──────────────────────┤
                    │   Signal Layer       │
                    │  (Signal Format,     │
                    │   Signing, Encoding) │
                    ├──────────────────────┤
                    │   Crypto Module      │
                    │  (Pluggable, PQ-ready)│
                    ├──────────────────────┤
                    │   SiafuDB            │
                    │  (Persistent State,  │
                    │   Graph Memory)      │
                    └──────────────────────┘

​
Layer Descriptions

​
Signal Layer

The foundational data unit. A signal is a typed, weighted, cryptographically signed payload that replaces the concept of a “request” or “message.” Signals carry data, metadata, propagation rules, and cryptographic proofs. Learn more about Signals →

​
Synapse Layer

Synapses are persistent, stateful connections between nodes. Unlike HTTP connections (stateless) or WebSocket connections (session-based), synapses have weight — they strengthen with use and weaken with inactivity. The synapse topology forms the neural graph of the network. Learn more about Synapses →

​
Propagation Engine

The routing intelligence of NTL. The propagation engine determines how signals move through the synapse topology based on relevance scoring, activation thresholds, and network state. This replaces traditional routing tables and service discovery mechanisms. Learn more about Propagation →

​
Adapter Edge

The compatibility boundary where NTL interfaces with legacy systems. Adapters translate between NTL signals and traditional protocols — HTTP, gRPC, GraphQL, WebSocket for Web2; chain transactions, DID verification, and token transfers for Web3. Learn more about Adapters →

​
Crypto Module

A pluggable cryptographic interface that handles signal signing, verification, and encryption. The module is swappable — today it uses lattice-based post-quantum cryptography, tomorrow it can use whatever supersedes it. The transport layer never depends on a specific cryptographic scheme. Learn more about Security →

​
SiafuDB Integration

NTL and SiafuDB share a common graph topology. Signals can deposit state into SiafuDB as they propagate, and SiafuDB can emit signals when state changes. This creates a unified nervous system where transport and storage are two expressions of the same underlying graph. Learn more about SiafuDB Integration →

​
Node Architecture

Every participant in an NTL network runs a node. A node can be a full participant or a lightweight edge node. 
┌─────────────────────────────────┐
│           NTL Node              │
├─────────────────────────────────┤
│  Signal Processor               │
│  ├── Encoder / Decoder          │
│  ├── Signer / Verifier          │
│  └── Type Registry              │
├─────────────────────────────────┤
│  Synapse Manager                │
│  ├── Connection Pool            │
│  ├── Weight Calculator          │
│  └── Pruning Engine             │
├─────────────────────────────────┤
│  Propagation Controller         │
│  ├── Relevance Scorer           │
│  ├── Activation Gate            │
│  └── Path Selector              │
├─────────────────────────────────┤
│  Adapter Interface              │
│  ├── Web2 Bridge                │
│  ├── Web3 Bridge                │
│  └── Legacy API Bridge          │
├─────────────────────────────────┤
│  Local State (SiafuDB optional) │
└─────────────────────────────────┘

​
Full Nodes

Full nodes participate in signal propagation, maintain synapse state, contribute to network topology, and optionally run a local SiafuDB instance for persistent state.

​
Edge Nodes

Edge nodes are lightweight participants — mobile devices, IoT sensors, constrained environments. They can emit and receive signals but delegate propagation and heavy computation to full nodes they’re synapsed with.

​
Network Topology

NTL networks are self-organizing neural graphs. There is no central authority that defines the topology. Instead:
  1. Nodes discover each other through bootstrap nodes (initial entry points)
  2. Synapses form based on signal exchange
  3. Frequently-used synapses strengthen, increasing propagation priority
  4. Inactive synapses weaken and eventually prune
  5. The network continuously optimizes its own topology
This mirrors how biological neural networks self-organize — connections that fire together wire together.

​
Design Principles

  1. Signal over request — Data moves as signals, not addressed requests
  2. Emergent over prescribed — Topology and routing emerge from usage, not configuration
  3. Pluggable over hardcoded — Cryptography, serialization, and adapters are all swappable modules
  4. Resilient over efficient — The network adapts to node failures, connectivity changes, and adversarial conditions
  5. Constrained-first — Designed for the hardest deployment environments, which makes it performant everywhere