SPT Documentation

Appearance

The Agentic Trust Fabric ​

Solving the Dual Crisis of AI Security and Monetization

SmartPoints Technology

Table of Contents ​

Executive Summary ​

The transition from Generative AI to Agentic AI — where autonomous software agents execute tasks, transact value, and modify infrastructure — represents a multi-trillion-dollar economic shift. Two critical deficits in existing internet architecture stall this shift:

The Security Abyss. Traditional perimeter security cannot distinguish between a legitimate customer's AI agent and a malicious bot swarm. Both operate on intent, not location, rendering IP-based firewalls obsolete.

The Economic Deadlock. Service providers cannot monetize agent traffic because anonymous bots cannot sign or honor contracts. Without verifiable identity, there is no accountability, no billing, and no enforceability of commercial terms.

SmartPoints Technology introduces the Agentic Trust Fabric, a "Layer 8" identity overlay that resolves both faults simultaneously. The Fabric transforms anonymous bots into SmartAgents — verifiable entities encapsulated in quantum-resistant .spt containers. This enables a deny-by-default infrastructure. Every packet is authenticated. Every interaction is bound by a negotiated Service Level Agreement. Every agent carries its own cognitive memory.

The Agentic Trust Fabric comprises four pillars:

PillarFunction
sptvector EngineHigh-performance vector database runtime with bio-inspired neural architecture, HNSW indexing, and 3-tier self-learning
.spt Container FormatSelf-booting binary container encapsulating agent logic, vector embeddings, knowledge graphs, and quantum-resistant cryptographic proofs
Agentic Identity Ledger (AIL)DAG-based ledger with quantum-resistant consensus enabling O(1) agent identity lookup and real-time capability verification
Noise Protocol ExtensionsHandshake protocol for negotiating asymmetric, directional SLAs between agents in under 100 ms

What distinguishes SmartPoints from theoretical proposals is that core components are already built and shipping. The sptvector engine runs in production as a 45-crate Rust workspace. The cognitive layer — self-learning, bio-inspired routing, knowledge graphs — operates inside a desktop cognitive assistant. The agent orchestration framework coordinates 622 AI agents across distributed development environments.

The Problem: Why TCP/IP Fails for Agents ​

The internet protocol suite connects locations (IP addresses), not entities. This architectural assumption — adequate for human-driven web browsing — collapses under agentic workloads.

Three Structural Failures ​

Lateral Movement is the Default. Once an attacker breaches a VPN or firewall, they inherit implicit network trust. A compromised agent inside the perimeter is indistinguishable from a legitimate one. Traditional security assumes a defensible boundary; agentic systems have none.

Zero Accountability. API requests carry bearer tokens but lack cryptographic proof of the requesting entity's current policy state, legal mandate, or behavioral history. An agent presenting a valid API key could be operating under revoked permissions, drifted objectives, or adversarial control — and the receiving service has no mechanism to know.

Static Infrastructure. Provisioning access requires manual approval workflows designed for human timescales. AI agents need to discover, negotiate, and consume services in milliseconds. The gap between infrastructure velocity and agent velocity creates a bottleneck that throttles the entire agentic economy.

What Current Art Cannot Provide ​

RequirementCurrent StateGap
Identity-bound transportTLS connects endpoints, not verifiable identitiesNo cryptographic binding between packet and actor
Random-access ledgersLinear blockchains (15–30 TPS) lack throughput for real-time agent memoryCannot serve as live state store for millions of agents
Directional capability enforcementActor models lack packet-level cryptographic enforcementNo way to enforce "read-only" or "write-once" at the transport layer
Cognitive continuityAgents restart stateless, losing learned behaviorsNo persistent, portable memory across sessions and hosts

The Solution: SmartPoints Architecture ​

SmartPoints replaces static, location-based trust with an identity-centric fabric where every entity — human or autonomous — carries cryptographically verifiable identity, capability proofs, and cognitive state.

The three-layer architecture: .spt containers feed the cognitive runtime, which connects to the Layer 8 trust fabric for identity, security, and governance.

