"Anywhere Local AI" Environment Realized with NVIDIA Brev

Introduction

Hello, I'm Morishige from Classmethod's Manufacturing Business Technology Department.

Many of you may be curious about NVIDIA Brev, announced at CES 2026. It's a service that proposes a rather exciting use case: "accessing your home GPU machine from anywhere outside."

You want to use your very own local LLM, but when you're at the office or on the go, you have no choice but to rely on cloud APIs... For developers wrestling with that frustration, Brev looks like it could be a new option.

This article introduces an overview of NVIDIA Brev and specific usage scenarios for software engineers. Please note that this is preview-stage information ahead of the official release planned for spring 2026.

The Demo Showcased at CES 2026

At the NVIDIA booth at CES 2026, a demo of remote access to a DGX Spark using Brev was presented.

The demo introduced the construction of a personal AI assistant using the robot "Reachy Mini" running on DGX Spark. After demonstrating tasks like checking a to-do list and generating video, at the end of the demo it was explained: "With Brev, I can share access to my Spark and Reachy. So I'm going to share it with Anna." Next, a scene was shown where Anna accessed the same Reachy from a different location via Brev and asked about her pet: "Hey Reachy, what's Potato up to?"

What this demo illustrated is that a locally installed DGX Spark can be securely shared with team members via Brev. Sharing an individual's development environment on a per-project basis, or granting access to team members only during reviews — these are quite attractive features for small AI development teams.

......Actually, watching this demo made me go ahead and order a Reachy Mini. Once it arrives, I'd like to explore what's possible in combination with DGX Spark.

What is NVIDIA Brev

NVIDIA Brev is a developer platform that bundles multiple cloud and on-premises GPU resources together, making it easy to spin up GPU environments for AI development. In July 2024, NVIDIA acquired Brev.dev, and integration has been progressing as part of DGX Cloud enhancements.

It's similar to GPU cloud services like Lambda Labs and Runpod, but what sets it apart is its design philosophy of "providing a layer that delivers the same development experience across any cloud or on-prem GPU." In other words, rather than simply renting out GPUs, it aims for a higher-level layer that abstracts GPU resources and enables unified management.

Differences from Existing Services

Brev's strength lies in its integration with NVIDIA's software stack. It seamlessly connects with tools like NGC Container Registry, NIM (NVIDIA Inference Microservice), and AI Workbench, aiming to achieve "the same environment no matter where you run it."

Relationship with AI Workbench

One thing worth clarifying here is the relationship with NVIDIA AI Workbench.

AI Workbench functions as "a layer that deploys the same project to both local and cloud." Below it sits Brev, which handles the actual procurement and management of GPU resources.

Thanks to this configuration, workflows like "develop locally → deploy to Brev → run inference on cloud GPU" become smooth.

One-Click Environment Setup with Launchables

One distinctive feature of Brev is "Launchables" — a mechanism that lets you spin up pre-configured GPU environments with a single click.

For example, Launchables are available that integrate with NVIDIA Blueprints, covering use cases like PDF to Podcast, multimodal PDF data extraction, and AI voice assistants. You can also create your own Launchables and share them with your team or externally.

By templating Docker images, GPU settings, exposed ports, and more, you can reproduce the same environment as many times as you need. Being able to reduce those painful experiences of "spending half a day on environment setup" is quietly very welcome.

Pricing

Because Brev aggregates resources from multiple clouds, prices are always fluctuating. As of January 2026, the general range for cloud GPU pricing looks something like this:

There are flexible pricing options including on-demand, spot, and reserved, and you can reduce costs depending on how you use it. Check the latest prices at the Brev official site.

Hybrid Operation with DGX Spark

After spring 2026, a feature expansion is planned that will enable hybrid operation of DGX Spark via Brev. In the future, local GPUs like RTX workstations are also expected to be integrated into the same framework, making use cases like "treating your home GPU as your own private cloud" increasingly realistic.

However, the detailed specifications are still at the preview stage and subject to change. It's best not to get overly excited, but the direction is quite interesting nonetheless.

Use Cases for Software Engineers

Now we get to the main topic. Let's take a concrete look at the use cases that Brev enables, from the perspective of a software engineer.

1. A "Remote Local" Code Completion Environment

Let's think about a configuration that uses a home DGX Spark as the backend for AI coding assistants like Continue.dev or Cursor.

Architecture

Ollama Startup Example

# Start the Ollama server on DGX Spark
ollama serve &
ollama pull qwen3-coder:30b
# Port 11434 by default, OpenAI-compatible API enabled

Continue.dev Configuration Example

// ~/.continue/config.json
{
  "models": [
    {
      "title": "Home DGX Spark",
      "provider": "openai",
      "model": "qwen3-coder:30b",
      "apiBase": "https://your-brev-tunnel.brev.dev:11434/v1"
    },
  ],
}

The benefit of this configuration is that sensitive code never needs to be sent to an external API. Even when dealing with confidential in-house code, inference is completed on your home GPU, so you can feel at ease.

Security Considerations

The key point is "not exposing your local GPU directly to the internet."

With conventional Dev Tunnels or ngrok there are risks of token leakage or accidentally open ports, but going through Brev allows for a configuration like this:

• Outbound connections only (no inbound ports opened)
• Identity-based access control
• E2E encryption + MFA support

This is also easy to adopt from a corporate network perspective.

2. Automatically Route Between "Local vs. Cloud" with an LLM Router

