canonical: https://jentic.com/apis/amazonaws.com/aws-robomaker

# AWS RoboMaker

Jentic publishes the only available OpenAPI specification for AWS RoboMaker, keeping it validated and agent-ready. AWS RoboMaker is a managed service for building, simulating, and deploying robotics applications at scale. It runs ROS-based simulation jobs in the cloud, generates synthetic worlds for training, manages over-the-air deployment of robot software to fleets, and tracks simulation batches so engineering teams can iterate on perception and navigation models without standing up their own GPU infrastructure.

## For AI agents

Run ROS simulation jobs, generate synthetic worlds, and deploy robotics applications to device fleets in the cloud.

## Scope

Does not train ML models, build simulator binaries, or run general-purpose IoT fleets - use for ROS robot simulation, synthetic world generation, and robot-application deployment only.

## Capabilities

- Launch and cancel ROS-based simulation jobs against custom robot and simulation applications
- Run batched simulation jobs to parallelise scenario testing with CreateSimulationJobBatch and CancelSimulationJobBatch
- Generate synthetic worlds and export them to S3 with CreateWorldGenerationJob and CreateWorldExportJob
- Register and inventory robots, fleets, robot applications, and simulation applications
- Deploy robot software over-the-air with CreateDeploymentJob and track per-robot deployment status
- Stream simulation logs and metrics by inspecting DescribeSimulationJob output and tagging assets for traceability

## Use cases

### Cloud-scale robot simulation testing

Robotics teams use AWS RoboMaker to run ROS simulation jobs in parallel against new perception and navigation code without provisioning local GPU clusters. CreateSimulationJob spins up a Gazebo or other simulator with the team's robot application and a chosen world; CreateSimulationJobBatch fans the same scenario across many parameter variations so regression tests finish in minutes, not hours.

Example prompt: Call CreateSimulationJobBatch with 30 simulation requests covering varied lighting and obstacle layouts for the same robot application, then poll DescribeSimulationJobBatch until all complete.

### Synthetic world generation for ML training

Perception teams use CreateWorldGenerationJob to produce thousands of procedurally varied indoor environments, then export them with CreateWorldExportJob to S3 for downstream training of object-detection and SLAM models. RoboMaker handles the variation parameters and storage, freeing engineers from running their own world-generation pipeline.

Example prompt: Submit CreateWorldGenerationJob with a worldCount of 500 against a residential template, then call CreateWorldExportJob to push the resulting worlds to s3://my-training-data/worlds/.

### Over-the-air robot fleet deployment

Operations teams use the deployment APIs to push new robot software versions to fleets in production. CreateDeploymentJob targets a fleet, applies a deployment configuration, and tracks per-robot rollout status, so a release engineer can confirm the version is live on every device without writing custom orchestration. RegisterRobot and DeregisterRobot keep the fleet inventory current.

Example prompt: Call CreateDeploymentJob targeting fleet arn:aws:robomaker:::fleet/prod-warehouse with a new robot application version, then poll DescribeDeploymentJob until all robots report SUCCEEDED.

### Agent-driven simulation workflow through Jentic

AI agents that orchestrate end-to-end robot release pipelines use Jentic to call CreateSimulationJob, DescribeSimulationJob, and CreateDeploymentJob without holding raw AWS credentials. Jentic stores the agent's keys in your Jentic One instance, signs each request with SigV4, and returns the structured response so the agent can branch on simulation outcome before triggering deployment.

Example prompt: Search Jentic for 'launch a RoboMaker simulation job', load CreateSimulationJob, execute against the navigation_test simulation application, and on SUCCEEDED status trigger CreateDeploymentJob to the staging fleet.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | /createSimulationJob | Launch a ROS simulation job |
| POST | /createSimulationJobBatch | Launch a batch of simulation jobs |
| POST | /cancelSimulationJob | Cancel a running simulation job |
| POST | /createWorldGenerationJob | Generate synthetic worlds for training and simulation |
| POST | /createWorldExportJob | Export generated worlds to S3 |
| POST | /createDeploymentJob | Deploy a robot application version to a fleet |
| POST | /createFleet | Create a fleet for grouping robots |
| POST | /createRobot | Register a robot |