mermaid
flowchart TD
    subgraph Layer8["Layer 8: Agentic Trust Fabric"]
        AIL["Agentic Identity Ledger\n(DAG + QR-Avalanche)"]
        SVS["Secure Virtualization Service\n(Inside-Out Tunnels)"]
        GOV["Governance Sidecars\n(622+ Agent Types)"]
    end

    subgraph Cognitive["Cognitive Runtime"]
        VEC["sptvector Engine\n(45+ Rust Crates)"]
        SONA["SONA Self-Learning\n(3-Tier Adaptation)"]
        NS["Nervous System\n(Bio-Inspired Routing)"]
        KG["Knowledge Graph\n(Hyperedge Relationships)"]
    end

    subgraph Container[".spt Container"]
        MEM["Vector Memory\n(HNSW + redb)"]
        REL["Relationship Graph\n(Directional Allowances)"]
        CRYPTO["Quantum Mandate\n(ML-DSA + ML-KEM)"]
        MANIFEST["Verifiable Credentials\n(JSON-LD)"]
    end

    Container --> Cognitive
    Cognitive --> Layer8
    Layer8 -->|"100ms Handshake"| Layer8

The architecture operates across three repositories under active development:

RepositoryRoleStatus
sptUnified monorepo: 45+ Rust crates (spt-*) delivering VectorDB, neural architecture, self-learning, LLM inference, wire protocol, and multi-target bindings — plus Go CLI (sptx), Terraform IaC, 622 AI agents, SPT Orchestrator swarm coordination, 3-tier persistent memoryActive development
spt-brainDesktop cognitive assistant: Tauri 2 app proving the cognitive layer with 7 subsystems, 60+ IPC commands, and cloud connector integrationActive development
quazarQuantum-resistant P2P: LibP2P mesh, onion routing, QR-Avalanche DAG consensus, ML-DSA/Falcon-512 cryptographyIn development

The sptvector Engine ​

At the foundation of the Agentic Trust Fabric lies sptvector — a high-performance vector database engine purpose-built for autonomous agent cognition. The product name "sptvector" refers to the engine implemented in the spt repository. Unlike general-purpose vector databases designed for search workloads, sptvector provides the full cognitive stack an agent needs to perceive, learn, reason, and remember.

Architecture ​

The engine is implemented as a Rust workspace of 45+ crates organized into five bounded domains.

The domain architecture of sptvector: core vector operations feed neural and learning subsystems, which connect to inference and security layers. Platform bindings enable cross-target deployment.

mermaid
flowchart TD
    subgraph Core["Core Domain"]
        DB["spt-core\nVectorDB + HNSW + redb"]
        COL["spt-collections\nCollections + Filtering"]
        MC["spt-mincut\nGraph Partitioning"]
    end

    subgraph Neural["Neural & Learning Domain"]
        SONA["spt-sona\n3-Tier Self-Learning"]
        NS["spt-nervous-system\nBio-Inspired Routing"]
        GNN["spt-gnn + spt-graph\nGNN + Knowledge Graph"]
        ATT["spt-attention\n20+ Mechanisms"]
    end

    subgraph LLM["Inference & Security Domain"]
        SPTLLM["sptllm\nLocal LLM Runtime"]
        COH["Coherence + Formal\nQuality Gating + Verification"]
        GATE["cognitum-gate\nKernel + Node + Pipeline"]
    end

    subgraph Bind["Platform & Bindings"]
        WIRE["spt-wire + spt-types\nSerialization + Type System"]
        TARGETS["spt-wasm + spt-node\nWASM + N-API Bindings"]
    end

    Core --> Neural
    Neural --> LLM
    Core --> Bind

Core Vector Database ​

The storage engine combines three technologies for crash-safe, high-throughput vector operations:

  • redb — An ACID-compliant, crash-safe key-value store providing persistent, append-only storage. Every write is durable; every read is consistent.
  • HNSW — Hierarchical Navigable Small World graphs deliver approximate nearest-neighbor search in O(log n), enabling sub-millisecond retrieval across millions of vectors.
  • simsimd — SIMD-accelerated distance calculations (cosine, L2, Hamming) exploit hardware vector instructions for maximum throughput on modern CPUs.

