Dell, Nvidia Roll Out Local GB10 Compute to Bypass Cloud AI Queues

From Code to Agent - Transforming the Developer Experience With NVIDIA and Dell Technologies — Ai4

Ai4

Deploying high-memory desktop accelerators alongside unified software stacks eliminates remote cluster bottlenecks and data-privacy constraints while ensuring local AI agents deploy seamlessly to enterprise data centers.

AI-assisted summary of From Code to Agent - Transforming the Developer Experience With NVIDIA and Dell Technologies — original source. Check the original for full context.

Source published:

Detailed notes

## Background Published on YouTube by Ai4 on August 20, 2026, this session features Sama Bali from NVIDIA and Logan Lawler from Dell Technologies. According to the page description, the talk examines how pairing desk-side accelerated compute with NVIDIA's optimized AI software stack eliminates developer friction and unlocks enterprise productivity for building and deploying AI agents.

## TL;DR The speakers address the core bottleneck in enterprise AI development: developer iteration latency caused by shared-cluster job queues, environment drift, and data privacy restrictions. Dell and NVIDIA resolve this by bringing data center-grade unified memory to the desk via the Dell Pro Max GB10 and GB300, delivering identical ARM-based architecture and seamless software parity from local prototyping to full production. The hardware is backed by the comprehensive NVIDIA AI software stack, NIM microservices, and the NVIDIA Agent Toolkit with OpenShell runtime governance. Production case studies from the Electric Power Research Institute (EPRI) and Make VFX studio demonstrate how local high-memory compute enables responsive, air-gapped inference on 120-billion parameter models while safeguarding sensitive proprietary data.

## Atmosphere & style The presentation carries a pragmatic, builder-focused tone that blends technical rigor with relatable enterprise empathy. Bali and Lawler maintain a smooth, collaborative tag-team dynamic, grounding architectural diagrams in everyday developer frustrations like underpowered corporate laptops and disruptive queue delays. Watching the session feels like an upbeat, solutions-oriented engineering showcase aimed directly at restoring developer flow state and autonomy.

## Key takeaways - [00:04](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=4s) Compute access and developer iteration velocity have replaced model availability and capability as the primary bottlenecks in enterprise AI agent creation. - [04:29](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=269s) Traditional shared remote clusters degrade developer productivity through queue delays, multi-tenant configuration drift, and architectural mismatches between development machines and production servers. - [07:08](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=428s) The Dell Pro Max with GB10 provides 128 GB of unified VRAM at the desk, establishing architectural parity with ARM-based data center servers while keeping sensitive IP on-premises. - [07:08](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=428s) The upcoming Dell Pro Max with GB300 scales desk-side unified memory to 775 GB, enabling local inference and fine-tuning for trillion-parameter class models across engineering workgroups. - [11:10](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=670s) Dedicated desktop-adjacent compute allows engineers to bypass corporate laptop hardware constraints and hand off validated pipelines directly to production clusters without architectural re-engineering. - [12:02](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=722s) Two decades of CUDA backward compatibility ensure that AI applications developed on local Blackwell-based hardware compile and execute identically across cloud and on-premise infrastructure. - [12:02](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=722s) NVIDIA AI Enterprise and NIM microservices simplify agent architectures by exposing validated, standardized APIs compatible with orchestrators like LangChain, LlamaIndex, and CrewAI. - [16:27](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=987s) The NVIDIA Agent Toolkit and OpenShell runtime engine provide governance boundaries, enforcing networking policies, sandboxing, and safety guardrails on autonomous agent tool usage. - [18:22](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=1102s) Regulatory compliance in utility research was demonstrated by EPRI running an air-gapped 120-billion parameter FP4 model on a single GB10, reaching 45 tokens per second for document search. - [18:22](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=1102s) Creative studio Make addressed strict intellectual property safeguards by clustering ten interconnected GB10 units into an air-gapped 1,280 GB compute pool for local visual effects rendering.

## Detailed walkthrough ### [00:04](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=4s) Introductions and the Proliferation of the Agent Landscape

The session opens with introductions from Sama Bali, Lead for AI Solutions Product Marketing at NVIDIA, and Logan Lawler, who oversees AI strategy on the Client Solutions Group (CSG) side of Dell Technologies—focusing on client devices such as laptops and desktops rather than the server, storage, and networking domain of the Infrastructure Solutions Group (ISG). Setting the stage for the presentation, Sama highlights that while industry discussions frequently revolve around AI agents and their capabilities, the critical conversation inevitably returns to the developers building them. Over the preceding twelve months, the agent landscape has expanded dramatically, giving engineers an overwhelming abundance of choices across foundation models, tooling, agent frameworks, storage solutions, and vector databases.

```mermaid flowchart TD accTitle: The AI Agent Developer Decision Dilemma subgraph S1["Evolving Ecosystem"] A["New Models & Frameworks Released Daily"] B["Abundance of Tools & Vector Databases"] end subgraph S2["Developer Friction"] C{"Evaluation & Testing"} D["Benchmark vs. Reality?"] E["Will it break existing code?"] end subgraph S3["The Core Bottleneck"] F["Compute Access & Iteration Speed"] end

A --> C B --> C C --> D C --> E D --> F E --> F ```

This rapid proliferation introduces significant friction. When new models and frameworks drop faster than teams can track, individual developers must evaluate whether adopting a new model is worth the risk of breaking existing pipelines and whether advertised benchmark improvements translate to real-world performance gains. The only reliable way to validate these choices is through direct local experimentation. However, access to compute—rather than developer capability, model availability, or budget—has become the primary bottleneck in enterprise AI development. Logan surveys the room about evolving open-source models like Nous Hermes, noting that developer curiosity demands continuous tinkering in an environment that has transformed completely in under two years.

- **Enterprise reality**: The primary determinant of success is developer iteration speed and autonomy rather than mere architectural planning. - **Ecosystem velocity**: The majority of current frameworks, vector tools, and specialized models did not exist two years prior, mirroring the rapid experimentation cycles seen during the early Stable Diffusion explosion.

---

[04:29](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=269s) Friction in the Traditional Shared-Cluster Workflow

Sama details the conventional pipeline that developers must navigate when working without dedicated accelerated hardware at their desk. In a standard workflow, a developer writes code, submits the job to a shared remote cluster, and is forced to wait in a queue for an available compute instance before they can test, inspect, or debug their agent. This cycle repeats on every single iteration, creating four critical bottlenecks:

```mermaid flowchart LR accTitle: Traditional Developer Iteration Bottleneck subgraph Shared["Remote Shared Infrastructure"] Q["Job Queue\n(Wait for instance)"] Env["Shared Cluster\n(Config drift & collisions)"] end subgraph Local["Developer Flow"] Code["Write Code"] Debug["Debug Environment\ninstead of AI Logic"] Limit["Constrained Testing\n(Drop experiments)"] end

Code --> Q Q --> Env Env --> Debug Debug --> Limit Limit --> Code ```

First, waiting for remote resources disrupts flow state; a ten-minute wait in a queue often costs an engineer twenty to twenty-five minutes just to regain mental context. Second, multi-tenant shared clusters suffer from environment drift and configuration collisions, forcing developers to spend valuable time debugging broken environment dependencies rather than their actual AI logic. Third, strict data governance policies frequently prohibit proprietary or intellectual property (IP)-sensitive data from leaving corporate networks, leaving sensitive projects locked out of the fastest cloud-based compute. Fourth, lengthy feedback loops actively suppress developer creativity, causing engineers to arbitrarily restrict their testing to just a handful of ideas due to limited allotted time windows. Logan adds a fifth challenge: architectural fragmentation between development environments and deployment targets, such as writing on x86 architectures while targeting modern ARM-based CPU/GPU servers in the data center.

---

[07:08](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=428s) Bringing Server-Grade Compute to the Desk: Dell Pro Max GB10 and GB300

To eliminate cluster queuing and environmental friction, Dell and NVIDIA introduced desk-side accelerated hardware that mirrors data center architecture. Logan highlights the Dell Pro Max with GB10 (equivalent to the NVIDIA DGX Spark platform), designed to deliver server-level compute straight to the engineer's desk. The system can function as an individual daily driver, an auxiliary desk-side machine accessed over Tailscale and SSH, or a localized network inference node serving a dedicated workgroup. Looking ahead, Logan previews the upcoming Dell Pro Max with GB300 (the counterpart to the NVIDIA DGX Station), which scales unified memory capacity from 128 GB of unified VRAM on the GB10 up to 775 GB on the GB300—capable of handling trillion-parameter class models and rivaling multi-rack data center configurations.

| Platform | Target Deployment Scale | Memory Capacity | Target Use Case | |:--- |:--- |:--- |:--- | | **Dell Pro Max with GB10** *(NVIDIA DGX Spark equivalent)* | 1:1 dedicated developer workstation or auxiliary system | 128 GB Unified VRAM | Individual prototyping, continuous iteration, fast local feedback loops | | **Dell Pro Max with GB300** *(NVIDIA DGX Station equivalent)* | Medium business / Workgroups of 10–12 developers | 775 GB Unified VRAM | Workgroup-level inference, massive local parameter models (up to ~1T parameters) | | **Enterprise Data Center** *(Dell PowerEdge / NVIDIA DGX Clusters)* | Full-scale enterprise production | Multi-node cluster scale | Scaled production training, large-scale orchestration, enterprise deployment |

