NeuraFrame Embodied

Raise it in simulation. Ship the memory. It keeps learning.

NeuraFrame Embodied is the portable experience layer for machines. A robot already has perception and control: a vision model, a policy or planner, sometimes a small language model. What it usually lacks is a transferable, self-improving memory of what it has already worked out, and a consistent way to say "I am not sure, stop and ask" instead of acting on a guess. Embodied is that layer.

The model stays in simulation

The heavy model that teaches the agent, a large language model, a vision-language model, or a big policy, runs on the server during training, where power and compute are cheap. You do not put it on the robot. NeuraFrame Embodied itself runs in both places, as the learner on the server and the runner on the robot; it is the model, not NeuraFrame, that stays behind in simulation. The robot gets its own install of NeuraFrame and then just the learned memory: the one thing that travels from the server is the memory pack, never the model. The robot acts on what it has learned in milliseconds, on modest hardware, and escalates anything it has not learned rather than running a heavy model on board. Train with the big model once, deploy the distilled experience everywhere.

1. Raise it in simulation

Run a virtual copy of the machine on a server, where mistakes are cheap and a supervisor can teach freely. NeuraFrame acts on each situation; where it is unsure it escalates, and the supervisor teaches the right action. It needs the policy less and less as its memory fills.

# the simulation feedback loop (orin/embodied)
agent = EmbodiedAgent(engine, policy=device_policy, guard=Guard(rules=[safety_law]))
curve = train(agent, scenario, oracle, epochs=4)
# epoch 1  memory 0/6   taught 6
# epoch 2  memory 6/6   taught 0   (learned)

2. Ship the memory

The learned memory is just the durable store, so exporting it is a single portable file. Copy that file onto the real machine. That is the whole transfer, no retraining.

MemoryPack.export(store_dir, "walker.nfmem")   # a small file
# copy walker.nfmem to the robot, then:
MemoryPack.import_("walker.nfmem", store_dir)   # boots warm

3. It keeps learning

On the device the machine boots warm, acting from the shipped memory. A new situation the simulation never covered is not guessed at: it escalates, a human or a sensor outcome teaches it once, and from then on it is served from memory. Learning on the device uses the same correction primitive as the simulation.

unknown object blocking a doorway  -> ESCALATE         (unsure, stop and ask)
# a human teaches it once
unknown object blocking a doorway  -> stop and replan  (from memory)

Safety: rules and escalate-when-unsure

Under the memory sit hard rules, the safety laws. An action that violates a rule, or that the machine is not confident in, is replaced by a safe fallback: stop and ask. The rule holds even if the memory is wrong, so a bad lesson cannot produce an unsafe action.

proposed 'advance' with a human in path  ->  ESCALATE  (rule vetoed the action)

This is the same honesty NeuraFrame uses everywhere: it never invents an action it cannot justify.

Safety is a shared responsibility

NeuraFrame Embodied gives you safety tools: hard rules and escalate-when-unsure. It is not a certified safety system and does not guarantee safe operation. You are responsible for your side. That means training your model and policy correctly, defining and testing the rules for your machine, making sure an escalation reaches a genuinely safe state on your hardware, meeting the safety standards that apply to your deployment, and validating thoroughly before any real-world use. Do not rely on NeuraFrame™ as your only safeguard. Keep independent hardware safety systems such as emergency stops and motion limits, and do not bypass, weaken, or override the rule layer. NeuraFrame™ is provided as is, without warranty; responsibility for safe deployment rests with the operator. See the EULA and Terms.

What is yours, and what is NeuraFrame's

Developer controls

• Deployment modes. A graduated safety dial: sim (train), shadow (runs alongside real control, suggests but never actuates), assist (acts only on confident memory, escalates the rest), autonomous, and frozen (memory locked, no learning) for a certified deployment.
• Rules and constraints. Boolean safety rules and numeric limits (never below a minimum clearance, never above a maximum speed), each an absolute law or a soft preference. A limit can be strengthened in the field but not loosened, and every veto is logged.
• Capabilities. Declare a new sensor or actuator. It augments what the machine can sense or do without discarding what it learned, the way a new sense enriches memory rather than erasing it. Only the specific decisions the sensor changes are re-examined; everything else keeps serving. Removing a sometimes-used sensor is non-destructive too.
• Escalation and feedback. On a situation it has not learned, it can stop and hold, ask a person (voice, a screen, teleop), learn from a sensor outcome, or call your own software (a server model, your LLM, any function) and learn the answer. You can pin a correction to fix a behavior instantly, or force escalation if your model misbehaves.
• Observability. Every decision records why it acted (memory, which rule, why it escalated), with metrics, so behavior is auditable.

Licensing across machines

The memory pack is portable experience, not a license. Running NeuraFrame™ actively on any machine requires that machine's own node-locked license, or a seat drawn from your organization's pool. A device without a license stays in pass-through: it serves nothing from memory and escalates, so a copied pack is inert until the device is licensed. Moving or copying the memory onto a fleet is a per-device, per-seat matter, exactly like any other install. See Fleet deployment for seat pools and one-token enrollment.

Try the demo

The demo tells the whole story in one run, with no model or robot required. It trains in simulation, exports the memory to a file, boots a fresh agent warm from that file, teaches it a new situation, and shows the safety law holding.

python3 embodied_demo.py