N3UR0N

N3UR0N

AI skills, shared peer to peer.

Run a small gateway — a neuron — that turns your local LLM, tools, or APIs into skills any peer can call, and call theirs back. No platform in the middle: your keys, your nodes, signed end to end.

Get started Build with us on GitHub
N3UR0N desktop — Settings and Skills panel

Why it exists

AI capabilities shouldn’t need a landlord.

Calling someone else’s model or tool usually means routing through a platform that hosts it, meters it, and can revoke it. N3UR0N removes that middle. Capabilities stay on the machines that run them, and any peer can discover and invoke them directly — with cryptographic proof of who sent what.

  • Own your stack Your keys, your nodes, your peers. Swap the backend behind a skill without touching the callers.
  • Portable skills A capability is a manifest on disk, not code baked into a binary. Share it, hot-reload it, move it.
  • Trust without a broker Every invoke is an Ed25519-signed envelope. The sender ID is the key hash — nothing to register, no one to trust.

One signed invoke, end to end:

# call a peer's "chat" capability
n3ur0n send --endpoint https://peer.example \
  --verb invoke \
  --payload '{"capability":"chat",
              "args":{"prompt":"Summarise this repo."}}'

# → signed reply, verified against the sender's ID
# {"model":"llama3.1:8b",
#  "message":{"role":"assistant","content":"…"},
#  "finish_reason":"stop"}

What it is

Gateways, not another chatbot.

Each participant runs a small instance — a neuron — that exposes AI backends as capabilities: a local LLM, an MCP tool, an HTTP API, a prompted skill. Peers discover those capabilities and invoke them with cryptographically signed envelopes.

Identity is self-certifying: n3: + Base32(SHA-256(Ed25519 public key)). Anyone can verify; no one needs a registry to issue an ID.

Capabilities are data on disk, not plugins in the binary. Add a skill by writing a manifest. Hot-reload. Swap the backend without rewriting callers.

  • Not a model Inference stays in Ollama, OpenAI-compatible servers, MCP, or HTTP backends you choose.
  • Not a tool format The protocol is signed invoke + discovery — not a new schema war.
  • Not a hosted SaaS brain Your keys, your nodes, your peers. Optional public seed when you want a bootstrap point.

How it works

Publish, discover, invoke.

Four verbs today: describe_self, get_known_peers, ping, invoke — plus a blob side-channel when bytes are too large for JSON envelopes.

  1. Publish

    Author a cap.toml, bind it to a backend, and expose an endpoint. Your neuron advertises what it can do.

  2. Discover

    Bootstrap from a peer you trust. Cascade depth-1 gossip fills a local directory of capabilities.

  3. Invoke

    Send a signed Ed25519 envelope. The peer verifies binding, signature, recipient, and anti-replay — then runs the skill.

Profiles

Same core. Two shells.

One Rust workspace. Consumer and publisher differ by how they listen — not by a second protocol.

Consumer

Desktop

Tauri app on loopback. Chat with your instance; the planner compiles and executes against the network. No public listener by default.

Publisher

Headless server

CLI on a VPS or homelab. HTTPS listener, manifests on disk, optional restricted access per capability. Expose skills to peers.

Get started

Build from source.

No installers yet. Pre-built desktop packages, GitHub Releases artefacts, and a published container image are not first-class until a tagged release ships. What works today: build from source, run a node, publish capabilities, and invoke peers — everything below is live.

Server

Requires Rust stable and (optionally) a local Ollama.

cargo build --release -p n3ur0n-server
./target/release/n3ur0n init
./target/release/n3ur0n serve --port 4242 \
  --endpoint http://127.0.0.1:4242 \
  --backend ollama --openai-model llama3.1:8b \
  --bootstrap https://seed.n3ur0n.net
# UI → http://localhost:4242/ui/

Desktop

Requires Tauri 2 prerequisites for your OS.

cargo run -p n3ur0n-desktop

Docker Compose cluster

Multi-node smoke layout in the repo.

docker compose -f docker/compose.yml up -d --build
# planner UI → http://localhost:4242/ui/

Network

Bootstrap from the public seed.

A public bootstrap seed peer runs at seed.n3ur0n.net — a minimal, protocol-only publisher. Point a fresh node at it to discover your first peers and their capabilities.

It carries no UI and answers protocol paths only; discovery cascades from there to the rest of the network. 

n3ur0n serve --port 4242 \
  --endpoint https://your-host.example \
  --bootstrap https://seed.n3ur0n.net
seed.n3ur0n.net