The problem: an overlay moves packets, not their rules

Weave Net solved a real and hard problem. Connecting containers across a fleet of hosts once meant hand-configuring VXLAN tunnels, BGP peers, or vendor SDN appliances, and reconciling that plumbing with a scheduler that moved workloads around continuously. Weave Net replaced much of that with an overlay that peers form automatically: each host runs a router that discovers others, establishes a full or partial mesh, and forwards container traffic between them, with WeaveDNS resolving service names and a kernel fast datapath keeping forwarding efficient. A team can get portable cross-host connectivity without becoming a networking vendor. That is genuinely valuable, and nothing here disputes it.

The architectural observation is narrower. A packet on a Weave Net overlay is an ordinary IP packet inside an encapsulation. It carries source and destination addresses and its payload. It does not carry, as a first-class field, the answer to questions like: who is allowed to mutate this object, under what quorum, along which trust-scoped path, with what verifiable history of prior handling. In a conventional deployment those questions are answered outside the packet. Reachability is decided by NetworkPolicy objects enforced at the host. Identity and authorization live in an application or service mesh layer above the network. Observability is reconstructed after the fact by external tooling. The packet flows; the governance is imposed around it.

That separation is a deliberate and often correct design. It keeps the overlay fast and the wire format small, and it lets the same network carry any workload. But it means the trust and governance state is not portable with the data. When traffic crosses a trust boundary, is cached, is replayed after a delay, or lands on a node that was not part of the original session, the surrounding policy context does not travel with it. It must be re-established from external systems.

What the Memory-Native Protocol makes a protocol primitive

United States Patent Application 19/366,760 discloses a network substrate in which the primary unit of protocol execution is not a stateless packet but a memory-bearing agent. As disclosed, each agent comprises a unique identifier, a payload, a memory field, a transport header, and a cryptographic signature. The memory field is an append-only record that includes verifiable lineage, access logs, and policy references, and those elements carry sets of instructions that govern routing, mutation, and consensus behavior for that agent.

The consequence is a shift in where the rules live. In the disclosed system, behavior of the routing layer, the indexing layer, and the consensus layer is determined by metadata embedded within the received agent. A node that receives an agent verifies the signature, parses the transport header and memory field, determines routing eligibility and mutation scope by evaluating the access log and policy references, executes protocol stack layers based on the memory field content, appends a trace log, and forwards the agent to eligible nodes. There is no dependence on external session state, a centralized controller, or a pre-configured address registry. The governance context is part of the operand.

Three mechanisms in the specification make this concrete:

  • Dynamic Routing Protocol (DRP). Rather than address-based forwarding, DRP scores candidate paths using trust information derived from the agent's memory field, network health signals, and semantic scope constraints from the transport header. As disclosed, a node builds a local trust graph from prior memory-field evaluations, assigns dynamic trust scores to routing candidates, excludes candidates that fall below policy-defined thresholds, and appends the chosen trust path to the agent's memory trace.
  • Adaptive Consensus Protocol (ACP). When an agent's memory field encodes a mutation proposal, the receiving node validates the embedded policy reference, evaluates its own eligibility, and participates in a trust-weighted quorum whose thresholds are specified in the agent's memory field. Consensus is scoped to the identity, memory, and mutation context of a single agent, without fixed validator sets or a global registry.
  • Dynamic Indexing Protocol (DIP) and the Network Health Monitoring System (NHMS). The substrate can restructure its own semantic index in response to entropy thresholds, and nodes emit signed health agents carrying congestion, latency variance, and entropy signals that adjust routing preferences and quorum thresholds. These are protocol-native adaptations, not out-of-band observability.

None of these require replacing the transport. The specification states the substrate can be deployed over TCP/IP, HTTP, WebSockets, WebRTC, mesh relay, or delay-tolerant networking without modification to agent structure, because the protocol stack operates above the transport and interprets the agent as a complete operand. A container overlay such as Weave Net is exactly the kind of underlying transport the agent can ride across, unchanged.

