Intel Physical AI Studio

Physical AI Studio is an end-to-end, open-source framework for teaching robots to perform tasks through imitation learning. It provides a browser-based interface covering the full workflow, from hardware setup and demonstration recording through Vision-Language-Action (VLA) model training and policy execution, and is designed to run on a developer's own hardware.

General
Release date	0.1.0 public preview
Developer	Intel Corporation
Type	Open-source robot imitation-learning and VLA training framework
License	Open source
GitHub	open-edge-platform/physical-ai-studio
Documentation	Physical AI Studio docs

Core Features

Browser-based UI — covers hardware setup, dataset recording, model training, and policy execution from a single interface.
Imitation learning pipeline — trains Vision-Language-Action policies from human demonstration data rather than hand-coded control logic.
physicalai-train package — a full-cycle VLA development stack for defining a PyTorch model, benchmarking it, and exporting it to a deployment framework.
Heterogeneous deployment — pairs with OpenVINO to run trained policies with low-latency, low-jitter control loops on Intel Core Ultra Series 3 hardware.

Tools and Resources

GitHub repository — open-edge-platform/physical-ai-studio, including release notes and setup docs.
Robotics AI Suite — Intel's broader software layer pairing Physical AI Studio with optimized ROS 2 implementations for deployment.
verify_stack.py — an included script for verifying the NPU, iGPU driver, OpenVINO, and LeRobot environment before running a workflow.

Ecosystem and Integrations

Built to run on Intel Core Ultra Series 2/3 processors, using the onboard NPU and iGPU for training and inference.
Uses OpenVINO as its inference and optimization backend, and LeRobot on PyTorch XPU for policy training.

Get started from the Physical AI Studio GitHub repository or the OpenVINO Physical AI for Robotics page.

TableMate — Voice-Driven Bimanual Physical AI

TableMate is a voice-driven Physical AI system for intelligent bimanual robotic manipulation in restaurant and table-service environments. The project uses two simulated SO-101 robotic arms in MuJoCo to transform natural-language instructions into coordinated, multi-step physical actions. Rather than executing a fixed sequence, TableMate represents restaurant requests as structured task plans and dynamically assigns actions to the left arm, right arm, or both arms cooperatively. The system supports parallel operations such as placing a plate and cutlery simultaneously, as well as cooperative bimanual tasks such as transporting a main dish. Current scenarios include fine dining, quick lunch, shared dinner, selective table clearing, and changing guest requests. TableMate is designed around the hackathon’s multimodal Physical AI challenge: combining language understanding, visual scene information, task context, bimanual coordination, manipulation, and verification. The architecture is being developed to support randomized MuJoCo environments and evaluation across multiple seeds to measure robustness to changes in object placement and scene conditions. The deployment pipeline targets Intel Core Ultra Series 2/3 and uses OpenVINO for supported AI inference optimization. The project also incorporates Intel Physical AI tooling and a reproducible simulation, evaluation, and benchmarking workflow. Speechmatics integration extends the interface from written commands to real-time spoken instructions, allowing a guest or operator to naturally request actions such as setting, serving, modifying, or clearing the table. The goal of TableMate is to demonstrate how Physical AI can move beyond isolated robotic actions toward an interactive agent that can understand what a person wants, reason about a changing environment, coordinate two arms, execute safely, and verify that a real-world-style task has been completed correctly.

EdgeVLA-Lite

We have built a high-throughput, zero-cloud visual anomaly detection and robotic intervention pipeline tailored for Intel Core Ultra hardware. We utilized the Intel OpenVINO and Anomalib frameworks to perform real-time edge defect localization and lightweight vision classification to output deterministic spatial coordinates for automated sorting or inspection workflows. We are able to successfully demonstrate the Physical AI ability of Intel's robotic arms through actual communication between the Physical AI Studio where the categorization made was between a lego block with permanent marker on it (categorized as bad), and lego block with no marker (categorized as good). The pipeline used ACT models for initial hop from picking station to inspection station and then moved the correct blocks to two different trays, one for good and one for bad.

AURA-VLA: Heterogeneous OpenVINO Robotics

AURA-VLA is a fault-tolerant, production-grade Vision-Language-Action (VLA) bimanual robotics control system engineered specifically for the Intel track. The system controls dual SO-101 6-DOF robotic arms in a 500Hz MuJoCo physics simulation to complete a dynamic table-setting task. To maximize performance and score the full Intel optimization points, AURA-VLA implements a heterogeneous compute pipeline using OpenVINO. The architecture dynamically routes inference across Intel hardware: the spatial visual defect monitor (Anomalib) and VLM (Qwen 2.5) are optimized and routed to the Intel iGPU via INT4 (42.1ms), while the 16-step continuous diffusion bimanual action policy executes at lightning speed on the Intel CPU (1.41ms/step). The OpenVINO codebase is also natively configured for dynamic NPU fallback (device_name="NPU") for next-gen AI PCs. AURA-VLA is deeply multimodal. We integrated Speechmatics for real-time WebSocket voice ASR (0.774s settling buffer) to issue natural language commands. Furthermore, the system is physically robust: Intel Anomalib continuously monitors the 20Hz camera feed for physical defects or displacements. If an anomaly surpasses the 0.65 threshold, it autonomously triggers a closed-loop replan, allowing the robot to self-heal and recover mid-trajectory. Empirical multi-seed evaluation across 10 domain-randomized environments proves a 100% task success rate (50/50 sub-goals completed). The system is fully observable via a Next.js/FastAPI cybernetic dashboard and exposes an official Model Context Protocol (MCP) server, allowing external agents to query live hardware latencies and sub-goal telemetry. AURA-VLA proves that Intel heterogeneous compute can power next-generation physical AI.