The engine supports multiple quantization strategies — scalar (int8/uint8), product quantization, and binary quantization — achieving 4–32x memory reduction while preserving retrieval accuracy. Memory-mapped file access via memmap2 allows datasets larger than available RAM.

Multi-Target Deployment ​

A single codebase compiles to three targets, allowing sptvector to run wherever agents operate:

TargetTechnologyUse Case
NativeRust binary (macOS, Linux, Windows)Desktop agents, server-side processing
WASMwasm-bindgen + dlmalloc microkernelBrowser agents, edge computing, sandboxed execution
Node.jsN-API bindings (darwin-arm64, darwin-x64, linux-x64)Orchestration runtimes, CI/CD pipelines

This tri-target architecture means an agent's cognitive engine follows it across environments — from a developer's laptop to a Kubernetes pod to a browser sandbox — with identical behavior and zero reimplementation.

The Cognitive Layer ​

Raw vector storage is necessary but insufficient for autonomous agents. An agent must learn from experience, route attention efficiently, and maintain coherent knowledge across sessions. The SmartPoints cognitive layer provides these capabilities through four bio-inspired subsystems, all operational today.

SONA: 3-Tier Self-Learning ​

SONA (Self-Organizing Neural Architecture) delivers continuous adaptation without catastrophic forgetting — a critical requirement for long-lived agents whose behavior must improve over time without losing previously learned capabilities.

TierMechanismFrequencyFunction
InstantMicroLoRAEvery interactionLow-rank weight updates adapt the agent's responses immediately based on the current trajectory
BackgroundK-means++PeriodicPattern clustering extracts recurring behavioral motifs from accumulated trajectories
ConsolidationEWC++ScheduledElastic Weight Consolidation prevents catastrophic forgetting by protecting important learned parameters

The system records interaction trajectories in a 384-dimensional embedding space, supporting up to 10,000 trajectories with 100 pattern clusters. This architecture mirrors biological memory consolidation: the hippocampus (Tier 1) handles immediate encoding, the neocortex (Tier 2) extracts patterns during rest, and synaptic consolidation (Tier 3) preserves critical knowledge permanently.

Bio-Inspired Nervous System ​

The nervous system provides four complementary routing and memory mechanisms drawn from computational neuroscience:

Modern Hopfield Networks. Associative memory with exponential energy functions enables pattern completion — given a partial input, the network retrieves the complete stored pattern. This powers "tip-of-the-tongue" recall where fragmentary cues retrieve full memories.

Oscillatory Router. Kuramoto phase coupling coordinates multiple cognitive modules through synchronized oscillations. Just as gamma-band synchronization in biological brains binds distributed neural populations into coherent percepts, the oscillatory router ensures that vector search, graph traversal, and learning processes operate in concert rather than interference.

Predictive Coding. Rather than transmitting full representations between subsystems, the predictive layer sends only residuals — the difference between what was predicted and what was observed. This achieves 90–99% bandwidth reduction between cognitive modules, a critical efficiency gain for resource-constrained agent runtimes.

Dentate Gyrus. Sparse random projections perform novelty detection and pattern separation. New inputs that differ significantly from stored patterns trigger heightened attention and explicit encoding, while familiar inputs pass through efficiently. This prevents memory saturation and focuses learning resources on genuinely novel experiences.

Knowledge Graph ​

The knowledge graph extends vector similarity with structured relationships through a persistent graph database supporting hyperedges — relationships that connect arbitrary numbers of entities simultaneously:

  • Nodes represent entities (documents, concepts, people, events) with typed properties
  • Edges encode pairwise relationships with directionality and metadata
  • Hyperedges capture multi-entity relationships that cannot be decomposed into pairwise connections (e.g., "this meeting involved persons A, B, and C discussing topics X and Y")

