At ROSCon 2026 in Toronto on September 22, 2026, Alphabet's industrial robotics unit Intrinsic released Intrinsic Core, a hardware-agnostic open-source robotics stack for industrial automation, under an Apache 2.0 license. The repo at github.com/intrinsic-ai/intrinsic-core bundles a local runtime, an SDK, and a real-time control framework for industrial robotics - and, per Intrinsic's own announcement, the same capabilities the company says it runs day to day in real manufacturing deployments. That production claim is the vendor's, and we will label it as such below. So what is actually in the repo? A containerized runtime on k3s, the ICON real-time control engine, motion and grasp planning, perception with NVIDIA FoundationPose 6-DoF pose estimation built in, local ML inference, Gazebo-based simulation, preconfigured ROS 2 drivers - plus a complete CNC machine-tending reference application, the Open Machine Tending Solution. What stays paid: Flowstate, the advanced AI models, and the industrial cloud services.
In short:
- What it is: an Apache 2.0 open-source industrial-manipulation stack from Alphabet's Intrinsic, announced September 22 at ROSCon 2026 in Toronto.
- What ships: a k3s-based runtime, the ICON real-time control engine with a hardware-agnostic abstraction layer, motion planning, perception with out-of-the-box FoundationPose 6-DoF pose estimation, local ML inference via Triton, Gazebo simulation, and preconfigured ROS 2 drivers.
- What is not free: Intrinsic Flowstate, the advanced AI models, and the industrial-grade cloud services remain commercial.
- Cost to try: Ubuntu 24.04 or 26.04 (the docs disagree - see below), ROS 2 Lyrical Luth, Bazel, k3s, and an NVIDIA RTX 3060/4060 or better for perception workloads. No ARM support. Expect roughly a 50-minute first build.
- Who should care: ROS-literate developers doing arm-based manipulation. Not mobile robots, not humanoids - that is the CTO's own stated scope.
What Actually Ships in the Repo, Module by Module
Reading the repo directly, it is organized as a small set of focused modules rather than one monolith. Here is what each one does, in developer terms:
- intrinsic_runtime - a pre-configured local execution engine, packaged as a native k3s containerized environment. It manages process life cycles, event scheduling, and application state synchronization on top of ROS 2, the de facto open-source robotics middleware. In practice, this is what saves you from hand-wiring a Kubernetes setup around your robot software.
- intrinsic_control (ICON) - the real-time motion and hardware coordination engine. Its control loop is deterministic and can switch controllers within a single cycle based on live sensor feedback. It ships with a standardized Hardware Abstraction Layer, so arms, grippers, and fieldbus I/O can be swapped without driver rewrites or hardware lock-in.
- intrinsic_motion_planning - collision-free path generation with high-throughput constraint solving across Cartesian tasks and wide-envelope C-space movements, exposed through a unified API. It enforces kinematic and workspace limits and supports heterogeneous motion blending.
- intrinsic_perception - the sensor processing and visual understanding layer. It standardizes camera and point-cloud interfaces and embeds out-of-the-box support for NVIDIA FoundationPose, giving you 6-DoF pose estimation of 3D parts without writing custom perception pipeline wrappers.
- intrinsic_inference - the local ML execution engine. It handles the hardware plumbing and model serving infrastructure (the Getting Started guide references Triton) and streams poses and detections into the planning and control loops through standardized APIs.
Beyond the five core modules, the release also includes grasp planning, Gazebo-powered simulation services, camera calibration, and preconfigured Intrinsic-ROS drivers for supported robots, grippers, and 3D cameras.
If you have built a manipulation stack by hand before, the pattern here is familiar: Intrinsic Core is not inventing new robotics science so much as shipping a coherent, pre-assembled version of the plumbing most teams rebuild from scratch - the runtime, the real-time layer, the perception-to-planning glue - under one API surface.
Is It Really the Same Stack Intrinsic Runs in Production?
That claim - "the same capabilities and services that Intrinsic uses day to day for real manufacturing deployments" - comes from Intrinsic's own announcement, so treat it as a vendor statement rather than an independently verified fact. The most direct elaboration comes from CTO Brian Gerkey (co-founder and board chair of Open Robotics), who told The Robot Report: "This is not us coming by and dropping off some code and saying, 'Have fun.' What we're sharing this week is the core of our own software stack, this is a thing that we're also depending on."
Two more voices frame the release. Geoffrey Biggs, CTO of the Open Source Robotics Foundation, called it "both the first step and a demonstration of where I think robotics is going to go," predicting robots will become much easier to produce on platforms like this - an opinion, not a fact. And Forbes ran the story under an "Android of robotics" headline, framing the giveaway as an ecosystem play; that article is paywalled, so only the framing is usable, not any of its specifics.
Gerkey also described the runtime approach plainly: "We're bringing in standard Linux containerization combined with Kubernetes to allow you to basically bring that together in a way that fits naturally with your ROS workflows." That matches what the repo actually does with k3s.
What It Takes to Run It: Prerequisites and Setup Cost
Short version: expect to provision Ubuntu 26.04, ROS 2 Lyrical Luth, Bazel, k3s, and - for perception - a dedicated NVIDIA RTX 3060/4060 or better. There is no ARM support. Here is the honest setup bill, straight from the repo's README and Getting Started guide:
- OS: the README lists Ubuntu 24.04 LTS (Noble) or Ubuntu 26.04 LTS, with Ubuntu 22.04 LTS also supported. But the Getting Started tutorial states that "Intrinsic Core requires Ubuntu 26.04." The two primary docs genuinely disagree. For a first install, follow the Getting Started guide and start from Ubuntu 26.04.
- ROS 2: the distribution you need is ROS 2 Lyrical Luth.
- Build system: Bazel, pulled in via Bazelisk.
- Runtime: k3s, a lightweight Kubernetes distribution, deployed through the provided setup_k3s.sh script. GPU support for perception needs one extra k3s configuration step.
- GPU: integrated graphics are fine for simulation only. ML and vision workloads require a dedicated NVIDIA RTX 3060/4060 or better, and running the full machine-tending app in simulation with perception requires that dedicated GPU. ARM architectures are strictly unsupported; AMD CPUs are fine for simulation-only setups.
- Extras: the GitHub CLI (gh auth login) for pulling assets, and patience - the first build of the reference application takes roughly 50 minutes because it compiles Gazebo and computational geometry libraries from source.
That last point deserves emphasis: this is a heavyweight industrial stack, not a pip install. The requirements are demanding because the software is doing real-time control and GPU-accelerated vision in the same process tree. If you have thought about how GPU memory gets partitioned when a model server and a control loop share one card, the same arithmetic applies here - and it is the same kind of math that governs how LLM KV cache eats VRAM on inference boxes.
What the Open Machine Tending Solution Gives You Out of the Box
The Open Machine Tending Solution is where the stack stops being modules and becomes a working cell. The OMTS repo (also Apache 2.0) is the proof that Intrinsic Core is meant for real work and not just demos. It is an open-source reference application for automated CNC machine tending, built on Intrinsic Core, and it runs both on Intrinsic Core and on the Open Robotics Suite.
What ships in it:
- Preconfigured assets, skills, and a native digital twin, so you can simulate the full cell before touching hardware.
- Skills that map to the core modules: move_robot (constraint-aware motion planning with real-time control and collision-free paths), move_to_contact (real-time force/torque feedback and compliant motion), estimate_pose (GPU-accelerated 6-DoF pose estimation via FoundationPose), and dio_set_output (digital I/O for actuating a CNC door or vise).
- A clean architecture: behavior-tree orchestration via the Solution Building Library, a skills and services layer, and unified hardware adapters for Robot, Gripper, Machine, and VisionSensor interfaces. FoundationPose is packaged as an MlModelAsset served through Triton.
Customization covers hardware from FANUC and Universal Robots, which means a shop with those arms can adapt the reference design rather than start from zero. The skill-based structure is also the most interesting part for a software-minded reader: it is a composition model, closer to the way agent builders chain tools than to the monolithic robot programs of the last decade - a distinction worth holding in mind when weighing AI agents against classic automation.
Where the Free Stack Ends: Open vs Paid, and Who This Is For
The open-vs-paid boundary is clean, at least on paper. Everything above - the runtime, ICON, motion and grasp planning, perception with the FoundationPose integration, the inference service, simulation, calibration, drivers, and the OMTS reference design - is Apache 2.0. What is not in the repo: Intrinsic Flowstate, the advanced AI models, and the industrial-grade cloud services. Intrinsic's announcement says solutions built with Core "work natively across all Intrinsic offerings," so no refactoring is needed when you move between the free and paid sides - a capability assertion from the vendor, worth treating as reported rather than proven.
Intrinsic's own guest framing elsewhere is blunt about limits: the open-source environment "is not intended to replace the engineering required for production," and the enterprise tier is an optional path. On scope, Gerkey is equally direct: the ideal user is someone already familiar with ROS doing manipulation-based work, and Intrinsic Core supports robotic arms only - no mobile robots, no humanoids. In other words, this is an industrial robotics open source release aimed at people who can read a Bazel file, not at factory owners browsing for turnkey packages.
One context note for the AI-agent crowd: there is no confirmed Gemini Robotics integration here. DeepMind's robotics models are a separate product line, and any LLM-agent connection to Intrinsic Core is adjacent-Google-ecosystem speculation, not a shipped feature. The confirmed AI link is on the NVIDIA side - FoundationPose for pose estimation. That is the physical AI story here so far: perception that grounds the stack in real workpieces, not language agents. For teams whose day job is running model-serving infrastructure, the local-inference-plus-k3s pattern here will feel familiar from LLMops setups: same containerization instincts, different payloads.
Finally, scale. Intrinsic's announcement reports "overwhelming interest from 5,000+ developers and roboticists across 115 countries" in its AI for Industry Challenge - vendor-reported figures, but a real signal of demand. And the company cites a statistic, relayed via SiliconANGLE, that only 8% of fabrication shops in the US and Europe employ any automation, due to cost and technical barriers. If open infrastructure genuinely lowers that barrier, the number to watch is not the repo's star count - it is how many of those shops ever get past the 50-minute build. That adoption number is the real scoreboard for Google's open-source robotics stack.
What to do next
If robots interest you, the best move is free: clone the Intrinsic Core repo, spin up the simulator, and run the CNC tending sample app end to end. You will learn more in one weekend of hands-on time than from any whitepaper. If you build something real with it, share it, because this stack is new and the community is still small.
You can explore the tools in this article, and hundreds more, on Toolbit.ai. We follow the industrial AI space on this blog every week.
