Get started with Cognis Weave

How a packet flows

The one idea to hold onto

Everything in Cognis Weave eventually becomes a Grain — a fixed-format, always-encrypted cell of roughly 484 bytes minimum, sized to survive the worst real bearer we know of (a 5 bps, 500-byte-MTU radio link). The Grain is the narrow waist: everything below it is a swappable medium, everything above it is medium-blind. Once you understand the trip a Grain takes, you understand the whole stack.

Let's follow one file — say, a 40 MB sensor dataset — from your laptop to a colleague, twice: once over the fast Internet, once over an off-grid LoRa mesh. It is the same protocol value both times; only the bearer bindings change.

Step 1 — Chorus: the conversation is typed before it runs

Your application doesn't open a socket; it instantiates a session-typed choreography in the Chorus layer. The exchange ("I offer a file, you accept, I transfer, you confirm") is a global protocol term built from four combinators — seq, choice, rec, par — mechanically projected into a per-endpoint state machine. Deadlock-freedom is checked before a single byte moves. If the choreography can wedge, it doesn't compile.

Step 2 — Corpus: the file becomes a self-certifying object

The dataset is cut by FastCDC content-defined chunking (so a future edit re-transfers only changed chunks), hashed into a per-file binary Merkle tree over 16 KiB leaves, and named by its root: a cognis:// link carrying the root hash plus optional hints. From this moment, trust lives in the identifier, not the transport. Any peer, cache, broadcast carousel, or origin server can serve any chunk, and your receiver verifies every block against the root before accepting it.

Step 3 — Flow: pick a lane, pick a controller

The transfer rides one of three delivery lanes on a single connection: ordered streams (T.Stream), interleaved messages (T.Message), or unreliable datagrams (T.Datagram) — all under one negotiated congestion-control module. A bulk transfer like this one typically takes the LEDBAT-class scavenger mode, so it never degrades your foreground traffic. On multiple paths (WiFi + cellular, say), T.PathSet runs per-path congestion control with coupled fairness: N subflows through one bottleneck take one fair share, not N.

Step 4 — Weft: reliability becomes repair symbols, not retransmissions

Each block passes through the coding layer as systematic RaptorQ: source symbols go out verbatim first (a clean path pays zero decode cost), and repair symbols follow at the measured loss rate, set by the Governor's live (loss, RTT) estimate. If the receiver comes up short, the sender doesn't repeat bytes — it emits fresh repair symbols (the HARQ-IR discipline). Any ~K+2 symbols, from any mix of paths or peers, complete the block with 99.9999% probability.

Step 5 — Strand: a route, and optionally a disguise

Routes form passively from cryptographically signed announces (the Reticulum pattern) — no chatty routing protocol burning airtime. The forwarding abstraction is a generalized label that can mean a packet next-hop, a timeslot, or an entire wavelength. If you asked for privacy, Strand wraps the path in a functor: Veil (3-hop onion circuits, ~300 ms–1 s added, resists local adversaries) or Fog (Sphinx mixnet with Poisson delays and cover traffic, resists a global passive adversary at a stated latency and bandwidth price). Privacy is a per-flow choice with a published cost, not a separate network.

Step 6 — Grain: everything becomes the same cell

Streams, repair symbols, handshakes, announces — all are packed into uniform, fully encrypted, fixed-size-padded Grains identified by connection ID, not by IP 4-tuple. Middleboxes see nothing they can ossify around; observers see nothing they can size-fingerprint. Your connection survives a network change because its identity was never an address.

Step 7 — Lumen: a Bearer Functor puts it on the wire (or the air, or the light)

Finally a Bearer Functor — a law-checked adapter, property-tested so that binding a composed protocol equals composing the bound pieces — maps Grains onto a physical medium.

Fast-path version: F.Ether encapsulates Grains in UDP across the Internet at NIC line rate; the whole transfer completes in seconds, multipath-aggregated, with QUIC-class 1-RTT hybrid post-quantum setup.

Off-grid version: F.LoRa carries the same Grains in 51-byte SF12 frames, scheduled against a duty-cycle token bucket the API exposes to you (EU868 allows 1% airtime — the radio's legal budget, not the protocol's choice). A single-Grain Noise handshake replaces multi-round setup, because at seconds-per-packet, round trips are unaffordable. Where the path is intermittent, F.Custody wraps the flow in store-and-forward bundles with hop-by-hop custody, and it resumes full Flow semantics on the far side.