Rather than simply using a local LLM, it's even more convenient to be able to automatically switch between local and cloud based on the nature of the query.

NVIDIA's LLM Router Blueprint is designed exactly for this purpose. It uses a DeBERTa-based classifier to determine query complexity and then selects and routes to either a local LLM or a cloud LLM.

Examples of Routing Rules

Routing Using Metadata

Even more interesting is the ability to use "metadata" in routing, not just the content of the query.

• Repository path → Always local for anything under /security/
• File extension → .cu / .ptx routed to CUDA-specialized model
• PR label → No cloud for PRs labeled confidential

# Pseudo-code for routing logic
def route_query(query: str, context: dict) -> str:
    # Forced routing based on metadata
    if "/security/" in context.get("file_path", ""):
        return "local"
    if context.get("pr_labels", []) and "confidential" in context["pr_labels"]:
        return "local"

    # Complexity assessment by LLM Router
    complexity = router.classify(query)
    if complexity < 0.5:
        return "local"  # Simple query
    else:
        return "cloud"  # Complex query

This kind of routing can be expected to reduce costs compared to continuously using a single large-scale model. The specific reduction rate depends on the workload and model configuration, but it enables smarter choices than "blindly throwing everything at GPT-5."

3. Private RAG That Keeps Data In-House

When building a RAG environment targeting internal documents, using Brev allows for flexible configurations.

Pattern 1: Fully Local Configuration

Pros: Data never leaves for the cloud at all
Cons: Model size constrained (within DGX Spark's 128GB VRAM)

This is similar to how ChatRTX or AnythingLLM is used. Suited for cases where confidentiality is the top priority.

Pattern 2: Combining Local Search with Cloud Inference

Pros: Can leverage high-performance frontier models
Cons: Context during inference passes through the cloud

Measures such as anonymizing search results before sending them to the cloud are necessary.

Pattern 3: Routing with Brev

Being able to route "only queries that are okay to send outside to the cloud" allows you to balance security and performance. Personally, I think this configuration is the most practical. That's because fully local has constraints on model size, and hybrid requires the effort of anonymization.

4. Integrating LLM-Powered CI Runners into Pipelines

Incorporating a local LLM into Pull Request reviews or automated test generation is also an interesting configuration.

Integration Image with GitHub Actions

# .github/workflows/llm-review.yml
name: LLM Code Review
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Start Brev GPU Instance
        run: |
          brev start --launchable code-review-llm --wait

      - name: Run LLM Review
        run: |
          curl -X POST ${{ secrets.BREV_ENDPOINT }}/v1/chat/completions \
            -H "Authorization: Bearer ${{ secrets.BREV_API_KEY }}" \
            -d @review-prompt.json

      - name: Stop Instance
        if: always()
        run: brev stop

By handling tasks that are called frequently (lint-like comments, simple refactoring suggestions) locally, you can reduce cloud API costs.

A "CI RAG Environment" as a Launchable

Taking it even further, you could consider a configuration like this:

• Crawl repository documentation every night to update embeddings
• During PR reviews, reference "latest docs + past PR history" via RAG
• Automatically generate review comments aligned with code style and design principles

"An LLM that reviews your code with an understanding of this repository's context" sounds quietly quite useful.

5. A Local CUDA Coding Assistant

Nsight Copilot, announced at CES 2026, is a CUDA coding assistant that runs offline on DGX Spark.

The three points NVIDIA emphasized were:

• No cloud inference costs
• No leakage of data or IP to external parties
• Performance comparable to cloud solutions

It's provided as a VS Code extension and runs on a CUDA-aware LLM powered by NIM. For those working on CUDA development, it looks set to deliver value especially in environments with strict security requirements.

Setup Flow (Preview Version)

1. Install NVIDIA AI Workbench

Install NVIDIA AI Workbench on your DGX Spark. AI Workbench is a tool that simplifies development environment setup.

2. Register Your Device with Brev

Register your device with Brev via AI Workbench. Linking with an NVIDIA account is required.

3. Configure Remote Access

Configure access via SSH tunnel or VPN. Zero-trust authentication, E2E encryption, and MFA are available for security.

4. Verify Operation

Connect via the Brev dashboard from outside your home and confirm that inference with Ollama or vLLM is working.

What to Expect in Spring 2026

Brev is currently in the preview stage, with the official version scheduled for release in spring 2026.

• Official support for DGX Spark registration with Brev
• General availability of hybrid routing (automatic local/cloud switching)
• Enhanced integration with LLM Router

Personally, I'd love to try a setup like "when I'm out, I connect to my home Spark via Brev, and overnight I hand off RAG index updates to Brev's L40S cloud."

Summary

NVIDIA Brev is a platform that blurs the boundary between local GPUs and cloud GPUs. What's interesting is that it's not just a GPU rental service — it aims for "the same development experience no matter where you run it."

For those who have purchased a DGX Spark, or are considering doing so, Brev looks like it will broaden the range of ways you can use it. Let's look forward to the official release.

Reference Links

• NVIDIA Brev Developer Page
• NVIDIA Brev Documentation
• Brev Launchable: Reachy Mini Demo Environment
• NVIDIA brings agents to life with DGX Spark and Reachy Mini (Hugging Face Blog)
• CES 2026 DGX Spark Wrap-up (YouTube)
• DGX Spark at CES 2026 (Igor's Lab)
• NVIDIA AI Workbench
• NVIDIA NIM
• LLM Router Blueprint
• Hybrid RAG with AI Workbench