OpenVINO

OpenVINO (Open Visual Inference and Neural Network Optimization) is Intel's open-source toolkit for accelerating deep learning inference. First released on May 16, 2018, it takes trained models from popular frameworks and compiles them to run efficiently across Intel CPUs, integrated and discrete GPUs, and NPUs, without requiring developers to rewrite their models for each target device.

General
Release date	May 16, 2018 (initial release)
Developer	Intel Corporation
Type	Open-source inference optimization toolkit
License	Apache License 2.0
GitHub	openvinotoolkit/openvino
Documentation	OpenVINO for AI PC

Core Features

Framework interoperability — imports models trained in PyTorch, TensorFlow, ONNX, Keras, PaddlePaddle, and JAX/Flax without manual conversion.
Heterogeneous execution — runs the same compiled model across Intel CPUs, GPUs, and NPUs, letting the runtime pick the most efficient device.
Generative AI support — the OpenVINO GenAI repository and OpenVINO Tokenizers add pipelines for running LLMs and diffusion models on Intel hardware.
Quantization and compression — the Neural Network Compression Framework (NNCF) applies quantization, pruning, and sparsity to shrink models for edge deployment.
Model serving — OpenVINO Model Server (OVMS) exposes optimized models as a scalable inference service.

Tools and Resources

Optimum Intel — integrates OpenVINO with the Hugging Face API for direct model loading and optimization.
OpenVINO Physical AI for Robotics — extends OpenVINO to robot-policy deployment as part of Intel's Robotics AI Suite.
GitHub repository — github.com/openvinotoolkit/openvino.

Ecosystem and Integrations

Used as the deployment layer in Intel's Physical AI Studio VLA workflow, optimizing trained policies for Intel Core Ultra processors.
Runs across Intel's AI PC lineup (Core Ultra) as well as Xeon servers and Intel Tiber AI Cloud instances.

Start with the OpenVINO GitHub repository or the AI PC developer guide to install the toolkit and run a first inference pipeline.

Craft.ai – Agentic AI App Builder

Craft.ai is an agentic AI app builder that transforms natural-language ideas into functional Python applications and installable Android APKs. Powered by AMD Token Factory, Craft.ai uses AI-driven reasoning to understand requirements, create development plans, generate code, diagnose errors, and iteratively improve applications. Unlike conventional AI app builders that primarily produce web applications, Craft.ai integrates with AnvPy, a Python development and execution environment designed for Android. AnvPy enables supported Python applications to run directly on mobile devices using a local CPython runtime, reducing the need for dedicated application servers for on-device functionality. The platform combines Python's flexibility with native Android capabilities, enabling access to Android APIs and integrations such as Google services and AdMob. It also supports a broad ecosystem of Python libraries, including OpenCV, NumPy, Pandas, and compatible machine-learning packages, opening possibilities for mobile AI, computer vision, data processing, and automation. Craft.ai connects AI-assisted development with the application build process, helping users move from an idea to generated code, debugging, and APK packaging. Rather than stopping at code snippets or browser previews, it aims to deliver installable applications that can use device capabilities beyond the browser. Our vision is to make mobile software development more accessible by combining AMD Token Factory's AI capabilities with Python and AnvPy's native Android execution environment. Craft.ai aims to empower developers and creators to build sophisticated mobile applications through natural language, with greater flexibility, local execution, and access to the Android ecosystem.

EdgeGate — Evidence-Gated Physical AI

EdgeGate is an evidence-gated runtime authorization layer for Physical AI. It addresses a critical deployment problem: perception systems can produce stale, drifting, obstructed, or unsafe observations while downstream AI systems may still attempt to act on them. EdgeGate places a deterministic authorization layer between perception and physical action. Every proposed action is evaluated against runtime evidence including perception confidence, scene freshness, spatial clearance, environmental drift, and restricted-zone constraints. The system produces an explicit runtime decision: PROMOTE, ROLLBACK, or REJECT. Instead of treating model output as automatically executable, EdgeGate requires the proposal to satisfy safety gates before authorization. The prototype includes replayable safety scenarios demonstrating how the same policy responds to fresh perception, stale state, drift, and restricted-zone violations. Each decision generates an evidence ledger containing the observed telemetry, gate results, reasons, and final authorization decision. OpenVINO provides the local CPU edge inference path, while the policy engine remains deterministic and auditable. This architecture is designed for low-latency edge deployment where connectivity, explainability, and predictable failure behavior matter. EdgeGate is a hackathon prototype using synthetic scene telemetry for deterministic policy demonstration. It does not directly control a physical robot and is not a safety certification.

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.

x-arm101

Two simulated SO-101 arms cooperate to set a dinner table in MuJoCo. One arm opens a drawer and retrieves cutlery, the arms perform a contact-based spoon hand-off, and a plate, cup, spoon and fork are placed on the table. Object poses, scene conditions and approach paths are randomized per seed, so each run requires the system to solve a slightly different task rather than replay a fixed trajectory. A cooperative scripted expert, built with inverse kinematics and contact-driven manipulation primitives, generates demonstrations for training. Across ten randomized evaluation seeds, the expert completes the full workflow with no monitored unintended collisions or numerical warnings. Demonstrations are exported as versioned LeRobot datasets and published as pinned Hugging Face releases for reproducibility. We fine-tuned SmolVLA on an Azure Tesla T4. The final multi-task dinner model was trained for up to 5,600 steps and early-stopped at the best validation checkpoint, step 4,749, with validation loss 0.0100. An earlier 20,000-step run on a 50-episode cup dataset established the training and evaluation pipeline. Policies are evaluated closed-loop on held-out seeds, with predicted actions validated before execution. Learned task success is not yet consistently reliable, and the scripted expert is used as the demonstration source and baseline rather than presented as the learned VLA. For Intel deployment, the fine-tuned policy exports to OpenVINO in FP16 and INT8 using static-shape prefix and denoise graphs. FP16 output differs from PyTorch by a maximum absolute action error of 0.00029, and the exported policy runs closed-loop in simulation. The pipeline supports CPU, iGPU and NPU benchmarking. Final Intel Core Ultra measurements are the remaining deployment step; current latency results are build-machine measurements only.

Bimanual SO-101: LLM-Planned Table Setting

We built an end-to-end perception-to-action pipeline for the Intel Bimanual VLA challenge: two SO-101 arms in MuJoCo open a drawer, retrieve a spoon and fork, hand the spoon from one arm to the other, place the plate and cutlery, and set the mug. Pipeline: (1) Understand - Qwen2.5-1.5B-Instruct quantized to INT4 and served with OpenVINO GenAI turns the instruction into a structured plan (items, arm assignment, handedness). A left-handed request mirrors the layout and changes which arm moves the mug. (2) Observe - an overhead camera feeds a small U-Net segmentation net exported to OpenVINO INT8 (about 2.3 ms per frame on CPU); object poses come from the camera, not simulator state. (3) Act - damped-least-squares IK skills coordinate both arms; the hand-off goes through a shared staging zone because two top-down SO-101 grippers cannot meet within 12 cm. Robustness: every seed randomizes object mass, friction, size, lighting, table colour and placement. Results: 10/10 tuning seeds, 10/10 hold-out seeds, 10/10 left-handed layout, all camera-driven and LLM-planned. The demo video shows the command, seed parameters, per-step placement error and final state for all 10 seeds. Honest scope: the planner and perception net are learned models; manipulation skills are scripted. Benchmarks so far are on a cloud Intel-compatible CPU (planner 2.8 s per plan, MuJoCo 20k steps/s); the bench script reports latency, throughput, device and precision per model and is ready to run on Core Ultra CPU/iGPU/NPU.