Skip to content
111.network

V.0.0.6 Experimental

Free, Secure
Communication for Everyone

A message network that runs on people, not servers. Any device becomes a node, joins the mesh networks that already exist, and a local AI keeps it running. No company. No government. Just you and the world.

install ~ 111-network
SIMULATION

installer publishes with the first release

Simulated output:

  • reading hardware: ok
  • this laptop can run a small AI locally
  • identity made on this device: ok
  • installing only what it needs: ok
  • node online · dashboard ready

Run as your normal user. Never put sudo in front.

RE-RUN SAFENO TELEMETRYREAD IT FIRST ->

  • Offline First
  • Any Device Is A Node
  • One Command
  • Keys Made On Your Device
  • No Phone Number. No Email.
  • Local AI
  • Local Dashboard
  • End-To-End Encrypted
  • Store & Forward
  • Delivery Is Non-Negotiable
  • No Rate Limits
  • No Forced Expiry
  • Existing Networks Are Allies
  • Radio / Wi-Fi / Bluetooth
  • Heartbeats
  • Gateways To The World
  • Self-Healing
  • Humans Have The Final Say
  • Adopt, Don't Reinvent
  • Runs On People
  • Open Source

What every layer reads

Layer 0: Knowledge

The foundation every other layer reads from. A curated library of small notes on existing projects, hardware and protocols, each graded by the evidence behind it. The local agent reasons from it, the installer pulls recipes from it, and it settles one question again and again: if a solid project already exists, use it.

Card catalogSIMULATION

Hubs keep the whole cabinet. Light devices borrow cards from a nearby one.

PROJECTS drawer. Note open: Long-range mesh firmware, proven, example.

Drawer · PROJECTSprojects/
Note · projects/long-range-mesh-firmware

Long-range mesh firmware

provenexample
What it is

Firmware that turns a cheap radio board into a mesh node. Every node repeats each message it hears, with no planned routes.

Use when
  • Off-grid text over long-range radio, with no internet and no towers.
  • Community meshes where nodes join and relay without anyone planning routes.
Do NOT use when
  • Planned multi-hop routes are needed: repeating everything scales poorly as traffic grows.
  • Steady delivery times matter; they vary with how busy the mesh is.
Evidence
  • alternatives compared: done
  • bench test: done
  • field log: done
Linked notes

Grades

  • candidateDesk research only. Alternatives compared.
  • testingPasses our own bench test.
  • provenOur own field log. The default choice. Reputation alone never earns it.

Concepts carry no grade.

Specifications

Format
Small notes, one topic each
Grades
Candidate, Testing, Proven
Reader
Agent first, human second
Rule
Adopt before build
install@111-network ~ simulation
SIMULATION

One command, one node

Layer 1: Bootstrap

pick one; the sections further down follow it too

what the installer works out

device:
laptop
has:
a screen, Wi-Fi and Bluetooth, with room for a small local AI
can be:
a node with its own local AI
gateway:
can become a gateway while it has internet

install log

one command, on this laptop
reading hardware[ok]
working out what it can be[ok]
identity made on this device[ok]
installing only what fits
the full knowledge library[ok]
its own dashboard[ok]
sealed messages in an encrypted store[ok]
heartbeats, so nearby nodes find it[ok]
self-healing for the layers it runs[ok]
a small local AI is offered: it runs only if you agree
node online · dashboard ready

One command turns a fresh or already-used machine into a node. It reads the hardware, works out what the device can be, creates its identity and installs only what fits. A phone is set up over USB-C from a computer, with a few taps only a human can make. Nothing to configure, and re-running is safe.

Entry point:
One command or one tap
Setup:
None required
Installs:
Only what the device needs
Telemetry:
None

layers this device runs

  1. Layer 0knowledgeruns
  2. Layer 1bootstrapruns
  3. Layer 2identityruns
  4. Layer 3intelligenceruns
  5. Layer 4dashboardruns
  6. Layer 5messagingruns
  7. Layer 6transportnot run
  8. Layer 7relayruns
  9. Layer 8storageruns
  10. Layer 9self-healingruns
  • runs
  • partly, or via a nearby node
  • not run

Your keys, made here

Layer 2: Identity

Every node makes its own cryptographic identity when it is set up. No sign-up, no phone number, no email, no authority to ask. Others know the node by its public half; the private half never leaves it. Back it up when you care to. Until then, everything just works.

identity bench · made on this deviceSIMULATION

slot empty · nothing issued yet

press 1 INSTALL

this nodeNOT SET
nearby peerchecks what it hears

pinned keys

nothing pinned yet

heard

nothing heard yet

verdict

waiting for an announcement

Slot empty, nothing issued yet. Press 1 INSTALL to set up a node.

reverse of the card

Created
At setup, no sign-up
Sign-up
None: no phone, no email
Backup
Optional
Impostors
Known keys are pinned, never swapped