By providing engineers with dedicated local compute sharing the same ARM-based architecture and NVIDIA AI software stack used in Dell PowerEdge data center servers, enterprises achieve seamless parity. Developers obtain instant feedback loops, guaranteed data privacy for on-premises IP, full GPU control without multi-tenant interruptions, and consistent execution environments that guarantee what is built locally at the desk runs identically when deployed to enterprise production clusters.

[11:10](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=670s) Overcoming the Corporate GPU Bottleneck with Local GB10 Compute

Logan Lawler illustrates the friction developers encounter inside large enterprises by sharing his personal setup constraints: the standard corporate laptop assigned to him lacks an onboard GPU, leaving him unable to test or run local models. Needing an automated way to compile weekly progress reports for Crystal and the NVIDIA team—tracking milestones and logistics such as speaking alongside Sama Bali multiple times at AI4—he bypassed the bottleneck by placing a Dell system equipped with an NVIDIA GB10 directly onto his local network. This setup gave him immediate feedback to test, debug, and refine his agent locally at his desk without latency or corporate data sharing concerns.

Having 128 GB of unified memory on the GB10 allowed him to harness the Hermes model to construct the agent smoothly. Once the pipeline was proven, moving it to enterprise scale required zero architectural rework. Lawler packaged the entire application into a standard tar archive and handed it off to Dell's data center engineering team, who deployed it straight into production. Having dedicated desktop-adjacent compute bridged the divide between rapid personal prototyping and formal data center rollout.

- **Corporate IT hurdle**: Standard enterprise laptops lack dedicated AI acceleration, blocking local agent development. - **Prototyping setup**: GB10 connected over the local network running Hermes with 128 GB of VRAM. - **Handoff efficiency**: Simple archive export (`.tar` file) allowed immediate data center deployment without re-engineering code.

---

[12:02](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=722s) The NVIDIA AI Software Stack: From Silicon to Agent Frameworks

Transitioning from hardware to software, Sama Bali stresses that raw accelerated compute solves only half of the developer experience equation. Speed requires a software ecosystem that removes hardware configuration toil so developers can focus purely on application logic. The foundation begins at the silicon level with Dell Pro Max platforms hosting GB10 or GB300 accelerators, directly integrated with NVIDIA CUDA drivers and low-level GPU kernels. This foundational layer provides deep backward compatibility: CUDA code authored nearly two decades ago compiles and runs seamlessly on modern Blackwell-generation chips, ensuring assets built on a GB10 transition identically to GB300 workstations, Dell enterprise servers, or public clouds.

Ascending the stack, core CUDA libraries interface directly with popular deep learning frameworks including PyTorch and JAX, which undergo continuous joint testing and kernel optimizations. For production readiness, the NVIDIA AI Enterprise tier supplies enterprise IT with validated, security-patched software development kits and frameworks. At the application tier, modular containerized NVIDIA NIM microservices expose standard APIs to run high-throughput inference, while native optimizations across orchestrators like LangChain, LlamaIndex, and CrewAI eliminate friction when assembling compound agentic workflows.

```mermaid flowchart TD accTitle: NVIDIA End-to-End AI Software Stack subgraph APP["Applications & Frameworks"] A1["Agents & Dev Apps"] A2["LangChain / LlamaIndex / CrewAI"] A3["NVIDIA NIM Microservices"] end subgraph PLATFORM["Enterprise Platform & Core"] P1["NVIDIA AI Enterprise (Security & Validation)"] P2["Frameworks (PyTorch / JAX) & CUDA Libs"] end subgraph HW["Infrastructure & Drivers"] H1["CUDA & GPU Drivers (Kernel Optimization)"] H2["Dell Hardware (GB10 / GB300 / Data Center)"] end APP --> PLATFORM PLATFORM --> HW ```

- **Architectural continuity**: Two decades of CUDA backward compatibility allow identical runtime behavior across laptops, local GB10/GB300 systems, and cloud clusters. - **Enterprise-grade validation**: NVIDIA AI Enterprise provides strict security, privacy vetting, and compliance guarantees required by IT governance. - **Plug-and-play agent integration**: NVIDIA NIM microservices integrate via standardized APIs alongside leading orchestration frameworks like LangChain, LlamaIndex, and CrewAI.

---

[16:27](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=987s) NVIDIA Agent Toolkit and OpenShell Runtime Governance

To consolidate agent construction into a standardized workflow, Bali highlights the NVIDIA Agent Toolkit—an open-source architecture designed as a unified environment to build, run, customize, and govern enterprise agents. Powered by underlying CUDA libraries, the toolkit allows engineers to pair custom domain datasets via the AI data platform with any open-source foundation model, including NVIDIA's specialized Nemotron model family.

```mermaid flowchart LR accTitle: NVIDIA Agent Toolkit Flow subgraph INGEST["Context & Foundation"] M1["Open-Source / Nemotron LLMs"] D1["AI Data Platform Context"] end subgraph CORE["Agent Framework"] T1["NVIDIA Agent Toolkit"] end subgraph GOVERN["Governance Runtime"] O1["OpenShell Runtime Engine"] O2["Security, Network & Guardrail Policies"] end INGEST --> CORE CORE --> GOVERN ```

Crucial to enterprise safety is OpenShell, an open-source runtime engine embedded in the toolkit that governs runtime agent behaviors. As agents gain autonomous tool-use capabilities, OpenShell enforces explicit operational boundaries: - **Policy enforcement**: Dictates strict boundaries around what external actions or APIs the agent is permitted to invoke. - **Networking controls**: Restricts external access paths and sandbox communication channels to protect enterprise perimeters. - **Privacy and safety guardrails**: Enforces content filtering and data privacy standards prior to response delivery. - **Portability**: Provides identical governance policies whether deployed on a local GB10, a GB300 workstation, a Dell on-premise server, or hybrid cloud infrastructure.

---

[18:22](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=1102s) Enterprise Proof Points: EPRI Power Chat and Make VFX Studio

Bali and Lawler ground the hardware-software stack in two distinct production case studies where local execution was non-negotiable due to data confidentiality and regulatory compliance.

The first example highlights the Electric Power Research Institute (EPRI), an organization operating within the highly regulated United States utility sector where strict compliance rules prohibit uploading proprietary grid documentation to public cloud providers. Utilizing a local GB10 unit compact enough to rest in the palm of a hand, EPRI built "Power Chat," an internal AI research assistant. The system runs an open-source 120-billion parameter model (GPT-OSS 120B) quantized to FP4 precision. Operating this model typically requires roughly 68 GB of dedicated VRAM—far outstripping standard workstations. On the GB10, EPRI achieves 45 tokens per second for an individual user and maintains 15 tokens per second when scaled across ten concurrent enterprise users.

Lawler follows with Make, an elite visual effects (VFX) studio producing assets for high-profile entertainment properties like Lucasfilm. To prevent intellectual property leaks on unreleased feature films, artists are physically locked inside secure production rooms without external internet access. To provide modern generative rendering capabilities without breaching security protocols, Make deployed an on-premise rack of 10 interconnected GB10 units inside their data center, aggregating 1,280 GB of unified compute. Running LTX and associated media models locally, artists perform high-resolution final-frame rendering, up-rezzing, and color scaling entirely on-premise.

| Organization | Deployment Setup | Model & Workload | Performance & Operating Scale | |:--- |:--- |:--- |:--- | | **Electric Power Research Institute (EPRI)** | Single GB10 system (palm-sized form factor) | 120B parameter model at FP4 (~68 GB VRAM footprint) for document search | 45 tokens/sec (single user); 15 tokens/sec across 10 concurrent users | | **Make (VFX Studio)** | Data center stack of 10× GB10 systems (1,280 GB aggregate compute) | LTX and custom rendering models | Local final-frame rendering, up-res, and color scaling in an air-gapped studio |

---

[20:41](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=1241s) Call to Action: Experiencing GB10 and GB300 at Booth 137

Wrapping up the session as the countdown timer expires, Bali and Lawler invite attendees to visit Dell Booth 137 on the exhibition floor. They encourage developers to see both the GB10 and GB300 hardware running live demos, interact with the NVIDIA software stack in person, and evaluate how compact, high-memory local acceleration changes the day-to-day developer experience.

## Notable quotes > [00:04](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=4s) Over the preceding twelve months, the agent landscape has expanded dramatically, giving engineers an overwhelming abundance of choices across foundation models, tooling, agent frameworks, storage solutions, and vector databases. — Sama Bali

> [00:04](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=4s) Access to compute—rather than developer capability, model availability, or budget—has become the primary bottleneck in enterprise AI development. — Logan Lawler

> [04:29](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=269s) Waiting for remote resources disrupts flow state; a ten-minute wait in a queue often costs an engineer twenty to twenty-five minutes just to regain mental context. — Sama Bali

> [04:29](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=269s) Multi-tenant shared clusters suffer from environment drift and configuration collisions, forcing developers to spend valuable time debugging broken environment dependencies rather than their actual AI logic. — Sama Bali

