Nov 11, 2026
This canvas covers the path from a trained model to fast, efficient and monitored inference for physical-AI platforms in heavy industry (construction, mining and earth-moving autonomy): on machines (for example NVIDIA Jetson Thor-class computers) and in the cloud (NIM, Dynamo-Triton, TensorRT). It is canvas 7 of 9 and follows a research-area exploration framework, with the Emerging (11–12) and Applied (13) modules added.
| Boundary | Owned here | Owned elsewhere |
|---|---|---|
| Training | Feeding latency and hardware limits back to training | Model design and training (canvas 3) |
| Evaluation | Producing the optimized engine that gates must test | Gate design and running (canvas 4) |
| Lifecycle | Building engines from registered models; runtime monitoring hooks | Registry, OTA rollout, rollback (canvas 5) |
| Infrastructure | Cloud serving stack and its autoscaling | Cluster capacity and scheduling (canvas 6) |
| SLOs and cost | Measuring latency, throughput and cost per inference | Setting standards and targets (canvas 8) |
Definition. Inference optimization turns a trained model into an engine that meets latency, throughput, memory and power targets on specific hardware, without losing required accuracy. Serving runs that engine reliably for its consumers: a control loop on a machine, or an API in the cloud. For robots, the job is not just running a model but running it alongside perception, control and planning stacks that already load the GPU and CPU (NVIDIA).
path to optimized inference · 6 stages owned here
One compiled, gated engine goes either to the machine or to the cloud; both report the same health signals back to monitoring.
Two very different targets
| On-machine (edge) | Cloud | |
|---|---|---|
| Hardware | NVIDIA Jetson Thor (T5000, T4000) as the reference platform in this canvas | Datacenter GPUs in owned clusters or GPU clouds |
| Main limit | Latency per control step, power, memory, safety timing | Throughput and cost per request at a latency target |
| Typical models | Perception, VLA policies, in-cab operator assistant | Assistant back-ends, teacher models, auto-labeling, evaluation |
| Runtime | TensorRT, TensorRT Edge-LLM, Holoscan / ROS 2 | NIM, Dynamo-Triton, TensorRT-LLM, vLLM |
Key sub-domains
| Sub-domain | Core question | Typical artifacts |
|---|---|---|
| Export and compilation | Can the model be compiled for the target? | ONNX exports per component; TensorRT engines |
| Quantization | How low can precision go without hurting results? | FP8, NVFP4, INT8 calibration sets and reports |
| Architecture-level speedups | Fewer denoising steps, smaller heads, distillation | Distilled students; step-reduced policies |
| Real-time execution | How do actions stay smooth despite inference delay? | Action chunking, asynchronous execution |
| On-machine scheduling | How do several models share one Thor? | MIG partitions, CUDA streams, priorities |
| Cloud serving | How do we serve many requests cheaply? | NIM containers, Dynamo routing, autoscaling |
| Runtime monitoring | Is inference healthy and in-distribution? | Latency, OOD scores, confidence telemetry |
Debate. Optimize the model (quantize, distill) or buy more hardware? On machines, hardware is typically fixed for years, so model optimization is usually necessary; in the cloud it is a cost trade-off.
Inference moved from compiling vision CNNs to INT8, to serving LLMs at scale, to running multi-billion-parameter VLAs at control rates on embedded GPUs.
| Year | Milestone | Why it matters here |
|---|---|---|
| 2026 | GR00T N1.7 on Jetson Thor with mixed NVFP4: 125 ms → 39.9 ms end to end, 25 Hz, no measurable task loss (Jetson AI Lab) | A 3B VLA runs at control rate on the machine |
| 2026 | Jetson T4000 and JetPack 7.1 with TensorRT Edge-LLM (January) (NVIDIA); Dynamo 1.0 | Production LLM/VLM runtime at the edge; stable distributed serving in the cloud |
| 2025 | Jetson AGX Thor GA (August); NVIDIA Dynamo announced (GTC) as successor to Triton; real-time chunking for VLAs (NeurIPS 2025) | FP4 at the edge; disaggregated serving; smooth asynchronous control |
| 2024 | NIM microservices; FP8 serving mainstream on Hopper | Packaged, optimized model containers |
| 2023 | TensorRT-LLM; vLLM (PagedAttention) | LLM-specific serving optimizations |
| 2018–2021 | Triton Inference Server; Jetson Xavier and Orin; INT8 quantization-aware training | Multi-framework serving; edge AI on machines |
| 2016–2017 | TensorRT 1.0; Jetson TX1/TX2 | Compiled, optimized inference on NVIDIA GPUs |
Paradigm shifts
From INT8 to FP8 and FP4. Blackwell's Transformer Engine switches between FP4 and FP8 at runtime on Thor (Edge AI Stack).
From one model per device to many models per device. Thor runs perception, VLA, speech and assistant models side by side, partitioned by MIG.
From synchronous to asynchronous control. Real-time chunking generates the next action chunk while the current one executes, with no retraining.
From monolithic to disaggregated serving. Cloud LLM serving splits prefill and decode across GPUs (NVIDIA).
On the machine, the question is whether a multi-billion-parameter policy can run at control rate next to everything else without losing behavior quality. In the cloud, it is cost per request at a latency target. Both are now solvable; neither is automatic.
Dominant frameworks
Export → calibrate → compile, per component. GR00T on Thor exports each component (vision encoder, LLM, diffusion head) to ONNX, calibrates to NVFP4 or FP8, and builds TensorRT engines (Jetson AI Lab).
TensorRT Edge-LLM for LLMs and VLMs on Jetson: an open-source C++ SDK with lower overhead than Python frameworks; speculative decoding gives large speedups (NVIDIA).
Real-time chunking (RTC). Generates the next action chunk while executing the current one, "freezing" committed actions and inpainting the rest; works with any diffusion or flow VLA without retraining (NeurIPS 2025).
Cloud: NIM + Dynamo-Triton + TensorRT-LLM. Dynamo-Triton (formerly Triton Inference Server) serves TensorRT, PyTorch, ONNX and more (NVIDIA); Dynamo adds disaggregated prefill/decode and KV-cache-aware routing for LLMs (NVIDIA).
Key research questions
| Question | State of evidence |
|---|---|
| Does low-bit quantization hurt closed-loop behavior? | Yes if done naively: small action errors compound in closed loop (QVLA, ICLR 2026); PTQ can cause kinematic drift (DA-PTQ) |
| Can action-aware quantization fix that? | Channel-wise, action-sensitivity-based bit allocation (QVLA), drift-aware PTQ and mixed precision (Mix-QVLA) recover most performance |
| Is smoothness enough, or does reaction time matter? | Asynchronous methods improve smoothness but can neglect reaction latency to sudden changes (FASTER, arXiv 2603.19199) |
| How do several models share one Thor? | MIG partitions and priorities; little published for safety-critical mixes |
| How cheap can cloud LLM serving get? | GB300 + Dynamo + TensorRT-LLM report 35x lower cost per token than Hopper (NVIDIA reference architecture) |
Challenges for heavy equipment
Timing guarantees. Safety layers need bounded latency, not average latency; GPU inference is hard to bound tightly.
Thermals and vibration. Machines run in heat, dust and vibration; sustained throughput may be below lab numbers.
Long hardware lives. Engines must be rebuilt and revalidated for each JetPack and hardware generation.
Mixed criticality. Safety perception, autonomy, assistant and telemetry share the same computer.
Debates
Quantize aggressively (FP4) vs keep safety models at FP8 or FP16.
NVIDIA-native stack (TensorRT, NIM) vs portable stack (ONNX Runtime, vLLM).
Cloud fallback for heavy reasoning vs everything on the machine (connectivity at sites decides).
NVIDIA supplies much of the edge and cloud inference stack used by heavy-industry autonomy developers; open-source projects and robot-learning labs push the frontier on latency and quantization.
| Cluster | Who | Contribution to this canvas |
|---|---|---|
| NVIDIA edge | Jetson Thor (T5000, T4000), JetPack 7.x, TensorRT, TensorRT Edge-LLM, Holoscan, Isaac ROS | On-machine compute and runtimes |
| NVIDIA cloud | NIM microservices, Dynamo and Dynamo-Triton, TensorRT-LLM, NeMo, NVIDIA AI Enterprise | Packaged, optimized serving |
| Open-source serving | vLLM, SGLang, ONNX Runtime, llm-d, KServe | Portable alternatives |
| VLA latency research | Physical Intelligence (real-time chunking: Black, Galliker, Levine); University of Hong Kong (FASTER) | Asynchronous and reactive execution |
| VLA quantization research | QVLA authors (ICLR 2026); DA-PTQ, HBVLA (arXiv 2602.13710), Mix-QVLA teams | Action-aware compression |
| Edge OS and fleet | Peridio / Avocado OS, Red Hat (canvas 5) | Deploying engines to Jetson fleets |
| Industry peers | Komatsu (NVIDIA partnership), Aurora (NVIDIA DRIVE Thor), Bedrock Robotics (see the evidence block below) | Public precedents for on-vehicle AI |
Inside heavy-equipment OEMs and autonomy developers (public evidence). The public record on on-machine inference is thinner than for cloud serving. What can be cited:
Komatsu and NVIDIA announced a collaboration (reported around 2017) to bring AI to construction sites, with Jetson described as the on-machine platform and cab-mounted stereo cameras as one planned use; operators stay in control first, with autonomous control as a longer-term aim (Equipment World). No recent progress update was found.
Rio Tinto and Komatsu run autonomous haulage at scale in the Pilbara; one trade report counts 300 autonomous haul trucks across 10 sites (AL Circle). Public reports describe the fleet, not the inference hardware inside it.
Bedrock Robotics announced autonomous excavators on three customer sites in August 2026 (Nevada, Texas and a civil sitework project); the machine stops automatically if a person or unauthorized object gets too close. The announcement mentions a "sensor and compute suite" but names no hardware (BD+C).
Aurora (autonomous trucking, an adjacent on-road case) announced NVIDIA DRIVE Thor in a dual configuration as the primary computer of its driver system, with Continental integrating the hardware and a separate independent secondary system for failure takeover; start of production was planned for 2027 (Business Wire). This is a published architecture pattern for primary plus independent fallback compute.
Takeaway: public evidence on bounded latency, quantization and mixed-criticality sharing for heavy machines is mostly absent, which is why those appear as gaps in section 7.
Debate. Should a heavy-equipment platform standardize on NVIDIA's runtime end to end, or keep a portable path in case of hardware change over a 10–20-year machine life (a long-life assumption, not a measured figure)?
Methods group by optimization step. Each has a default and a frontier.
| Step | Default method | Frontier |
|---|---|---|
| Profile | Measure latency per component on target hardware (Nsight Systems) | Continuous profiling on fielded machines |
| Export | ONNX per component (vision encoder, LLM backbone, action head) | Direct PyTorch-to-TensorRT paths (Torch-TensorRT) |
| Quantize | FP8 or INT8 post-training quantization with calibration; NVFP4 on Blackwell | Action-aware mixed precision (QVLA, Mix-QVLA); drift-aware PTQ; quantization-aware fine-tuning |
| Reduce compute | Fewer diffusion or flow steps; smaller action heads; distillation (canvas 3) | One-step or consistency-distilled action heads |
| Compile | TensorRT engines with fused kernels and CUDA graphs | Whole-pipeline graphs across models |
| Execute in real time | Action chunking with asynchronous execution; RTC for smooth chunk transitions (Black et al.) | Reaction-aware asynchronous methods (FASTER) |
| Share the device | MIG partitions; CUDA stream priorities; fixed memory budgets per model | Deadline-aware GPU scheduling for mixed-criticality workloads |
| Serve in the cloud | NIM containers; Dynamo-Triton; TensorRT-LLM; autoscaling on Kubernetes | Disaggregated serving, KV-cache routing, speculative decoding |
| Monitor | Latency percentiles, dropped frames, temperature, OOD scores | On-device anomaly detection feeding canvas 5 monitoring |
Validation methods
Compare optimized engine against the reference model on closed-loop tasks, not only per-frame accuracy, because quantization errors compound over time.
Worst-case latency testing under thermal stress and full system load.
Hardware-in-the-loop tests in simulation (canvas 2) using the exact engine and JetPack version.
Analysis techniques
Latency budget breakdown: sensor → preprocess → model → postprocess → actuator.
Accuracy-latency Pareto curves across precisions and step counts.
Cost per 1,000 requests and GPU-hours per day for cloud services.
Inference is where training meets the machine. Each interface needs a contract.
| Connects to | What crosses the boundary | Contract to define |
|---|---|---|
| Canvas 1: data flywheel | On-machine triggers and confidence signals that select data to upload | Trigger API and telemetry schema |
| Canvas 2: simulation | Hardware-in-the-loop and software-in-the-loop testing of exact engines | Same engine and runtime version in simulation and on the machine |
| Canvas 3: training | Latency, memory and precision budgets per target | Budgets agreed before training starts |
| Canvas 4: evaluation | Optimized engines for gate testing | Gates always run on the shipped engine |
| Canvas 5: MLOps | Engines registered and linked to source models; OTA packages | Engine build is a registered, reproducible step |
| Canvas 6: infrastructure | Cloud serving capacity, MIG, autoscaling | Inference node pools and quotas |
| Canvas 8: observability | Latency, throughput, cost, thermal metrics | Shared metric names; SLOs per service |
Outside fields
Embedded and real-time systems: deterministic timing, RTOS and safety partitions on the machine computer.
Controls engineering: how learned actions feed hydraulic controllers at fixed rates.
Thermal and electrical engineering: power and cooling for Thor in machine cabs and enclosures.
Computer architecture: precision formats, memory bandwidth, accelerator design.
The frontier is co-design: models trained for the precision, step count and latency the machine can afford, with behavior-preserving compression checked in closed loop.
Emerging trends
FP4 at the edge. NVFP4 on Thor makes 3B-parameter VLAs practical at 25 Hz (Jetson AI Lab).
Action-aware compression. Quantization judged by action error and closed-loop success, not perplexity.
Reactive asynchronous control. Methods that keep motion smooth and also react quickly to sudden changes.
Speculative decoding on the edge. Large speedups for assistant LLMs on Thor (NVIDIA).
Unified cloud serving. Dynamo absorbs Triton; NIM packages models with optimized engines.
Smaller modules. Jetson T4000 brings 1,200 FP4 TFLOPS and 64 GB in a 40–70 W envelope (NVIDIA), opening lower-cost machines.
Research gaps in heavy-industry physical AI
| Gap | Why it is open | Opportunity |
|---|---|---|
| Bounded latency for learned policies | Average-latency benchmarks dominate | Worst-case timing analysis for VLA pipelines under load and heat |
| Mixed-criticality sharing of Thor | Little published work on safety and non-safety models on one GPU (a literature-search impression, not a systematic review) | Partitioning patterns (MIG, priorities) qualified with safety engineering |
| Quantization effects on hydraulic control | Studies use arms and simulators | Closed-loop quantization tests on excavator policies |
| Long-life runtime support | Engines tied to JetPack and hardware versions | Rebuild-and-requalify pipeline per platform release |
Potential breakthroughs
A single Thor running safety perception, autonomy policy and assistant with documented timing guarantees.
One-step action heads that remove most of the diffusion latency without quality loss.
Tools and platforms, by layer
| Layer | NVIDIA | Open source / other |
|---|---|---|
| Edge hardware | Jetson AGX Thor (T5000: 2,070 FP4 TFLOPS, 128 GB), T4000 (1,200 FP4 TFLOPS, 64 GB) | — |
| Edge software | JetPack 7.x, TensorRT, TensorRT Edge-LLM, Holoscan, Isaac ROS, DeepStream | ROS 2, ONNX Runtime, vLLM |
| Compression | TensorRT Model Optimizer (FP8, NVFP4, INT8), NeMo | QVLA / DA-PTQ research code, llm-compressor |
| Cloud serving | NIM, Dynamo, Dynamo-Triton, TensorRT-LLM | vLLM, SGLang, KServe, llm-d |
| Profiling | Nsight Systems, Nsight Compute, DCGM | PyTorch profiler |
| Benchmarks | AIPerf (Dynamo), Jetson AI Lab benchmarks | MLPerf Inference (Edge and Datacenter) |
Journals and conferences
Systems: MLSys, OSDI, ASPLOS, EuroSys.
Robotics: RSS, CoRL, ICRA (real-time VLA papers); NeurIPS, ICLR (quantization papers).
Embedded: EMSOFT, RTSS (real-time systems).
Industry: NVIDIA GTC, Embedded Vision Summit, MLPerf results.
Funding sources
Company R&D budgets of OEMs and autonomy developers; venture funding for autonomy start-ups (for example Bedrock Robotics, see section 4).
Vendor and ecosystem programs: NVIDIA developer programs and Jetson ecosystem partners for ruggedized compute.
Public research funding for robotics and real-time systems (national science and innovation agencies).
Read real-time chunking and QVLA first; they define the two biggest on-machine issues (latency and compression).
Recent influential works (2025–2026)
| Year | Work | One-line takeaway |
|---|---|---|
| 2026 | Xu et al., QVLA (ICLR) | Channel-wise, action-centric bit allocation; uniform LLM-style quantization is flawed for robots (Emergent Mind) |
| 2026 | DA-PTQ | Drift-aware post-training quantization against temporal error accumulation |
| 2026 | Mix-QVLA | Task-evidence-aware mixed precision |
| 2026 | HBVLA | 1-bit post-training quantization for VLAs |
| 2026 | Lu et al., FASTER | Reaction latency, not only smoothness, limits real-time VLAs |
| 2026 | NVIDIA, GR00T N1.7 on Thor | 3.1x speedup with mixed NVFP4; 39.9 ms end to end |
| 2025 | Black, Galliker, Levine, Real-Time Execution of Action Chunking Flow Policies (NeurIPS) | Asynchronous inpainting of action chunks; robust to large delays |
| 2025 | Kim et al., OpenVLA-OFT (canvas 3) | Parallel decoding and chunking: 26x faster action generation |
Seminal works
| Year | Work | Contribution |
|---|---|---|
| 2023 | Kwon et al., PagedAttention / vLLM (SOSP) | Efficient LLM serving memory |
| 2022 | Frantar et al., GPTQ; Dettmers et al., LLM.int8() | Post-training quantization for transformers |
| 2018 | Jacob et al., Quantization and Training of Neural Networks for Efficient Integer-Arithmetic-Only Inference | Quantization-aware training |
| 2015 | Han et al., Deep Compression | Pruning, quantization, coding |
| 2015 | Hinton et al., Distilling the Knowledge in a Neural Network | Knowledge distillation |
| 2022 | Micikevicius et al., FP8 Formats for Deep Learning | FP8 training and inference |
Gap in the literature: no published closed-loop study of quantized VLAs on full-size hydraulic machines.
One machine computer will run several model families with different timing needs. A starting allocation for a Thor-class machine computer in construction or mining equipment (illustrative, not drawn from any named deployment):
| Workload on the machine | Criticality | Latency need | Precision approach | Runtime |
|---|---|---|---|---|
| Person and obstacle detection | Safety-related | Tight, bounded per frame | FP8 or FP16; quantize only with full regression | TensorRT, own MIG partition |
| Autonomy policy (VLA or imitation) | Safety-related behind certified limits | Control rate, e.g. 25 Hz with action chunks | Mixed NVFP4/FP8 with closed-loop checks | TensorRT engines + real-time chunking |
| In-cab operator assistant (speech + compact LLM) | Non-safety | Conversational, around a second | Aggressive (FP4/INT4) acceptable | TensorRT Edge-LLM or vLLM |
| Data triggers and telemetry models | Non-safety | Seconds | Aggressive | TensorRT |
| Cloud: assistant back-ends, auto-labeling, teachers | Non-safety | Throughput at latency target | FP8 / NVFP4 | NIM, Dynamo-Triton, TensorRT-LLM |
Figures are illustrative; set real budgets with controls and safety engineering.
Field-level application areas
| Application | Inference demand | Public evidence |
|---|---|---|
| Construction autonomy (excavators, earthwork) | Perception, planning and control on the machine at control rate; stop-on-proximity safety behavior | Bedrock Robotics deployments on three sites (BD+C) |
| Mining haulage | Fleet-scale autonomy with on-truck perception and control plus site-level dispatch | Rio Tinto and Komatsu autonomous haulage (AL Circle) |
| In-cab and operator assistance | Cab cameras and speech or LLM models on the machine computer; non-safety latency targets | Komatsu and NVIDIA cab-camera plans (Equipment World) |
| Jobsite digital twins and cloud analytics | Batch and interactive cloud inference for mapping, progress tracking and simulation; cost per request matters | Cloud serving stack: Dynamo, NIM (see section 3); no heavy-industry-specific benchmark found |
| Autonomous trucking (adjacent) | Primary plus independent secondary compute for failure takeover | Aurora, Continental and NVIDIA (Business Wire) |
Industry connections
NVIDIA: Jetson Thor, JetPack, TensorRT, NIM; GR00T deployment recipes.
Ruggedized compute partners: Jetson-based industrial computers for machine cabs.
Machine OEM electronics and controls suppliers: machine computer integration and safety partitions.
Future applications (speculative): lower-cost autonomy kits using Jetson T4000-class modules for smaller machines; retrofit kits for existing fleets.
Technology integration
Engine build as a pipeline step. Every registered model produces engines per target (Thor T5000, T4000, cloud GPU), built in CI with pinned TensorRT and JetPack versions (canvas 5).
Same engine everywhere. Simulation, evaluation and the machine run the identical engine file.
Device budgets. Each model gets a GPU partition, memory budget and latency budget on the machine computer.
Telemetry. Latency percentiles, dropped deadlines, temperature and OOD scores stream to monitoring (canvases 5, 8).
Ethical considerations
Silent degradation. Compression can reduce accuracy for rare cases (e.g. people in unusual postures) while averages look fine; check safety slices.
Privacy on the machine. Cameras and microphones in the cab (operator assistants) capture operators; process on the machine where possible and minimize uploads.
Energy. Efficient inference reduces power draw on machines and in the data center.
Regulatory requirements
| Rule | What it means for inference |
|---|---|
| EU Machinery Regulation 2023/1230 (from 20 January 2027) | Software and AI performing safety functions are safety components; the deployed engine is what is assessed. AI-specific requirements may follow via delegated or implementing acts (see canvas 5) |
| ISO 13849 / IEC 62061; ISO 17757 | Timing and fault-handling requirements for safety functions; learned components need a safe architecture and monitoring |
| Cybersecurity (EU Cyber Resilience Act, Machinery Regulation essential requirements) | Signed engines, secure boot, protection against tampering with models on the machine |
| Privacy (GDPR and local laws) | In-cab audio and video handling for operator assistants |
Implication: optimization changes behavior, so each optimized engine is a new artifact that must pass gates, not a free speedup.
Build in four phases. Start with a reproducible engine pipeline and latency budgets; push precision lower only with closed-loop evidence.
inference rollout · 4 phases, 3 gates
Phases are sequenced, not dated. Phase 1 is highlighted because every later speedup must be measured against a reproducible baseline engine.
Required resources
Teams: inference and performance engineers; embedded engineers for the machine computer; MLOps for cloud serving; safety and controls partners.
Infrastructure: CI with Jetson Thor build and test runners; hardware-in-the-loop rigs; cloud serving clusters (canvas 6).
Partners: NVIDIA (TensorRT, JetPack, NIM); ruggedized compute suppliers.
Risk assessment
| Risk | Likelihood | Impact | Mitigation |
|---|---|---|---|
| Quantized policy behaves differently in closed loop | Medium | High | Closed-loop gates on the optimized engine; action-aware quantization; keep safety models at higher precision |
| Latency spikes under load or heat | Medium | High | Worst-case testing; MIG partitions; deadline monitors with safe fallback |
| Engine incompatible after JetPack upgrade | High | Medium | Pinned versions; rebuild-and-requalify pipeline per platform release |
| Too many models for one Thor | Medium | Medium | Device budgets set before training; distillation |
| Cloud serving costs grow | Medium | Medium | FP8/NVFP4, batching, autoscaling; cost per request tracked (canvas 8) |
| Vendor lock-in | Medium | Medium | Keep ONNX exports and a portable fallback runtime |
Success metrics
| Metric | What it shows |
|---|---|
| p99 latency per on-machine model vs budget (ms) | Real-time readiness |
| Deadline misses per operating hour | Timing reliability |
| Closed-loop task success: optimized vs reference engine (%) | Behavior preservation |
| Speedup from optimization (x) | Optimization value |
| Cloud cost per 1,000 requests ($) | Serving efficiency |
| Time from registered model to validated engine (days) | Pipeline speed |
Set targets after phase 1 baselines.
Open questions for practitioners
Follow-up prompts (from the exploration framework)
Elaborate on a latency budget for an autonomous excavator from camera frame to valve command.
Provide detailed methods for closed-loop validation of a quantized VLA policy.
Analyze MIG partitioning options for mixed-criticality workloads on Jetson Thor.
Suggest an experiment comparing FP8 and NVFP4 engines for a digging policy in simulation and on a test site.
Accelerate AI inference with Jetson T4000 and JetPack 7.1 (NVIDIA); reprint (Edge AI and Vision Alliance)
Isaac GR00T N1.7 on Jetson Thor (Jetson AI Lab)
Jetson Thor vs AGX Orin 2026 (Edge AI Stack)
NVIDIA Dynamo; Dynamo-Triton; Introducing Dynamo (NVIDIA)
Real-Time Execution of Action Chunking Flow Policies (Black, Galliker, Levine; NeurIPS 2025)
Komatsu brings artificial intelligence to heavy equipment with NVIDIA-powered cameras (Equipment World)
Rio Tinto welcomes 300th Komatsu autonomous haulage truck (AL Circle)
Fully automated excavators deployed on construction jobsites (BD+C)
Aurora, Continental and NVIDIA partner to deploy driverless trucks at scale (Business Wire)