What just happened

The file's identity, integrity model, encryption, and choreography were identical in both runs. What changed — rate, latency, framing, scheduling — lived entirely inside the bearer's stated envelope. That's the design promise, stated in practice: one verified algebra of identity, integrity, and content from 5 bps whisper radio to 800G photon fabric — with performance that tracks the bearer, never magic that outruns it.

A protocol pitch that claims to beat everything usually understands nothing. Cognis Weave borrows deliberately and relentlessly from prior art — QUIC's connection IDs, RaptorQ's RFC 6330 semantics, Reticulum's constrained-network floor, BitTorrent v2's Merkle trees, GMPLS's generalized labels, Sphinx's uniform packets. The invention is the certified composition, not any single trick. Here is where it genuinely differs, and where the incumbents remain excellent.

vs TCP/IP + QUIC

QUIC is superb on the fast Internet, and Cognis Weave keeps its wins — streams, connection IDs, 0-RTT, multipath — essentially intact. The differences: QUIC assumes UDP/IP underneath and has nothing to say to a 300 bps HF link, a one-way FM subcarrier, or a lambda circuit; its loss recovery is retransmission-first; migration resets congestion state; and it carries no content addressing, swarming, or privacy routing. Cognis Weave puts QUIC-generation transport above a narrower waist, makes rateless FEC the first-class recovery mechanism, and carries validated path capacity across resumption (careful-resume). It does not claim to be faster than QUIC on a clean fiber path — on that path, both are bounded by the same NIC and the same congestion physics.

vs BitTorrent / IPFS

BitTorrent's verbatim-block exchange makes the last rare block the tail bound of every swarm; IPFS famously conflates addressability with availability. Cognis Weave's fountain gear changes the arithmetic: peers emit distinct RaptorQ repair symbols, so any ~K+2 symbols from any combination of peers, paths, or even one-way broadcast carousels complete a block — the last-block problem largely dissolves, and multi-source aggregation becomes trivial. It keeps what BitTorrent got right (Merkle verification over 16 KiB leaves, per-block banning, rarest-first as a fallback) and states the conservation laws BitTorrent marketing skips: aggregate throughput ≤ total peer upload, first-copy time ≥ filesize / seed upload, and content addressing gives immutability, not availability — pinned always-on seeds are part of the architecture, not an apology.

vs Tor / I2P / Nym

Each of these networks hard-codes one point on the anonymity trilemma (strong anonymity, low latency, low bandwidth overhead — provably pick two, Das et al. 2018); changing threat models means changing ecosystems. In Cognis Weave, privacy is a routing functor over one relay substrate: Direct, Veil, or Fog, negotiated per flow, each with its trilemma coordinate stated. Veil resists local network adversaries at ~300 ms–1 s added latency but — like Tor itself — explicitly does not resist a global passive adversary running end-to-end flow correlation. Fog does resist one, at the stated price of 50–500 ms of mix delay plus roughly Mbps-class continuous cover traffic. Grain cells are sized for hybrid post-quantum key material from day one, sidestepping the 509-byte cell bind Tor is currently fighting. What Cognis Weave cannot fix: Sybil attacks on open membership can be made costlier, never impossible, and anonymity-set size scales with user count — which a new network will not have at launch.

vs LoRaWAN / Reticulum

Reticulum is, frankly, the best constrained-network stack in existence, and Cognis Weave adopts its core moves wholesale: the 5 bps / 500-byte / one-way-degradation floor as spec discipline, cryptographic announce routing, and propagation-node store-and-forward. Where Reticulum is deliberately modest, Cognis Weave extends: multipath congestion-controlled transport, a rateless bulk plane, content-addressed swarming, a photonic label control plane, and a zero-copy AI data plane — all carrying the same cell that works at the 5 bps floor. LoRaWAN, by contrast, is an operator-centric star topology with application servers in the trust path; Cognis Weave's F.LoRa binding is peer-to-peer, crypto-first, and exposes the duty-cycle budget in the API so applications schedule sends instead of failing at the radio.

Cognis Weave's AI data plane is not a new idea wearing a cape. It is a wire-format guarantee built from patterns that already shipped and were already measured — safetensors and Arrow for zero-copy layout, NIXL for descriptor transfers, NCCL's factoring for collectives, Kraken for fleet-scale distribution — composed under the same certification gate as everything else.

Two planes, never crossed

