net.
moves
at light.
A latency-first encrypted mesh where every computer, app and device is a first-class node. Existing networks operate in milliseconds (10⁻³). NET operates in nanoseconds (10⁻⁹).
No clients. No servers. No coordinators. The mesh propagates state, not connections.
Flagship use: agentic capability federation — agents discovering, invoking, and recovering work across a trusted mesh.
arpanet assumed scarcity.
net assumes abundance.
TCP was designed when nuclear war was a real possibility. Packets were precious. The network had to guarantee delivery because the next packet might not get through.
That was the right design for 1969. It's the wrong design now. Sensors don't pause. Token streams don't wait. Market feeds don't care that your queue is full. The firehose doesn't have a pause button.
In a world of abundance, guaranteeing delivery is a threat — you're promising to deliver data that will bury the receiver. The bottleneck isn't delivery. It's processing. Arrival doesn't equal usefulness.
NET inverts the default. TCP starts with trust and detects abuse. NET starts with zero assumptions and lets trust emerge from consistent behavior.
Nodes reject work they can't process within a time window. Dropping a packet and re-requesting from a faster node costs nanoseconds. Waiting for a congested node's guaranteed response costs milliseconds. When dropping is cheaper than waiting, delivery guarantees become overhead.
The remaining latency is physics: NIC, wire, speed of light. The software got out of the way.
a new class of system.
Existing networking falls into two categories. NET is neither.
nine axioms.
one runtime.
Latency-first
Sub-nanosecond header serialization. Nanosecond heartbeats, hops, recovery. Packet scheduling at timescales reserved for local function calls.
0.20 ns ▸ fwd
sub-ns floorStreaming-first
Data is continuous flow, not documents. Sharded ring buffers, adaptive batching. No requests and responses — everything is a stream.
▶▶▶▶▶▶▶▶▶▶▶▶▶▶ ░░░░░░░░░░░░░░
Zero-copy
Ring buffers, no garbage collector, native Rust. No unsafe. Forwarding doesn't allocate or copy payload data. Design principle, not optimization.
[mem]──refs──▶[wire] no alloc
Encrypted E2E
Noise protocol handshakes. ChaCha20-Poly1305 AEAD with counter nonces. Every packet encrypted source→dest. Intermediate nodes never see plaintext.
A ─ChaCha20──▶ B
relay sees ░░░Untrusted relay
Nodes forward packets without decrypting payloads. The mesh routes through infrastructure you don't trust. Networks grow through adversarial nodes.
trust := observation
not assumptionSchema-agnostic
Transport moves bytes, not structures. Raw event = payload + hash. Protocol never inspects content. Structure emerges where participants agree.
[hdr][hash][░▒▓█▓]
opaque payloadOptionally ordered
Ordering is per-stream, not global. Unordered path is the fast path. Causal ordering available where streams need it. Cost paid only by streams that require it.
e₁ → e₂ → e₃ chain.verify()
Optionally typed
The protocol doesn't care what's in the payload. Behavior plane can. Typing is a local agreement between nodes, not a network requirement.
type ∈ peer-pair
not networkNative backpressure
Nodes drop without reply. Not a failure mode — the design. The proximity graph makes silence a signal. Automatic rerouting.
silent → suspect suspect → reroute
existence proofs.
All numbers measure packet scheduling — the time to process, route, encrypt, and queue a packet for transmission. They do not include NIC transfer or wire latency.
| operation | M1 Max | i9-14900K |
|---|---|---|
| ▸ routing | ||
| routing header forward | 0.57 ns1.75G/s | 0.20 ns4.96G/s |
| header serialize | 2.19 ns456M/s | 1.21 ns829M/s |
| routing lookup (hit) | 38 ns26.5M/s | 38 ns26.2M/s |
| ▸ multi-hop forwarding | ||
| 1 hop | 62 ns16.2M/s | 53 ns18.7M/s |
| 3 hops | 160 ns6.25M/s | 121 ns8.26M/s |
| 5 hops | 271 ns3.69M/s | 190 ns5.28M/s |
| ▸ failure detection & recovery | ||
| heartbeat | 40 ns25.2M/s | 69 ns14.4M/s |
| circuit breaker check | 9.55 ns105M/s | 11 ns90.0M/s |
| full fail + recover | 291 ns3.44M/s | 280 ns3.58M/s |
| ▸ swarm / discovery | ||
| pingwave roundtrip | 0.93 ns1.07G/s | 0.64 ns1.57G/s |
| new peer discovery | 39 ns25.3M/s | 38 ns26.4M/s |
| ▸ capability system | ||
| filter (require GPU) | 47 ns21.4M/s | 43 ns23.4M/s |
| GPU check | 40 ns24.7M/s | 41 ns24.6M/s |
// scheduling floor
Routing header forward on i9-14900K. Per-packet overhead. Software is not the bottleneck — physics is.
// hot path
Operations per second on a single core for the forward path. Five billion. Per second. Per core.
// SDK ingest
Python via PyO3 batch ingest. The "slow" binding language hits nine and a half million events per second.
// test systems
► M1 Max macOS, aarch64
► i9-14900K @5GHz, Win11
► date 2026-06-12
► profile release + LTO + CG=1
▸ BENCHMARKS.md↗
state moves.
connections don't.
In Cyberpunk, Mikoshi is Arasaka's construct for storing engrams — consciousness held in digital space, minds persisting outside their original hardware.
Mikoshi in NET lets a deamon hop between machines. The machine underneath changes; the daemon keeps its identity, its history, its pending work, and its place in the conversation. The source packages its state, the target unpacks it, and for a brief moment the daemon exists on both nodes, then collapses onto the target as routing cuts over.
The daemon doesn't know it moved. Neither does anything talking to it. The hardware shifted; the stream didn't notice.
A factory controller hops from a dying edge box to a healthy one mid-shift. A trading agent migrates to a node closer to the exchange without dropping a single tick.
Mikoshi doesn't move a copy. Mikoshi moves the daemon itself.
compute
lives on
the wire.
A program on NET is called a daemon. Its identity is a public key — an origin_hash derived from ed25519, which doesn't change when the daemon moves. Its history is a causal chain — every event it produces is signed and links to the previous one, verifiable by any node. Its location is wherever in the mesh has the capabilities it asked for. When that location goes away, the daemon doesn't.
// what is a daemon
Stateful programs that live on the mesh, not on a machine. It holds working state, snapshots periodically, and exposes five trait methods. Everything else — placement, migration, durability — is the runtime.
- cryptographic identity — origin_hash from ed25519. survives moves.
- causal chain — every event signed, links to parent. self-authenticating.
- capability requirements — daemon declares needs. mesh finds matching node.
- snapshot + replay — state captured periodically. gap replayed on restore.
- opaque to mesh — what the daemon does is its business. mesh just hosts.
Mikoshi migration · 6 phases
zero-downtime cutover · ~280ns totalreplica
member 0 ● event #58 → result member 1 ○ idle member 2 ○ idle round-robin · seq=58
For horizontal scale on stateless workloads. Each replica has its own causal chain derived from a deterministic seed — fail one, spawn another with the same identity. No state to transfer.
fork
parent @ seq=42 · single chain, no divergence · awaiting fork directive pre-fork · monitoring
For experiments, A/B testing, scenario branching. Each fork carries a cryptographic sentinel linking back to the parent at the fork point. Forks share a past but not a future.
standby
active ● processing seq=102 standby ○ synced_through=98 standby ○ synced_through=101 all healthy · 3 nodes online
For stateful services that need failover without running duplicate copies. One active daemon runs; warm standbys stay synced. If it fails, the most-recent standby takes over and catches up. Zero duplicate compute.
0x0500Dataforts:
data became
a fluid.
For 60 years, files were objects nailed to a location — a disk in a box. Traditional storage treats files like permanent objects locked to a single machine.
Dataforts treats storage as flow and data as fluid. When a device approaches capacity, it overflows onto the mesh. The capacity is the mesh. The folder stays local. Reads create gravity. Hot data moves closer. Everything is in motion.
Overflow
storage doesn't run out. when one disk fills up, the mesh catches the spillover.
Data Gravity
the files aren't moved. files settle near nodes that use them.
Content-Addressed
the hash is the handle. one address gets you the file — wherever it lives.
Durability Tiers
pick your guarantee. fire-and-forget, fsync, or N-peer replicated. one call.
MeshOS:
programs move.
clusters think.
Programs move between machines without stopping. Storage autobalances. Daemons migrate seamlessly across the mesh while maintaining full state.
Placement happens intelligently — gravity pulls workloads toward their data, capabilities match tasks to nodes, and drift detection triggers automatic rebalancing. No central orchestrator. No single point of failure. Just self-organizing coordination at nanosecond scale.
Mikoshi Lifecycle
spawn, migrate, supervise. daemons hop between machines without losing state, history, or place in the conversation.
Gravity Placement
workloads pull toward their data. compute lands near the bytes it touches — gravity-based scoring, not central scheduling.
Daemon Supervision
start, drain, restart, gate. exponential backoff. backpressure signals. graceful shutdown or forced.
Capability Match
nodes advertise what they are — device, compute, storage, daemon, datafort. MeshOS routes daemons to nodes that fit.
MeshOS turns your mesh into a living system. Sensors adapt. Storage flows. The daemons move.
four primitives.
one mesh.
The mesh moves bytes. Everything above is a thin, optional layer — local-first, feature-flagged, opt-in. Light up the ones you need; the wire doesn't care which.
nRPC
Request/response semantics built from a pair of streams. A server registers a handler with serve_rpc; clients dispatch with call_typed. The streams stay primitive — nRPC just wraps them in a typed handle and completes when the response lands.
RedEX
The log unbundled and local. 20-byte index records, optional disk persistence per channel, atomic backfill-then-live tailing. A Pi keeps a tiny log of its own readings; a server keeps a huge one. No cluster consensus — log is local, replay is local, retention is local.
CortEX
A reactive, queryable projection of the log, updated event-by-event. Your "database" isn't a process you connect to — it's a Vec<Task> or HashMap<Uuid, Memory> in your code, updating as events fold in. Queries are direct memory access.
NETDB
One handle bundling typed collections under db.tasks, db.memories, and friends. Prisma-style find_unique / find_many across Rust, TypeScript, and Python — whole-database snapshots round-trip between languages.
five languages.
one engine.
All SDKs wrap the same Rust core. The SDK is the developer experience, the engine is Rust.
// C bindings via net.h — build cdylib with . Lower-level bindings (skip SDK ergonomics, talk directly to the engine): net-mesh, @net-mesh/core, net-mesh (PyPI binding).
everything that
can't wait.
Anywhere latency matters. Anywhere the cloud round-trip is too slow. Anywhere there's no central infrastructure to route through.
AI Agents
Tool calls, state, and memory transfer between heterogeneous GPU nodes. Token streams flow through the mesh; an agent's working memory follows it from node to node mid-conversation. The mesh is the runtime.
Vehicular Sensor Mesh
Cars sharing LIDAR, radar, camera. Vehicles sync intent — braking, turning, route changes. The car behind doesn't react to braking. It knows about the braking before the brake pads touch the rotor.
Robotics Factory Floor
Robots don't need line-of-sight for networking. The mesh routes through whatever nodes are reachable. Reroute scheduled in sub-microsecond time. The assembly line doesn't stop.
Energy Grids & Extraction
Electrical substations, oil and gas pipelines, drilling rigs, mine haul trucks, distributed solar — coordinating in real time across geographies that fiber doesn't reach. Protective relays trip in single-digit milliseconds; the mesh isolates faults before they cascade. Routes through whatever radios and edge boxes survive.
Remote Surgery
Control signals and haptic feedback routed across the mesh. If the primary compute node lags, the mesh reroutes mid-operation. The surgeon doesn't notice. The patient doesn't notice. The scalpel doesn't stop.
Drone Swarms
Coordinated flight without a ground controller. A drone that loses a motor broadcasts the failure; the swarm adjusts formation before the drone has begun to fall.
Live Performance
Lighting, audio, video, pyro synchronized across hundreds of nodes. A DMX controller dies, another node picks up the cue list. Audio sync tighter than the speed of sound across the venue.
Medical Nanorobotics
Swarms of nanoscale machines coordinating in vivo — drug-delivery vectors, targeted ablation, vascular monitoring. Sub-microsecond reroute when a node leaves the swarm. No cloud round-trip; the patient is the network.
safety isn't declared.
it's derived.
In Cyberpunk, the Blackwall isn't a wall around the threats — it's a wall around the safe zone. NET works the same way. The "safe mesh" is the part you can observe: nodes that respond within heartbeat intervals, honor their capability announcements, don't flood, respect TTL.
The wall isn't one mechanism. It's the emergent effect of every constraint working together.
▸ Backpressure
Nodes limit in-flight events, prevent overload, and apply pushback by going silent. No node can be forced to accept more than it can process.
▸ Bounded queues
No infinite buffers. Ring buffers have explicit capacity limits. A flood fills a buffer and gets evicted, it doesn't grow the buffer.
▸ Fanout limits
Events don't propagate to everyone. Dissemination is controlled by the proximity graph and routing table. Prevents O(n²) explosion.
▸ Deduplication
The same event doesn't explode repeatedly. Idempotency at the event level protects against loops and amplification.
▸ TTL limits
Events expire. Pingwaves have a hop radius. A misbehaving node's traffic dies at the boundary of its TTL, not the edge of the mesh.
▸ Rate limits
Per-node, per-peer limits. One node cannot flood the mesh. Its neighbors enforce their own limits independently through device autonomy rules.
Any single mechanism can be overwhelmed. All of them together form the wall. No single point to breach because the Blackwall is the mesh itself.
not anti-cloud.
post-cloud.
Cloud infrastructure solves the wrong problem. It moves compute closer to a central provider. NET decouples storage and compute from hardware and location.
Cloud adds a trusted intermediary by definition. NET has no intermediaries. Relay nodes forward encrypted bytes they cannot read. There is no Cloudflare, no AWS, no Azure in the path because the path is yours.
Cloud was the right answer when compute was scarce and hardware was expensive. Compute is abundant. Hardware is cheap. The coordination layer should reflect that.
A manufacturing plant running on NET doesn't route sensor data to AWS us-east-1 and back. The sensor talks directly to the decision system on the factory floor. The latency is physics, not geography plus cloud overhead.
running.