Bimanual Dinner-Table AI on Intel Edge

We built an end-to-end Physical AI system in which two simulated SO-101 robot arms set a dinner table from a single natural-language command in MuJoCo. A planner turns the sentence into a two-arm plan: open the drawer, fetch the spoon and fork, place the plate, hand the fork from arm B to arm A, and pour from a bottle into a mug that the other arm holds steady by its handle. A closed-loop executor carries out each step, checks the result against the actual scene, and retries or re-plans when something fails or a finished goal gets undone, such as the drawer being bumped shut. Every seed randomizes object positions, masses, friction, sizes, mug shape and lighting. With scripted bimanual skills, the full task succeeds on 10/10 evaluation seeds and 7/10 held-out seeds. For learning, we collected 300 expert episodes (117k frames) and trained ACT-Lite, a 1.6M-parameter language-conditioned action-chunking transformer that uses two cameras, joint state and the sub-instruction. When it handles the plate and mug picks, the full task succeeds on 5/10 seeds, and it completes 80% of its picks without help. The policy is exported to OpenVINO IR in FP32, FP16 and INT8 (NNCF quantization). On an Intel i9-13900HX, INT8 inference takes 1.35 ms, 5.2x faster than PyTorch, with 3,400 inferences per second in throughput mode; the Intel iGPU runs it in 2.56 ms. Simulation, perception and policy together run faster than real time. The repo includes the MuJoCo scene, data collection, training, export, benchmark and 10-seed evaluation scripts, plus a video of all seeds. Limitations are stated openly: grasping uses a weld-based assist, pouring is judged geometrically, and there are no NPU numbers because the test laptop is not a Core Ultra system.

Dinner-Table Relay: SmolVLA on Intel Core Ultra

Two SO-101 arms face each other across a dinner table. Given "bring the cup across the table and set it on the plate", the right arm grasps and lifts a 130 mm cup, sets it mid-table, and the left arm places it on the plate. "Slide the cup to the middle of the table" is the single-arm half. A language-conditioned policy must do the right one. What we built: • Physics-honest simulation in MuJoCo 3 (Menagerie SO-101, 200 Hz physics / 50 Hz control). Our early scripted demos were not grasping at all — they rewrote object pose. We replaced that with real jaw contact and a holding() check; the scripted controller passes 7/10 and 14/20 with no predicate loosened. • Dataset: 749 attempts → 400 success-only episodes, 323,442 frames at 50 fps, 3 cameras, 12-D bimanual state/action, 2 task strings, DART noise. Every failure is counted and the fault taxonomy is published. • SmolVLA (450M) fine-tuned with LeRobot 0.6.1. Run 1: Tesla T4, 1.0 epoch. Run 3: RTX 5090, bf16, 2.5 epochs. • OpenVINO export: FP32 1,586 MB → FP16 800 MB → INT8 409 MB (NNCF). The full flow-matching loop is inside the IR. • A torch-free closed-loop evaluator run on Intel's bare-metal Core Ultra X7 358H: FP16 on CPU 1,991 ms, on the Arc B390 iGPU 124.6 ms per 50-step action chunk — 8× real time, 16× faster than CPU. INT8 is 35% slower on CPU (dequantisation cost); the NPU compiler rejected the dynamic-shape graph. Results, stated plainly: both runs score 0/20 closed-loop. Best cup-to-plate error 105 mm (run 1) and 96 mm (run 3). Replaying training observations through the IR gives 0.66–0.85 correlation, so the pipeline is correct and the shortfall is structural to the imitation budget, not undertraining. We would rather submit a measured 0/20 with the cause isolated than an unmeasured claim. Every number has an evidence file in the repo. Limitations: simulation only; fixed cup size; NPU unexercised.

Team 2: Lego anomaly detection demo

Uses 3 ACT (original spot to front of camera, front of camera to red box, front of camera to blue box) models and Anomalib (anomaly detection) based python in condition to route policies. Uses intel physical ai studio to power ACT. Created datasets for 3 ACT models. We had 3 cameras, one on wrist, 2 fixed, one in front (anomaly detection), one on top to guide movement. We used SO101 with physical AI studio Calibrated the leader follower. Calibrated the leader follower. Calibrated the leader follower. Calibrated the leader follower. Calibrated the leader follower. Calibrated the leader follower. Calibrated the leader follower. Calibrated the leader follower.