Ziva for Isaac Sim

AI for Isaac Sim that works inside the simulator

Ziva is an AI development agent for NVIDIA Isaac Sim. It reads the OpenUSD stage the way the viewport does, writes Python against the Isaac Sim API version you are actually pinned to, wires ROS 2 graphs and Replicator pipelines, and steps the simulation to check what it built.

Contact Enterprise

Built for Isaac Sim teams

AI Development Agent
OpenUSD and Isaac Lab aware
Runs headless on your cluster
SOC 2 compliant
Self-hosting

In the simulator

An agent that speaks OpenUSD, not just Python

Almost nothing about an Isaac Sim project is in the Python file. The robot is an articulation on a USD stage, the sensor rig is a prim graph, the ROS 2 publishers are OmniGraph nodes, and the thing that is wrong is usually a joint drive gain. An assistant that can only read text is guessing at all of it.

Reads the USD stage

Traverses the composed stage, resolves prims by path, type or API schema, and reads attribute values and transforms off them — instead of parsing a .usda layer and hoping composition resolved the way it looks.

Edits prims, layers and references

Creates and reparents prims, sets attributes, and authors into the layer you meant, so references, payloads and variant sets survive the edit rather than being flattened into it.

Writes Python against your pinned version

The Isaac Sim API was renamed wholesale between releases, and models trained on the old namespace confidently write code that no longer imports. The agent works against the version your project is pinned to and checks that the script actually runs.

Imports and tunes robots

URDF, MJCF and CAD imports turned into articulations that behave: joint drive stiffness and damping, collision approximations, mass properties, and the self-collision flags that decide whether the arm explodes on the first step.

Wires ROS 2 bridges

Action Graph nodes for publishers, subscribers, TF trees and the simulation clock, matched to the message types your stack already ships, so the sim talks to the same nodes your robot does.

Builds Replicator pipelines

Synthetic data generation with the randomizers, annotators and writers your training run needs — bounding boxes, segmentation, depth, poses — written out in the dataset format your pipeline already ingests.

Authors Isaac Lab environments

Observation, reward and termination terms, action spaces and curricula for a manager-based or direct RL environment, and the config plumbing that makes a new task runnable rather than a file that imports.

Reads the Kit log

Python tracebacks, extension load failures, PhysX warnings and USD composition errors land in the agent's context as they happen, so a broken stage is something it triages instead of something you paste.

Steps the sim and looks

Runs the scene headless, steps physics, and screenshots the viewport and the camera sensors — so a spawned robot that fell through the floor is caught by the agent rather than by you an hour later.

Domain randomization for sim-to-real

Lighting, textures, materials, physics parameters and sensor noise randomized across the ranges your hardware actually sees, because a policy that only works on the nominal scene does not transfer.

Sensor rigs that match the robot

RTX lidar, stereo and fisheye cameras, IMUs and contact sensors placed and calibrated against your real extrinsics, so what the policy trains on is what the robot will see.

Assembles digital twins

Warehouse, factory and lab scenes built from SimReady assets with the conveyors, racks and fixtures laid out to your floor plan, instead of a demo environment you then have to replace.

How an engagement works

Scoped with your team, not thrown over a wall

Ziva already ships as an in-editor agent for Godot and, in beta, for Unity. Isaac Sim support is delivered as an engagement, because what a robotics program needs is decided by your Isaac Sim version, your ROS 2 distribution and your training cluster — not by us.

We scope your stack

Isaac Sim and Isaac Lab versions, ROS 2 distribution, which robots you simulate, where training runs, and what your customer contracts allow to leave the building. That decides the shape of everything after it.

We bring what already works

The agent, its editor integration and the way it drives a running simulation already work in two engines. The Isaac Sim work is the tools your program needs, not building the agent over again.

We wire in your tooling

Your Nucleus server, asset library, experiment tracker, dataset store and internal CLIs become tools the agent can call, over MCP.

You deploy it where it is allowed to run

Vendor cloud, your own VPC, or hardware in the building with no egress. Dedicated inference capacity if your seat count needs it.

Robotics pipeline

Fits the pipeline your robots already train in

A robotics program is not one workstation running the GUI. It is a Nucleus server, a GPU cluster running headless jobs, gigabytes of synthetic data per run, and a policy that eventually has to work on real hardware. Any agent that ignores those is a demo.

Runs headless on your cluster

Point the agent at a batch job: sweep the randomization ranges, regenerate the dataset, run the regression scenes, and open the change with the results attached.

Nucleus and your asset library

The agent works against the assets your team already publishes rather than pulling a fresh copy of the sample library into every scene.

Your in-house tools, as agent tools

Any MCP server becomes something the agent can call — your experiment tracker, your dataset store, your fleet telemetry, the internal CLI only your team has.

Checkpoints and undo

Every agent turn is checkpointed in a project-scoped history separate from your VCS, so an experiment can be rewound without a revert that touches the team.

Your conventions, not generic Isaac

Briefed on your extension layout, naming rules and review standards, so the code it writes reads like the rest of your repository instead of like the sample scripts.

Ziva as an MCP server

Point Claude Code, Cursor or your own agents at Ziva and let them use the simulator tools from outside the GUI.

Versus a general AI coding assistant

Copilot cannot open your stage

