Loading…
NVIDIA
Technology company that designs powerful computer chips used for video games, data centers, and artificial intelligence.
- 158 posts summarised
- latest
The Good Stuff
Paid picks we use ourselves. Links carry a referral code — a subscription through one earns us a commission at no extra cost to you.
From their blog
Latest articles
Add Runtime Controls to AI Agents with NVIDIA OpenShell
AI agents with broad access to systems and data can cause failures like modifying production data or exposing secrets. NVIDIA OpenShell 0.1.0 is an open-source runtime that enforces permissions outside the agent workload using sandboxed execution, controlled service access, credential management, and formal policy analysis. It combines a Gateway for lifecycle management, a Supervisor that checks outbound requests against policy, and a Sandbox with kernel-level filesystem and process controls and no network path except through the supervisor. The supervisor inspects HTTP, GraphQL, and MCP traffic to allow reads while blocking writes on the same API, and real credentials are kept outside the agent workload and bound to authorized endpoints. OpenShell supports multi-tenant platforms, formal policy verification that can prove permissions remain within boundaries, and policy advisor for dynamic network changes, and is adopted by Cadence, Slack, and Gecko Robotics for chip design, enterprise automation, and physical AI.
How NVIDIA DSX MaxLPS Maximizes AI Factory Throughput and Efficiency
AI factories often underutilize power capacity due to static provisioning for peak GPU draw. NVIDIA DSX MaxLPS uses policy-governed dynamic power allocation to reclaim stranded capacity. In a joint evaluation with Nscale using Kimi K2.5 workloads on GB300 NVL72 systems, DSX MaxLPS enabled 37% more GPUs (192 vs 140) within the same 264.4 kW budget. Aggregate throughput increased 49.2% to 1.62 million tokens/s, while per-instance throughput remained unchanged and median latency stayed within 5% of baseline. However, P99 time to first token increased 17%, highlighting the need to evaluate tail latency alongside capacity gains.
Efficient MoE Training for Biological Foundation Models
Mixture-of-experts (MoE) architectures scale model capacity more efficiently than dense transformers by activating only a subset of experts per token, but naive implementations suffer from fragmented expert computation, routing overhead, and memory pressure. NVIDIA Transformer Engine (TE) addresses these bottlenecks with optimized primitives including GroupedLinear for batched expert GEMMs, MXFP8 low-precision training, and a fused GroupedMLP kernel that combines quantization, SwiGLU activation, and routing-weight scaling. The BioNeMo recipe implements these techniques for biological foundation models, using TE’s autocast API for MXFP8 precision and the Sequential API to fuse the gate-up, ScaledSwiGLU, and down projections into a single operation. On eight NVIDIA B200 GPUs, the recipe achieved up to 2.21x the training throughput of the Hugging Face baseline for a Mixtral-8x7B model. The tutorial provides prerequisites, code examples, and configuration commands to reproduce the optimizations.
Introducing NV-Reason-CT Open 3D CT VLM for Radiologist Chain-of-Thought Reasoning
NVIDIA released NV-Reason-CT, a vision language model for 3D CT analysis that processes volumes as true 3D input rather than independent 2D slices. The model generates structured diagnostic reports covering 30 chest and 29 abdominal abnormalities and emulates radiologist chain-of-thought reasoning with systematic anatomical reviews and uncertainty articulation. Its architecture pairs a Qwen3.5-4B language model with a full 3D ViT encoder that processes volumes resampled to 192³ voxels at 2mm isotropic resolution using 8x8x8 patch tokens and 3D MRoPE for spatial token relationships. Training uses supervised fine-tuning on roughly 550,000 QA examples from CT-RATE, NIH CT, and CancerVerse followed by Group Relative Policy Optimization that refines reasoning quality based on diagnostic accuracy. NV-Reason-CT is an open research foundation not a cleared clinical product and sits within NVIDIA’s Medical AI ecosystem alongside NV-Reason-CXR, NV-Segment-CTMR, and NV-Generate-CTMR.
Validate GPU Cluster Readiness Before AI Workloads Land
GPU clusters can pass standard health checks yet fail under real AI training workloads due to a single degraded GPU, network link, or misrouted traffic. NVIDIA Cluster Readiness Engine (NVCRE) is an open source Kubernetes controller that runs real distributed workloads across topology-aware node groups before production jobs land, measuring results and reporting which nodes failed each test. Its layered API uses Custom Resource Definitions for Certification, Workflow, and Job resources, attributing each failure to a specific node and category such as NCCL bandwidth or training goodput. The WorkloadRun API handles platform detection, NCCL settings, shared-memory volumes, and gang scheduling, so operators do not need to write those manifests by hand. NVCRE integrates with NVSentinel for passive telemetry and is available under Apache 2.0, with a roadmap for inference and automated lifecycle validation.
Manage Kubernetes Node Fleets with NodeWright
Managing Kubernetes node fleets, especially GPU nodes, is difficult because host-level changes can disrupt long-running training jobs, and traditional tools are not cluster-aware. NodeWright, an open-source Kubernetes-native package manager from NVIDIA, solves this by declaratively configuring and updating node operating systems while respecting PodDisruptionBudgets and non-interruptible workload labels. The operator orchestrates a sequence of cordon, wait, drain, apply, interrupt, and uncordon on each node, using container image packages that carry modifications such as kernel parameters, security agents, and verification scripts. It supports progressive rollouts across a fleet via DeploymentPolicy compartments with configurable disruption budgets and strategies like batch, canary, and rolling. NodeWright integrates with NVIDIA AI Cluster Runtime for validated configurations and is part of the DSX OS open-source portfolio, available under Apache 2.0.
Enabling Private High-Performance Production AI Inference with NVIDIA Confidential Computing
NVIDIA Confidential Computing (CC) enables secure AI inference by using memory-encrypted confidential VMs, confidential GPUs, and encrypted NVLink. Running inference frameworks like TensorRT LLM in a CC environment introduces performance overhead because secure execution changes assumptions about memory movement, timing, and multi-GPU communication. To quantify this overhead, the post presents a controlled methodology comparing CC-on and CC-off performance on a workload with long input context, extended output generation, and low concurrency. With CC-aware adaptations—including pageable memory selection, asynchronous readback, GPU %globaltimer for autotuning, and CC-aware multi-GPU communication—TensorRT LLM retained 96.1–98.2% of baseline throughput on eight NVIDIA B200 GPUs while keeping per-token latency overhead below 5%. The post concludes that security configuration and inference optimization should be treated as a single deployment problem for organizations moving private inference into production.
Topology-Aware Workload Scheduling with NVIDIA Topograph
AI factories are power-limited systems where GPU workload placement is a key optimization; poor placement fragments topology domains and forces traffic across shared links, reducing throughput and raising job costs. NVIDIA Topograph discovers cluster topology from cloud APIs or on-premises fabric systems, normalizes it into a common model, and publishes it in formats each workload manager expects, such as Kubernetes node labels, Slurm topology configuration, or Slinky ConfigMaps. It uses five components: API Server, Node Observer, Node Data Broker, Provider, and Engine to keep the topology view current as the cluster changes. The post covers deploying Topograph with Helm on Kubernetes, as a system package on Slurm, and as a Helm chart on Slinky, with support for cloud providers including Google Cloud, Lambda, Nebius, Nscale, and OCI. Topograph works alongside Dynamic Resource Allocation and KAI Scheduler to enable topology-aware gang scheduling, improving AI factory efficiency and tokens per watt.
Accelerating a ROS 2 Node with an AI Agent and NVIDIA Isaac ROS
GPU acceleration alone does not guarantee fast ROS 2 graphs because messages may still be serialized or copied through CPU memory. NVIDIA contributed the rosidl::Buffer abstraction and CUDA buffer backend to ROS 2 Lyrical, enabling zero-copy transport of GPU-resident payloads between co-located nodes when they share the same host, CUDA device, Linux user, and a supported RMW implementation, with automatic CPU fallback otherwise. An AI coding agent using the migrate-node-to-rosidl-buffer skill can audit an existing CUDA-accelerated node by tracing data movement, running a copy-boundary audit, and implementing a minimal interface-preserving patch. The tutorial demonstrates this on the Depth Anything 3 TensorRT node, updating subscription options and message storage to use CUDA buffer backend without changing the sensor_msgs/msg/Image message definition. The resulting accelerated workload can be deployed on NVIDIA Jetson AGX Thor, preserving standard ROS 2 messages while avoiding unnecessary serialization and host copies.
Simplifying Model Serving Across Multiple GPUs with NVIDIA TensorRT Multi-Device Integration in NVIDIA Dynamo-Triton
NVIDIA TensorRT multi-device inference enables a single TensorRT network to execute across multiple GPUs using NCCL-backed distributed collectives, supported from TensorRT 11.0. Integrated into Dynamo-Triton release 26.07, one model instance can own multiple GPUs and expose a single gRPC endpoint so the client does not coordinate GPU ranks. The post demonstrates this with Cosmos 3 Nano video generation, where the transformer uses Ulysses context parallelism to distribute 44,160 video tokens across up to eight GPUs. End-to-end latency drops from 156.6 seconds on one GPU to 34.2 seconds on eight GPUs, achieving a 6.09x transformer RPC speedup. Teams can trade additional GPU resources for shorter request latency while keeping the application interface and surrounding workflow stable.
How to Evaluate AI Agents From Tool Calls to Task Completion
Standard LLM benchmarks are insufficient for evaluating AI agents because they score static outputs rather than multi-step tool-call sequences against a live environment. The post explains that agent evaluation requires two scoring layers: step-level (process scoring) checks each call’s validity and usefulness, while end-to-end (E2E) scoring checks only the final environment state. A trace logs every step and environment state, and metrics roll up through a hierarchy of benchmark, trial, task, turn, and step. Key metrics include task success rate, consistency, tool-call precision, argument accuracy, steps per success, and cost per success. The post argues that benchmarks are converging on tool use because deployed agents always use tools, and enterprise benchmarks should measure task completion against real APIs and policies.
Turn Your Latest Observations Into Timely Weather Decisions With NVIDIA Earth-2
Weather-sensitive industries can now turn real-time observations into timely decisions using the AI data assimilation tools in NVIDIA Earth-2. The tutorial covers two techniques: Score-Based Data Assimilation (SDA) for constraining diffusion models with point observations, and HealDA for assimilating disparate datasets into a consistent global state. SDA works within downscaling models like CorrDiff and forecasting models like StormCast, guiding denoising steps toward observations without retraining. A concrete example showed SDA reducing wind-speed RMSE by 54% at held-out stations when applied to CorrDiff downscaling over Europe. Earth2Studio provides a unified interface across gridded, conventional, and satellite data sources, making it easy to connect proprietary observations to weather pipelines.
Benchmarking LLM Inference at Scale with AIPerf
AIPerf is NVIDIA’s successor to GenAI-Perf, intended to benchmark large-scale LLM inference without letting the load client become the bottleneck. Its multiprocess architecture combines worker processes, separate record-processor services, and ZMQ coordination, while supporting 15+ endpoint types, public datasets, and trace-replay formats. The walkthrough serves Qwen3-0.6B through vLLM, using streaming synthetic requests with fixed 128-token inputs and outputs; AIPerf reports TTFT, ITL, request latency, output token throughput, percentile distributions, and optional GPU telemetry in CSV and JSON. A second profile uses Poisson arrivals averaging 10 requests per second, variable input and output lengths, and a fixed random seed, producing wider latency distributions than the static baseline as concurrency and workload variability increase.
How to Use AI Agents to Prepare 3D Scenes for Simulation
Preparing a Blender scene for robotics simulation requires more than exporting attractive assets: the world needs semantic labels, simulation-aware materials, sensors, collision geometry, physics properties, and validation against a target profile. The described workflow uses Codex or Claude as an orchestration agent, NemoClaw to coordinate specialized Hermes subagents, and NVIDIA Omniverse Libraries to inspect, modify, render, and validate the scene. Blender MCP supplies a structured inventory, while OpenUSD becomes the shared scene contract; ovphysx handles physics authoring and checks, and ovrtx produces visual preflight views. Safe mechanical repairs can be automated, but ambiguous choices such as semantic labels or physical behavior are escalated to a human, with follow-up checks run after approved changes. The intended handoff is a simulation-ready USD world for NVIDIA Isaac Sim or NVIDIA Isaac Lab.
TensorRT Edge-LLM Completes the MLPerf Edge Agentic Benchmark 6.4x Faster on Jetson AGX Thor
Edge agentic workloads require repeated tool-calling turns, growing conversation histories, and valid function calls on constrained devices rather than single-prompt responses. On one NVIDIA Jetson AGX Thor Developer Kit, TensorRT Edge-LLM ran Qwen3.6-27B in SingleStream mode and completed the benchmark’s 1,007-turn performance workload in 24 minutes and 36 seconds, versus 2 hours and 37 minutes for the llama.cpp reference run. It reported 52.33 tokens per second, 247.12 ms median time to first token, and 87.94% BFCL overall accuracy. The implementation combines NVFP4 weights and activations, FP8 KV cache, reusable prompt prefixes with recurrent-state restoration, and tree-based multi-token prediction; roughly 96% of prompt tokens used hot cache, while tree-based MTP could achieve about 40% more decoding performance than linear MTP with three draft steps.
Translating CUDA Tile Operations from Python to Rust Using Agentic AI
cuTile Rust (cutile-rs) extends Rust’s ownership model to tile-based GPU kernels, and this post describes an agentic workflow for translating cuTile Python and Triton-TileIR implementations. Because all three front ends target CUDA Tile IR and share the tileiras compiler, the workflow compares reference and translated IR while making Python’s implicit specializations explicit through Rust const generics, fixed dtype symbols, and FFI checks. A bounded multi-agent pipeline covers analysis, device kernels, host and FFI code, correctness, and benchmarking, with machine-checkable verdicts controlling progress. It ported all 24 public TileGym operators, roughly 40 kernels, and reported 99.5% average cuTile Python performance across 347 paired configurations on NVIDIA DGX B200. The skill ships with TileGym and uses acceptance checks requiring correctness, backend execution, and a geomean speedup of at least 0.95.
Dense vs. MoE Models: Active Parameters, Throughput, and When to Choose Each
Dense models activate every parameter for every token, while Mixture-of-Experts (MoE) models route each token through a selected subset of feed-forward experts. This changes the relationship between capacity, memory, and compute: total parameters determine the memory required to load a model, whereas active parameters largely determine per-token work. At equal total size, MoE models often provide higher throughput, especially at batch size one, but routing, simultaneous expert residency, and reduced KV-cache room add serving complexity; latency advantages narrow at high concurrency. The comparison uses Nemotron 3.5 Lightning, a roughly 30B-parameter Mamba-2 plus MoE plus Attention hybrid with 3B active parameters, alongside dense and MoE examples, and concludes that dense models suit simpler serving and fine-tuning while MoE models suit throughput-oriented deployments with manageable memory and operational complexity.
How NVIDIA Groq 3 LPX Deterministic Execution Drives Power-Efficient High-Interactivity Inference on NVIDIA Vera Rubin
AI factories are constrained by site power, making performance per watt especially important for high-interactivity inference. The NVIDIA Groq 3 LPX rack uses deterministic execution: its compiler schedules computation, data movement, and clock-cycle timing across 256 LPU chips, then derives a cycle-level current-demand curve. Preemptive Power (PEP) prepares the power-delivery network for upcoming spikes, while Clock Period Synthesis (CPS) lengthens or shortens selected cycles to reduce di/dt, voltage droop, and the voltage guardband. Internal testing reported more than 60% less voltage drop, while the source estimates a high-single-digit baseline-voltage reduction and potentially low-double-digit workload-power reduction; paired with Vera Rubin NVL72, the platform is described as delivering up to 35x higher throughput per megawatt than GB200 NVL72 for 2T+ parameter models at long context and high interactivity.
How NVIDIA NVLink 6 Delivers Multi-Layer Resiliency for AI Factories
NVIDIA NVLink 6 is presented as a scale-up networking fabric for large AI factories, where dropped packets, link degradation, and node interruptions can reduce training goodput or inference capacity. It connects 72 Rubin GPUs in the Vera Rubin NVL72 into a single scale-up domain and uses a multi-layer resiliency stack spanning physical, link, application, software, and system layers. Physical Layer techniques include lightweight FEC, Physical Layer Retry (PLR), UPHY recovery, and hardware replay buffers, while credit-based flow control (CBFC) prevents injection when the next hop lacks buffer capacity. Redundant switch trays and management paths, local fault containment, NMX high availability, checkpointing, topology-aware recovery, and targeted switch maintenance are described as mechanisms for containing failures and preserving workloads; the post concludes that this integrated design targets continuous operation and maximum cluster productivity.
Scaling Federated Learning Across Docker, Kubernetes, and Slurm with NVIDIA FLARE
NVIDIA FLARE addresses the operational challenge of running federated learning across sites that use different infrastructure, including Docker, Kubernetes, and Slurm. Its two-layer architecture keeps long-running server and client parent processes available for authentication and coordination while launching transient job workers through each site’s native runtime. Jobs declare portable GPU, CPU, and host-memory requirements, which local launchers translate into Docker containers, Kubernetes pods, or Slurm allocations; studies add scoped membership and site-owned mappings for datasets, images, secrets, and scheduling policy. The result is a heterogeneous federation where organizations retain local resource authority, can allocate compute on demand, and run multiple studies without requiring one shared platform.
Topics they write about
All topics →Weekly digest
The best engineering reads, once a week.