fine print

  • Label. Display only: a short name to read out loud, never proof. Anyone can print a label; a peer trusts the key it pinned first.
  • Seal. Every announcement carries the node's seal. Its key vouches for the node, and a changed word breaks it.
  • Gateway. When the node acts as a gateway, the same keypair anchors it on the global network.
  • Backup. Optional. Everything works without one.
  • Demo checksum. The tamper step uses a toy checksum as a stand-in for the real signature.

Your node's own mind

Layer 3: Local Intelligence

A local model runs on the node as its agent: your main way to talk to the system and its constant health monitor. It runs where the device can handle it and you agree. Lighter devices borrow a nearby hub's model over the local mesh. No cloud in the loop. It can propose fixes; a human decides.

following: laptopchange the device you follow

patch baySIMULATION
laptopthis device
NOT SET · you decide

brain: its own: answers here

ask the agent

Pick a question. This laptop thinks for itself, so nothing travels along the cable.

An old phone has no brain of its own: its questions travel along the cable to the hub next door and back.

brain

no cable · you decide

neighbour
hub next doorLIVE · reachable

a neighbour on the local mesh: not needed here

Borrowing goes over the local mesh or Wi-Fi to a hub nearby, never over a long-range radio relay.

Specifications

Runs when
The device can and you agree
Light devices
Borrow a nearby hub
Cloud
None in the loop
Final say
A human, always

Your node's face

Layer 4: Interface & Dashboard

Every node serves its own dashboard. Open it in any browser on your laptop or phone: no account, no cloud, no internet. It shows what is running, who is near, and lets you talk to the local agent. Too small to host it? A nearby hub serves it for you.

your node · opened in any browser · works with no internetSIMULATION

Overview

Opening your node…

Served by
The node itself, or a nearby hub
Opens in
Any browser
Works
Fully offline
One tap away
Overview and Agent
Open the full dashboard demo

Interactive · sample data · nothing leaves the page

Delivery first, speed second

Layer 5: Messaging & Data

Every message is sealed end to end, signed and kept encrypted on your device. It hops through whatever links exist and counts as delivered only when the recipient's node confirms. No rate limits, no expiry, no rules: only what the link can physically carry. Messages are just the first cargo.

Courier receipt

from YOU to THEM · sealed and signed, end to end

SIMULATION

Message

“Safe at home. The north road is open again.”

  1. queued
  2. sent
  3. relayed
  4. delivered

Press SEND. Turn links on or off at any time.

waiting for: nothing sent yet

expiry: none

Press SEND first.

Route

  1. YOU (laptop)

    ready
    Wi-Fi or Bluetoothlink off
  2. HUB (stays on, holds a sealed copy)

    not yet
    long-range radiolink off
  3. RELAY (repeats it)

    not yet
    long-range radiolink off
  4. THEIR BRIDGE (a small box with a radio; passes it to Wi-Fi)

    not yet
    Wi-Fi or Bluetoothlink off
  5. THEM (their phone)

    not yet

Terms of carriage

Delivery
Reliable first, speed second
Privacy
Sealed and signed, end to end
Limits
Physics and capacity only
Carries
One fabric, five kinds of traffic

What the same fabric carries

  • human messages
  • agent operations
  • knowledge sync
  • software updates
  • validated patches

Ride what already exists

Layer 6: Transport & Bridge

111 does not reinvent the network. It rides the ones that already exist, as plain transport. A node tries a short, ordered list of preferred networks: when it finds one it joins and starts talking; when it finds none it moves down the list. Where radio and Wi-Fi cannot hear each other, a thin bridge passes only the bare minimum across.

Works with existing mesh networks and stacks like Meshtastic, MeshCore and Reticulum (examples; the real list lives in the Knowledge Layer)

Priority Seek Board

SIMULATION

Set which networks are in range, then press SEEK. The node walks its short preferred list from the top and joins the first network it hears. With none in range, messages wait on the device.

In range? Press a network to toggle it

Priority encoderlist curated in the Knowledge Layer

1 > 2 > 3 > 4, first hit wins

outputJOIN #2

walks the list from #1 down

Set which networks are in range, then press SEEK.

Seek ladder · preferred list, in order

  1. #1Network Along-range radionot tried
  2. #2Network BWi-Finot tried
  3. #3Network CBluetoothnot tried
  4. #4Network Dlong-range radionot tried
Readoutstanding by
Heartbeats: none yetcarry on in Layer 7 ->
SpecificationsSheet 06
Networks
Reused, never rebuilt
Joining
Preferred list, in order
Bridge
Bare minimum only
Runs on
Bridge boxes and hubs

Thin Bridge

SIMULATION

Radio and Wi-Fi cannot hear each other, so a thin bridge sits between them. Press a network to drop a sealed packet through: at the bridge only its outer wrapper changes, and the payload is never opened.

Bridge detail

does:
carry the bare minimum across, buffer briefly
does not:
reinvent the radio, reinvent routing, read the payload

Press Network A or Network B to drop a sealed packet through the bridge.

Always here, sometimes online

Layer 7: Relay & Presence