The honest comparison

The right way to frame this is not Weave Net versus the memory-native protocol as competitors for the same job. Weave Net is a container overlay network, and it does connectivity, mesh formation, and service discovery well. The memory-native protocol addresses a different axis: making trust scope, policy authority, mutation lineage, and consensus rules travel inside the data object so that any node can evaluate them locally and deterministically.

Where they meet is the boundary case. An overlay assumes a live network fabric and an ambient policy plane sitting above it. When execution must survive that assumption failing, when the object crosses administrative domains, is validated after a long delay, or lands on a node with no prior session, the memory-native model keeps the governing rules attached to the object. As disclosed, an agent carries all necessary context for execution, including policy, mutation proposal, quorum metadata, and routing constraints, allowing it to propagate and be validated even after long delays and in intermittently connected environments such as edge or IoT deployments.

It is also fair to note what Weave Net offers that the specification does not claim. Weave Net provides mature Layer 2 and Layer 3 container connectivity, automatic peer discovery and mesh formation, transparent name resolution, and an efficient kernel datapath that a memory-native agent layer would simply run on top of rather than replace. The memory-native protocol, as disclosed, is explicitly designed to sit above such transports and interoperate with legacy clients through dual-mode, phased deployments rather than to displace them. A realistic architecture uses an overlay like Weave Net for host-to-host container transport and layers memory-native agents where portable governance and trust-scoped autonomy are required.

Enablement: how a skilled implementer would build this over a container overlay

The disclosure is enabling at the level a practitioner needs. An agent is a serializable object with five fields; over a Weave Net overlay it can be carried inside any ordinary TCP or UDP flow between containers, since the substrate operates above the transport and treats the agent as a complete, self-contained operand. The receiving service, before acting on the payload, runs the disclosed evaluation sequence: verify the signature over a canonical serialization of UID, payload, memory field, and transport header using the sender's public key; parse the transport header for trust scope, time-to-live, semantic class, latency sensitivity, and quorum priority; evaluate the access log and policy references to determine routing eligibility and mutation scope; execute the applicable stack layers; append a signed, hash-chained trace entry to the memory field; and forward to eligible nodes.

Embodiments and variations the specification supports include: stateless-mode nodes that derive all decisions solely from agent-resident data, suitable for ephemeral containers or constrained IoT devices; memory-aware nodes that maintain a persistent trust graph for reputation-aware quorum forecasting; minimal edge configurations running only DRP and a simplified semantic memory layer; and full-stack core nodes running DRP, DIP, ACP, and NHMS. Policy references may be embedded as canonical identifiers or resolved by alias against a zone-local table. Consensus may be omitted, run per node, or scoped across federated domains that each define their own policies. The substrate may run over any of the enumerated transports, a container overlay among them, and may interoperate with cognition-layer semantic payloads carrying intent fields and behavioral constraints without the substrate needing to interpret their internal semantics.

A skilled implementer starting from a Weave Net cluster and this specification could encode the agent as a message inside a normal container-to-container connection, add the memory-field evaluation path to the receiving service or a sidecar, and obtain trust-scoped, policy-in-payload execution without changing the overlay.

Disclosure Scope

The technical subject matter attributed here to the memory-native protocol, including the agent structure, the memory field, the Dynamic Routing Protocol, the Adaptive Consensus Protocol, the Dynamic Indexing Protocol, the Network Health Monitoring System, stateless and memory-aware deployment modes, and transport-agnostic operation, is disclosed in United States Patent Application 19/366,760, and this article is a public description tied to that filing. All statements about Weave Net, Weaveworks, the Container Network Interface, Kubernetes, and container overlay networking describe external, independently developed technology and are provided as market and architectural context. Weave Net is the work of its respective maintainers and community; nothing here is a claim of that work or an assertion of any defect in it. Any comparison is limited to the specific architectural axis of memory-native, policy-bearing, trust-scoped execution described in the filing, and characterizations of Weave Net are stated at a general, widely-understood architecture level.