Product

The Agentic OS for Physical AI

One typed language for perception, motion, and data.
Browse it as skills, as an agent, or as the infrastructure underneath.

Explore the Stack

Overview

Every layer, one operating system.

Built for robotics engineering teams shipping real-world robots: Telekinesis is one Python library that unifies perception, reasoning, execution, and the data that trains all three, so a natural-language prompt becomes a program you can read, review, and deploy on hardware.

Applications

Bin Picking

Pick & Place

Palletizing

Assembly

Machine Tending

Sorting

Packaging

Material Handling

Architecture

The Agentic OS for Physical AI

A full-stack, standardized operating system that turns any robot into an intelligent machine.

Read the Docs

AgentA VLM/LLM system that uses Code-as-Policy to turn a natural-language prompt into an executable robot program.
SkillsModular Physical AI capabilities for robotic perception, motion, and planning.
Data EngineData infrastructure for structuring and generating high-quality data for Physical AI training.
Hardware Abstraction LayerUltra-fast robotics communication framework (BabyROS) for cloud-to-robot connectivity.

Robotic Arm
Mobile Robot
Humanoid

Any Robot, Any Form Factor

Skills

Modular building blocks for perception, motion, and planning.

250+ production-grade Skills across four areas: strongly typed Python functions that compose into everything an Agent writes.

Vision AI

2D and 3D perception: detection, segmentation, point clouds, and the geometric operations you compose around them.

Classical Robotics

Cartesian and joint-space motion, kinematics, force and servo control, and full state readback, across every major robot brand.

VLAs & World Action Models

Learned, end-to-end policies and world-model-based behaviors for manipulation and locomotion, trained and deployed like any other Skill.

Reinforcement Learning

Sim-to-sim and sim-to-real policy training and tuning, across Gymnasium, mjlab, and Isaac Lab.

Agent

Code-as-Policy.

A VLM/LLM-powered Physical AI Agent that turns a natural-language prompt into a runnable, auditable robot program by composing Skills under the Code-as-Policy paradigm.

Data Engine

Every deployment makes the next Skill smarter.

Standardized data types, synthetic data generation, and continuous logging that closes the loop between training and deployment. The robots you ship today generate the data that improves the robots you ship next.

Synthetic DataSkill TrainingDeploymentData Collection

Communication

One publish/subscribe layer, cloud to robot.

BabyROS gives Skills and Agents ultra-low-latency pub/sub and client/server messaging, with ROS-style ergonomics from one pip install, cloud to device over Zenoh.

PublisherSubscriberSubscriberSubscriber

Start Building

Running in five minutes, no hardware required.

Install the SDK, drop in an API key, and run a pre-built example that visualizes robot motion in software, before you ever point it at a real arm.

Get Started

pip install telekinesis-ai
export TELEKINESIS_API_KEY="..."
# run a pre-built example, no hardware required

Agents

The intelligence layer of the OS.

A VLM/LLM-powered Physical AI Agent that turns a natural-language prompt into a runnable, auditable robot program by composing Skills under the Code-as-Policy paradigm.

Input

A natural-language prompt plus the robot’s camera view.

Reasoning

The model composes the task from 250+ existing Skills, generating new ones only where the task actually needs them.

Output

Production-grade robot program in readable and executable Python. Nothing runs on hardware until an engineer has read and approved it.

Prompt

Pick up the aluminum parts from the angled tray and place them in the box in a grid format

Robot View

Physical AI Agent

Reasoning

VLM / LLM

Skill Library

250+ Skills

New Skills

Generated Skills

Code-as-Policy

pick_and_place.py

from telekinesis import cornea
from telekinesis.synapse import robot, gripper

# Perceive: segment the target part
mask = cornea.segment_image_using_sam(image, color="red")
pose = estimate_pose_from_mask(mask, intrinsics)

# Act: pick and place by composing Skills
robot.set_cartesian_pose(pose, speed=0.25)
gripper.close(force=50.0)
robot.set_cartesian_pose(place_pose, speed=0.25)
gripper.open()

The model never touches the robot directly. It writes a typed program out of the same Skills in the catalogue, so every action it takes is something you can read, diff, and replay before it runs on hardware.

Why Code-as-Policy

A policy you can read, not a black box you have to trust.

VLAs and world models hide behavior inside network weights no engineer can inspect. Our Agents write it as an ordinary program instead: version it, review the diff, roll back a regression. Manufacturing, logistics, and aerospace demand systems you can verify, not something that worked once in a demo.

End-to-End PolicyVLA / World Model

“Pick up the part”

VLA / World Modelreasons, then writes actions

Policy of Actions

Risky to deploy: can’t audit or debug

Code-as-PolicyTelekinesis Agent

“Pick up the part”

VLM / LLMreasons, then writes code

Policy as Code

Safe to deploy: auditable and debuggable

Advantages

Weeks to retrain vs minutes to reprompt.

An end-to-end policy means weeks of data collection to learn a new task, and a retrain-and-hope cycle every time it fails. A Code-as-Policy Agent gets there with a prompt, a line-edit, and a Skill you can reuse on the next robot. Plus it gets better every time you add one.

Category	End-to-End Policy	Code-as-Policy Agent
Output	A stream of low-level actions	A human-readable program
Auditable	No, the weights are opaque	Yes, code review applies
Fix a failure	Retrain the model	Edit the code directly
Data needed	Large, task-specific datasets	A pretrained model + existing Skills

Benchmarks

State-of-the-art, not just production-ready.

On LIBERO-PRO, the standard Physical AI benchmark, our Code-as-Policy agent outperforms every leading published VLA model, both zero-shot and fine-tuned, across object, spatial, and goal-conditioned tasks.

LIBERO-OBJECT

