Everything included in Kite.

Before Kite, engineers wire together MuJoCo or Isaac for simulation, write custom scripts for synthetic data, provision cloud GPUs by hand, maintain URDFs across repos, and re-implement glue code for every new robot. A new team typically takes weeks to reach the first meaningful training run.

With Kite, you open the IDE, pick a robot, describe the environment, and run a policy. Everything underneath — sim backends, controllers, sensors, datasets, and compute — is already wired and validated. Sim-to-real compatibility is baked into the project layout rather than bolted on afterwards.

Unitree G1 (humanoid), Unitree Go2 (quadruped), Boston Dynamics Spot, and the SO-100 arm come preloaded with validated URDFs, collision meshes, actuator models, and reference controllers. Switch between them from the IDE's robot picker without modifying project code.

Drop a custom URDF (single file or zipped package with meshes) into the project. Kite parses joints, links, transmissions, and sensors; validates the kinematic chain; surfaces physical inconsistencies; and rebuilds the simulation scene automatically.

The agent reads your project files, URDF, sim config, and run logs. It proposes code edits, generates reward functions, fixes observation and action spaces, and explains why a training run is diverging — with references to the exact file and line.

A fast coding agent ships on the Free plan for single-file assistance. The Pro plan unlocks a deeper agent with multi-file refactors, longer context, and access to training-run telemetry as a first-class tool.

Describe an environment — warehouse with mixed-height shelving, cluttered domestic kitchen — and Kite produces a Gaussian-splat plus mesh representation with collision geometry. Seeds are preserved so a training run can be reproduced from the prompt alone.

Vary lighting, clutter density, surface materials, and layout per episode to avoid overfitting. Each variation is deterministic given its seed, which keeps evaluation runs reproducible.

Upload an image, click the object you want, and Kite runs SAM 3D to produce a clean mesh with estimated geometry and textures. The result is tagged with a material model and ready to drop into a world.

Generated assets come with inertia estimates, collision primitives, and contact-friendly meshes so they behave predictably in MuJoCo. Batch generation is supported for data-augmentation workflows.

The current registry includes Physical Intelligence π0 and π0-FAST, with additional members of the π-series onboarded as they are released.

Point a training job at a Kite dataset, pick a base checkpoint, and launch. Kite manages image, state, and action normalization, PEFT adapters, and evaluation replay against the sim you trained on.

An evaluation run rolls one policy out across N randomized sim episodes in parallel on GPU MuJoCo (MJX). Each episode is scored into a labelled outcome — success, or a failure mode (object dropped, timeout, not placed, not reached) — and the dashboard aggregates the fleet into a success rate, a failure-mode histogram, and a tile grid that flips between pass and fail as outcomes land, each with a playable rollout video.

Choose the scene from one of your projects, or from a built-in benchmark-environment catalog (e.g. SO-Arm Pick & Place, SO-Arm Reach) so you can evaluate a policy with no project setup at all. ACT, π-series, smolVLA, and reinforcement-learning policies are all supported.

Augmentation is a standalone, in-memory flow: import a dataset, preview a few episodes, approve, and the pipeline generates visually-varied episodes with Google's Gemini models while preserving each episode's motion. The joint/action trajectory is carried over from the source so the new episodes stay physically consistent, with an optional Claude vision pass for object-changing edits.

Nothing is stored on Kite's servers — you review the generated episodes and push the result to HuggingFace under your account using a write token you connect in Settings → Integrations. The pipeline is provider-pluggable (mock for offline dev, per-frame image editing, Veo, and Gemini Omni via the Vertex Agent Platform).

MuJoCo provides articulated dynamics, soft contacts, sensors, and deterministic rollout. Kite's adapter exposes the state as structured observations and wires your robot's URDF into the scene graph automatically.

Kimodo handles mocap retargeting, joint-space motion blending, and quaternion-safe transform composition. It bridges captured or synthesized motions into the simulator without the usual coordinate-system breakage.

Kimodo sits between your task definition and the simulator. It generates joint-space motions from high-level task primitives, retargets them onto the target robot's kinematic topology, and preserves quaternion-safe transforms across coordinate frames — so the same task runs on a quadruped, an arm, or a humanoid without re-authoring per embodiment.

Each episode produces synchronized observations, proprioception, and actions in the Kite dataset format. Lighting, textures, friction, mass, sensor noise, and camera placement are randomized per episode; seeds are logged so any sample is reproducible. Datasets export directly to HuggingFace, LeRobot, and raw parquet for downstream training.

Training jobs run on Google Vertex AI custom jobs and Cloud Run GPU, with the same container image used locally. Kite mints short-lived tokens per job and streams logs back into the IDE.

Basic-plan workspaces get CPU processing — enough to run simulations, generate datasets, and train small policies. Upgrade to Pro to unlock GPU compute on demand: provisioned per-run with burst capacity during training spikes, then released. No rig to buy, cool, or maintain.