Actor Infrastructure Platform
AIP is the foundational layer of the Actor ecosystem: the actors, services, runtime, communication, and security required for distributed, concurrent, autonomous computing — from edge devices to HPC. Every Point of Data product sits on it, so it is worth understanding.
Everything is written in C. Actor and Evolutionary Neural Memory services need nothing running but the base OS — no interpreter runtimes, no phalanx of packages, no version dependencies — across all modern POSIX-compliant operating systems.
Actors
An Actor Gateway accepts messages, routes them to the correct actor, and returns the actor's reply to the requestor. It manages the actors assigned to it, turning them on and off as required. Gateways talk to everyone — other actors, any other software — over TCP sockets.
MESSAGES
interconnections
Something that happens at a specific time and place, sent from a specific entity to a specific entity. Edge software captures telemetry in surgery and sends it to Evolutionary Neural Memory. Messages are like email — except they carry instructions and data: store an event, search memory, request a service, and infinitely more.
A requestor only needs an address. AIP handles every hop of routing and inter-actor communication needed to finish the request.
llm-use-case-prompts@pointofdata.ai
Evolutionary Neural Memory DB Service
ENM runs as its own actor type. It captures and searches high-fidelity, dense context, stored in a hypergraph — a set of vertices with edges that can each link a different number of vertices. Every vertex is an Event Object: whatever the engineer, scientist, or AI decides is worth tracking over time.
AIP natively connects time, data, and named-tag information. That removes most of the work of building a high-fidelity memory — and gives you a new capability: understanding and searching data in context.
“The circumstances that form the setting for an event, statement, or idea, and in terms of which it can be fully understood and assessed.”
Programmable search
Searching high-fidelity context takes more than keywords or vectors. ENM search runs conditions and branches, pattern matching, and mathematical search across events, tags, and links — and can run concurrently across multiple memories.
Security
AIP manages security for the creator, with full control over each layer — SSL and AIP Advanced Security. New to the market: encrypted memory search that never decrypts the data during the search, so you pay neither the computation cost nor the security risk.
Structure, context, and behavior arise bottom-up.
In complex systems theory, emergence describes how sophisticated patterns arise from simple components following local rules — with no central designer dictating the global form. Most stacks fight that or approximate it expensively. Pod-OS, Evolutionary Neural Memory, and the Actor Infrastructure Platform bake it into the substrate: structure, context, memory, and complex behavior emerge from event objects and autonomous actors instead of being imposed by schemas, shared state, or central orchestration.
Every piece of data, whatever its type or format, is an event object that inherently carries when, where, and who. A document is an event; modifying it is another event.
Neural Memory stores a time- and location-based state slice as a hypergraph of objects. High-level objects emerge from relationships that are defined or discovered — never from a schema.
Everything is an actor — ENM, gateways, application logic. Actors all the way down. Private state, messages only, location-transparent from edge device to hypercomputer.
Long-term memory lives in the ENM hypergraph, durable and evolutionary. Short-term and real-time stay actor-local. The result is dense, associative, contextual memory.
Those rules produce dense hypergraphs, adaptive agent behavior, and scalable autonomous systems — outcomes traditional approaches reach only with high cost, complexity, and information loss. Emergence is not supported here; it is the default operating principle.
Performance
Platform software and storage are performant and efficient by design — which is where the efficiency gains come from.
AIP runs Actor Gateways that vend actors you define, reachable by messages addressed to actor@gateway. Messages travel over TCP sockets, with SDKs that make sending and receiving easy, concurrent, and performant. The Evolutionary Neural Memory DB service is a hypergraph store that explicitly and implicitly links events and describing tags; each event carries a payload up to 2 GB and is infinitely describable and linkable. Search is programmable, runs encrypted, and spans multiple memories concurrently. The runtime needs under 1 MB of disk and 5 MB of memory per actor, with no layers of dependent software adding cost and technical debt. Each memory holds up to 1.8 quadrillion events, and an average Orange Pi with an SSD inserts up to 10,000 event objects per second.
TLDR is short for “too long, didn't read” — the synopsis engineers and ML scientists use to accelerate the search for a candidate solution. This one is for our friends. May your next delivery go smoothly.