> [07:08](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=428s) The upcoming Dell Pro Max with GB300 scales unified memory capacity from 128 GB of unified VRAM on the GB10 up to 775 GB on the GB300—capable of handling trillion-parameter class models and rivaling multi-rack data center configurations. — Logan Lawler

> [12:02](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=722s) Raw accelerated compute solves only half of the developer experience equation. Speed requires a software ecosystem that removes hardware configuration toil so developers can focus purely on application logic. — Sama Bali

> [12:02](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=722s) CUDA code authored nearly two decades ago compiles and runs seamlessly on modern Blackwell-generation chips, ensuring assets built on a GB10 transition identically to GB300 workstations, Dell enterprise servers, or public clouds. — Sama Bali

> [16:27](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=987s) Crucial to enterprise safety is OpenShell, an open-source runtime engine embedded in the toolkit that governs runtime agent behaviors. — Sama Bali

> [18:22](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=1102s) On the GB10, EPRI achieves 45 tokens per second for an individual user and maintains 15 tokens per second when scaled across ten concurrent enterprise users. — Sama Bali

## Mentioned Ai4, Blackwell, CrewAI, Crystal, CUDA, Dell Technologies, Dell Pro Max with GB10, Dell Pro Max with GB300, Dell PowerEdge, Electric Power Research Institute (EPRI), GPT-OSS 120B, JAX, LangChain, LlamaIndex, Logan Lawler, LTX, Lucasfilm, Make (VFX Studio), Nemotron, Nous Hermes, NVIDIA, NVIDIA Agent Toolkit, NVIDIA AI Enterprise, NVIDIA DGX Spark, NVIDIA DGX Station, NVIDIA NIM, OpenShell, Power Chat, PyTorch, Sama Bali, Stable Diffusion, Tailscale

## Video description Sama Bali - Sr Manager, AI Solutions Product Marketing, NVIDIA Logan Lawler - Dell Pro Precision AI Strategy, Dell Technologies

Building AI agents requires more than great models. It demands a developer experience designed for speed. In this session, Dell and NVIDIA show how bringing accelerated compute closer to developers, combined with NVIDIA's optimized AI software stack, unlocks a new level of productivity for building AI agents. Learn how Dell and NVIDIA equip development teams with everything they need to build, iterate, and deploy intelligent agents at enterprise scale.