For the Agentic Trust Fabric, the knowledge graph stores the relationship shard within each .spt container — the directed capability graph that determines which other agents this agent may communicate with, what message types are permitted, and in which direction data may flow.

Graph Neural Networks ​

GNN-based tensor compression reduces the memory footprint of stored knowledge while preserving its structural properties. The GNN subsystem also enables self-healing behavior: by analyzing interaction patterns across the knowledge graph, the system identifies degraded relationships, outdated capabilities, and reputation changes — feeding these signals back into the Agentic Identity Ledger for real-time trust score updates.

Proven in Production ​

These cognitive subsystems are not theoretical — they run today inside spt-brain, a Tauri 2 desktop cognitive assistant that serves as the proving ground for the full Agentic Trust Fabric. spt-brain orchestrates all five subsystems through a bridge architecture:

Bridge ModuleSubsystemIntegration
vector_store.rsVectorDBThread-safe wrapper around spt-core with HNSW and redb persistence
sona_bridge.rsSONA LearningManages 3-tier adaptation lifecycle with trajectory recording
nervous_bridge.rsNervous SystemCoordinates Hopfield, oscillatory routing, predictive coding, and novelty detection
graph_bridge.rsKnowledge GraphPersistent entity relationships with hyperedge support
compress_bridge.rsGNN CompressionTensor compression for memory-efficient knowledge storage
engine.rsCognitive EngineOrchestrates all bridges into a unified cognitive pipeline

The desktop application processes user content through a complete cognitive pipeline: content extraction, chunking (512 tokens, 128 overlap), embedding (ONNX all-MiniLM-L6-v2, 384 dimensions), vector storage, self-learning trajectory recording, nervous system routing, and knowledge graph enrichment. This identical pipeline powers SmartAgents in the Agentic Trust Fabric.

The .spt Container Format ​

The .spt file format is an evolution of the SPT (SPT Format) standard — the crash-safe, append-only vector storage format already shipping in spt and spt-brain. An .spt file is not merely a data format; it is a Self-Booting Actor Container that encapsulates everything an agent needs to operate autonomously.

Container Structure ​

The four segments of an .spt container: header, vector memory, relationship graph, cryptographic mandate, and verifiable manifest.

mermaid
flowchart LR
    subgraph SPT[".spt Container"]
        direction TB
        H["Header (64 bytes)\nMagic: SPTS\nProtocol Version\nDID Root Hash"]
        S1["Segment 1: VEC\nVector Memory\nHNSW Index\nProduct Quantization"]
        S2["Segment 2: RELATIONSHIPS\nDirectional Allowances\nTarget DIDs\nNoise PSK Hashes"]
        S3["Segment 3: CRYPTO\nML-DSA-65 Public Keys\nKyber-1024 / ML-KEM\nEphemeral Keystores"]
        S4["Segment 4: MANIFEST\nJSON-LD Credentials\nRoot Authority Signatures\nCapability Declarations"]
        H --> S1 --> S2 --> S3 --> S4
    end
SegmentContentsImplementation
Header (64 bytes)Magic bytes (SPTS), protocol version, agent's DID root hashspt-wire zero-copy serialization with xxhash3 checksums and CRC32C validation
VEC (Vector Memory)High-dimensional embeddings compressed via product quantizationspt-core with HNSW indexing, redb persistence, configurable dimensionality
RELATIONSHIPS (Graph Shard)Directional allowances: { Target_DID, Allowed_Msg_Types, Direction, Noise_PSK_Hash, Expiry }spt-graph hyperedge storage with typed properties
CRYPTO (Quantum Mandate)ML-DSA-65 public keys, ephemeral Kyber-1024 / ML-KEM encryption keysspt-crypto + quazar quantum-resistant primitives
MANIFESTJSON-LD Verifiable Credentials signed by a root authorityspt-manifest with versioned kernel headers and spt-types unified type system

Wire Protocol ​

