From intelligence
to executable action.

Capability alone does not make a system that works in the world.

For a model's decision to hold as an operation in software or as a movement of a robot, something has to sit in between: the technology of execution and control.

What VirtualHatch implements is the sequence

Intelligence → Control → Action

and we implement it on both sides — in software and in Physical AI.

In software, we govern the AI's authority and its outward effects, so that only permitted actions run, and run safely.

In Physical AI, we integrate sensing, reasoning, action generation, runtime and robot control, turning a decision into motion that holds in the real world.

The domains differ. The boundary we are designing is the same one.

Turning an AI's decision into action that is controllable and executable.

When an AI agent acts on an external system, safety is not settled by the instructions given to the model.

What matters is how you design the boundary an AI's decision has to cross before it becomes a real action.

Through OmniHatch, we govern that space between AI and action by the following principles.

1. 01

   Identity — Establish who is acting

   Establish whose action it is.

   Every action on a system has to be tied, reliably, to whoever asked for it.

   Not by a model or a piece of running code asserting who it is, but by establishing the actor at a trusted system boundary — and governing everything downstream on that basis.

2. 02

   Authority — Bound what is permitted

   Bound what is permitted.

   Rather than granting an AI blanket permission to use a system, limit the operations, the targets, the conditions and the scope.

   Where it matters, put human approval on the execution path: an action that needs a person's judgement does not run until it has it.

   Capability and authority are two different things, and they are kept apart.

3. 03

   Mediation — Mediate every outward effect

   Every outward effect passes through the boundary.

   Calling an external API, changing data, running code, deploying — an AI or generated code never has a direct route to any of it.

   Mediating every outward effect at a trusted execution boundary is what makes authorisation, policy and approval binding on the action itself, rather than advisory.

   This is complete mediation, the long-standing principle from computer security, applied to systems where an AI acts.

4. 04

   Isolation — Isolate the execution environment

   Keep intelligence and authority apart.

   Model-generated code and untrusted execution carry no implicit authority over the outside world.

   Compute is separated from external authority, and only the actions that cross the boundary are treated as things to govern.

   That removes the need to fully trust how a model or its generated code behaves.

5. 05

   Integrity — Protect the integrity of an action

   When the state is uncertain, fail safe.

   With outward actions, not knowing whether something ran is itself the risk.

   Duplicate execution, partial failure, lost connections, a control boundary behaving oddly: when safety or consistency cannot be confirmed, the system does not press on via a detour or an unconditional retry.

   It fails closed, and the integrity of the action holds.

6. 06

   Governance — Govern change to the system

   Govern not just execution, but change.

   An AI system is not static. Agents, models, tools, policies and runtimes all keep changing.

   So control has to extend to knowing which configuration is running, and to evaluating, approving, deploying and — when needed — rolling back a change.

   Even when the AI proposes the improvement itself, it does not rewrite the running system. The change is evaluated and approved, and the system moves to its next configuration.

Governing not only the action, but the system's own change.

In Physical AI, a model producing the right decision is not enough.

The state of the world has to be perceived, an action generated from that state, and the action turned into control the hardware can actually execute.

Built around VLA, we integrate everything from sensing to robot control as a single system.

1. 01

   Perception — Read the world

   Vision and other sensors capture the state of the world the AI has to decide on.

   Not one input alone: what the environment offers is combined, and passed on to reasoning and action generation.

2. 02

   Reasoning — Understand the situation

   The environment as observed and the instruction as given are brought together, and the action that fits the current situation is decided.

   The model's reasoning is not treated in isolation, but as one step in a continuing exchange with the world.

3. 03

   Action Generation — Turn a decision into motion

   The model's decision becomes an action a real robot can carry out.

   This is the join between a high-level instruction and the specific movement the hardware will perform.

4. 04

   Runtime — Connect the model to the machine

   Inference and the robot's own execution stack are integrated into a system that keeps running in a real environment.

   Inference time, execution timing, state updates: the model and the machine are treated as a single runtime.

5. 05

   Robot Control — Execute it as physical motion

   The generated action becomes machine motion, shaped by the hardware's characteristics and its control conditions.

   A model's output is not motion by itself; it is connected to control that actually holds on the machine.

6. 06

   Safety — Work within the constraints of the world

   In the real world, perception drifts, inference is delayed, exceptions occur and hardware has limits. None of it can be avoided.

   These are treated as conditions on the whole system, so that the AI's actions hold safely in the world.

Calling an API, rewriting data, moving a robot —

to an AI these are all the same thing: the action that follows a decision.

For actions in software and actions in the physical world alike, VirtualHatch builds

the systems technology that carries intelligence through to action.