Mechanobot

AI agents that build, simulate and program industrial robots from plain English, in your browser. Powered by NVIDIA Nemotron on Nebius.

Comment

Mechanobot

Describe a robot cell in plain English. An AI agent builds it, tests every move in simulation, and writes the real robot program.

Powered by NVIDIA Nemotron on Nebius Token Factory.

TL;DR for Judges

Mechanobot is a complete robot-cell design, simulation, and offline-programming studio that runs in the browser, with an AI Copilot capable of operating the entire application.

Key Highlights

  • NVIDIA Nemotron on Nebius Token Factory

    • Nemotron 3 Ultra (nvidia/Nemotron-3-Ultra-550b-a55b) powers the agent loop.
    • Nemotron 3.5 Lightning (nvidia/Nemotron-3_5-Lightning) handles fast guardrail checks.
    • Both models use the OpenAI-compatible API at https://api.tokenfactory.nebius.com/v1 with a single NEBIUS_API_KEY.

  • Tavily Integration: web_search and web_extract allow the Copilot to research manufacturer datasheets and safety standards before acting, with citations.

  • NVIDIA SimReady: Browse 2,677 simulation-ready OpenUSD assets and import them on demand.

  • Automated Testing: 1,089 tests passing, 22 skipped, and 0 failed.

  • Open Source: Public repository under the MIT license.

The Problem

Factories installed 603,000 industrial robots in 2025, a record, according to the International Federation of Robotics. More than five million industrial robots are now at work worldwide.

Every robot must be programmed, and often reprogrammed whenever a product changes.

On the factory floor, this means stopping production while a specialist teaches the robot every movement in the manufacturer's proprietary language, such as RAPID for ABB or KRL for KUKA.

Offline simulation can eliminate much of this downtime, but traditional solutions are expensive. Engineers still need to model the entire cell, verify robot reach, detect collisions, and optimize cycle times. For many small manufacturers, the cost and complexity make these tools inaccessible.

AI could make robot programming dramatically easier, but generating robot code is unforgiving. A single incorrect instruction can send a robot arm into a fixture.

AI-generated robot programs must be validated in simulation before they reach a physical robot.

Mechanobot addresses this challenge by combining AI-driven cell construction, simulation, validation, and offline programming in one accessible browser-based environment.

What Mechanobot Does

Mechanobot takes a robot cell from an idea to a validated, controller-ready program.

1. Build the Cell

Design a complete robotic workstation using:

  • An online library containing 2,165 items.
  • Robot arms, tools, external axes, and workstations.
  • NVIDIA SimReady assets.
  • CAD imports, including STEP, IGES, STL, OBJ, and GLB.

2. Program the Robot

Create and configure robot programs with support for:

  • Target positions.
  • Joint, linear, and circular movements.
  • Input/output operations.
  • Function calls and threads.
  • Attach and detach events.
  • Machining, welding, and 3D printing.
  • Sandboxed scripts and Python.

3. Validate the Program

Mechanobot provides automated checks before execution, including:

  • Inverse kinematics with joint-limit enforcement.
  • Reachability analysis.
  • Singularity checks along paths.
  • Collision detection.
  • Cycle-time estimation.
  • Optional rigid-body physics simulation.

4. Simulate and Generate Robot Code

Mechanobot supports 73 robot post-processors, covering manufacturers including ABB, KUKA, FANUC, Universal Robots, Yaskawa, Kawasaki, and Stäubli.

These post-processors are the default for 95.1% of the robot models in the library: 1,399 out of 1,471 robots.

The result is a workflow that connects cell design, simulation, validation, and real robot program generation.

5. Automate Everything

Mechanobot includes:

  • An AI Copilot that can operate the entire application.
  • An MCP server for external coding agents.
  • A RoboDK-compatible API.
  • A Python package.

The Copilot uses Mechanobot's own command registry, shared by the application's menus, keyboard shortcuts, API, and MCP clients.

This means:

  • The agent can perform the same actions as a human user.
  • Every change appears live in the 3D view.
  • Each action is a single undo step.
  • Python programs and post-processors generated by the agent require user approval before execution.
  • Every operation can also be performed manually through the interface.

How It Works

Mechanobot connects a browser-based robotics studio to AI models, web research tools, and simulation-ready 3D assets.

Architecture:

Browser UI (React 19 + React Three Fiber) ⇄ Next.js server ⇄ Nebius Token Factory, Tavily Search and Extract, and Hugging Face nvidia/simready-assets.

Technical Architecture

Frontend

  • React 19.
  • React Three Fiber.
  • Interactive 3D robot-cell visualization.

Backend

  • Next.js server.
  • TypeScript execution engine.
  • A unified command registry shared by the UI, Copilot, API, and MCP.
  • Rust-based kinematics.
  • Collision checking and CAD readers compiled to WebAssembly.
  • Python-based post-processors.

AI Infrastructure

  • Nebius Token Factory runs the Nemotron models.
  • Nemotron 3 Ultra powers the agent loop.
  • Nemotron 3.5 Lightning handles guardrail classification.

External Integrations

  • Tavily Search and Extract for web research.
  • NVIDIA SimReady assets hosted through Hugging Face.