The spt-wire crate provides the binary serialization layer:

  • Zero-copy deserialization via rkyv — segments are read directly from memory-mapped files without parsing overhead
  • Integrity verification through dual checksums: xxhash3 for fast validation, CRC32C for data integrity
  • Versioned segment headers ensure backward compatibility as the format evolves
  • Cross-platform — identical binary representation across native, WASM, and Node.js targets

Coherence Gating ​

Before a container's contents are trusted, the cognitum-gate system enforces multi-level verification:

Gate LevelCrateEnforcement
Kernelcognitum-gate-kernelVerifies container structural integrity and cryptographic chain
Nodecognitum-gate-nodeValidates permissions against the agent's current capability set
Pipelinecognitum-gate-verifyRuns formal verification checks on behavioral constraints
MCPmcp-gateExposes coherence validation as Model Context Protocol tools

Container Lifecycle ​

When loaded into the sptvector engine, an .spt container executes a deterministic boot sequence:

  1. Verify — The witness chain (Merkle proof) is validated against the Agentic Identity Ledger
  2. Spawn — The agent instantiates inside a sandboxed runtime (Firecracker MicroVM or WASM isolate)
  3. Hydrate — Vector memory, knowledge graph, and SONA learning state are restored from the container segments
  4. Enforce — The Directed Messaging Loop activates: inbound packets are filtered by the RELATIONSHIPS graph; outbound messages are restricted to authorized DIDs
  5. Learn — SONA begins recording interaction trajectories; the nervous system resumes oscillatory synchronization

The Agentic Identity Ledger ​

Linear blockchains are fundamentally unsuitable for agent identity. Ethereum's 15–30 TPS throughput and multi-second finality cannot support millions of agents performing sub-second negotiations. The Agentic Identity Ledger (AIL) is a Directed Acyclic Graph built on quazar's QR-Avalanche consensus protocol.

DAG Architecture ​

A SmartAgent queries the Kademlia DHT for a DID, which resolves through the QR-Avalanche DAG to retrieve state shards. GNN self-healing continuously updates trust scores.

mermaid
flowchart LR
    subgraph AIL["Agentic Identity Ledger"]
        direction TB
        DHT["Kademlia DHT\nO(1) Agent Lookup"]
        DAG["QR-Avalanche DAG\nQuantum-Resistant Consensus"]
        SHARD["Memory Shards\nEphemeral + TTL"]
        GNN2["GNN Self-Healing\nReputation + Routing"]
    end

    A1["SmartAgent A"] -->|"Query DID"| DHT
    DHT -->|"Resolve"| DAG
    DAG -->|"State Shard"| SHARD
    GNN2 -->|"Update Scores"| DAG

Random-Access Memory. The DAG structure, overlaid with a Kademlia DHT, allows O(1) random access to agent state shards. Each agent's identity, capability declarations, and behavioral history are stored as individually addressable shards — turning the ledger into a global, decentralized memory bank rather than an append-only log.

Quantum Resistance. Post-quantum cryptography implemented in quazar secures the ledger:

AlgorithmPurposeStandard
ML-DSA (Dilithium)Digital signatures for identity bindingNIST FIPS 204
Falcon-512High-speed signature verificationNIST Round 3
ML-KEM (Kyber-1024)Key encapsulation for ephemeral channelsNIST FIPS 203

This ensures resilience against "harvest-now-decrypt-later" quantum attacks — a critical consideration for infrastructure designed to persist for decades.

Self-Healing. Graph Neural Networks — the same GNN architecture prototyped in spt's spt-gnn crate and proven in spt-brain's cognitive engine — continuously analyze interaction patterns across the ledger. The GNN identifies reputation degradation, detects coordinated malicious behavior, and optimizes routing paths based on historical trust scores.

Digital Evaporation. Memory shards carry a TTL (Time To Live). Upon expiry, the encryption keys stored in a separate ephemeral keystore are cryptographically shredded, rendering the shard's contents mathematically inaccessible. This provides privacy-by-design: agents accumulate only the memory they need, and that memory dissolves when its purpose is fulfilled.

