High-Performance Developer Environments with Devboxes

Managed developer environments for humans and AI coding agents. Devboxes provide consistent, reproducible workspaces with enterprise-grade performance and intelligent lifecycle management.

Devboxes are currently in early access. Register for early access to get started.

Why Namespace Devboxes?

  • High-performance infrastructure built on AMD EPYC, AmpereOne, and Apple M4 Pro processors
  • Dockerfile-based base images define your development software with familiar Docker tooling
  • Reusable blueprints spin up new devboxes from templates in seconds
  • Automatic lifecycle management starts on-demand and pauses when idle to optimize costs
  • Flexible resource allocation from lightweight testing to resource-intensive workloads
  • Cost-effective scaling with transparent pricing - pay only for what you use
  • Enterprise ready with SAML SSO, SCIM, SLAs, audit logs, and external log & metric sinks

What are Devboxes?

Devboxes are persistent, fully managed developer environments designed for both developers and AI coding agents. They run on Namespace infrastructure and provide:

  • Persistent development instances that maintain your work across sessions
  • Intelligent lifecycle management automatically starting on-demand and pausing when idle
  • Base images defined with Dockerfiles for reproducible software environments
  • Blueprints combining git repositories, initialization hooks, ports, and secrets for instant setup
  • Remote access via SSH, web terminals, and IDE integrations

Learn more about these concepts in the Core Concepts guide.

Quick Start Guide

Enable GitHub integration

Enable the GitHub integration in your Namespace workspace.

Define a base image

Create a Dockerfile for your development tools:

FROM ubuntu:24.04

# Install system dependencies
RUN apt-get update && apt-get install -y \
    git curl build-essential ca-certificates

# Install uv
COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv

# Install Python and create a virtual environment with tools
RUN uv venv /opt/venv --python 3.12
RUN uv pip install --python /opt/venv/bin/python pytest black mypy ruff

# Add venv to PATH so tools are available
ENV PATH="/opt/venv/bin:$PATH"

Create a blueprint

Using the CLI, create a blueprint:

$devbox blueprint create \
--name=main \
--machine_type=32x64 \
--dockerfile=Dockerfile \
--repository=github.com/myorg/myrepo

Create a devbox

Create a devbox from your blueprint:

$devbox create --auto --from=main

The devbox will be created with your base image, repository cloned, and ready to use in seconds.

Connect and develop

Once your devbox is ready, you can connect in multiple ways:

Via the Dashboard:

Devbox dashboard with initialization log

The dashboard shows your devbox status, initialization progress, and provides quick access to open the devbox in your preferred IDE.

Via SSH:

$devbox ssh main

Via VSCode, Cursor, or VSCode on the Web:

Devboxes have built-in support for popular code editors. You can open your devbox in your preferred IDE:

From the dashboard, click the "Open VSCode" dropdown to choose:

  • Open in VSCode (desktop)
  • Open in Cursor (desktop)
  • Open in VSCode on the Web (browser-based)

Or use the CLI:

$devbox open-ide main

These integrations use the Remote-SSH extension to provide a seamless development experience with full IDE features running directly on your devbox.

Use Cases

Shared Environment Definitions

A key advantage of Devboxes is that developers and AI coding agents share the same environment definition. When you define a blueprint with a Dockerfile, everyone—whether a developer or Claude Code—uses the exact same tools, dependencies, and configuration. This ensures:

  • Consistent behavior: Code that works in Claude Code will work for developers, and vice versa
  • Reproducible results: Everyone sees the same build outputs, test results, and runtime behavior
  • Single source of truth: One Dockerfile defines the environment for your entire team, including AI agents
  • No environment drift: Eliminate "works on my machine" problems between humans and AI

Developers

Devboxes provide consistent, high-performance environments for development teams:

  • Onboard new team members instantly with pre-configured blueprints
  • Work in the same environment as Claude Code and other AI agents
  • Access powerful compute for resource-intensive workloads
  • Switch between projects without managing local dependencies
  • Built-in git access for seamless source control operations

AI Coding Agents & Claude Code Workspaces

Devboxes are optimized for AI-powered development workflows. Claude Code can be enabled directly in a blueprint, with the workspace configured automatically:

  • One-click enablement: Enable Claude Code in your blueprint settings for automatic workspace configuration
  • Quick workspace creation: Spin up isolated devboxes for each major change or feature
  • Shared environment definition: AI agents use the same Dockerfile and tools as your developers
  • Parallel development: Work on multiple features simultaneously, each in its own devbox
  • Clean slate: Start fresh for each task without polluting your main environment
  • Isolated, sandboxed environments: Complete isolation for secure code execution
  • Long-running sessions: Support persistent state across agent sessions
  • Built-in git access: Full git access for commits, branches, and pull requests
  • Automatic resource management: Resources scale based on agent activity

Security & Isolation:

Claude Code runs with bypassPermissions enabled by default, as each devbox environment is completely isolated. This provides seamless operation while maintaining security through isolation. For added protection, network policies can be applied to limit the workspace's access to external resources.

This approach enables you to maintain multiple parallel workstreams without environment conflicts or setup overhead, with the guarantee that what works for Claude Code will work for your team.

Builds on Namespace's infrastructure

Devboxes leverage Namespace's infrastructure capabilities out of the box:

  • Geographic optimization: Automatically created in a location closer to you to minimize latency
  • Cache volumes: Automatically used for fast incremental building and testing, with sub-second lookups and high IOPS
  • Persistent volumes: Backed by our high-performance storage for reliable, fast access to your development files
  • High-performance Docker builds: Pre-configured remote builders for optimal container build performance
  • Remote registry: Built-in access to nscr.io for fast image pulls and pushes
  • Build tool caching: Bazel and Turborepo caching pre-configured for maximum build acceleration
  • Network performance: Optimized networking for fast git operations and package downloads
  • Compute isolation: Each devbox runs on dedicated resources with guaranteed performance

These features work together to provide a development experience that's faster and more reliable than local development, without any additional configuration.

Platform Support

Devboxes currently support Linux on high-performance AMD EPYC and ARM processors (AmpereOne, Apple M4 Pro).

macOS and Windows support coming soon.

Next Steps

Core Concepts → Learn about base images, blueprints, and lifecycle management in detail.

Machine Shapes → Explore available CPU and memory configurations to find the optimal shape for your workload.

Observability → Monitor resource usage, view logs, and track performance metrics for your devboxes.

Enterprise Support

Need dedicated capacity, custom machine shapes, or specialized support for your development team? Contact our support team for consultation on complex development environment requirements.

Last updated