Copilot, Cursor and a browser tab are strong at Python in a file. None of them can resolve a prim on the composed stage, see that the articulation root is on the wrong link, read the Kit log, or step the simulation. In a project where most of the state is USD, that is most of the project.

Capability	Copilot · Cursor · ChatGPT	Ziva for Isaac Sim
Writes Python from your codebase	strongest at this	plus stage context
Targets the Isaac Sim API you pinned	writes the renamed namespace	your version, then runs it
Reads prims and attributes on the stage	sees a USD layer, if anything	through the USD API
Tunes articulations and joint drives	no physics to observe	steps PhysX and measures
Reads the Kit log and PhysX warnings	you paste the traceback	as errors happen
Runs the scene to verify a fix	reads code and guesses	headless run, viewport capture
Self-hosted or air-gapped deployment	vendor cloud only	your VPC or your building

Ziva ships today as an in-editor agent for Godot and, in beta, for Unity. Isaac Sim capabilities are delivered per customer on an enterprise engagement and scoped with you before it starts — the agent, its editor integration and its ability to drive a running simulation already run in two engines.

Security and infrastructure

Run it the way your Isaac Sim team has to

Customer site data, robot designs under NDA and the policies you are about to ship decide where your source and your datasets are allowed to go. That is a deployment question, so we answer it with deployment options rather than a promise in a privacy policy.

Self-hosted and air-gapped

Run the agent and the models inside your own VPC, or on hardware in the building with no egress at all. Nothing leaves the network you control.

Dedicated inference hardware

Reserved GPU capacity for your studio instead of a shared queue, so a crunch week doesn't turn into rate limits for forty seats at once.

SOC 2 compliant

The controls your security review is going to ask about, with the answers ready before procurement opens the questionnaire.

Never trained on your code

Your project is never used to train a model, on any tier. Generated code and assets are your IP, and prompts are not retained for training by us or the providers we route to.

SSO, seats and spend caps

SAML sign-in, seat management, per-seat and per-team budgets, and an audit log of what the agent did — so finance and security both get a number they can hold.

Bring your own models

Route to Anthropic, OpenAI, Google or DeepSeek on your own keys and your own contracts, or to a model you host yourself. Ziva is the agent, not the only path to a model.

Read the evidence

What Ziva already does inside a 3D engine

Isaac Sim support is scoped with your team, so judge us on the engines where you can see the work today.

Ziva for Godot

The shipping product: an agent in the editor that reads the scene tree, edits nodes, writes code and debugs the running game.

Ziva for Unity

The second engine, in beta — scene hierarchy, prefabs, C#, the Console and the Test Framework, all from inside the editor.

The agent that plays a whole build and reports what broke

The verification loop this is built on: launch the build, send real input, and return a pass or fail backed by what it measured.

We benchmarked Claude Code in Unity on a real game

Four models, one build, measured on tool calls, wall time, cost and a rubric. How we judge a model before we put it in front of you.

AI for Isaac Sim, answered

Is there an AI for NVIDIA Isaac Sim?

Ziva brings an AI development agent to Isaac Sim teams through an enterprise engagement. The agent, its editor integration and its ability to drive a running simulation already ship in two engines — Godot publicly and Unity in beta — and the Isaac Sim surface is scoped with your team around the USD stage, Python extensions, robot imports, the ROS 2 bridge, Replicator and Isaac Lab.

Why does a general AI assistant struggle with Isaac Sim?

Two reasons. First, most of an Isaac Sim project is the OpenUSD stage rather than the Python file, and a file-based assistant cannot resolve a prim, read an attribute or see that the articulation root is on the wrong link. Second, the Isaac Sim API was renamed wholesale between releases, so a model writes the namespace it saw most in training and produces code that does not import on the version you are pinned to.

Can AI help with Isaac Lab reinforcement learning?

Yes, on the parts that are engineering rather than research. The agent writes observation, reward and termination terms, action spaces and curricula against your environment's config structure, sets up the domain randomization ranges, and runs the scene to confirm the environment steps before you spend cluster time on it. Deciding what the reward should be is still yours.

Can the agent generate synthetic training data?

Yes. It builds Replicator pipelines — randomizers, annotators and writers — so the dataset comes out with the bounding boxes, segmentation, depth or poses your training code expects, in the format it already ingests. It can also run the generation headless on your cluster and report what came out.

Does our simulation code and robot data leave our network?

Only if you allow it to. The agent runs on the developer's workstation, and only the context a turn needs is sent to the model you chose. Your project is never used to train a model. For teams under customer or defense NDAs, Ziva can run entirely inside your VPC or air-gapped on hardware you own, so nothing leaves your network at all.

Which Isaac Sim versions are supported?

Scoped per engagement, because the API rename between the 4.x and 5.x lines is exactly the thing the agent has to get right. Tell us the Isaac Sim and Isaac Lab versions your program is pinned to, and the ROS 2 distribution you bridge to, and we will scope against those rather than against the latest release.

How do we get Ziva for Isaac Sim?

Contact Ziva Enterprise. Tell us your Isaac Sim version, team size, which robots you simulate and where the agent is allowed to run, and we will come back with a plan covering the in-simulator agent, the headless pipeline work, and whether you want it self-hosted or on dedicated inference hardware.

Bring Ziva to your Isaac Sim team

Tell us your Isaac Sim version, team size, source control and where the agent is allowed to run. We come back with a plan built around it.

Talk to us about Isaac Sim