Secure Virtualization Service ​

Traditional APIs expose inbound ports — each one an attack surface. The Secure Virtualization Service (SVS) inverts this model entirely.

The "Inside-Out" Connection Model ​

The SVS connection flow: infrastructure initiates an outbound tunnel to a Rendezvous Point. SmartAgents present their .spt container for verification before gaining access.

mermaid
sequenceDiagram
    participant Infra as Protected Infrastructure
    participant RP as Rendezvous Point<br/>(Tier-1 CDN)
    participant Agent as SmartAgent

    Note over Infra: No inbound ports open
    Infra->>RP: Initiate outbound tunnel
    Agent->>RP: Present .spt container + DID
    RP->>RP: Verify against AIL
    RP->>Infra: Relay authenticated request
    Infra->>RP: Response via existing tunnel
    RP->>Agent: Deliver response
    Note over Agent,Infra: Asymmetric channel established

No Inbound Ports. Infrastructure initiates secure outbound tunnels to a global mesh of Rendezvous Points deployed on Tier-1 CDNs. Protected assets never listen for incoming connections — they are invisible to port scanners, vulnerability probes, and reconnaissance bots.

Cloaked Assets. Services exist only to cryptographically authorized agents. An unauthorized agent cannot discover that a service exists, let alone attempt to access it. This eliminates the reconnaissance phase of the attack kill chain entirely.

Asymmetric Directional Negotiation. The messaging backbone uses SPT Wire (DID-addressed QUIC transport) with Noise Protocol Framework extensions, layered on quazar's LibP2P mesh and onion routing. Agents negotiate channel directionality at the cryptographic level — a "read-only" channel is not a policy label but a mathematical constraint enforced at the packet level.

Intelligent Business Negotiation ​

The 100ms Contract ​

Before data exchange begins, agents perform a Digital Handshake that establishes a legally binding, cryptographically enforced Service Level Agreement.

The negotiation flow: Governance Sidecars on both sides exchange proposals via Noise Protocol until terms converge, then both agents sign with ML-DSA.

mermaid
sequenceDiagram
    participant A as SmartAgent A<br/>(Data Consumer)
    participant GA as Governance Sidecar A
    participant GB as Governance Sidecar B
    participant B as SmartAgent B<br/>(Service Provider)

    A->>GA: Propose terms
    Note right of A: Dataset access<br/>< 50ms latency<br/>US-East residency
    GA->>GB: Noise Protocol handshake
    GB->>B: Validate against policies
    B->>GB: Counter-proposal
    GB->>GA: Negotiate terms
    GA->>A: Final terms
    A->>B: Both sign with ML-DSA
    Note over A,B: Smart Relationship stored in AIL
  1. Proposal. Agent A declares its requirements: data scope, latency constraints, geographic residency, compliance mandates
  2. Negotiation. Both agents' Governance Sidecars exchange counter-proposals via Noise Protocol extensions until terms converge or negotiation fails
  3. Binding. Both agents sign a Smart Relationship using ML-DSA. This creates a temporary, cryptographically enforced SLA stored in the AIL with automatic expiry

The entire sequence completes in under 100 milliseconds — fast enough for real-time agent-to-agent commerce at internet scale.

Governance Architecture ​

Control Zones and Micro-Segmentation ​

The architecture divides the network into identity-based Control Zones — logical boundaries defined not by IP ranges but by capability sets and trust levels. An agent's .spt container MANIFEST segment determines zone membership, not network location.

Governance Sidecars ​

Every Control Zone is monitored by Governance Sidecars — lightweight AI agents operating at less than 1% CPU overhead. The sidecar architecture is already proven at scale: spt's SPT Orchestrator orchestrator coordinates 622 AI agents organized into specialized plugins:

PluginAgentsFunction
Agentic QE58Quality engineering, behavioral verification, drift detection
Code Intelligence~50Static analysis, pattern recognition, anomaly flagging
Test Intelligence~40Strategy validation, coverage verification
Perf Optimizer~30Resource monitoring, bottleneck detection
Teammate21 MCP toolsMulti-agent coordination and consensus
Gastown Bridge20 MCP toolsWASM-accelerated orchestration and memory synchronization

