Vendor and Product Reality
Anduril's Lattice is the company's software platform for autonomy and command-and-control, and Lattice Mesh is a networking capability that lets heterogeneous defense platforms (drones, sensors, ground vehicles, and command nodes, including systems from multiple vendors) share data with one another in a decentralized way rather than routing everything through a central server. It is built for the environments where conventional networking struggles: contested electromagnetic conditions, intermittent connectivity, and multi-vendor coalitions where no single cloud is reachable or trusted by everyone. Lattice Mesh is a prominent commercial expression of an idea this body of work also holds, that autonomy at the edge benefits from a decentralized data fabric rather than a hub. Its prominence helps establish the category. A decentralized data fabric for autonomy is now a serious market.
The agreement is genuine and worth stating before the divergence. Both Lattice Mesh and the Memory-Native Protocol move coordination away from a single central server, and both target contested, multi-vendor, partition-prone conditions. The comparison here is scoped to one architectural axis only: what the transmitted data unit is permitted to be, and where the rules for handling it reside.
The Architectural Choice: Packets as Payload
In a mesh built on conventional networking principles, however decentralized the topology, the transmitted data unit is payload and governance lives in the nodes. Routing decisions, access-control rules, and trust state are held in node-resident configuration, and a packet is the thing moved between nodes that hold that configuration. This works well when nodes are consistently configured and reachable, and it is the model that mature mesh fabrics optimize. Its structural property is that a packet arriving at a node is handled according to whatever that node currently holds as configuration and trust state. Keeping that state consistent across a contested, multi-vendor, partition-prone mesh is itself a hard problem, precisely the kind of consistency that partition and adversarial conditions strain. The packet carries data; it does not carry the rules for its own handling. That is a neutral description of the conventional layering, not a claim about any specific internal design of Lattice Mesh.
What the Memory-Native Primitive Provides
The Memory-Native Protocol makes the transmitted data unit a self-governing operand. In the disclosure the unit is an agent, and each agent comprises a unique identifier, a payload, a memory field, a transport header, and a cryptographic signature. Governance is carried inside the agent rather than held only in the node.
The memory field is an append-only record containing verifiable lineage (the sequence of structural changes and the zones and policies under which they occurred), access logs (prior read, write, and execution events with trust metadata), and policy references (canonical identifiers or embedded stubs pointing to policy agents that encode who may mutate, route, or vote on the agent and under what quorum rules). The transport header carries routing constraints such as time-to-live, trust radius or scope, semantic class, latency sensitivity, and quorum priority. The cryptographic signature is computed over a canonical serialization of the UID, payload, memory field, and transport header using the originating node's private key, and each trace entry appended along the path is itself signed by the contributing node and hash-chained, so lineage and hop history are individually verifiable and time-ordered without a central lookup.
Because the rules travel with the data, a receiving node evaluates the agent against the policy and trust context the agent carries, using locally cached or embedded policy resolution, without a round trip to a central controller or session store. A modular protocol stack (a memory-aware routing layer, an optional indexing layer, and a consensus layer) reads the memory field before acting: routing scores candidate next hops from carried access logs and health feedback rather than static addresses; consensus, when a mutation is proposed, forms an ad hoc trust-weighted quorum scoped by the agent's embedded policy reference. In fully stateless mode, a node relies exclusively on the agent's embedded data for trust evaluation, quorum participation, and policy enforcement, which is what lets resource-limited or intermittently connected participants take part without persistent infrastructure.
A skilled implementer can build this over an existing transport. The disclosure states the substrate operates above the transport layer and can run over TCP/IP, HTTP, WebSockets, WebRTC, mesh relay, or delay-tolerant networking, with agents serialized as structured payloads and treated as fully portable, self-contained units. Embodiments range from minimal edge nodes that only route and verify, through memory-aware nodes that also validate mutations, to full-stack nodes that additionally index, monitor health, and host consensus, and the same agent format spans all of them. Nothing above depends on any particular field layout unique to one deployment; the load-bearing idea is that lineage, access history, and policy references ride inside the unit and are evaluated locally.
Complementary at the Problem, Divergent at the Wire
Lattice Mesh and the Memory-Native Protocol address the same problem under different architecture. At the level of the problem, decentralized data sharing for autonomy in contested, multi-vendor environments, they are aligned, and a decentralized delivery fabric is exactly the kind of transport over which a self-governing agent could ride as an ordinary payload. At the level of wire architecture they diverge: node-resident governance over data units treated as payload, versus carried governance in data units treated as self-contained operands. Because the disclosed substrate operates above the transport layer, the divergence is composable rather than exclusive. A mesh optimized for decentralized delivery can transport self-governing agents and gain per-message, data-resident governance without changing how it routes. This is a description of complementary architectures, not a claim about Anduril's roadmap or internals. No relationship, endorsement, partnership, or infringement is asserted or implied; the comparison is architectural.
Disclosure Scope
The Memory-Native Protocol, in which the data unit is a cryptographically signed, memory-bearing agent carrying verifiable lineage, access logs, and policy references in an append-only memory field together with routing constraints in a transport header, and in which nodes evaluate that carried governance locally through a memory-aware routing, indexing, and consensus stack without a central authority, is disclosed in United States Patent Application 19/366,760. That application is the sole basis for statements in this article about what the invention does; any capability not traceable to it is outside the disclosure.
The framing of Anduril's Lattice and Lattice Mesh, and of the mesh-networking and defense-autonomy market generally, is external context drawn from public materials, provided for comparison only. It is not part of the filing and not a claim of the filing. References to Anduril and Lattice describe publicly known, architecture-level characteristics and are used neutrally; nothing here asserts any relationship, endorsement, or infringement, or characterizes non-public internals of Lattice Mesh.