How We Use NVIDIA Nemotron on Nebius Token Factory

Mechanobot uses two Nemotron models with distinct responsibilities: one for complex reasoning and tool execution, and another for fast safety and scope checks.

Nemotron 3 Ultra — The Agent

Model: nvidia/Nemotron-3-Ultra-550b-a55b

Nemotron 3 Ultra powers the main agent loop. It plans actions, reasons about the user's request, and calls tools from Mechanobot's command catalogue.

Key characteristics:

  • 550B-parameter mixture-of-experts model, with 55B active parameters.
  • 1-million-token context window.
  • Access to the application's tool catalogue, approximately 198 KB of tool schemas per request.
  • Measured first output in 1.9–2.9 seconds with the full tool catalogue.

We chose Ultra for its reasoning capabilities and tool-calling performance, allowing the Copilot to translate high-level instructions into concrete actions across the robotics environment.

Nemotron 3.5 Lightning — The Guardrails

Model: nvidia/Nemotron-3_5-Lightning

Lightning acts as a fast guardrail classifier. It evaluates requests and web content using a yes/no probability derived from a single token's log probabilities.

Configuration:

  • top_logprobs: 20
  • Thinking disabled.
  • Measured classification latency of 160–300 ms per check.

This low latency allows Mechanobot to screen requests and web results without introducing substantial delays into the workflow.

Additional Model Options

Nemotron 3 Super and Nemotron 3 Nano are also selectable in Options → Copilot, providing speed and cost trade-offs.

Why Nebius Token Factory?

Token Factory accelerated our implementation in several ways:

  • OpenAI-compatible API: We reused our existing Agents SDK integration by changing the base URL and model ID.
  • One API key: A single key serves both the agent and guardrail models.
  • Log probabilities: Nemotron's log probabilities enabled calibrated classifiers without training a separate model.
  • Large context window: The 1-million-token context accommodates the full tool catalogue.

This architecture follows the intended division of responsibilities: a powerful model for complex reasoning and a smaller, faster model for frequent guardrail checks.

How We Use Tavily

Mechanobot's Copilot can research technical information before acting.

We integrated two Tavily tools:

  • web_search — Tavily Search with an answer.
  • web_extract — Tavily Extract.

The Copilot can use these tools to retrieve relevant information and cite its sources. Citations appear as cards in the chat interface.

Typical research tasks include:

  • Looking up a robot's payload and reach in the manufacturer's datasheet.
  • Researching safety guidance, including ISO 10218.
  • Finding gripper specifications and other equipment requirements.

Measured Example

We tested the following request:

"What payload and reach does the UR10e have?"

The Copilot returned:

  • Payload: 12.5 kg.
  • Reach: 1,300 mm.
  • Citations from universal-robots.com.

Measured end-to-end response time: 11.9 seconds.

Additional measurements:

  • Tavily search: approximately 0.7 seconds when warm.
  • Tavily extract: approximately 0.6 seconds.

Tavily allows the Copilot to ground its decisions in external technical documentation rather than relying exclusively on the model's internal knowledge.

Guardrails: Scope, Prompt Injection, and Privileges

An AI agent that can modify a robot cell, execute code, and retrieve external information needs explicit safety boundaries.

Mechanobot uses layered protections combining model-based classification with deterministic rules.

1. Request Scope

Nemotron 3.5 Lightning screens each request before the agent executes it.

Measured scores:

  • In-scope requests: 0.76–0.999.
  • Off-topic requests: 0.000–0.016.

For example, a request such as "Write me a poem" is declined in approximately 0.2 seconds, before any tool executes.

2. Prompt-Injection Protection

Web content passes through multiple checks before it reaches the agent:

  1. Content cleaning.
  2. Pattern-based screening.
  3. Nemotron Lightning classification.
  4. Isolation inside randomly bounded untrusted-data markers.

Measured classification scores:

  • Injected text: 0.78–0.88.
  • Benign text: 0.03–0.12.

Across 21 real web results, we observed zero false positives.

3. Privilege Gate

A separate, deterministic privilege gate controls sensitive operations without relying on another model decision.

Key restrictions include:

  • The Copilot cannot change its own endpoint, model, guardrails, or API keys.
  • After web content enters a turn, risky commands require user confirmation.
  • Confirmation is required for actions that cannot be undone or that write files, execute code, change settings, or initiate downloads.
  • Web queries are checked for secrets before being sent.
  • web_extract can only read URLs returned by searches within the current conversation.
  • Each turn is limited to four searches and two page reads.

These protections help maintain a balance between agent autonomy and user control.

NVIDIA SimReady Integration

Mechanobot integrates NVIDIA SimReady assets to make building realistic robot cells easier.

The Robot Library includes a dedicated SimReady tab containing:

  • 2,677 assets.
  • 196 categories.
  • Asset thumbnails.
  • On-demand asset importing.

The Copilot and MCP interfaces also expose the simready.search and simready.load commands.

How Asset Importing Works

Assets are downloaded only when added to a cell and are then cached for subsequent use.