In the Agentic Trust Fabric, these agent types serve as the foundation for Governance Sidecars that monitor for model drift, policy violations, and adversarial behavior patterns — the same orchestration infrastructure, applied to network-level trust enforcement.

3-Tier Persistent Memory ​

Governance agents maintain coherent state across sessions through a 3-tier memory architecture already operational in spt:

TierNameTechnologyScope
1BeadsGit-native JSONLCross-session decisions, architectural context — persists across agent restarts
2TasksNative task memorySession-scoped working context — tracks in-progress operations
3SptDBspt WASM + HNSWLearned patterns and semantic memory — 150x–12,500x faster retrieval than linear search

This architecture ensures that governance decisions are durable (Tier 1), operational context is efficient (Tier 2), and learned behavioral patterns are semantically searchable (Tier 3). A Governance Sidecar that detects a novel attack pattern stores it in SptDB, making it instantly retrievable by every other sidecar in the mesh.

Double-Handshake Protocol ​

Cross-zone traffic requires mutual cryptographic approval from both zones' Governance Agents. Neither zone's sidecar alone can authorize transit — both must independently validate the requesting agent's identity, verify its capability declarations against the AIL, and confirm that the requested operation falls within the negotiated Smart Relationship.

Implementation Status ​

SmartPoints is not a theoretical architecture. Core components are built, tested, and running.

Active Repositories ​

The implementation stack: spt monorepo provides the foundation Rust crates (spt-) consumed by spt-brain (desktop) and the Go CLI/orchestration layer. quazar provides the quantum-resistant network substrate.*

mermaid
flowchart TD
    subgraph SPTMonorepo["spt Monorepo"]
        MIND["spt-* Crates\n45+ Rust Crates\nVectorDB • SONA • Nervous System\nGraph • GNN • LLM • Wire Protocol"]
        FLO["sptx CLI + Infra\nGo CLI + Terraform\n622 AI Agents\nSPT Orchestrator Orchestration"]
    end

    subgraph Applications["Application Layer"]
        BRAIN["spt-brain\nTauri 2 Desktop App\n7 Cognitive Subsystems\n60+ IPC Commands"]
    end

    subgraph Network["Network Layer"]
        QUAZ["quazar\nLibP2P Mesh • Onion Routing\nQR-Avalanche Consensus\nML-DSA • Falcon-512 • ML-KEM"]
    end

    MIND -->|"6 crates as\nworkspace members"| BRAIN
    SPTMonorepo --> Network
    Applications --> Network

spt-* — Core Engine (45+ Crates) ​

The foundation layer within the spt monorepo. A Rust workspace delivering every computational primitive the Agentic Trust Fabric requires:

DomainCratesCapabilities
Vector Databasespt-core, spt-collections, spt-filter, spt-mincutHNSW indexing, redb persistence, SIMD distance functions, metadata filtering, dynamic graph partitioning
Neural & Learningspt-sona, spt-nervous-system, spt-attention, spt-gnn, spt-graph, spt-sparse-inference3-tier self-learning, Hopfield associative memory, 20+ attention mechanisms, graph neural networks, knowledge graph with hyperedges
Inferencesptllm, spt-coherence-gate, spt-formal, mcp-gateLocal LLM runtime (GGUF, Metal/CUDA), output quality gating, formal verification, MCP coherence server
Platformspt-wire, spt-types, spt-manifest, spt-crypto, spt-wasm, spt-node, spt-wasm, spt-nodeZero-copy serialization, unified type system, WASM microkernel, N-API bindings, cryptographic operations
Securitycognitum-gate-kernel, cognitum-gate-node, cognitum-gate-verifyKernel-level coherence, node-level permission gates, verification pipeline

spt-brain — Cognitive Proving Ground ​