[Source](https://www.youtube.com/watch?v=7-tZU2I7mHc)

中文简报

戴尔与NVIDIA推出本地GB10算力以避开云端AI排队 部署高显存桌面加速器与统一软件栈，消除远程集群瓶颈和数据隐私限制，同时确保本地AI Agent无缝部署至企业数据中心。 演讲者探讨了企业AI开发的核心瓶颈：由共享集群任务排队、环境漂移及数据隐私限制所导致的开发者迭代延迟。戴尔与NVIDIA通过Dell Pro Max GB10和GB300将数据中心级统一内存引入桌面端来解决这一问题，提供一致的ARM架构以及从本地原型设计到全面生产环境的无缝软件对齐。该硬件由全面的NVIDIA AI软件栈、NIM微服务以及具备OpenShell运行时治理的NVIDIA Agent Toolkit提供支持。来自美国电力研究协会（EPRI）和Make视觉特效工作室的生产案例表明，本地高显存算力如何在保护敏感专有数据的前提下，实现对1200亿参数模型快速响应的物理隔离推理。 算力获取与开发者迭代速度已取代模型可用性与能力，成为企业构建AI Agent的主要瓶颈。 (0:04) 传统的共享远程集群由于排队延迟、多租户配置漂移以及开发机与生产服务器之间的架构不匹配，降低了开发者的生产效率。 (4:29) 搭载GB10的Dell Pro Max在桌面端提供128 GB统一显存，在将敏感知识产权保留在本地的同时，实现了与基于ARM的数据中心服务器的架构对齐。 (7:08) 即将推出的搭载GB300的Dell Pro Max将桌面端统一内存扩展至775 GB，使工程团队能够针对万亿参数级模型开展本地推理和微调。 (7:08) 专用的桌面级算力使工程师能够突破企业笔记本电脑的硬件限制，无需重新进行架构改造即可将验证后的流水线直接移交给生产集群。 (11:10)

Reading summary

NVIDIA and Dell Technologies argue that local compute access—rather than developer capability or model choice—is the core bottleneck in building enterprise AI agents, advocating for desk-side accelerators that share architectural parity with production clusters. Bottlenecks in Traditional Shared-Cluster Development (4:29) The rapid expansion of foundation models, vector databases, and frameworks forces developers to constantly evaluate new tools through local trial. However, enterprise workflows usually rely on shared remote clusters. According to Sama Bali and Logan Lawler, waiting in job queues breaks developer flow states—a ten-minute queue can require 20 to 25 minutes of context recovery—while multi-tenant environments introduce configuration drift and dependency collisions that pull engineers away from application logic. Shared infrastructure also clashes with enterprise constraints. Strict data governance often bars proprietary datasets from public clouds or external networks. Furthermore, architectural friction emerges when developers build on standard corporate laptops or x86 machines while targeting ARM-based server clusters in data centers, limiting the scope of experimentation. Bringing Data Center Architecture to the Desk (7:08) To eliminate queue delays and environment drift, Dell and NVIDIA introduced desk-side hardware matching data center architectures. The Dell Pro Max with GB10 (equivalent to NVIDIA DGX Spark) offers 128 GB of unified VRAM for individual prototyping or auxiliary network compute. Dell also previewed the Dell Pro Max with GB300 (equivalent to DGX Station), designed with 775 GB of unified VRAM to serve workgroups of 10 to 12 developers running models with up to approximately one trillion parameters. Lawler demonstrated this workflow by overcoming his own GPU-lacking enterprise laptop: placing a GB10 on his local network allowed him to build an automated reporting agent with the Nous Hermes model. Because the local hardware shares the same ARM architecture and software stack as Dell PowerEdge enterprise servers, the working prototype was packaged into a standard tar archive and handed directly to IT for production deployment without code refactoring. Software Stack and OpenShell Agent Governance (12:02) Hardware parity is paired with an integrated software stack that maintains backward compatibility across two decades of CUDA code, enabling assets created on local GB10 or GB300 units to run unchanged in cloud or data center environments. At the framework level, CUDA libraries integrate with PyTorch and JAX, backed by NVIDIA AI Enterprise for enterprise IT compliance. NVIDIA NIM microservices offer containerized inference APIs that connect to orchestration tools such as LangChain, LlamaIndex, and CrewAI. To standardize enterprise agent development, the open-source NVIDIA Agent Toolkit links domain datasets with foundation models, including NVIDIA Nemotron. The toolkit embeds OpenShell, a runtime governance engine that enforces policies on autonomous agents. OpenShell defines strict boundaries around permitted API calls, restricts external networking paths to secure the enterprise perimeter, applies content and privacy filters, and maintains consistent policy enforcement across local and cloud deployments. Enterprise Validation Across Regulated Environments (18:22) The local compute model was highlighted through two enterprise use cases facing strict confidentiality mandates. In the regulated utility sector, the Electric Power Research Institute (EPRI) was barred from uploading grid data to public clouds. Using a palm-sized GB10 system, EPRI deployed 'Power Chat,' running a 120-billion parameter model quantized to FP4 across roughly 68 GB of VRAM. The system achieved 45 tokens per second for a single user and maintained 15 tokens per second across 10 concurrent users. Similarly, visual effects studio Make required an air-gapped environment to prevent intellectual property leaks on unreleased film assets for clients like Lucasfilm. Make installed an on-premise rack of 10 interconnected GB10 units inside their data center, aggregating 1,280 GB of unified compute. This local cluster enabled artists to run LTX and custom media models for final-frame rendering, up-rezzing, and color grading without connecting to external networks. Dell and NVIDIA present desk-side, data-center-matched hardware as a remedy for developer friction and data governance limits. However, the presentation focuses on workstation and cluster-scale implementations, leaving open broader questions regarding total hardware procurement costs for enterprise-wide rollouts.

精炼阅读摘要

NVIDIA产品营销主管Sama Bali与戴尔科技AI策略负责人Logan Lawler指出，企业AI智能体开发的核心瓶颈并非模型可用性，而是本地算力匮乏与共享集群排队造成的迭代摩擦；通过在桌面端部署具备统一内存且与数据中心同构的硬件设备（Dell Pro Max GB10/GB300），配合端到端软件栈与OpenShell运行时治理，能够在严守数据合规的前提下大幅提升开发者的实验效率与生产交付速度。 共享集群瓶颈与开发者流状态损耗 (4:29) Bali与Lawler分析指出，尽管过去一年各类开源模型、框架及向量数据库呈爆发式涌现，但企业AI项目的成败主要取决于工程师的迭代与验证速度。在依赖远程共享集群的传统工作流中，开发者在任务队列中每等待10分钟，往往需额外耗费20至25分钟来重新找回心智上下文。此外，多租户集群普遍存在环境配置漂移和版本冲突，导致开发者将大量时间消耗在调试运行依赖而非优化智能体逻辑上。 更为严峻的是，企业内部严格的知识产权与数据治理政策，严禁将敏感代码或专有数据上传至云端公共集群。加之日常编写代码使用的x86笔记本与数据中心目标部署环境（现代ARM架构CPU/GPU节点）之间存在架构分裂，这些阻碍迫使工程团队主动收缩测试方案，严重削弱了智能体架构的探索与创新活力。 桌面同构算力消解架构割裂 (7:08) 为消除漫长的排队并统一研发与生产环境，戴尔与NVIDIA联合推出了面向开发者工位的桌面级硬件平台。Dell Pro Max配备GB10（对应NVIDIA DGX Spark），提供128 GB统一显存，既能作为单兵日常工作站，也可通过Tailscale与SSH配置为工作组局域推理节点；后续规划的GB300（对应DGX Station）则将统一显存拓展至775 GB，旨在支持万亿参数级别大模型的本地运行与协同开发。 由于该系列平台直接采用与戴尔PowerEdge数据中心服务器一致的ARM架构及NVIDIA技术栈，开发者获得了环境同构优势。Lawler分享个人实践指出，在自身办公电脑缺乏本地GPU的情况下，他在局域网配置GB10成功运行Hermes模型并构建了汇报智能体；完成验证后，应用直接打包为标准tar归档文件并无缝交付数据中心上线，未经历任何底层代码修改或重构。 全栈软件协同与动态治理规范 (12:02) Bali强调，硬件算力仅能解决开发体验的一半挑战，底层必须依赖能够屏蔽硬件繁琐配置的软件生态。NVIDIA架构保持了近二十年的CUDA向下兼容性，使既有算法资产能在现代Blackwell架构芯片上直接运行。在系统上层，核心库深度优化了PyTorch和JAX框架，NVIDIA AI Enterprise提供经过安全漏洞修补与合规检验的企业级SDK，并通过标准化的NIM微服务容器降低对接LangChain、LlamaIndex等编排工具的集成门槛。 针对智能体自主调用外部工具引入的失控风险，NVIDIA Agent Toolkit内嵌了开源运行时引擎OpenShell。该引擎在系统运行时设定刚性边界：精确约束智能体所能调用的外部API范围、限制沙箱网络通信链路以守护企业内网，并在生成响应前执行内容过滤与隐私审核。这套治理机制在本地GB10系统、工作站及数据中心集群间保持完全一致的策略标准。 强监管与物理隔离场景的落地实践 (18:22) 演讲列举了两个因合规与保密要求无法依赖云端的企业生产案例。美国电力科学研究院（EPRI）受公用事业法规约束，严禁向公共云上传电网敏感资料。该机构基于掌上尺寸的单台GB10系统搭建了内部问答助手“Power Chat”，本地运行经FP4量化后的1200亿参数开源模型（GPT-OSS 120B，需约68 GB显存），在满足数据不出内网的同时，实现单用户每秒45个token、10个并发用户每秒15个token的检索吞吐量。 另一案例是承担卢卡斯影业等制作任务的视觉特效工作室Make。为了防止未上映影片资产泄露，该团队在物理断网的涉密工作间中部署了由10台GB10组成的集成机架，汇聚1280 GB统一算力。艺术家得以在完全断开外网的受控局域网内直接调用LTX及专用渲染模型，高效完成高分辨率终帧渲染、超分辨率提升与色彩缩放工作。 演讲展示了通过高集成度、大容量统一内存的桌面同构算力与治理框架，化解企业AI开发在隐私保护、排队延迟及环境割裂方面的实际路径。不过，发布内容重点展示了原型探索、本地推理与中小工作组场景的适配性，关于此类高密度桌面设备在持续高负载微调下的热管理、全生命周期硬件运维成本以及更复杂分布式训练场景的实际表现，源材料未做进一步说明。

Detailed notes — zh

## Background 本内容由 Ai4 于 2026 年 8 月 20 日发布在 YouTube 平台。演讲由 NVIDIA 的 AI 解决方案产品营销高级经理 Sama Bali 与戴尔科技（Dell Technologies）客户端解决方案群的 Logan Lawler 共同呈现，主要探讨如何通过将加速算力直接引入开发者桌面并结合 NVIDIA 全栈 AI 软件，彻底打破研发瓶颈，加速企业级 AI 智能体的构建与部署。 ## TL;DR 演讲围绕重塑 AI 开发者体验展开，指出当前团队面临的最大瓶颈并非模型质量，而是远程共享集群带来的排队等待、环境冲突与架构割裂。戴尔与 NVIDIA 联合推出以 Dell Pro Max（GB10/GB300）为核心的桌面加速算力方案，让开发者拥有高达 128GB 至 775GB 的独立统一显存，实现本地即时高频迭代。配合 NVIDIA CUDA、NIM 微服务、Agent Toolkit 及 OpenShell 安全运行时，开发者在桌面调试完成的智能体可零摩擦一键部署至私有数据中心。现场还分享了受监管电力科研机构（EPRI）单机本地运行 120B 大模型，以及好莱坞特效工作室多机堆叠实现高保密影视级渲染的落地案例。 ## Atmosphere & style 整个演讲节奏明快、生动且极富现场感，两位讲者配合默契，在严谨的技术布道中穿插着诸如‘Ctrl+C 与 Ctrl+V’、向同事幽默周报等接地气的调侃。现场互动热烈自然，从对开发者‘心流被打断’的深刻共情，层层递进到硬核的软硬件一体化赋能，让观众既能感受到工程落地上的务实与痛快，又充满对工位桌面直接掌控顶级算力的探索兴奋感。 ## Key takeaways - [01:17](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=77s) 企业构建 AI Agent 的首要瓶颈已从模型质量或专业技能转向算力资源的即时获取与本地迭代速度。 - [04:29](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=269s) 传统提交至远程共享集群的研发模式存在排队打断心流、环境依赖冲突、数据合规受限以及拉长反馈周期四大摩擦点。 - [04:29](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=269s) 现代 AI 数据中心加速转向 ARM+GPU 架构，若桌面端停留在传统 x86 架构将产生额外的跨架构兼容负担。 - [07:08](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=428s) 戴尔与英伟达推出 Dell Pro Max 系列（GB10 与 GB300），将数据中心同款 ARM+GPU 架构算力直接下沉至开发者工位桌面。 - [07:08](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=428s) Dell Pro Max with GB10 配备 128 GB 统一显存供单人专属加速，而 GB300 则拥有高达 775 GB 显存，可在桌面端承载 1 万亿参数大模型。 - [11:10](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=670s) 得益于桌面端与数据中心底层架构的高度一致性，本地调优完成的 Agent 环境可直接打包并一键无缝部署至生产数据中心。 - [12:09](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=729s) NVIDIA 软件栈提供跨越 20 年的 CUDA 向后兼容性，并在 GPU 内核层全面加速 PyTorch、JAX 及各类开源 Agent 框架。 - [12:09](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=729s) NVIDIA AI Enterprise 与 NIM 容器微服务为企业级 Agent 落地提供了符合合规审查的 SDK 和标准推理 API。 - [16:27](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=987s) 开源 NVIDIA Agent Toolkit 结合 OpenShell 运行时，为企业级 Agent 注入业务私域知识并设立严格的安全与网络行为护栏。 - [18:28](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=1108s) 美国电力科学研究院（EPRI）在单台掌上 GB10 上通过 FP4 精度成功运行 120B 大模型，实现数据不出本地的高吞吐知识检索。 - [18:28](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=1108s) 顶级 VFX 工作室在物理隔离环境中堆叠 10 台 GB10 聚合 1,280 GB 显存，无需上云即可在本地高效运行工业级视觉生成与渲染管线。 ## Detailed walkthrough ### [00:04](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=4s) 聚焦开发者体验：构建 AI 智能体的现实瓶颈 会议开场，来自 NVIDIA 的 AI 解决方案产品营销高级经理 Sama Bali 与 Dell Technologies 的 Logan Lawler 共同登台进行自我介绍。Logan 幽默地澄清了自己在戴尔的业务归属：戴尔内部主要分为两大业务群，负责服务器、存储和网络的 ISG（基础架构解决方案群）“并不归我管”，他所在的则是负责笔记本、台式机及终端 AI 战略的 CSG（客户端解决方案群）。 Sama 明确指出了本次演讲的核心主旨——全面重塑“开发者体验”（Developer Experience）。尽管当前行业都在热议如何构建和运行 AI Agent（智能体），但在与一线开发者的无数次交流中，对话最终都会回归到最真实的痛点：构建这些智能体的人究竟在哪些环节被卡住了？接下来的讨论将围绕开发者面临的效率瓶颈展开，阐述如何通过将加速算力直接引入工位桌面、结合深度优化的软件栈，彻底释放开发者的生产力与创造力。 ```mermaid flowchart TD accTitle: AI 开发者传统远程集群流程与桌面加速算力流程对比 subgraph SharedCluster["传统远程集群工作流（高延迟与环境摩擦）"] A["编写 Agent 代码"] --> B["提交任务至远程共享集群"] B --> C["长时间排队等待算力分配"] C --> D["测试并排查环境/依赖冲突"] D --> A end subgraph DeskCompute["桌面专用加速算力工作流（即时反馈闭环）"] E["本地桌面编写 Agent 代码"] --> F["GB10 / GB300 专属算力即时测试"] F --> G["快速调优并一键无缝部署至数据中心"] end ``` --- ### [01:17](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=77s) 爆发的智能体生态与首要瓶颈：算力访问与迭代速度 在过去短短的 12 个月里，AI 智能体生态呈现出指数级倍增的趋势。模型、工具链、开发框架、向量数据库以及底层存储的选择呈井喷式爆发。然而，选择的多样性对开发者而言却成了一把双刃剑：当新技术和新模型推出的速度远远超越人类的跟进极限时，开发者每天都要被迫做出艰难抉择——“我到底要不要尝试这个新模型？它会破坏我现有的系统吗？这个新版本在实际业务中真的更强，还是单纯跑分更高？”而验证这些疑问的唯一途径，就是亲自上手运行测试。 Sama 指出，企业在推进 AI 落地时面临的头号瓶颈既非开发者的专业技能，也不是模型本身的质量或预算限制，而是**算力资源的即时获取与迭代自由度**。在日新月异的技术浪潮中，唯有具备极速迭代能力的团队才能保持领先。Logan 在现场互动中向观众发问，调研大家对开源模型（如 OpenChat 或 Nous Hermes 系列）的了解情况，发现现场约有一半的观众感到陌生。Logan 感慨道，开发者天生充满好奇心且热衷于动手探索，但如今 AI 领域的演进速度甚至超过了两年前的 Stable Diffusion 时期，“今天我们所使用的大多数工具，在两年前甚至根本不存在”。 - **模型与框架激增**：开发者难以仅凭评测指标判断模型优劣，必须进行本地实测。 - **核心瓶颈转移**：从“构建什么”转变为“能否快速获取算力以维持高频迭代”。 - **生态演进飞速**：工具链与开源架构日新月异，促使团队必须具备极短的验证周期。 --- ### [04:29](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=269s) 传统共享集群的四大摩擦点与架构割裂 在传统的研发流程中，开发者编写完代码后必须提交至远端共享集群，随后陷入漫长的排队等待，获得实例后进行调试，再反复循环。Sama 总结了该模式下扼杀创意的四大核心痛点： 1. **远程资源排队等待**：当开发者的灵感迸发时，却不得不排队等待算力。即使只等待 10 分钟，打断心流后往往需要额外耗费 20 到 25 分钟才能重新进入深度编码状态。 2. **共享环境相互干扰**：多人在同一集群上协作，其他成员更改环境配置或依赖包后，开发者不得不花费大量时间去调试被破坏的底层运行环境，而非专注于自身的 AI 智能体逻辑。 3. **数据隐私与合规限制**：各行业中普遍存在严禁离开企业内网的核心专有数据与知识产权资产，导致最关键的业务场景反而无法使用最强劲的云端加速算力。 4. **反馈循环拉长导致创造力萎缩**：由于算力获取困难且占用时间受限，开发者往往草草测试几个方案便被迫放弃深入探索，严重阻碍了创新可能。 Logan 补充了第五个关键难题——**计算架构的不一致性**。目前多数现代 AI 数据中心正在向 ARM 架构的 CPU 与 GPU 协同计算迁移，而如果开发者的桌面端依然停留在传统 x86 架构，在向最新 NVIDIA GPU 或戴尔服务器提交任务时，就会产生额外的架构兼容性负担。 --- ### [07:08](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=428s) 算力直达桌面：Dell Pro Max 系列与全栈协同 为了打破这一僵局，戴尔与 NVIDIA 合作推出了将数据中心级算力下沉到工位桌面的解决方案。Logan 调侃道，不管是叫 NVIDIA DGX Spark 还是 Dell Pro Max with GB10，“本质上都是同款硬核产品（Ctrl+C 与 Ctrl+V）”。该设备专为解决上述环境冲突、排队延迟及 ARM/GPU 架构统一性问题而生。 Logan 建议不要将 GB10 仅作为日常办公主电脑，而是作为一台专属的辅助加速工作站，通过 Tailscale 或 SSH 接入，或者作为工作组内部的网络化推理端点。此外，戴尔即将推出定位更高的 Dell Pro Max with GB300（对标 DGX Station），其性能大幅跃升，统一显存（Unified VRAM）直接从 GB10 的 128 GB 飙升至 775 GB，算力提升近 20 倍，能够直接在桌面端承载高达 1 万亿（1 Trillion）参数规模的大模型，足以匹敌数据中心内的整套机架服务器。 | 规格维度 | Dell Pro Max with GB10 (对标 DGX Spark) | Dell Pro Max with GB300 (对标 DGX Station) | |:--- |:--- |:--- | | **定位场景** | 开发者单人专属辅助加速系统 (1:1 独立算力) | 10–12 人中型工作组 / 部门级桌面 AI 数据中心 | | **统一显存 (Unified VRAM)** | 128 GB | 775 GB | | **参数支持规模** | 百亿 / 千亿级模型快速微调与 Agent 原型构建 | 最高支持 1 万亿参数 (1T) 大模型推理与实验 | | **架构一致性** | 与数据中心完全相同的 ARM+GPU 架构及 NVIDIA 软件栈 | 与数据中心完全相同的 ARM+GPU 架构及 NVIDIA 软件栈 | Sama 强调，工位算力不仅带来了即时的反馈闭环和绝对的数据隐私安全，还赋予了开发者 100% 的 GPU 控制权。由于桌面硬件与戴尔后端服务器均运行相同的 NVIDIA 软件栈及底层架构，开发者在工位原型验证成功的 Agent 应用，可以毫无阻碍地一键复刻并无缝部署至大型数据中心。在谈及实际使用感受时，Logan 准备分享一个生动的故事：即便戴尔与 NVIDIA 是极度紧密的战略合作伙伴，NVIDIA 团队（特别是未到场的 Crystal）也时刻密切关注着他们究竟在用这些桌面怪兽搞出什么新名堂…… ### [11:10](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=670s) 戴尔内部实践：从本地桌面算力到数据中心无缝部署 在许多企业环境中，开发者往往面临着基础硬件不足的窘境。Logan Lawler 幽默地分享了自己在戴尔内部的真实经历：公司配发的标准办公电脑根本没有独立 GPU，而他当时正需要构建一个自动化智能体，用来定期向英伟达的 Crystal 等团队成员汇报每周工作进展——比如幽默地盘点自己在 Ai4 大会上要和 Sama 一起登台演讲好几次。由于无法将敏感数据直接扔到公有云，他迅速在本地网络接入了一台配置强大的 GB10 设备。这台设备就放在他的办公桌旁，不仅提供了绝对的私密性，更凭借高达 128 GB 的显存让他能流畅运行 Hermes 模型来开发和调优智能体，在本地获得了毫秒级的即时反馈。 更关键的价值在于开发与部署的一致性。当他在本地把智能体调试完善后，戴尔内部的数据中心团队直接将整个环境打包成一个标准的 tar 压缩包，发送给数据中心的工程团队便实现了直接上线部署，整个过程完全省去了跨平台重写和环境重新适配的繁琐折磨。这生动证明了将高规格算力直接放在开发者手边，能够彻底打破等待远程算力排队的研发瓶颈。 - **办公环境算力破局**：无需依赖配备强大 GPU 的厚重工作站，通过本地网络挂载桌面级紧凑加速设备（如 GB10）即可满足开发需求。 - **128 GB VRAM 本地支持**：利用大容量统一显存轻松承载类似 Hermes 的大模型，实现极速迭代。 - **零摩擦交付**：本地开发镜像可直接打包（tar/zip）无缝移交至戴尔数据中心生产环境上线。 --- ### [12:09](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=729s) 软硬一体：NVIDIA AI 全栈加速与企业级支持 有了合适的硬件只是成功了一半，软件生态才是决定开发者能否以最快速度构建应用的关键。Sama Bali 详细拆解了 NVIDIA 与戴尔深度协同的全栈 AI 软件体系。从底层硬件（Dell Pro Max、GB10、GB300）向上，第一层是高度优化的 CUDA 与 GPU 驱动层。英伟达在此投入了极大的工程力量以确保极致的向后兼容性——开发者即便运行 20 年前编写的 CUDA 代码，在最新一代的硬件上依然可以顺畅运行。这意味着无论代码最初是在 GB10、GB300、戴尔笔记本还是戴尔数据中心编写，都能天然实现全平台兼容，开发者完全无需为底层的驱动调优而操心。 再往上一层是深度学习框架与核心库，涵盖 PyTorch、JAX 等主流开源框架，英伟达在 GPU 内核级别进行了自动化适配与性能加速。在企业级运维层面，NVIDIA AI Enterprise 提供了经过严格安全检查、隐私验证和漏洞审查的生产级 SDK 与运行库，虽然开发者可能更关注写代码本身，但这对 IT 与架构部门的合规投产至关重要。在应用层，NVIDIA 提供了容器化形态的 NIM（NVIDIA Inference Microservices）微服务，开发者可通过标准化 API 将高性能推理引擎直接嵌入智能体流水线，并对 LangChain、LlamaIndex、CrewAI 等主流 Agent 框架进行了原生优化，避免开发者陷入硬件兼容性的泥潭。 ```mermaid flowchart TD accTitle: NVIDIA 全栈 AI 软件架构 subgraph AppLayer["应用与智能体层 (Application & Agent Layer)"] A1["AI Agents & 开发者应用"] A2["Agent 框架优化: LangChain / LlamaIndex / CrewAI"] A3["NVIDIA NIM 微服务 (容器化推理引擎与标准 API)"] end subgraph EnterpriseLayer["企业级保障层 (Enterprise Grade)"] B1["NVIDIA AI Enterprise: 生产级安全、隐私验证与认证 SDK"] end subgraph FrameworkLayer["核心库与框架层 (Libraries & Frameworks)"] C1["PyTorch / JAX / 开源框架生态 (内核级优化)"] C2["CUDA 加速库 (cuDNN, TensorRT 等)"] end subgraph HardwareDriverLayer["基础驱动与硬件层 (Driver & Hardware)"] D1["CUDA 驱动与 GPU 驱动 (长期向后兼容)"] D2["Dell Pro Max / GB10 / GB300 / 戴尔数据中心算力"] end AppLayer --> EnterpriseLayer EnterpriseLayer --> FrameworkLayer FrameworkLayer --> HardwareDriverLayer ``` - **20年跨代向后兼容**：CUDA 驱动层彻底屏蔽底层差异，保护历史代码资产，打通桌面端到数据中心的迁移通道。 - **开箱即用的框架加速**：PyTorch 与 JAX 在 GPU 内核层全面优化，免除开发者手动调优开销。 - **NIM 容器微服务**：标准 API 封装的高性能推理单元，即插即用集成到复杂业务链条中。 --- ### [16:27](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=987s) NVIDIA Agent Toolkit 与 OpenShell 运行时护栏 为了让开发者能够真正掌控并定制智能体，Sama 重点介绍了开源架构——NVIDIA Agent Toolkit。该平台充当了构建、运行、定制和治理 AI 智能体的一站式工具包。它完全依托底层 CUDA 算力库进行加速，不仅支持全球主流的开源基础模型，也深度集成了英伟达自研的 Nemotron 系列模型。搭配底层的 AI 数据平台，开发者能够顺畅地为智能体注入特定企业的私域业务上下文与知识库。 在整个架构中，Sama 特别强调了被称为 "OpenShell" 的开源运行时模块。企业部署智能体最大的顾虑在于失控，而 OpenShell 能够帮助团队制定严格的执行策略、安全隐私边界与网络访问规则，从底层明确定义智能体“可以做什么、严禁做什么”。从本地单机原型验证（如在 GB10 上开发），到横向扩展至 GB300，再到最终部署在私有数据中心或指定云端，这套软件架构保证了全流程策略的一致性与可控性。 ```mermaid flowchart LR accTitle: NVIDIA Agent Toolkit 核心架构 subgraph DevPlatform["NVIDIA Agent Toolkit 架构"] direction TB M["模型层: 开源模型 / Nemotron"] D["AI 数据平台 (业务私域上下文与 RAG)"] O["OpenShell 运行时 (安全策略 / 隐私边界 / 护栏限制)"] end subgraph DeployTargets["多端无缝部署目标"] direction TB T1["GB10 本地桌面端"] T2["GB300 工作站"] T3["企业私有数据中心 / 云端"] end DevPlatform --> DeployTargets ``` - **开源可控架构**：支持灵活切换包括 Nemotron 在内的各种开源前沿模型，避免供应商锁定。 - **OpenShell 护栏机制**：内嵌网络隔离、权限策略与行为围栏，为企业智能体落地提供安全底线。 - **端到端生命周期覆盖**：从本地环境无缝过渡到大规模分布式集群，软件调用栈完全保持一致。 --- ### [18:28](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=1108s) 真实落地场景：受监管电力机构与重度特效工作室 在演讲的最后阶段，两位讲者列举了严苛现实场景下的客户案例。第一个案例来自美国电力科学研究院（EPRI，Electric Power Research Institute）。作为典型的受严格监管行业，电力科研机构的核心数据与技术文档严禁上传至公有云。EPRI 借助手掌大小的 GB10 紧凑设备构建了名为 "Power Chat" 的本地 AI 助手，该系统直接在本地运行高达 1200 亿参数（120B）的开源大模型。通过 FP4 量化技术，原本需要 68 GB 显存的庞大模型被轻松塞入单台本地硬件中。在单用户交互时，推理速度达到了惊人的 45 tokens/秒；即便是扩展至 10 位并发用户同时查询，系统依然能保持 15 tokens/秒的高吞吐输出，彻底打破了高参数模型无法本地低成本部署的固有认知。 ``` +-----------------------------------------------------------------------------------+ | EPRI: "Power Chat" 本地大模型系统 | +------------------------------------+----------------------------------------------+ | 核心痛点 | 强监管行业，核心数据严禁上传公网云端 | | 部署硬件 | 单台便携紧凑型 GB10 (手掌大小) | | 运行模型与精度 | 120B 参数级开源大模型 (FP4 量化) | | 显存占用 | 约 68 GB 本地显存需求 | | 性能表现 (单用户) | ~45 tokens/s | | 性能表现 (10 用户并发) | ~15 tokens/s | +------------------------------------+----------------------------------------------+ ``` 另一个案例来自为卢卡斯影业（Lucasfilm）等好莱坞顶级片方制作视觉特效的 VFX 工作室。由于电影 IP 资产价值极高，电影制作行业有着严密的保密纪律，特效制作人员甚至需要在物理封闭的独立保密房间内工作，资产绝对无法调用外部云端大模型。该工作室在本地机房搭建了由 10 台 GB10 堆叠组成的系统，聚合了高达 1,280 GB 的庞大显存算力，直接在本地运行 LTX 等前沿视觉生成与渲染模型，顺畅完成镜头最终帧渲染、AI 超分辨率提升（Upres）以及色彩校准等全套重度管线。在演讲结束前，讲者热情邀请现场观众前往 137 号戴尔展位，亲身体验 GB10 与 GB300 的实机性能。 - **EPRI 强监管突破**：在单台掌上 GB10 上以 FP4 运行 120B 参数超大模型，在本地保障数据安全的前提下实现企业级文档智能检索。 - **VFX 极高保密渲染**：堆叠 10 台 GB10 打造 1,280 GB 显存本地集群，支撑影视工业级超分、调色与最终帧渲染。 - **展位互动**：戴尔与英伟达在现场 137 号展台展示实机运行效果，直观呈现开发者体验的跃迁。 ## Notable quotes > [01:17](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=77s) 今天我们所使用的大多数工具，在两年前甚至根本不存在 — Logan Lawler > [07:08](https://www.youtube.com/watch?v=7-tZU2I7mHc&t=428s) 本质上都是同款硬核产品（Ctrl+C 与 Ctrl+V） — Logan Lawler ## Mentioned Sama Bali, Logan Lawler, NVIDIA, Dell Technologies, Dell Pro Precision, ISG (Infrastructure Solutions Group), CSG (Client Solutions Group), AI Agent, OpenChat, Nous Hermes, Stable Diffusion, ARM, x86, NVIDIA DGX Spark, Dell Pro Max with GB10, Dell Pro Max with GB300, DGX Station, Tailscale, SSH, Crystal, Ai4, CUDA, PyTorch, JAX, NVIDIA AI Enterprise, NIM (NVIDIA Inference Microservices), LangChain, LlamaIndex, CrewAI, NVIDIA Agent Toolkit, Nemotron, OpenShell, EPRI (Electric Power Research Institute), Power Chat, FP4, Lucasfilm, LTX ## Video description Sama Bali - Sr Manager, AI Solutions Product Marketing, NVIDIA Logan Lawler - Dell Pro Precision AI Strategy, Dell Technologies Building AI agents requires more than great models. It demands a developer experience designed for speed. In this session, Dell and NVIDIA show how bringing accelerated compute closer to developers, combined with NVIDIA's optimized AI software stack, unlocks a new level of productivity for building AI agents. Learn how Dell and NVIDIA equip development teams with everything they need to build, iterate, and deploy intelligent agents at enterprise scale. [Source](https://www.youtube.com/watch?v=7-tZU2I7mHc)

Source quotes

[1:17] Logan Lawler: 今天我们所使用的大多数工具，在两年前甚至根本不存在 [7:08] Logan Lawler: 本质上都是同款硬核产品（Ctrl+C 与 Ctrl+V）

Source quotes

[0:04] Sama Bali: Over the preceding twelve months, the agent landscape has expanded dramatically, giving engineers an overwhelming abundance of choices across foundation models, tooling, agent frameworks, storage solutions, and vector databases. [0:04] Logan Lawler: Access to compute—rather than developer capability, model availability, or budget—has become the primary bottleneck in enterprise AI development. [4:29] Sama Bali: Waiting for remote resources disrupts flow state; a ten-minute wait in a queue often costs an engineer twenty to twenty-five minutes just to regain mental context. [4:29] Sama Bali: Multi-tenant shared clusters suffer from environment drift and configuration collisions, forcing developers to spend valuable time debugging broken environment dependencies rather than their actual AI logic. [7:08] Logan Lawler: The upcoming Dell Pro Max with GB300 scales unified memory capacity from 128 GB of unified VRAM on the GB10 up to 775 GB on the GB300—capable of handling trillion-parameter class models and rivaling multi-rack data center configurations. [12:02] Sama Bali: Raw accelerated compute solves only half of the developer experience equation. Speed requires a software ecosystem that removes hardware configuration toil so developers can focus purely on application logic. [12:02] Sama Bali: CUDA code authored nearly two decades ago compiles and runs seamlessly on modern Blackwell-generation chips, ensuring assets built on a GB10 transition identically to GB300 workstations, Dell enterprise servers, or public clouds. [16:27] Sama Bali: Crucial to enterprise safety is OpenShell, an open-source runtime engine embedded in the toolkit that governs runtime agent behaviors. [18:22] Sama Bali: On the GB10, EPRI achieves 45 tokens per second for an individual user and maintains 15 tokens per second when scaled across ten concurrent enterprise users.

Original transcript

[0:04] All right folks, good afternoon. Very nice to meet  you all. We will start first with introductions. [0:10] Uh my name is Sam Bali. I lead AI solutions  product marketing at NVIDIA. And I am going to [0:15] gang up today with Logan. Logan, introductions. So  Dell, two sides of the house. ISG server storage [0:21] networking not me CSG me laptops desktops AI  strategy. Awesome. Okay. So our agenda today [0:30] is to just talk about one key thing which is all  about the developer experience. Right? You've all [0:36] heard a lot about agents building them running  them but every conversation that I tend to have [0:42] essentially goes back to that one topic which  is you know let's talk about the people who are [0:46] actually building these agents and we're seeing  you know where they have those common bottlenecks. [0:51] And this is what the entire session is going  to be all about. We'll talk about everything [0:56] from where we're seeing developers get stuck, how  you know bringing accelerated compute to them at [1:02] the desk is going to help and then we'll talk  about you know the optimizations with software [1:06] and how you can actually elevate that entire  developer experience. So that's our plan for [1:11] the next 20 minutes. I'm going to get started  first by talking about you know this entire [1:17] era of agents and where we see developers.  So we've got three key things happening here. [1:23] The first one we are seeing is that the agent  landscape is doubling and especially with the last [1:30] 12 months itself right you've got more and more  choices when it comes to models tools frameworks [1:37] u system stoages you've got vector databases  right and abundance is a great thing till you know [1:44] it comes down to the developer who has to then  start thinking about all these different kinds [1:49] of choices and it becomes even more interesting  when you see that you have new models and new [1:56] frameworks coming in you know faster than your  developer can keep up with because at this point [2:01] in time it is your developer who has to make that  decision of do I try this new model is it worth [2:08] it is it going to break what I've already built  here u they also have to think about is this new [2:14] version of the model you know that much better in  reality or is it just you know benchmarking better [2:19] itself so all the problems that the developer has  to think through and the only way honestly is to [2:26] think I mean to think through this is going to be  about testing these models running it on your own [2:31] which then gets me to my next point here and  that's that number one bottleneck that I get [2:37] to see right developers want to try things that's  the only way for them to actually experiment test [2:44] learn but getting access right getting that  iteration speed freedom becomes the number [2:50] one bottleneck not the developer scale, not  you know, not having the right kind of model, [2:56] not any kind of budget issues, but having access  to compute to actually get started with all of [3:02] these new frameworks. So what we see especially  with enterprises is that it's not really trying [3:10] to figure out what you are trying to build.  It becomes at the end of the day the developer [3:14] freedom, the developer iteration speed because  you have so much happening right now, right? [3:19] There are so many new announcements every single  day with models, frameworks, tools. It's the teams [3:25] who have the ability to iterate faster. It's them  who are able to keep up with all of this. Logan, [3:32] you tend to build a lot of different kinds of  AI agents. I try. Do you relate to these? Um, [3:38] yeah. Cuz I mean I mean, show of hands, who's an  OpenC fan? Show of hands. Who's a Hermes fan? Who [3:46] has any idea what I'm talking about right now?  if you have no idea. Okay, that's about 50%. So, [3:51] it changes. It's It's hard. I think developers  generally are curious minds and like to tinker [3:57] and toy. And there's going to be a new version of  Hermes. There'll be a new version coming out that [4:02] people are going to tinker with. And the space,  like you said, is evolving so rapidly. It's it's [4:07] not as easy as just saying, "Hey, here's this  model kind of like let's go." So, it's like it [4:13] was kind of in the stable diffusion like two  years ago. It's just rapidly evolving. Yep. I [4:18] It's interesting. All the tools that we see today  didn't even exist. Most of them didn't even exist [4:22] two years ago, right? Like the speed is is so fast  right now. Uh let's move forward, right? Let's [4:29] talk about the challenges. Where are we seeing  that big bottleneck for developers? Now, what you [4:35] see on the right side is that you know the usual  pipeline for developers. They write the code, [4:40] they submit it to uh a shared cluster. That's  when they wait in Q trying to get that instant to [4:46] actually go test it out themselves and then they  debug and then the cycle keeps getting repeated [4:52] every single time with every single you know uh  instance that they're testing out every single day [4:57] itself. Now we see four key issues here. The first  one is waiting for the remote resources. Right now [5:06] put yourself in that developer mindset. Right?  You've got this great idea. You've got creativity [5:12] flowing. You're going to go test this idea out.  And guess what? Now you're waiting in queue. Which [5:19] means that it took you let's say 10 minutes to get  that shared resource. It's going to get you 20 25 [5:24] minutes to be back in the zone itself of building  that specific idea that you had. Right? The second [5:31] problem we see is with the shared clusters. Now  here you have multiple people trying to share the [5:38] same resource. One of them went ahead changed the  configuration or change the environment and now [5:43] me as a developer I'm going to spend more and more  time just debugging the environment not debugging [5:49] my AI project or my AI agent but debugging that  environment itself. The third key problem we see [5:56] is in a lot of industries and and I would say I  want to say in a lot of most companies you have [6:03] certain teams which have proprietary data which  just cannot leave your network. Right? So at that [6:08] point for those use cases you don't have your  fastest compute available altogether and then [6:15] last but not least it's your feedback loops right  they tend to really really slow that entire you [6:21] know creativity process because now your developer  is waiting he's forgotten what he was doing and [6:26] at most scenarios we end up seeing developers  they're like you know what I have this for a [6:30] very short period I'm just going to try four ideas  and that's about it and move on which again is now [6:37] hampering your creativity. Can I add one more?  Yes, please. Which kind of ties into our next [6:42] slide is when you're doing work, right, whether  you're writing like x86 or you're writing ARM, [6:47] that's just an additional complexity of where  you're sending it to, right? Like for example, [6:51] if you have the latest Nvidia GPUs or Dell powered  servers running, you know, kind of ARMbased CPUs [6:56] and GPUs or you have more, I won't say legacy  because they're still awesome, but like H100's [7:01] and H200s, right? It's a little bit different  architecture, which leads us to the next slide. [7:08] Okay. How many people have heard of the Nvidia  Spark device? Huh? DGX. Nvidia DGX Spark. Pardon [7:16] me. How many of you heard about the Dell Pro  Max with GB10? Oh god, it hurts my heart. It's [7:22] the same thing. Control CRLV. So basically, it's  the exact same product. And this is what it was [7:28] really designed to do, right? Is bring server  level compute down to the desk side. So you [7:33] could give your developers to solve kind of those  four problems and kind of solve that fifth problem [7:38] right around architecture right because most data  centers are going to kind of an ARMbased GPU CPU [7:43] combined right so the biggest thing to take away  from this what I love about the GB10 it does two [7:49] things one it can be your individual system which  it can be your daily driver I don't necessarily [7:53] recommend that what I recommend is you have it  as an auxiliary system where you can push some [7:59] of those workloads via tail scale SSH however  you want to do it or we'll talk about this use [8:04] case at the end. You could put them on a network  cluster and then have a workg groupoup actually [8:08] go out and hit those inference endpoints and kind  of have your own AI data center within your work [8:14] group. Right? The Dell Pro Max with GB300 which  is equivalent to the DGX station has not launched [8:20] yet. If you ask me the date, I can't tell you  probably in a couple of weeks. Um which think [8:25] of GB10 as the smaller brother or smaller sister,  younger sister to the older brother, older sister. [8:31] So you're kind of going up by a scale of about  20 in terms of performance with tops in terms of [8:36] you know one trillion parameter size but you're  going from 128 gigs of unified VRAM up to 775. [8:44] So I mean that rivals couple of racks and stacks  of you know servers sitting in a data center. So [8:50] the way that I like to think about the stack is  think of the GB10 as a one two one. the GB300, [8:58] think like medium business and up where it's more  of a work group like 10 to 12 working with it and [9:04] then obviously up from there you go straight  to the data center. All the problems that we [9:10] discussed before, right? It all comes down to  those developers having that dedicated compute, [9:15] the freedom of going ahead doing testing,  being able to actually experiment, prototype, [9:21] build something. This is what these platforms  actually solve for, right? You've got that [9:26] dedicated instance for each developer. They have  the freedom to go ahead with their use cases and [9:32] the one common thread being these have that same  architecture that's running in our Dell servers [9:37] altogether. They run the same software stack from  Nvidia. So you have the ability to build something [9:43] at your desk. You have full autonomy around it.  But then you have the ability to move these to [9:48] the data center, reproduce these easily without  having any kind of issues. So that gets me to you [9:54] know how and why bringing that compute right at  the desk actually helps you so much because now [10:00] you again have that instant feedback loop. I have  a new version that I want to try. I can do that [10:06] at my desk. I don't have to queue up. I don't  have to wait. Uh I have full data privacy. So [10:12] even for use cases where you had to have you know  your uh IP protected data they get that same level [10:18] of accelerated compute that all other workloads  within your organizations get third being full [10:25] GPU control right the developers have that full  autonomy they don't have to share especially a [10:30] GB10 right that can be one for each developer  itself they've got that full autonomy on the [10:36] system and then third being consistent environment  you define the policies the software West stack, [10:42] all of it to make sure that it runs at your desk,  but it also runs in the data center. Now, Logan, [10:48] you've built a lot of projects on GB10 and you've  moved them around to different places. I have. [10:54] What has been your experience with it? Um, I'll  tell you a good story about kind of solved all of [11:00] these problems is that Nvidia great partner, but  they like to know what we're doing, especially [11:05] Crystal who's not here to defend herself. She  likes to know what me and my team are doing. the [11:10] corporate system that I get, guess what? Doesn't  have a GPU. Nothing I can do about that. But what [11:16] I was able to do instead of trying to build an  agent where it would deliver kind of a weekly [11:21] summary to Crystal and the Nvidia folks around  what are we doing? What are the projects? Oh, I'm [11:25] speaking AI4 with Sama like four different times,  yada yada yada. I was able to get a GB10 very [11:31] quickly on the network where I was able to set up  my agent and harness that gave me instant feedback [11:36] as I built it and let me refine it. It was private  because it was clearly right at sitting at my desk [11:41] at work. I had 128 gigs of VRAM which kind  of shot through me using Hermes to build the [11:46] agent and it was consistent because ultimately  what we did is a bigger part of Dell because we [11:52] do have a Gentic projects going on. I was able to  literally just tar up [snorts] my you create like [11:57] a tar file zip it up send it to the developers in  the data center and they deployed it for me now. [12:02] So without [snorts] that that wouldn't have been  possible. Very cool. Okay. So we've solved that [12:09] first problem we started off with, right? When it  came to the developer experience, we spoke about [12:13] having, you know, the ability to iterate quickly.  I'm now going to move forward and we'll talk about [12:20] the second half of the equation, right? Because  just having the right hardware is not the full [12:25] story. You want to make sure your developers have  the ability to get started with building their [12:30] applications as quickly as possible. And that's  where software tends to play a much much bigger [12:36] role. So here is that full NVIDIA AI software  stack. We've made sure that each and every [12:42] layer that you're seeing here is optimized to  the hardware that you're going to be using. So [12:48] I'm going to start from you know the bottom layer  itself. That's where your hardware with Dell Pro [12:53] Max with GB10 or GB300 tend to sit. Right on top  of that are your CUDA and GPU drivers. So this is [13:01] again a software layer which will make it easy for  your developers to talk directly to the hardware. [13:06] You don't have to worry about configuring the  hardware every single time that you're downloading [13:10] a model. This is the piece that is taken care of  you. Now I do want to remind you there is a lot of [13:16] work that gets into these drivers and this is what  makes it possible that if a developer had written [13:20] a code I want to say 20 years ago using CUDA that  still runs today on any of our newer generations. [13:28] So there's a lot of backward compatibility to make  sure that anything that you're building today on [13:33] any of the platforms. It could be on the GB10,  GB300, you want to move it to uh a Dell laptop, [13:39] you want to move to the Dell data center. It's all  compatible. So you don't have to worry about this [13:44] layer at all. I'm going to move up to the  CUDA libraries and deep learning deep learning [13:49] frameworks. Now this is where we are working with  almost all open-source framework providers and [13:57] making sure that once you are using any of these  frameworks there is automatic compatibility there [14:03] is testing validation and in a lot of scenarios  optimization done there as well so that you as a [14:10] developer gets the best experience without having  to do any kind of rework there. Then we have the [14:16] Nvidia AI enterprise and I know developers don't  care about this at all but IT people really care [14:22] about it because here is where you get production  gear grade access to our all the frameworks they [14:29] are thoroughly checked for security privacy this  is everything that anytime you're wanting to move [14:35] to production we've got production grade uh  SDKs frameworks libraries available which you [14:41] can move into production level deployments and  then last but not the least are your developer [14:47] applications and AI agents. This is where we see  the developers actually using their creativity to [14:53] build different kinds of agents. And we've made  sure that any tool, any model they're using, [15:00] uh any framework that they're using, we've made  sure that that it's already tested. We've got [15:05] this massive ecosystem with Nvidia. It's tested,  it's validated. In a lot of scenarios, it's also [15:10] optimized. So most of the common tools out there  will run out of the box on these platforms. I've [15:17] got another view of this entire layer as well. And  then again you'll see the CUDA drivers. This is [15:23] where we are making sure that they're optimized  at the GPU kernel level. So developers don't [15:28] really have to do any kind of work. Uh when it  comes to AI frameworks, most of the most common [15:34] frameworks out there, right? PyTorch, Jax, these  are all optimized for these set of platforms. [15:40] So developers get the best experience out of the  box. Uh talking about inference engines, uh Nvidia [15:47] themselves provides Nvidia Nim microservices.  Think of these as containerbased microservices. [15:54] U you can drop them using standard APIs into  any agent applications and they're good to go. [16:00] And then last but not the least, we've got our  agent framework. So if you're working with folks [16:04] uh applications from lang chain, llama index,  crew AI, we've got full optimizations across [16:12] these agent frameworks as well to make sure that  your agentic pipelines have full support. Again, [16:18] the idea is to elevate that developer experience.  We don't want them going into a rabbit hole of [16:23] making sure that the software stack they're  trying to use works with the hardware. Nvidia [16:27] has done the work for you already. And that gets  me to my Nvidia agent toolkit. I won't be doing [16:33] justice if I don't talk about this. I know here  almost everybody is looking to actually build a [16:38] lot of these agents. This is that one open-source  architecture, right? This is that one-stop shop [16:45] platform which is going to help you build and  run agents but also have the ability to actually [16:51] customize and control these agents. So again, uh  this is powered by a lot of the CUDA libraries. [16:58] So you get the same acceleration that you get with  a lot of the apps that you're using today for your [17:03] agents. You have the ability to use literally any  open-source model out there to build your agents, [17:10] including the models from Nvidia. They're called  Neotron models. And then last but not the least, [17:15] we've got our AI data platform here. This is  what gives you the ability to provide context to [17:21] the agent that you're building, right? So that it  understands your business. Now one thing I do want [17:27] to call out here is the green bucket that you're  seeing towards the end which is open shell right [17:33] as you are building your agents you want to make  sure that you define the policies for the agent [17:39] you define the guardrails and this is what open  shell gets you. This is your open-source runtime. [17:46] It helps you define you know your security privacy  networking policies essentially telling what the [17:52] agent can and cannot do. So this is what gets you  that full coverage of making sure that your agent [17:59] acts the way you define it is going to be acting.  So this is that one architecture and I do again [18:05] want to remind everybody this architecture helps  you build agents locally. You can get started on [18:11] a GBTL10, move it to a GB300, move it to a data  center, move it to a cloud of your choice as well. [18:17] So it's literally starting with the software  layer for this building your agents and then [18:22] gradually moving it to any of the deployment  targets. Okay, I don't think I'll do a good job [18:28] if I don't talk about any of our customers and  how they're using these platforms and software [18:33] stack as well. So I've got one quick story uh for  EPRI. This is Electric Power Research Institute. [18:40] uh they're based here in the US and as you can  imagine just like any other regulated industry [18:46] they don't have the ability to move a lot of their  data to the cloud. So they came up saw GB10 in [18:52] action and they've built this uh application  called Power Chat. So what it does is a it's [18:58] it is ingesting all of their documents and it's  becoming an AI assistant. Now what I do want you [19:04] to go for is seeing they actually have the ability  to run a gigantic model. So they're using GPT OSS [19:12] 120 billion parameter model and they're using this  at uh FP4 which means that at a normal system this [19:20] would require about 68 gigs of compute which  again most laptops most on-prem devices don't [19:27] get to you but this one tiny small device which  fits in my palm altogether has that much compute [19:33] that they're running this agent all locally uh for  a single user they're seeing about I want to say [19:40] 45 tokens per second, but you have the ability  to actually scale that same agent that they've [19:45] built to about 10 users and even there they're  seeing 15 tokens per second. That's that's that [19:50] performance that they're seeing across the  board. We've got another story for you. So, [19:56] this one's a great one. I've got 25 seconds to  do it and I'll make through it quick. So, make [20:00] is a VFX studio. Um, privacy is a huge concern.  I mean, they do work with Lucas Films and others, [20:07] right? Where, believe it or not, there's literally  rooms that people get locked into to do work. So, [20:12] the IP of what movie they're working on can't  escape. Obviously, they can't be sending this [20:17] to cloud models. So, they built a stack of 10GB10s  that set in a data center. 1,280 gigs of compute [20:25] running LTX and other models, which allow them to  render, do final frame, do upres, color scaling, [20:33] etc., all locally and I think you're telling  us to leave. Okay, so that was us. Again, [20:41] you have a lot of options out there. Come see  us at the Dell booth. We are at booth 137. You [20:48] get get to see GB10, GB300 in action and how you  can elevate that developer experience. Thank you.