What's the minimum memory stack for a humanoid robot?

Three layers, not one

A humanoid robot trying to keep all its memory on-device ends up with a bloated chassis and fragile state. The working architecture is three layers. On the robot: a short-term buffer that captures sensor data, in-flight actions, and reflex-level state. Remote: a persistent graph holding the long-term memory of environments, people, and decisions. Alongside: a policy engine that tells the robot what it is and is not allowed to do. bRRAIn provides the remote and policy layers through the Vault and Security Policy Engine.

The on-robot buffer stays small

The short-term buffer is the only part that has to live on the robot, and it should stay small. Its job is to hold the last few seconds of sensor state and the currently-executing plan. Anything older, anything shared, anything audit-relevant belongs in remote memory. By keeping the on-robot buffer lean, you reduce the compute budget, the cooling demand, and the failure surface. The robot becomes a client in the classic sense — real-time reflexes local, durable knowledge fetched through the Embedded SDK.

The remote persistent graph carries the weight

The graph is where the robot's real intelligence lives. bRRAIn's POPE Graph RAG layer stores environments, events, relationships, and decisions with provenance. When the robot needs to plan, it queries this layer through the handler and receives a grounded context. When it completes an action, it writes the outcome back. Swap the chassis tomorrow and the replacement boots with the full memory intact. The Consolidator keeps the graph coherent as multiple robots feed observations into it simultaneously.

Policy is the third, non-negotiable layer

A humanoid without a policy engine is a liability. bRRAIn's Security Policy Engine evaluates every action against role, context, and rule before it executes. The robot cannot grant itself new authority; the policy engine holds that power centrally. This is what makes deploying humanoids in human-shared spaces survivable. The robot's short-term logic proposes; the policy engine disposes. Together with the buffer and the graph, it forms the minimum viable memory stack.

Relevant bRRAIn products and services

• bRRAIn Vault — durable remote store for the long-term humanoid memory layer.
• POPE Graph RAG — the persistent graph that carries the robot's real intelligence.
• Security Policy Engine — the non-negotiable policy layer for human-adjacent robots.
• Embedded SDK — the client surface that keeps the on-robot buffer small.
• SDK quickstart — integration path for a three-layer humanoid memory stack.
• Architecture overview — how the eight zones support robotic deployments.