A Tauri 2 desktop application (Rust backend + React 18 frontend) that proves the cognitive layer works end-to-end:

  • 7 cognitive subsystems operating in concert: VectorDB, SONA self-learning, nervous system routing, knowledge graph, GNN compression, LLM inference, AI provider routing
  • 60+ IPC commands bridging the React frontend to the Rust cognitive engine
  • 11 background task cycles — file indexing, email indexing, SONA adaptation, nervous system synchronization, cloud sync, clipboard monitoring, health checks
  • Cloud connectors — Dropbox (OAuth2), Microsoft Graph (SharePoint, Outlook, O365), local filesystem — all producing unified IndexableContent through a common chunking and embedding pipeline
  • HTTP API on localhost:19519 — REST endpoints for cognitive operations, used by the companion CLI and MCP server
  • Companion CLI — standalone binary for scripted interaction with the cognitive engine
  • MCP Server — exposes cognitive capabilities to external AI tools via Model Context Protocol

spt — Agent Orchestration at Scale ​

A complete AI-augmented development infrastructure proving that large-scale agent coordination works:

  • Go CLI (Cobra + Viper) managing Coder v2 workspace lifecycle — create, SSH, start, stop, restart
  • 10+ Terraform modules provisioning Azure infrastructure: AKS clusters, Key Vault secret management, Entra ID SSO, GitHub OIDC federation, networking
  • 622 AI agents organized by specialization, orchestrated by SPT Orchestrator
  • Docker-based and Kubernetes-based workspace templates with pre-configured toolchains
  • CI/CD pipelines — GitHub Actions with GoReleaser for cross-platform CLI distribution (Homebrew, Chocolatey, winget)
  • 3-tier memory (Beads + Tasks + SptDB) providing persistent, searchable agent memory across sessions

quazar — Quantum-Resistant Communication ​

The network substrate providing the cryptographic and communication primitives the Trust Fabric requires:

  • LibP2P mesh networking with onion routing for metadata-resistant communication
  • QR-Avalanche consensus — DAG-based protocol designed for high-throughput agent identity operations
  • Post-quantum cryptography — ML-DSA (Dilithium) for signatures, Falcon-512 for high-speed verification, ML-KEM (Kyber-1024) for key encapsulation
  • Peer discovery and NAT traversal for agents operating behind restrictive networks

Market Impact and Adoption ​

SmartPoints is the Network Operating System for the Agentic Economy. It enables enterprises to shift from a defensive posture — blocking AI traffic they cannot identify — to an offensive one: monetizing every authenticated agent interaction through cryptographically binding SLAs.

Adoption Path ​

The architecture supports incremental adoption. You do not rewrite your infrastructure; you wrap it:

  1. Deploy SVS Gateway. Existing APIs gain inside-out security by routing through Rendezvous Points. No code changes required.
  2. Issue .spt Containers. Authorized agents receive containers with appropriate capability declarations. Unauthorized traffic is denied by default.
  3. Enable Governance. Deploy Governance Sidecars (built on the same SPT orchestration framework already managing 622 agents) to monitor agent behavior and enforce policy compliance.
  4. Activate Commerce. The 100ms Contract handshake enables automated, legally binding SLA negotiation between agents — turning every API call into a monetizable transaction.

Why SmartPoints Wins ​

Not starting from zero. The sptvector engine, cognitive layer, and agent orchestration framework are built and running. Competitors proposing agent identity solutions are typically presenting architectures; SmartPoints is presenting implementations.

Bio-inspired, not rule-based. Governance Sidecars powered by SONA self-learning and nervous system routing detect novel threats through pattern recognition, not signature matching. The system adapts to attacks it has never seen before.

Quantum-ready from day one. Every cryptographic operation uses post-quantum algorithms. There is no migration path to plan because there is nothing to migrate from.

Multi-target runtime. The same cognitive engine compiles to native binaries, WASM isolates, and Node.js runtimes. Agents carry identical cognitive capabilities regardless of deployment environment.

Contact ​

SmartPoints Technology

Released under the MIT License.

Copyright 2024-present SmartPoints Technology