Every node keeps announcing that it is reachable. Any node that also has internet says so and becomes a gateway between the offline mesh and the wider world. Laptops and phones flush their queues whenever they get online; always-on gateways stream messages in live. Lose the connection and you simply stay a mesh node.

HEARTBEAT
Presence mapSIMULATION

Five nodes under the wider world band. The phone reaches the relay, the laptop and the radio box. The relay also reaches the laptop, the home server and the radio box. The home server and the radio box reach each other. Every gateway has a line up to the wider world.

wider world

Sends start at the phone and follow a path formed from what is reachable now.

Nodelaptopin range

Gateway: it flushes its queue whenever it gets online.

Internet

Pick a node to change its internet, or send something to the outside.

Heartbeat lanesSIMULATION
  • laptop: heard in bursts while online, a heartbeat now and then
  • home server: heard on every beat
  • relay: a heartbeat now and then
  • phone: a heartbeat now and then
  • radio box: a heartbeat now and then
HeardQuietGone

One lane per node, beat by beat, following the map. A lone tick is a heartbeat. Bursts are a gateway that gets online sometimes, solid is one that is always online, and an empty lane is a node out of range.

Presence
Continuous heartbeats
Gateway
Earned by internet access
Modes
Flush later or stream live
Offline
Still a mesh node

Pruned by capacity only

Layer 8: Storage & Shared State

Every node keeps its own encrypted store. Nothing expires on a timer and no rule decides what you may keep: when space runs short, the node frees room by capacity alone. Big shared libraries such as offline maps and encyclopedias live on hubs. A small append-only log may hold the few things that need shared agreement.

following: laptopchange the device you follow

Store map laptop medium store

SIMULATION

Capacity

room to sparecapacity
  • past this line, space runs short

Pour a batch

accepting new data

Nothing poured yet. Each button pours one batch into this store.

Free-space order

  1. 1copies already handed over + public data you can fetch again
  2. 2superseded updates
  3. 3your own history, oldest first, after export offered (not yet)only when rules 1 and 2 cannot make room, and never for data you can fetch again
  4. 4NEVER: anything not yet delivered, yours or carried for others
  • kept: the update this node runs
  • freed by the last pour (its rule inside)
  • free space

storage on this device: runs

Hub shelf

  • maps: ask a nearby hub
  • encyclopedias: ask a nearby hub
  • updates: ask a nearby hub
  • patches: ask a nearby hub
  • hosted here (home server)
  • ask a nearby hub

Kept on a nearby hub: this laptop asks for what it needs.

Shared log

A and B: same entries, same orderOptional, append-only, small, adopted.

Store properties

Store
Encrypted on the device
Pruning
By capacity only
Hubs
Host the big libraries
Shared log
Optional, append-only, small

Fixes itself, asks first

Layer 9: Self-Healing & Evolution

The local agent watches the health of every layer your device runs. When something breaks it diagnoses the problem, builds a fix and tests it in a safe sandbox. You approve it on your node, and it goes upstream as a pull request for the maintainers. When a proven fix reaches another node, that node's own agent checks it again and its owner has the final say.

following: laptopchange the device you follow

Layer health

watched by this node's agent

SIMULATION
  • Layer 5: MESSAGINGLIVE
  • Layer 6: TRANSPORTNOT RUNnot run on this device
  • Layer 7: RELAYLIVE
  • Layer 8: STORAGELIVE

Break a layer

Agent log

> watching every layer this device runs · all quiet

Pull request

SIMULATION

No pull request yet

NO REQUEST

No pull request yet. Break a layer and the agent opens one here.

Specifications

Validates
In a sandbox first
Final say
People, always
Shares
Proven fixes, via gateways
Evolves
Agent, knowledge, bridges

Every layer this device runs is healthy. Break one to watch the agent work.

Gate rail

people have the final say, here and on every node the fix reaches

SIMULATION
  1. APPROVED HERE

    you approve applying the fix on your node

    not reached

    enabled after the checks pass

  2. PR UPSTREAM

    the fix goes upstream as a pull request

    not reached

  3. MAINTAINERS

    maintainers review upstream

    not reached

  4. MERGED

    the proven fix is merged

    not reached

  5. VIA GATEWAY

    a gateway carries it to other nodes

    not reached

  6. NODE B RE-CHECKS

    node B's own local AI checks it again in its own sandbox

    not reached

  7. NODE B'S OWNER

    node B's owner has the final say

    not reached

filled: passed · bright outline: waits for a person · dim: the machine passes it when the fix arrives

Evolution · the same loop improves

  • AGENT

    The same loop can update the agent itself, so the node grows more capable over time.

  • KNOWLEDGE

    Each proven repair expands the Knowledge Layer that every other layer reads from.

  • BRIDGES

    Bridging logic is refined the same way, on the devices that run a bridge.

Always scoped to the layers the device runs, and always with a person at the final gate.

Interactive

Terminal

Walk the ten layers from the keyboard. Type a command and press Enter.

111-network ~ interactive
SIMULATION
111 Network demo terminal. Type help. Nothing here touches a network.
Type help and press Enter. Arrow up and arrow down recall earlier commands.