## Key resources

- **SimulationJob** — A single ROS simulation run combining a robot application, simulation application, and world
- **SimulationJobBatch** — A batch of related simulation jobs run in parallel
- **RobotApplication** — Versioned robot-side software bundle for deployment and simulation
- **SimulationApplication** — Versioned simulator-side software bundle
- **Fleet** — A logical grouping of registered robots that share deployments
- **DeploymentJob** — A rollout of a robot application version to a fleet
- **World / WorldGenerationJob** — Procedurally generated 3D environments for simulation and training

## Why Jentic

- **Setup:** Wiring RoboMaker by hand means computing SigV4 HMAC signatures per request, routing to the correct regional robomaker host, plumbing IAM roles, and packaging simulation and robot applications yourself. Through Jentic you install once, import AWS RoboMaker from the API Directory, store your AWS access keys once, and your agent calls it with signing done per request.
- **Permission scoping:** Job, fleet, and robot definitions travel in the request body rather than the URL path, so you limit the agent to the operations it needs, such as CreateSimulationJob and CreateWorldGenerationJob. Operations like CancelSimulationJob or deleting a fleet are included only when you grant them.
- **Credential handling:** Your AWS access keys are stored once, encrypted, by your own Jentic One instance and used to produce a SigV4 signature per request. The raw secret access key never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'launch a robot simulation job', and Jentic returns CreateSimulationJob with its input schema so the agent supplies the right roleArn, maxDuration, and simulation application settings without browsing the reference docs.

## Related APIs

- **Amazon SageMaker** — Train ML models on the synthetic data RoboMaker generates
- **AWS IoT SiteWise** — Ingest telemetry from deployed robots once they are operating in the field
- **AWS IoT Greengrass** — Edge runtime and fleet deployment for general IoT - more general than RoboMaker's robot-specific deployment

## FAQ

### Why is there no official OpenAPI spec for AWS RoboMaker?

AWS does not publish an OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call AWS RoboMaker via structured tooling. It is validated against the live API and kept up to date. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the AWS RoboMaker API use?

AWS RoboMaker uses AWS Signature Version 4 HMAC signing with an access key ID and secret access key, optionally with a session token. Through Jentic, those credentials live in your Jentic One instance and the agent never handles raw secrets - Jentic signs each request server-side.

### Can I run my own custom simulator with AWS RoboMaker, or only Gazebo?

RoboMaker accepts a SimulationApplication that you build and upload (typically a containerised ROS + simulator bundle), so you are not restricted to Gazebo. The simulation application is registered via CreateSimulationApplication and referenced from CreateSimulationJob - but note AWS announced RoboMaker is on a deprecation path, so check current service status before adopting it for new workloads.

### What are the rate limits for the AWS RoboMaker API?

AWS does not publish a fixed RPS in the spec; standard AWS API throttling applies. Long-running operations such as CreateSimulationJob also have concurrency limits per account and region - overage returns LimitExceededException, so production agents should poll capacity and queue jobs accordingly.

### How do I launch a simulation job with the AWS RoboMaker API through Jentic?

Search Jentic for 'launch a RoboMaker simulation job', load the CreateSimulationJob operation schema, and call POST /createSimulationJob with your robotApplications, simulationApplications, and IAM role ARN. Then poll DescribeSimulationJob until status reaches Completed. Install the SDK first with pip install jentic.

### Can the AWS RoboMaker API train ML models, or only run simulations?

RoboMaker itself runs simulations and generates synthetic worlds - it does not train models. The typical pipeline is: generate worlds with CreateWorldGenerationJob, export to S3 with CreateWorldExportJob, then train with Amazon SageMaker on that data. RoboMaker is the simulation and data-generation layer, not the training layer.

### Can I limit what my agent is allowed to do with the AWS RoboMaker API?

Yes. Because you run Jentic One yourself, your own rules decide which RoboMaker operations and which AWS credentials the agent may use. Since job, fleet, and robot definitions travel in the request body rather than the URL path, you can allow only the operations the agent needs, such as CreateSimulationJob and CreateWorldGenerationJob, while withholding operations like CancelSimulationJob or fleet deletion. Those operations are callable only when you explicitly grant them.