Telekinesis Agent (fine-tuned)
100 percent success rate
Telekinesis Agent (zero-shot)
79 percent success rate
Cap-X - Nvidia, UC Berkeley, Stanford
22 percent success rate
Pi0.5 - Physical Intelligence
20 percent success rate
UniVLA - Chinese Academy of Sciences
0 percent success rate
Pi0 - Physical Intelligence
0 percent success rate
OpenVLA - Stanford, UC Berkeley, DeepMind
0 percent success rate

LIBERO-SPATIAL

Telekinesis Agent (fine-tuned)
63 percent success rate
Telekinesis Agent (zero-shot)
36 percent success rate
Pi0.5 - Physical Intelligence
20 percent success rate
Cap-X - Nvidia, UC Berkeley, Stanford
12 percent success rate
UniVLA - Chinese Academy of Sciences
10 percent success rate
Pi0 - Physical Intelligence
0 percent success rate
OpenVLA - Stanford, UC Berkeley, DeepMind
0 percent success rate

LIBERO-GOAL

Telekinesis Agent (fine-tuned)
44 percent success rate
Telekinesis Agent (zero-shot)
43 percent success rate
Pi0.5 - Physical Intelligence
38 percent success rate
Cap-X - Nvidia, UC Berkeley, Stanford
26 percent success rate
UniVLA - Chinese Academy of Sciences
10 percent success rate
Pi0 - Physical Intelligence
0 percent success rate
OpenVLA - Stanford, UC Berkeley, DeepMind
0 percent success rate

Modes

Two ways to work, one agent underneath.

Tzara, our Physical AI Agent, adapts to how you build. Either refine interactively or generate straight to production.

Read the Docs

Chat

Interactive refinement and debugging of generated code, inside a native VS Code extension.

Best forExploring capabilities, debugging generated code, learning by example

Code Generation

Prompt straight to Python, built for pipelines rather than back-and-forth.

Best forQuick prototyping, batch code generation, CI/CD pipelines

Data Engine

The data infrastructure layer of the OS.

Standardized data types, synthetic data generation, and continuous logging that closes the loop between training and deployment.

Overview

The robots you ship today train the robots you ship tomorrow.

Synthetic data bootstraps a new Skill before any real robot has run it. That Skill deploys to production, every run it makes is captured back into the same standardized datatypes, and that data trains the next version of the Skill, with each pass around the loop compounding on the last.

The more robots run a Skill, the faster it improves, and the faster the next deployment ships.

Synthetic Data

Skill Training

Training Loss

Deployment

Data Collection

Synthetic Data Generation

Photorealistic data, without a robot in the loop.

The Data Engine generates photorealistic, perfectly labeled synthetic datasets at scale, with no manual collection or annotation. Extreme Domain Randomization (EDR) aggressively varies lighting, texture, geometry, material, and pose, forcing a Skill to learn what is actually invariant about a task before it ever sees a real robot.

Randomized on every render

Lighting
Texture
Geometry
Material
Pose

Data Logging and Continual Learning

Every run is captured, and every capture is training data.

Every Skill run in production is captured through the same standardized types: typed inputs and outputs, sensor streams, transforms, trajectories, and outcomes. Contract-shaped data flows straight into training, the resulting Skills redeploy, and each run becomes the training set for the next: continual learning, not a one-time export.

Live Feed

Detection
Logger

Dataset

📁 images/0

train/

val/

test/

📁 labels/

📄 data.yaml

80%10%10%

Datatypes as Contracts

A typed contract for every signal.

Every signal exchanged between a Skill, an Agent, and the Data Engine moves through a strongly typed contract. Because the shape is known up front, the Data Engine can fix it, turning asynchronous, mismatched-rate robot data into the synchronous, aligned, fixed-size batches training actually expects.

Category	Without Datatypes	With Datatypes
Shape	Asynchronous, mismatched-rate signals	Synchronous, aligned, fixed-size batches
Integration	Hand-written glue code per dataset	One typed contract, enforced everywhere

Read the Docs

105 of 105 results

Synthetic Datasets

SYNTHETIC DATA

Bin Picking: Hinge 09

Instance Segmentation • 10,000 images of photorealistic synthetic data, generated with Extreme Domain Randomization (EDR) for sim-to-real transfer. Free on Kaggle.

View docs →

SYNTHETIC DATA

Bin Picking: Rod End 01

Instance Segmentation • 7,000 images of photorealistic synthetic data, generated with Extreme Domain Randomization (EDR) for sim-to-real transfer. Free on Kaggle.

View docs →

SYNTHETIC DATA

Bin Picking: Pistons

Instance Segmentation • 7,000 images of photorealistic synthetic data, generated with Extreme Domain Randomization (EDR) for sim-to-real transfer. Free on Kaggle.

View docs →

SYNTHETIC DATA

Bin Picking: Flange 4 Holes

Instance Segmentation • 9,000 images of photorealistic synthetic data, generated with Extreme Domain Randomization (EDR) for sim-to-real transfer. Free on Kaggle.

View docs →

SYNTHETIC DATA

Bin Picking: Gear Wheel 20 Teeth

Instance Segmentation • 10,000 images of photorealistic synthetic data, generated with Extreme Domain Randomization (EDR) for sim-to-real transfer. Free on Kaggle.

View docs →

SYNTHETIC DATA

Bin Picking: Bracket 01

Instance Segmentation • 10,000 images of photorealistic synthetic data, generated with Extreme Domain Randomization (EDR) for sim-to-real transfer. Free on Kaggle.

View docs →

SYNTHETIC DATA

Bin Picking: Bracket 02

Instance Segmentation • 12,000 images of photorealistic synthetic data, generated with Extreme Domain Randomization (EDR) for sim-to-real transfer. Free on Kaggle.

View docs →