For AI

Networking built for AI

Cognis Weave treats model weights, KV-caches, tensors, and gradients as first-class traffic — a zero-copy data plane that never touches a control encoder, torrent-class distribution for checkpoints, a stable transfer contract for disaggregated inference, and portable collectives. The same protocol reaches from an RDMA fabric to a field radio.

Why it's different

The AI data plane, done right

Every capability below is patterned on shipped, measured systems — safetensors, Arrow, NIXL, NCCL, Kraken — composed under one certification gate.

⚡

Two planes, never crossed

Two-plane spine: compact schema'd control messages (µs-class encode cost, irrelevant at control frequency)

📦

Weights move like torrents

A.Frame bulk objects are offset-addressable by construction (name → dtype/shape/offset/length header + flat region, safetensors/Arrow pattern): any consumer can range-fetch, parallelize, resume, and mmap — the single serialization decision behind 76x model-load speedups and seconds-scale cold starts for 200+ GiB models, now a wire-format guarantee.

🔀

KV-cache handoff, contracted

Model and dataset distribution rides Corpus: weights are Merkle-verified, FastCDC-deduped, swarm-fetched from LAN peers first — a fleet pulling a new checkpoint behaves like Kraken (20k 1 GB blobs in under 30 s), and incremental fine-tune deltas transfer only changed chunks.

🧮

Collectives, portable

A.Descriptor gives disaggregated inference a stable transfer contract: register memory once, post async scatter/gather descriptor lists with out-of-order completion, over pluggable bearer functors (RDMA/GPUDirect where NIC and GPU share a PCIe switch — topology is part of the stated correctness envelope — TCP, NVMe-oF, object storage), the NIXL shape vLLM already treats as a swappable connector.

📡

Tail-latency armor

A.Collective factors collectives exactly as NCCL does — fused primitives × algorithms × transports — but the transport axis is a certified Bearer Functor, so a ring allreduce is provably the same protocol value over NVLink, IB, or an OCS-scheduled lambda fabric; ring stays bandwidth-optimal (2(N−1)/N lower bound stated, not 'beaten').

🛰

Edge AI on any bearer

Tail latency is the design metric, not the mean (UEC rationale: synchronous step time = max over workers): T.Spray provides per-flow packet spraying, out-of-order delivery with in-order completion, and selective retransmission, benchmarked at P99.9.

What it replaces

The overhead you stop paying

Today's stack	The tax	Cognis Weave
gRPC / Protobuf for tensors	~65% CPU on tag-based encode; 4 MB message caps; manual chunking	Zero-copy `A.Frame`: wire layout equals memory layout — mmap-able, range-fetchable, never through the control encoder
HTTP/2 flow control	Control-window stalls preempt bulk tensor streams	Per-semantic-stream, payload-class-aware credit — control never preempts tensors
Ad-hoc weight rsync / S3 pulls	N nodes × origin bandwidth; no verification; cold starts	Content-addressed, Merkle-verified, fountain-swarmed — LAN-first, Kraken-scale fan-out, deltas only
Bespoke KV-cache connectors	One connector per deployment; brittle prefill→decode handoff	`A.Descriptor`: register memory once, async scatter/gather, pluggable RDMA / TCP / NVMe-oF / object store
NCCL locked to one transport	Collectives assume a fixed fabric	`A.Collective`: same ring/tree allreduce provably identical over NVLink, IB, or an OCS-scheduled lambda

In practice

From one CLI

# distribute a 200 GiB checkpoint to a fleet — content-addressed, verified, swarmed
cognis share ./llama-70b.safetensors --seed
# → cognis://b3:9f2c… (Merkle root)

# every node pulls LAN-first; any RaptorQ symbol from any peer completes a block
cognis get cognis://b3:9f2c… --into /models --profile fabric

# disaggregated inference: register KV-cache memory once, stream out-of-order
cognis xfer kv --peer decode-07 --backend rdma --descriptors ./kv.plan