Mechanobot's custom OpenUSD composer converts assets into meshes with:

  • Millimeter-based dimensions.
  • Z-up orientation.
  • Material colors.
  • Physics mass.
  • Automatic placement in an available location within the cell.

The composer handles complex OpenUSD features, including sublayers, references, payloads, variants, overrides, instancing, and per-part materials.

Measured Performance

We tested the system with a conveyor containing 950,458 triangles.

  • First conversion: 36.7 seconds.
  • Initial download: 82.7 MB.
  • Cached conversion: under 3.1 seconds.

This integration makes realistic simulation assets accessible without requiring users to manually manage the underlying USD composition process.

Judging Criteria: Evidence

Technological Implementation

  • Nemotron 3 Ultra agent loop implemented in src/server/agent.ts.
  • Unified application command registry in src/engine/registry.ts.
  • Nemotron 3.5 Lightning log-probability guardrails in src/server/copilot/guardrails.ts.
  • Tavily research tools in src/server/copilot/websearch.ts.
  • OpenUSD composer in src/server/simready/usd.ts.
  • Rust kinematics compiled to WebAssembly in crates/rc_core.
  • Forward kinematics exact on 98.89% of 523,693 stored pairs.
  • Inverse kinematics solved 13,305 of 13,306 cases, as documented in VERIFICATION.md.
  • 1,089 automated tests passing, with 22 skipped and zero failures.

Design

Mechanobot provides one coherent studio for cell construction, programming, simulation, and AI assistance.

  • The chat interface displays the selected model, the "via Nebius Token Factory" provider label, and Tavily and guardrail status.
  • Source cards and guardrail notices explain the Copilot's decisions.
  • A dedicated SimReady tab exposes the asset catalogue.
  • Every Copilot action is visible and undoable.

Relevant components include src/components/ChatPanel.tsx and src/components/SimReadyPanel.tsx.

Potential Impact

Mechanobot aims to make industrial robotics more accessible to small manufacturers, integrators, and educational institutions.

Users can design robot cells, validate reachability, detect collisions, estimate cycle times, and generate controller-specific code through 73 post-processors.

By bringing these capabilities into a browser-based environment, Mechanobot reduces reliance on expensive simulation licenses and specialized programming workflows.

Quality of the Idea

Mechanobot's Copilot operates through the same commands as the human user, making its actions observable and auditable.

The architecture combines:

  • A powerful Nemotron model for reasoning and tool execution.
  • A fast Nemotron model for guardrail checks.
  • Tavily-powered technical research.
  • NVIDIA SimReady assets for realistic robot-cell construction.
  • Simulation and validation before physical deployment.

The result is an integrated approach to AI-assisted industrial robotics rather than a standalone chatbot that merely generates code.

What Changed During the Submission Period

Mechanobot's simulator existed before the hackathon. The baseline commit was 48b1ddd1, dated October 21, 2026.

The following capabilities were added for this submission:

  • The Copilot powered by Nemotron 3 Ultra through Nebius Token Factory.
  • Nemotron 3.5 Lightning guardrails and the deterministic privilege gate.
  • Tavily-powered web research tools.
  • NVIDIA SimReady integration, including the asset catalogue, on-demand downloads, OpenUSD conversion, and placement.
  • UI indicators for the selected model, provider, web-search status, and guardrails.
  • Submission documentation and the MIT license.

This work extends an existing robotics simulator with an AI agent capable of operating the application, researching technical requirements, and helping users build and validate robot programs.

Challenges and Honest Limitations

1. OpenUSD in a Web Server

Composing complete OpenUSD packages was challenging without a dedicated USD runtime.

Assets can contain payloads, physics variants, MDL materials, and geometry layers exceeding 50 MB. We built our own composer to handle these features and fixed a quaternion-ordering bug discovered while processing real assets.

2. AI Safety

Allowing an agent to research the web and modify a complex application required multiple layers of protection.

We combined model-based guardrails with deterministic privilege rules, confirmation requirements, and restrictions on web access.

3. Multi-Robot Programming

Long, complex tasks remain challenging for the agent.

Nemotron can reliably build cells containing robots, grippers, tables, and SimReady components, then run, validate, and generate programs. However, programming a two-robot packing task entirely from scratch still requires further work.

The tandem segment in our video demonstrates the Copilot operating Mechanobot's built-in two-arm assembly cell.

4. Cold Starts

The guardrail classifier is designed to allow requests through if Nebius becomes slow after a period of inactivity. This avoids making the entire application unusable because of a temporary model-service delay.

The Vision

Mechanobot aims to make robot programming as accessible as describing a task in plain English.

Instead of manually assembling a cell, teaching every movement, and writing controller-specific code, users can work with an AI agent that understands the application, researches technical requirements, constructs the environment, and validates programs in simulation.

By combining NVIDIA Nemotron, Nebius Token Factory, Tavily, and NVIDIA SimReady, Mechanobot brings AI-assisted robotics design, simulation, and offline programming into a single workflow.

Describe the task. Build the cell. Validate the motion. Generate the robot program.

All in one place.

Built With

  • nebius
  • nemotron
  • nextjs
  • nvidia
  • tavily
Share this project:

Updates

Submission history