I am an engineer. I build developer platforms, ML infrastructure, and simulation pipelines for robotics. This map shows the territories of my work and how they connect.
Managed GPU workstation fleets for robotics development.
Robotics development needs serious hardware: GPUs for simulation and rendering, large storage for assets, and low-latency streaming to wherever the engineer sits.
I build platforms that give teams fleets of cloud desktops inside their own cloud accounts. Desktops stream to a browser or an IDE. Snapshots capture a machine and restore it anywhere. Credentials refresh themselves.
The interesting problems are operational: GPU capacity is scarce, desktops are stateful and personal, and an update must never destroy a week of work. I care about migrations that respect people's machines.
In 2026 I moved every user off a three-year-old desktop platform and shut it down on the announced day: 326 desktops to zero, nothing left running. Stopped desktops are patched offline, and a patch only commits once the GPU driver is verified to build against the new kernel; that check caught a no-display desktop on its first run.
Managed workflow orchestration, in production use across a portfolio of teams.
ML teams want to write a flow, deploy it, and trigger it. They do not want to operate a cluster, an authentication system, or a scheduler. I build the platform that owns those.
Recent work: self-service deployment under each user's own identity, and consumer-contract tests. The contract tests verify the interfaces customers depend on against every release candidate, so no release reaches a team until it passes the checks that team relies on.
Design work in flight: routing workloads to external compute, and fair-share scheduling across teams on shared GPU capacity.
CAD assemblies in, simulation-ready assets out.
Robots are designed in CAD. Simulators speak USD (OpenUSD, the 3D scene format). Between the two sits a pipeline: conversion, semantic grouping, mesh optimization, collision geometry, validation, and versioned publishing.
I work on that pipeline and lead its technical vision. A CAD assembly goes in; a standardized asset comes out. Any simulation team can consume it without manual cleanup.
Conversion fidelity is the hard part: physics material properties, kinematic structure, and joint naming. Render-comparison gates prove a converted asset still looks like its source.
Moving the converter inside the CAD tool made it 25 times faster; a 2,000-document assembly converts in about five hours. Automated checks reject a broken asset before it is published.
Versioned storage for simulation assets, built like git.
Simulation assets are large, deeply nested, and change one file at a time. The store records each version as content-addressed folder trees, the same idea git uses, so unchanged folders are shared across history and a lookup reads only the folders on its path.
That change halved the time to open a large scene for the first time (43 s to 20 s). Before switching it on, every existing repository was converted and compared against the old format: zero mismatches.
Assets resolve straight into simulators through a USD asset-resolver plugin, shipped prebuilt where the simulator's USD ABI allows it, so installing it needs no compiler.
Measuring the gap between simulation and reality.
A simulation is only useful if you know how far it is from reality. Sim-to-real gaps are usually investigated case by case; I build infrastructure that makes the validation repeatable and automatic.
Scientists validate policies with a copy-paste quickstart: no cluster setup, no infrastructure exposure. A checkpoint event triggers evaluation, and results return to the scientist.
The direction: validation as a gate in the development loop, not an afterthought. The gate runs on every commit to a robot-learning codebase; its first catch was a production robot model 140 mm out of position.
USD, Omniverse and Unreal, built the same way on every platform.
Simulators are only as usable as their install. I build the native layer around them: OpenUSD from source as one shared dependency, custom USD schemas with C++ and Python bindings, a mirror of upstream simulator packages so builds stop depending on external downloads, and Unreal Engine from source in a container.
The same tools ship on Linux, Windows and macOS. One Windows build went from about two hours to nine minutes, and the macOS download shrank by 92%.
On my own time I am building Loupe, a native macOS OpenUSD renderer with MaterialX and MDL. One dependency build produces both a Metal app and a WebGPU browser version, and correctness is checked by rendering randomized scenes against path-traced references.
Agent loops build and review this work.
Every change starts as a plan. I interview the plan until it is exact. An agent then implements it in loops: failing test, implementation, passing test, review.
Independent reviewers check each change: correctness, security, spec conformance, documentation, and user-facing behavior. Findings loop back until a review passes clean.
The method is packaged as portable skills that carry the process between machines and agents. This site is itself a product of those loops: two agents dogfooded every feature, one visual, one blind but geometric.
Where tests are not enough, I state invariants before code and prove them with model checkers. A Rust service carries 59 Kani proofs in its release build; they catch 20 of 21 deliberately seeded bugs and found a real overflow. Loupe's cache protocol is a C11 state machine whose nine invariants CBMC proves for every possible history, on every commit; the proofs found two production defects.
I write about this practice; the writing lands here as it grows.
Contact and elsewhere.
I work on robotics infrastructure at Amazon. Everything on this page is my own view, described at the altitude of a resume: what I build and how, never the internals.
The site grows over time: writing, projects, and experiments will land as new chapters. The map above is data-driven; growing the site means editing one file.
hello@suyashshetty.dev