# bandwidth-limited link? carry the tensor semantically, not byte-exact
cognis send ./grads.arrow --fidelity task-sufficient   # DeepJSCC lane

AI primitives

The building blocks

Certified generators for AI traffic — core data-plane plus advanced semantic and resource-assisted modes from Solutions.

Core data plane · 3

A.Frame

Zero-copy bulk frame: tiny header of {name → dtype, shape, offset, length} + flat byte region (safetensors/Arrow pattern); wire layout equals memory layout — mmap-able, range-fetchable, never touches the control encoder.

A.Descriptor

Register memory regions once, post async scatter/gather descriptor-list transfers with out-of-order completion (NIXL/RDMA verbs shape) over pluggable backends — RDMA, TCP, NVMe-oF, object storage.

A.Collective

NCCL's factoring made protocol-level: fused steps (send, recv, recvReduceSend, recvCopySend) arranged by interchangeable algorithms (ring — bandwidth-optimal 2(N−1)/N, tree, NVLS-class) over interchangeable bearer functors.

Advanced · 14

task-distortion-transmit

Send the Information-Bottleneck minimal sufficient statistic for a declared downstream task and its distortion measure (accuracy/perceptual/effect) instead of byte-exact reconstruction — the strongest honest way to 'get past lossless' for AI traffic, because the effective source entropy is genuinely lower under a task-sufficient measure (stays inside Shannon RD).

graceful-degrade-link

Carry a payload over a co-trained joint source-channel mapping that degrades smoothly with link quality (no cliff effect), trading a bounded fidelity loss for continued delivery under adverse/variable channels and tight latency budgets — the DeepJSCC operating regime where separation is not tight.

fidelity-contract

Attach a declared fidelity level (lossless / task-sufficient / perceptual-generative) plus matched encoder-decoder identity and domain to every stream, so a receiver refuses or downgrades when content falls outside the trained task or when bit-exactness is actually required. Typed as a linear-logic proposition so a mismatch fails to typecheck.

entropy-guided-rate-allocation

Use a learned entropy model over semantic latents to spend more channel uses on informative content and less on predictable content (NTSCC-style variable-rate JSCC), aligning bandwidth to semantic importance rather than uniform bit budget.

generative-reconstruct

Transmit a compact semantic descriptor (segmentation map / prompt / sparse latent) and synthesize a perceptually faithful reconstruction at the receiver, with a mandatory fidelity-vs-perception flag warning that unmodeled detail is generated, not delivered — never counting a decoder's hallucinated detail as received information.

EntanglementAssistedChannel

Consume a pre-shared correlation resource to lift throughput above the channel's own unassisted capacity ceiling, with the advantage growing as the channel gets noisier. The consumed resource is metered explicitly, so the gain is never mistaken for a free capacity increase.

UntrustedMidpointRelay

Reframe a point-to-point link as measure-in-the-middle at a zero-trust rendezvous node, converting linear loss/rate-vs-distance scaling into square-root scaling (the TF/MDI-QKD move) without granting the node any trust.

InfoTheoreticKeyAgreement

Establish shared secrets whose security rests on physical/mathematical impossibility (no-cloning, monogamy, Bell violation) rather than computational hardness, with eavesdropping self-revealing as physical disturbance — paired with device-independent certification of untrusted hardware from correlation statistics alone.

WaveDomainCompute

Push matrix-style computation (precoding, transforms, estimation) into the transport medium so it happens during propagation, offloading the central processor — the stacked-intelligent-metasurface analogue of computing inside the channel. Reshapes the effective channel; per-stream Shannon capacity is unchanged.

RatelessChannel

Emit an unbounded incremental-redundancy stream from a fixed payload (spinal-hash / SPARC style) and let the receiver stop as soon as it decodes, converting a fixed rate-vs-reliability choice into an adaptive 'take what the link needs' contract with ACK feedback — the legitimate 'bent question' that operates against the higher feedback-aware curve.

FiniteBudgetOptimalityGauge

