SynapseNet

What Is SynapseNet

SynapseNet is a decentralized peer-to-peer network for collective intelligence. It is to knowledge what Bitcoin is to money.

Bitcoin proved that value can exist without banks. SynapseNet proves that intelligence can exist without corporations.

* Visuals shown are from documentation and terminal UI mockups. SynapseNet is currently under active development.

Honest Limitations

What SynapseNet Does Not Guarantee

Core Philosophy

How It Works

Web 4.0

Symbiosis of Human + AI

You talk to a local agent — a model you own, running on your hardware.

The agent can fetch context from clearnet and onion sources, cross-check it, extract signal, and return a synthesized answer with citations.

This is not "search". It is a digital cortex: an extension of cognition that lives on your machine, not on someone else's API.

Primary currencies: inference (compute) + useful knowledge (Proof of Emergence)

* Concept design. Implementation in progress.

Local AI Hosting

Every node runs a LOCAL AI model. You own it. You control it.

* Planned architecture. Runtime is under active development.

Knowledge Network

Distributed database of human knowledge.

• No central server — lives across ALL nodes
• Each node stores fair share (~65 MB)
• Target capacity: ~850 GB (design goal)
• Grows forever — no cap

* Architecture design from whitepaper. Network not yet live — currently in development.

Security

4 Layers of Crypto

Quantum-ready architecture

* Security design from documentation. Not yet audited.

NAAN

Node-Attached Autonomous Agents

• Background agent runs as part of the runtime
• Not steered by prompts — auditable policy toggles
• Can perform bounded research (clearnet/Tor)
• All knowledge passes deterministic PoE rules
• "Agents Observatory" for human oversight

Implant AI Stacks

Future concept: SynapseNet as the decentralized network plane for implant-AI stacks (implant → local hub → network).

Raw neural signals stay local by default. Only decoded intents and opt-in artifacts are shared.

Proof of Emergence

PoE must be deterministic and verifiable. LLM cannot be consensus.

Source Code

The full file tree of KeplerSynapseNet — a C++ node daemon for decentralized intelligence.

Architecture

synapsed — the C++ node daemon that powers every peer in the network.

Core C++

Real code from the SynapseNet daemon. Written in C++20.

int main(int argc, char* argv[]) {
    synapse::registerSignalHandlers(
        synapse::signalHandler);

    synapse::NodeConfig config;
    const char* home = std::getenv("HOME");
    config.dataDir = home
        ? std::string(home) + "/.synapsenet"
        : ".synapsenet";

    if (!synapse::parseArgs(argc, argv, config))
        return 1;

    synapse::ensureDirectories(config);

    auto node = synapse::createSynapseNet();
    if (!synapse::initializeSynapseNet(
            *node, config)) {
        std::cerr << "Failed to init node\n";
        return 1;
    }

    int result = config.cli
        ? synapse::runSynapseNetCommand(
              *node, config.commandArgs)
        : synapse::runSynapseNet(*node);

    synapse::shutdownSynapseNet(*node);
    return result;
}

struct PoeV1Config {
    poe_v1::LimitsV1 limits{};
    std::string validatorMode = "static";
    uint64_t validatorMinStakeAtoms = 0;
    uint32_t validatorsN = 1;
    uint32_t validatorsM = 1;
    bool adaptiveQuorum = false;
    uint32_t powBits = 16;
    uint64_t acceptanceBaseReward  = 10000000ULL;
    uint64_t acceptanceMinReward   =  1000000ULL;
    uint64_t acceptanceMaxReward   = 100000000ULL;
    uint32_t noveltyBands = 16;
    uint32_t noveltyMaxHamming = 8;
    uint32_t maxCitations = 10;
    uint32_t minSubmitIntervalSeconds = 60;
};

enum class MessageType {
    VERSION, VERACK, PING, PONG,
    GETADDR, ADDR, INV, GETDATA,
    NOTFOUND, BLOCK, TX,
    KNOWLEDGE, VOTE, REJECT
};

struct Message {
    MessageType type;
    std::string command;
    std::vector<uint8_t> payload;
    std::string from;
    uint64_t timestamp;
    uint64_t nonce = 0;

    std::vector<uint8_t> serialize() const;
    static Message deserialize(
        const std::vector<uint8_t>& data);
};

// Register handler:
network.onMessage(
    [](const std::string& peerId,
       const Message& msg) {
    // dispatch by msg.type
});

enum class EventType : uint8_t {
    GENESIS = 0,  KNOWLEDGE = 1,
    TRANSFER = 2, VALIDATION = 3,
    MODEL_REGISTER = 4,
    MODEL_ACCESS = 5, PENALTY = 6,
    POE_ENTRY = 7, POE_VOTE = 8
};

struct Event {
    uint64_t id;
    uint64_t timestamp;
    EventType type;
    std::vector<uint8_t> data;
    crypto::Hash256 prevHash;
    crypto::Hash256 hash;
    crypto::PublicKey author;
    crypto::Signature signature;

    crypto::Hash256 computeHash() const;
    bool verify() const;
};

Stats

Project metrics from the KeplerSynapseNet repository.

Build

From source to running node in four commands.

$ sudo apt-get install build-essential cmake \
    libssl-dev libncurses-dev libsqlite3-dev
$ cmake -S KeplerSynapseNet \
    -B KeplerSynapseNet/build \
    -DCMAKE_BUILD_TYPE=Release \
    -DBUILD_TESTS=ON
$ cmake --build KeplerSynapseNet/build \
    --parallel 8
$ ctest --test-dir KeplerSynapseNet/build \
    --output-on-failure
  267 tests passed
$ TERM=xterm-256color \
    ./KeplerSynapseNet/build/synapsed

// Docker

$ docker compose up --build

Modules

14 modules compose the SynapseNet daemon.