Is this page helpful?

NVIDIA AI Workbench#

Overview#

AI Workbench is a free platform for working in local and remote GPU environments from your laptop.

You install the Desktop App on Windows, macOS or Ubuntu and work locally or connect it to remote systems.

This gives you the same UI/UX no matter where you are working: a local machine, a cloud instance, a data center server or a remote workstation.

AI Workbench provides reproducibility through managed system software, containers and Git repositories.

It handles NVIDIA drivers, container toolkit, builds and runtimes automatically.

Versioned configuration files let you define and adapt the environment to different machines and users.

Every project runs in a sandboxed container with full visibility into changes.

The container boundary keeps IDEs, agents and other tools scoped to the project without affecting the host.

In addition, both code and environment are Git managed with changes detected and surfaced in the Desktop App. This provides visibility and control over what gets commited and run.

You can work with your preferred IDEs, AI coding agents and tools.

VS Code, Cursor and Claude work with AI Workbench projects. Web apps like JupyterLab and RStudio run in the project container and are accessible through your browser.

You can also install and configure custom apps in the container, and the Desktop App will surface and manage them for you.

Key Concepts#

Project

A Git repository under management by AI Workbench. Uses configuration files to define a containerized development environment.

Location

A machine (host) with AI Workbench installed. Can be your local machine or a remote system like a cloud instance, workstation, or server.

Desktop App

A lightweight client application that runs on your laptop to manage locations and projects. Installs on Windows, macOS, or Ubuntu Desktop with no dependencies.

CLI

A command line interface invoked with nvwb with feature parity to the Desktop App. Scriptable with JSON output for use by agents and scripts.

Project Container

The containerized development environment that runs your code and sandboxes your agents. Defined by versioned configuration files that live in the repository.

Compose Stack

Multi-container setup that is defined by a compose file in the repository. Runs alongside the project container and shares a network with it.

Specification Driven Automation#

AI Workbench uses versioned configuration files to define and implement the environment.

The main file is .project/spec.yaml, which works similarly to devcontainer.json. Optional files like requirements.txt and build scripts provide additional detail for the container build.

AI Workbench both reads and writes configuration files as you work.

For example, installing packages or changing the attached GPUs updates the relevant configuration files. Workbench will automatically include the packages in the next build and attach the new number of GPUs on the next container run.

This keeps things current without you doing the manual bookkeeping.

Management and Abstraction#

AI Workbench abstracts the system and network layers between you and your environments.

It manages NVIDIA drivers and the container toolkit on each location automatically. SSH tunneling, proxies and remote container commands stay hidden — you interact with local and remote locations the same way.

This makes it straightforward to move work between machines.

The configuration files declare what the environment should be, and AI Workbench handles the build on each location. You can prototype locally on a laptop and then scale up to a cloud instance or data center server with more powerful GPUs.

Use Cases#

Agent-driven development in sandboxed containers.

Run an agent in project container with your own customized configuration, permissions and hooks. The agent works in an isolated environment, and you review it’s changes through Workbench.

  • Sandboxed execution: Agents work in the project container without affecting the host

  • Controlled permissions: Include your settings and hooks to enforce agent behavior

  • Reproducible setup: Versioned build and runtimes make agent setup reproducible

  • Git visibility: Review diffs, commit selectively or roll back in the Desktop App

  • Self-hosted inference: Run a local/remote inference endpoint and configure the agent to use it

AI, data science and machine learning workflows.

Build the environment and run GPU workloads with reproducible configuration across machines and users.

  • RAPIDS: GPU-accelerated data processing (cuDF) and machine learning (cuML)

  • Large Language Models: Fine-tuning models such as Llama 3 and Mistral

  • Image Generation: Fine-tuning and customization of diffusion models

Multi-container full stack environments.

Define a full stack application with a compose file and share it as a repository that others can clone and run.

  • Agentic RAG: Applications enhancing RAG through agentic web search and response evaluation

  • Hybrid RAG: RAG applications that combine local inference with remote endpoints

  • Multi-Container Applications: Architectures involving multiple coordinated services

Remote prototyping and sharing.

Deploy a project to a remote location and share access to running web apps for testing and feedback.

  • External Access Mode: Configure the remote location to accept traffic on port 10000

  • Shared Access: Generate a secure URL that binds access to a user’s browser session

  • Remote Deployment: Deploy and iterate on a remote from the Desktop App