Score any encode/decode pipeline against its meta-converse and RCU achievability bounds at the ACTUAL finite budget (n, error target) rather than against asymptotic capacity, exposing real remaining slack instead of a misleadingly small 'gap to capacity.' The anti-hype instrument for the whole coding stack.

LinearChannel

A channel typed by a linear-logic proposition and used exactly once; its two endpoints must be dual (or coherent, for multiparty), so mismatched or dropped protocols fail to typecheck before any code runs. The substructural core (no silent copy/discard) that makes messages behave like real resources.

private-fetch

Retrieve a record from a shared store without revealing which record was requested — single-server lattice PIR (SimplePIR/YPIR) for cold reads, Piano-style client-preprocessing for repeated sublinear reads. Reframes privacy as retrieval-privacy (a different quantity than the trilemma's who-talks-to-whom).

AnalogLinearOffload

Route the large fixed parallel linear transform of a workload to a fast cheap approximate channel while keeping state, nonlinearity, and control in the slow reliable channel — the photonic-tensor-core-plus-electronic-control split, generalized. Honors Miller's limit: match each sub-operation to the substrate that is cheap at it, never pretend optics does logic or RAM.

Every advantage

The full list

Two-plane spine: compact schema'd control messages (µs-class encode cost, irrelevant at control frequency) strictly separated from a zero-copy data plane whose wire layout equals memory layout — tensors and KV-caches never pass through the control encoder (the 65%-of-CPU protobuf tax stays out of the hot path).
A.Frame bulk objects are offset-addressable by construction (name → dtype/shape/offset/length header + flat region, safetensors/Arrow pattern): any consumer can range-fetch, parallelize, resume, and mmap — the single serialization decision behind 76x model-load speedups and seconds-scale cold starts for 200+ GiB models, now a wire-format guarantee.
Model and dataset distribution rides Corpus: weights are Merkle-verified, FastCDC-deduped, swarm-fetched from LAN peers first — a fleet pulling a new checkpoint behaves like Kraken (20k 1 GB blobs in under 30 s), and incremental fine-tune deltas transfer only changed chunks.
A.Descriptor gives disaggregated inference a stable transfer contract: register memory once, post async scatter/gather descriptor lists with out-of-order completion, over pluggable bearer functors (RDMA/GPUDirect where NIC and GPU share a PCIe switch — topology is part of the stated correctness envelope — TCP, NVMe-oF, object storage), the NIXL shape vLLM already treats as a swappable connector.
A.Collective factors collectives exactly as NCCL does — fused primitives × algorithms × transports — but the transport axis is a certified Bearer Functor, so a ring allreduce is provably the same protocol value over NVLink, IB, or an OCS-scheduled lambda fabric; ring stays bandwidth-optimal (2(N−1)/N lower bound stated, not 'beaten').
Tail latency is the design metric, not the mean (UEC rationale: synchronous step time = max over workers): T.Spray provides per-flow packet spraying, out-of-order delivery with in-order completion, and selective retransmission, benchmarked at P99.9.
Flow control is per-semantic-stream and payload-class aware — control windows never preempt tensor streams (the gRPC/HTTP/2 failure mode) — and chunk size plus concurrency are explicit negotiated parameters so network/staging/device-copy overlap is tunable per link.
Chorus session types make multi-agent and multi-worker choreographies checkable: global protocol values project to endpoint state machines with deadlock-freedom guaranteed under stated reliable-channel assumptions (failure semantics — timeouts, retries, idempotency — documented separately, never implied to be covered by the type system).
Cross-region training honesty: ~5 µs/km propagation makes WAN synchronous collectives physics-bound, so the spec pushes WAN-scale learning to asynchronous/hierarchical patterns over F.Custody rather than pretending a protocol can shrink the speed of light.
Edge-AI reach: the same Chorus choreography that moves KV-caches over RDMA runs a 51-byte quantized-gradient exchange over F.LoRa — one protocol algebra from datacenter collective to duty-cycled field sensor.

Go deeper

See the AI data plane in the architecture, the semantic-transport solution, or install and try it.