The design's central rule: compact, schema'd control messages and a zero-copy data plane are architecturally separate, and tensors never pass through the control encoder. The familiar failure mode — bulk tensors ground through a tag-based Protobuf encoder at a measured ~65% CPU tax while HTTP/2 flow-control windows let control traffic preempt tensor streams — is excluded by construction. Encoding cost exists only at control frequency, where it is irrelevant.

Offset-addressable by construction

An A.Frame is a tiny header of {name → dtype, shape, offset, length} plus a flat byte region: wire layout equals memory layout. Any consumer can mmap it, range-fetch it, parallelize across it, and resume mid-object. This is the single serialization decision behind the published 76× model-load speedups and seconds-scale cold starts for 200+ GiB models — made a property of the wire, not a library choice.

Checkpoints move like torrents, verified like releases

Model and dataset distribution rides Corpus: weights are Merkle-verified, FastCDC-deduped (a fine-tune delta transfers only changed chunks), and swarm-fetched LAN-first. The design target is Kraken-class behavior — 20,000 nodes pulling 1 GB blobs in under 30 seconds — with fountain-mode symbols making every peer's contribution additive.

Disaggregated inference gets a stable contract

A.Descriptor is the NIXL shape made protocol-level: register memory regions once, post async scatter/gather descriptor lists with out-of-order completion, over pluggable backends — RDMA/GPUDirect where the topology supports it (and topology is part of the stated correctness envelope), TCP, NVMe-oF, or object storage. KV-cache handoff between prefill and decode fleets is a first-class, certified protocol value, not a bespoke connector per deployment.

Collectives, factored and portable

A.Collective keeps NCCL's proven factoring — fused steps × interchangeable algorithms × interchangeable transports — but makes the transport axis a certified Bearer Functor: a ring allreduce is provably the same protocol value over NVLink, InfiniBand, or an OCS-scheduled lambda fabric. Ring stays bandwidth-optimal at its 2(N−1)/N lower bound — stated, not "beaten." And because synchronous step time is the max over workers, the design metric is P99.9 tail latency, served by per-flow spraying, out-of-order delivery with in-order completion, and selective retransmission.

The engineering detail

Two caveats, because "great for AI" earns trust only with its boundaries attached. First, this competes with an entrenched NCCL/RDMA/UEC ecosystem, and "provably the same protocol value" must beat hand-tuned incumbents on P99.9 benchmark curves, not on category theory — the honest positioning is a certified, portable contract for the transfers AI systems already do, not a performance revolution. Second, physics: at ~5 µs/km of propagation, cross-region synchronous training is speed-of-light-bound, and no protocol shrinks the speed of light — so WAN-scale learning belongs to asynchronous and hierarchical patterns over F.Custody, and the spec says exactly that.

One algebra, edge to fabric

The closing note is the span itself: the same Chorus choreography that hands a KV-cache across RDMA also runs a 51-byte quantized-gradient exchange over a duty-cycled LoRa field sensor. Same identity, same integrity, same session types — different bearer functor, different (published) envelope.

FAQ

What is Cognis Weave, in one line?

One composable network protocol whose single encrypted cell — the Grain — runs unchanged from a 5 bps radio link to an 800 Gb/s photonic circuit, with reliability, swarming, privacy, and an AI data plane built in.

Do I need special hardware?

No. On the Internet it's a userspace daemon over UDP. On radio it drives commodity RNode/LoRa boards, KISS TNCs for packet radio, or any FM/DRM receiver for one-way carousel reception. The same binary scales up to RDMA and lambda fabrics.

How fast is it?

On fast paths it's QUIC-generation: 1-RTT hybrid post-quantum setup, multipath aggregation, per-stream flow control, and packet spraying tuned for P99.9 tail latency. On lossy or long paths it pulls ahead of TCP by replacing retransmission round-trips with rateless repair.

Is it good for large files and model weights?

It's built for them. Objects are content-addressed and Merkle-verified; in fountain mode every peer emits distinct RaptorQ symbols, so any symbols from anyone complete a block — multi-source downloads saturate your link and a fleet pulls a checkpoint in Kraken-class time.

What about privacy?

Privacy is a per-flow choice: Direct (uniform encrypted cells), Veil (onion circuits), or Fog (Sphinx mixnet). All cells are post-quantum sized from day one. See Solutions for the full threat model.

Is it production-ready?

Cognis Weave is in private preview under invitation. Access, licensing, and support terms are covered by the Terms of Service. Request access at access@cognis.network.