KB5079257: Windows 11 Gains On Device AI with TensorRT RTX Execution Provider

Microsoft has quietly pushed KB5079257 — a Windows Update component that installs NVIDIA TensorRT‑RTX Execution Provider (EP) version 1.8.24.0 — to eligible Windows 11 devices, advancing Microsoft’s modular on‑device AI strategy by updating the runtime layer that delivers GPU‑accelerated inference on consumer RTX PCs. (support.microsoft.com)

Background / Overview​

Windows 11 has been moving AI acceleration out of monolithic drivers and applications and into a modular runtime model: a managed inference runtime (ONNX Runtime/Windows ML) dispatches subgraphs to specialized vendor Execution Providers that ship independently from the OS feature set. Microsoft distributes many of those EPs as small, versioned components through Windows Update so they can be updated more frequently than the main OS. KB5079257 is one such component update targeted at consumer RTX systems.
This particular update replaces the previously released KB5077528 package and targets Windows 11, version 24H2 and 25H2. The KB is intentionally terse: Microsoft’s official note lists the version (1.8.24.0), the delivery mechanism (Windows Update — automatic), the prerequisite (latest cumulative update for 24H2/25H2), and the fact that the update “includes improvements to the execution provider component.” There is no line‑by‑line changelog in the public KB. (support.microsoft.com)

---

What is the NVIDIA TensorRT‑RTX Execution Provider?​

How it fits into Windows ML and ONNX Runtime​

The NVIDIA TensorRT‑RTX Execution Provider is a vendor‑specific plugin that allows ONNX Runtime and Windows ML to offload supported neural network operations to NVIDIA RTX GPUs using NVIDIA’s TensorRT for RTX runtime. Unlike the legacy, datacenter‑focused TensorRT EP, the TensorRT‑RTX EP is designed for consumer RTX GPUs (GeForce/RTX family) and for interactive, low‑latency local AI workloads — the kinds of tasks Copilot+, image editing, LLM inference, and other on‑device AI features rely on.
Key characteristics of the TensorRT‑RTX EP include:

• Small package footprint (designed for end‑user systems).
• Just‑in‑time (JIT) engine compilation that builds RTX‑optimized kernels on the target GPU in seconds.
• Runtime caching so compiled engines persist and subsequent session startup is much faster.
• Optimizations for consumer RTX architectures (Ampere and later) rather than datacenter SKUs.

These design choices make the EP the preferred GPU path on RTX consumer hardware within Windows ML — simpler to use than the datacenter TensorRT EP and typically faster than the pure CUDA EP fallback for many client scenarios. Microsoft’s KB text explicitly describes the EP in these terms. (support.microsoft.com)

---

Why KB5079257 matters (for users and IT teams)​

For end users and enthusiasts​

If you own an RTX‑class GPU and run Windows 11 (24H2 or 25H2), this update can change which EP your apps use behind the scenes. Apps that rely on Windows ML or ONNX Runtime and that allow vendor EP selection may start to get improved GPU acceleration without any action from the user because Windows Update can install the EP component automatically. That means faster, lower‑latency local AI experiences in apps that are integrated with the Windows ML stack, such as image editing, generative media tools, and some Copilot+ features. (support.microsoft.com)

For developers​

Developers who ship ONNX models or integrate Windows ML should be aware that the device runtime environment is now dynamic. The EP version can change independently of the app or the OS, which affects:

• runtime behavior (JIT compile time and caching),
• supported data types (FP16/BF16/FP8/FP4/INT8 in later EPs),
• performance characteristics and fallback behaviors, and
• potential binary compatibility with custom TensorRT plugins or model optimizations.

Because the EP performs JIT compilation and can persist compiled kernels, the time‑to‑first‑inference and steady‑state throughput can differ significantly between EP versions and across GPUs. Developers should test with the EP versions their customers will receive (or allow controlled registration of an EP in app deployments where determinism matters). ONNX Runtime’s TensorRT/TensorRutlines configuration knobs and caching options developers can use.

For IT administrators​

KB5079257 is delivered automatically through Windows Update but requires the latest cumulative update for Windows 11 24H2 or 25H2 to be installed on the target device. Administrators need to account for this in patch sequencing and deployment plans: the EP will not apply where OS servicing is out of date, and the device will show the installed EP package in Settings > Windows Update > Update history once applied. The KB replaces KB5077528 so update sequencing may be relevant for change logs and compliance audits. (support.microsoft.com)
Community reporting and early rollout notes show Microsoft has been delivering these EP updates iteratively for months; forum threads track version rollouts and practical impacts on Copilot+ RTX devices. Those community threads are useful for real‑world symptoms and pilot testing feedback.

---

What the vendors say — performance and features (verified)​

Microsoft’s KB is functional and short on detail, so to assess the real technical impact we cross‑checked NVIDIA and ONNX Runtime documentation and public technical posts.

• NVIDIA’s TensorRT for RTX technical blog and documentation describe the runtime’s approach: a two‑stage AOT+JIT compilation model that produces a hardware‑specific engine quickly on target RTX GPUs, enabling per‑GPU optimizations and kernel replacement that can raise throughput substantially after initial runs. The blog claims large performance gains versus baseline DirectML in some workloads and promotes multiprecision support (FP32/FP16/BF16/FP8/FP4/INT8).
• ONNX Runtime’s TensorRT Execution Provider docs and the TensorRT‑RTX EP guides describe configuration options (device_id, stream, caching controls) and the interaction between the EP and the overall runtime. ONNX Runtime notes that using a TensorRT family EP often yields better instantaneous and sustained performance than generic GPU acceleration paths and documents the compatibility matrix with CUDA/TensorRT versions. These details line up with NVIDIA’s claims about JIT compilation, caching, and per‑GPU optimization.

Taken together, the vendor sources corroborate Microsoft’s positioning: the TensorRT‑RTX EP is a consumer‑focused, lighter‑weight GPU execution provider that can materially improve local AI performance on supported RTX hardware, while being manageable via Windows Update for the end user.

---

Compatibility, driver and runtime prerequisites — what to check before you deploy​

Both Microsoft and NVIDIA/ONNX Runtime documentation prescribe specific compatibility constraints. These are essential because mismatches (driver versions, CUDA support, or GPU generation) are the main causes of functional failures.

• Microsoft’s KB requires the latest cumulative update for Windows 11, version 24H2 or 25H2. The component model enforces OS servicing preconditions before installing the EP. (support.microsoft.com)
• ONNX Runtime and NVIDIA documentation indicate that the TensorRT/TensorRT‑RTX EPs depend on compatible CUDA and driver stacks. The ONNX Runtime TensorRT page lists supported TensorRT and CUDA combinations across ONNX Runtime releases; TensorRT‑RTX documentation and NVIDIA’s developer pages specify the GPU architectures supported (Ampere and later for the RTX‑focused EPs) and minimum driver/CUDA recommendations for Windows builds. Validate driver builds and CUDA versions before accepting automated rollout.
• Microsoft’s Foundry Local and Windows ML documentation show the EPs can be downloaded dynamically and note minimum recommended driver versions for particular EPs on Windows. If your environment uses packaged images or strict driver baselines (for example in enterprise imaging or VDI), confirm those baselines support the EP before broad deployment.

Practical checklist:

• Confirm Windows 11 version and install the latest cumulative update for 24H2/25H2. (support.microsoft.com)
• Verify NVIDIA driver version and CUDA runtime compatibility against the TensorRT‑RTX support matrix.
• Pilot the EP on representative hardware and inspect app behavior and event logs for ONNX/Windows ML warnings.

---

Real‑world impact: what to expect after the update​

• Faster inference on supported RTX GPUs for workloads that are eligible for EP offload, particularly generation and image models, where Tensor Cores and optimized kernels are used. Vendors have reported double‑digit to multi‑times speedups in targeted workloads versus older, generic GPU paths like DirectML. Expect the biggest improvements for models that map well to TensorRT optimizations and for GPUs that support advanced numerP4 on newer architectures).
• Reduced time‑to‑first‑use after the JIT cache warms: JIT compilation adds a small one‑time penalty, but a runtime cache reduces subsequent session startup times considerably. That makes the EP especially effective for interactive use where the same models are invoked repeatedly.
• Potential changes in memory and CPU/GPU utilization during the JIT and engine building phases. Some systems may see higher transient GPU memory usage during compile phases, so test memory pressure for memory‑constrained laptops.

---

Troubleshooting and rollback guidance​

• If an application fails to use the EP or shows degraded performance, check ONNX Runtime provider listings to see which EPs are available and active. ONNX Runtime exposes APIs to list and register providers; logs often indicate whether a provider loaded successfully or fell back to CPU/DirectML.
• Confirm Windows Update history (Settings > Windows Update > Update history) to see whether KB5079257 or the prior replacement package applied successfully. Microsoft lists the installed EP update name in the Update history after installation. (support.microsoft.com)
• Verify NVIDIA driver compatibility; many runtime and EP issues stem from a driver mismatch or an outdated CUDA runtime. Update to an NVIDIA driver recommended by the TensorRT‑RTX support matrix if necessary.
• For managed enterprise environments, use Windows Update for Business, WSUS, or your patch management tool to stage and test the EP rollout. If rollback is necessary, allow Windows Update policies to defer or pause the update while you troubleshoot; in extreme cases you may need to restore a system image for a clean state. (Best practice: pilot first.) (support.microsoft.com)

Community reports and forum threads show admins catching issues by piloting Copilot+ RTX devices and comparing behavior before and after EP updates; those threads are useful for spotting real‑world regressions that don't appear in vendor documentation.

---

Security, privacy and licensing considerations​

• The KB itself is a functional update and not a security patch, but any component that interfaces with GPU firmware and kernel drivers must be treated as a potential attack surface. Keep drivers up to date and follow vendor security advisories. NVIDIA and ONNX Runtime documentation include security and license references for their libraries and plugins.
• Licensing: EPs often ship under vendor SDK EULAs. When Windows ML dynamically downloads an EP to a device, the underlying NVIDIA SDK license applies; administrators and developers should ensure licensing terms are acceptable for their use case (development, internal, or commercial distribution). Microsoft’s and NVIDIA’s documentation both point to vendor license terms for EPs.
• Telemetry and local AI: Because these EPs accelerate on‑device AI, make sure any local models, prompts, or user data processed by those models align with your privacy policy. The update itself does not change model behavior, but faster local inference may increase the frequency or scale of on‑device processing. Administrators should map where models run and what data they touch. (support.microsoft.com)

---

Practical recommendations — how to prepare and test KB5079257 in your environment​

• For individual users and enthusiasts:
• Make sure Windows 11 is up to date (install the latest cumulative update for 24H2/25H2).
• Update NVIDIA drivers to the versions recommended by TensorRT‑RTX docs.
• Check Settings > Windows Update > Update history to confirm the EP install. (support.microsoft.com)
• For developers:
• Reproduce your app’s inference pipeline with ONNX Runtime and explicitly enumerate providers to confirm which EP is active.
• Test model startup and steady‑state throughput across representative RTX hardware and document runtime caches and JIT times.
• Add a capability probe in diagnostics to report EP version and whether a cached engine was used so support teams can triage issues rapidly.
• For IT administrators:
• Stage KB5079257 in a pilot ring (representative hardware including gen‑varied RTX GPUs).
• Verify cumulative OS servicing is current on pilot devices so the EP will install. (support.microsoft.com)
• Confirm driver baseline compatibility and update driver packages centrally as needed.
• Monitor event logs and application telemetry for provider load errors or abnormal resource usage during initial JIT builds.

---

Risks, unknowns and where to be cautious​

• Lack of a public changelog. Microsoft’s KB notes that the update “includes improvements” but does not publish fine‑grained change history in the support article. That lack of transparency makes it harder to anticipate behavioral changes; conservative operators should pilot and collect metrics before broad rollout. (support.microsoft.com)
• Driver/runtime mismatches. The EP depends on a compatible NVIDIA driver/CUDA/TensorRT stack; mismatches are the common source of failures or subtle regressions. Rigid driver baselines in locked enterprise images can block the EP or cause unexpected fallbacks.
• JIT compile overhead and resource spikes. The initial JIT and engine creation phases can increase GPU memory and CPU activity briefly; on shared or thermally constrained devices this could affect user experience during the model’s first run. Plan pilot tests that include real‑world workloads to measure this.
• Third‑party plugin compatibility. Models that rely on custom TensorRT plugins or vendor‑specific optimizations may require validation against the new EP version; plugin ABI changes or different runtime behaviors can cause failures. Developers that rely on custom plugins should test with the exact EP build applied by the KB.
• Vendor EULA and redistribution. Dynamic download of vendor EPs implies acceptance of vendor SDK license terms on each device; enterprises that redistribute SDKs or embed EPs in images should check licensing terms carefully.

---

The bigger picture: modular on‑device AI and operator responsibility​

KB5079257 is a small but meaningful example of a broader platform strategy: Windows increasingly treats hardware‑specific AI runtimes as modular, updatable components. That approach lets vendors iterate faster and deliver hardware‑targeted optimizations to end users without requiring full OS servicing releases. The trade‑off is that the runtime environment for AI apps becomes more dynamic, requiring better telemetry, staged testing, and closer coordination between ISVs, driver teams, and IT operations.
For IT organizations, this means shifting some responsibilities:

• inventory GPU and driver baselines,
• include EPs in testing matrices,
• add EP version reporting to device health telemetry, and
• ensure change control and pilot rings include on‑device AI runtime components in addition to drivers and the OS.

---

Conclusion​

KB5079257 itself is not a dramatic change — Microsoft describes it as “improvements to the execution provider component” — but it embodies the steady evolution of Windows into a modular on‑device AI platform. For RTX PC owners, it promises faster, more efficient local AI inference delivered transparently via Windows Update. For developers and IT administrators, it raises concrete responsibilities: validate driver compatibility, pilot EP versions, and instrument apps to detect provider changes.
If you run RTX hardware, verify your OS and driver baselines, pilot the update on a small set of machines, and collect the startup and steady‑state inference metrics that matter to your workloads. That will let you capture the performance benefits of the TensorRT‑RTX EP while avoiding the common pitfalls of version and driver mismatches. Microsoft’s KB lists the package and requirements, and NVIDIA/ONNX Runtime documentation explain the technical mechanisms behind the speedups and caching behavior — together they form the practical guidance you’ll need to adopt the update safely. (support.microsoft.com)

---

Source: Microsoft Support KB5079257: Nvidia TensorRT-RTX Execution Provider update (1.8.24.0) - Microsoft Support

 

[ChatGPT]

Microsoft has quietly pushed an update that matters to anyone running AI inference on an RTX-equipped Windows PC: KB5079259, which updates the NVIDIA TensorRT‑RTX Execution Provider to version 1.8.24.0 for devices running Windows 11, version 26H1. The patch is delivered automatically through Windows Update, replaces the previous KB5078981 delivery, and requires that systems already have the latest cumulative update for 26H1 installed before it will apply. (support.microsoft.com)

Background​

Windows has been moving to a modular, componentized model for on‑device AI: instead of bundling every vendor runtime inside apps or central system binaries, Microsoft distributes Execution Providers (EPs) — vendor-supplied acceleration components that ONNX Runtime (and Windows ML) can call into at runtime. This model allows Microsoft to push vendor improvements (for Intel, AMD, NVIDIA, etc.) independently through Windows Update, so RTX PC owners can get up-tcapabilities without waiting for major OS feature updates. The pattern has been visible across several EP updates in recent months.
NVIDIA’s TensorRT‑RTX is a consumer‑focused branch of the TensorRT family purpose‑built for RTX GPUs on Windows. Unlike the datacenter‑oriented TensorRT EP or the generic CUDA EP, TensorRT‑RTX emphasizes a small disk footprint, fast just‑in‑time (JIT) engine generation tuned for consumer GPUs, and features such as runtime caching and CUDA Graph capture that are designed to improve inference responsiveness on end‑user devices. NVIDIA and Microsoft have collaborated to surface this capability through Windows ML and ONNX Runtime, making TensorRT‑RTX the preferred execution provider on RTX PCs.

---

What KB5079259 actually changes​

Microsoft’s KB note for KB5079259 is concise: it states that the package updates the Nvidia TensorRT‑RTX Execution Provider component to version 1.8.24.0 for Windows 11 26H1 machines, clarifies that the update is distributed via Windows Update and that it replaces the earlier KB5078981 entry. It also repeats the familiar prerequisite: the latest cumulative update for Windows 11, version 26H1 must be present before the component will install. To verify presence, Microsoft points users and administrators to Settings > Windows Update > Update history. (support.microsoft.com)
Important, measurable changes (as with many of these component updates) are typically handled inside the NVIDIA runtime itself — performance improvements, bug fixes, and hardware compatibility adjustments — rather than changes to the OS kernel or major public APIs. For that reason, Microsoft’s KB page intentionally stays high‑level and refers readers to the Windows AI component release history for additional context. (support.microsoft.com)

---

Why this update matters: practical impact for RTX PC owners​

• Faster, more efficient inference on RTX hardware. TensorRT‑RTX is designed to outperform the CUDA Execution Provider in many consumer scenarios because it performs graph‑level optimizations, stores tuned engines, and can make use of precision modes and Tensor Cores more aggressively on supported GPUs. ONNX Runtime documentation and NVIDIA engineering notes both observe that while results vary by model and shape, TensorRT engines can deliver substantial runtime gains compared to plain CUDA EP runs when the model subgraphs are supported.
• Smaller runtime footprint and faster first‑use behavior. TensorRT‑RTX was engineered with consumer install constraints in mind: smaller package size (targeting around a 200 MB footprint in early messaging), a split AOT/JIT design so engines can be compiled quickly on the user’s GPU, and runtime caching that makes subsequent runs faster. That matters for desktop apps that ship AI features but don’t want to bundle large runtimes.
• Better support for modern precisions and dynamic shapes. TensorRT‑RTX supports multiple numeric precisions (FP32/FP16/BF16/FP8/INT8/FP4 on newer hardware where supported), dynamic‑shape specialization, and automatic CUDA Graph capture to reduce CPU overhead for repeated sequences — features that translate to more throughput and lower latency for many models, particularly vision and diffusion pipelines. The vendor docs and recent release notes document these improvements and the runtime’s adaptive inference behavior.
• Easier delivery for IT. Because the EP arrives via Windows Update, administrators managing fleets of Copilot+ RTX or AI‑capable PCs can rely on standard patch management pipelines to keep the execution provider current, rather than orchestrating separate driver or runtime installs per device. Microsoft’s KB makes this explicit: "This update will be downloaded and installed automatically from Windows Update." (support.microsoft.com)

---

Technical verification: what we can confirm and where the details live​

Microsoft’s KB (KB5079259) documents the presence of the update and the installation mechanics; it does not list line‑item release notes about driver internals or micro‑fixes. For the technical specifics — exact performance deltas, bug fixes, and known issues — the authoritative sources are the NVIDIA TensorRT‑RTX release notes and developer blog posts that describe feature changes and compatibility. NVIDIA’s public release notes and technical blogs (and ONNX Runtime execution provider docs) provide the details that explain why TensorRT‑RTX tends to outperform CUDA EP and how the AOT/JIT engine flow operates on consumer GPUs. When Microsoft replaces one KB with another (as it did here), the actionable confirmation about version and distribution comes from Microsoft while the technical deep dive comes from NVIDIA’s documentation. (support.microsoft.com)
Because IO and kernel‑level behavior are not being modified by the KB itself, the safest way to confirm the practical impact on your machine is to measure — run controlled inference benchmarks before and after the update using your application model and dataset. ONNX Runtime’s guidance and NVIDIA’s performance notes explain how to set up GPU‑specific profiling and how to interpret results when some operators fall back to CPU or CUDA kernels.

---

What’s new in TensorRT‑RTX (context from NVIDIA release notes relevant to 1.x series)​

NVIDIA’s TensorRT‑RTX documentation and release notes (the product documentation that tracks 1.0 → 1.2 and related maintenance releases) call out a number of behaviors and limitations that are important to understand when a Windows Update pushes a new EP version:

• AOT/JIT split with runtime caching: engines are compiled quickly on the local GPU at runtime and cached so subsequent loads are faster. This delivers faster first‑use times compared to legacy TensorRT workflows that required prepackaged engines.
• Built‑in CUDA Graph capture and dynamic‑shape support: these features reduce CPU overhead and can improve throughput for repeated invocations. NVIDIA explicitly documents automatic CUDA Graph capture and integration with dynamic shape kernels as a key throughput optimization.
• Expanded precision support on new architectures: FP8, FP4, and other low‑precision options are increasingly supported on Ampere and newer GPUs (with Blackwell and Ada offering the broadest feature sets). Performance for LLMs and other transformer workloads is being iteratively improved in recent releases. The support matrix clarifies which precisions are available on which GPU architectures.
• Known limitations and compat notes: TensorRT‑RTX engines are not necessarily forward‑compatible across runtime versions; the docs recommend generating engines and running them on matching runtime versions, and warn about cache growth, timing cache semantics, and some edge cases where AOT/JIT behavior interacts poorly with very old hardware. These limitations are relevant for users who move engine blobs between machines or who rely on precompiled artifacts.

---

Risks, caveats, and operational considerations​

• Automatic delivery and enterprise control
• Microsoft’s decision to distribute these EP updates via Windows Update is a double‑edged sword. For most end users it simplifies getting the latest vendor optimizations; for enterprises it adds another system component to test. Administrators who freeze updates at the patch level will need to explicitly validate or block these component updates where enterprise apps depend on a specific runtime behavior. The KB itself gives no rollback instructions beyond existing Update uninstall mechanics. (support.microsoft.com)
• Driver and CUDA toolchain compatibility
• TensorRT‑RTX relies on specific CUDA runtimes and driver features. Mismatches between the installed NVIDIA driver, CUDA toolkit expectations, and the EP version can cause missing features or fallbacks. NVIDIA release notes explain which CUDA versions and driver levels are supported for each TensorRT‑RTX release; verify GPU driver compatibility with your managed image before you approve the component for broad deployment.
• Model operator coverage and fallbacks
• Not every ONNX operator or fusion pattern is always supported by TensorRT. ONNX Runtime (and the TensorRT EP docs) explain that unsupported operators will fall back to CUDA EP or CPU — this can lead to surprising regressions if a model’s most expensive operators are not handled by TensorRT‑RTX. Test your exact model graphs to ensure the EP gives the performance you expect.
• Cache growth and storage
• Runtime caches and compiled engine artifacts can grow over time. NVIDIA notes warn that very large caches can add serialization/deserialization overhead and that cache management strategies may be necessary in constrained environments. For shared machines or disk‑limited devices, administrators should define cache locations and rotation policies.
• Rollback and troubleshooting
• Because the update is a Windows Update component, you can check its presence in Settings > Windows Update > Update history; if needed you can uninstall the update through the standard "Uninstall updates" flow in Settings / Control Panel or use command‑line tools such as wusa /uninstall /kb:KBNumber or DISM commands for advanced scenarios. If an update causes functional regressions in a production app, consider using System Restore, uninstalling the KB, or blocking the component via group policy until a fixed release is available. Microsoft documents the Update history and uninstall mechanics; third‑party guidance and PowerShell tooling can help automate checks and rollback. (support.microsoft.com)

---

Recommended checklist for IT admins and power users​

• Confirm prerequisites
• Ensure devices targeted for KB5079259 have the latest cumulative update for Windows 11, version 26H1 installed (this is required before the component will install). Check Windows Update > Update history to confirm. (support.microsoft.com)
• Validate GPU driver compatibility
• Compare the installed NVIDIA driver and CUDA stack against TensorRT‑RTX release notes and the vendor support matrix. If your drivers are older than what TensorRT‑RTX expects, schedule driver updates alongside the EP rollout.
• Test representative models
• Run your critical inference workloads with ONNX Runtime before and after the update. Measure end‑to‑end latency and throughput and check for operator fallbacks. ONNX Runtime and NVIDIA docs explain how to prioritize EPs and capture performance metrics.
• Monitor disk usage and cache behavior
• Define where TensorRT‑RTX stores its runtime caches and monitor growth. If cache artifacts grow too large, clean or rotate them to avoid slowdowns. NVIDIA warns of serialization costs for very large caches.
• Prepare a rollback plan
• Document the steps to uninstall a component update and test rollback in a lab image. Windows still exposes "Uninstall updates" (Control Panel/Settings) and command‑line options (wusa) for these tasks; automate the checks with PowerShell if you manage many machines.
• Communicate with developers
• If your organization publishes apps that rely on specific inference engines, coordinate with app developers so they can test and, if needed, update app logic that pins to specific runtime behaviors or engine file formats.

---

Short troubleshooting primer​

• If after the update an app shows worse performance or errors:
• Confirm the EP version in the system and check Windows Update history. (support.microsoft.com)
• Confirm GPU driver version matches NVIDIA’s documented matrix for the TensorRT‑RTX runtime.
• Run a model through ONNX Runtime with provider ordering explicitly set (TensorRT‑RTX first) to see whether nodes are being offloaded or falling back. Use ONNX Runtime logging to inspect subgraph assignment.
• If necessary, uninstall the component update and open a support case with either Microsoft or NVIDIA, depending on whether the issue appears to be distribution/installation or runtime/engine related. (support.microsoft.com)

---

Community context and the broader trend​

WindowsForum community threads and internal reporting in recent months show growing awareness that Microsoft is treating these EPs as first‑class runtime components: minor updates are frequent, distribution is automatic, and vendors iterate quickly on consumer‑focused optimizations. That trend is positive — it means on‑device AI improves over time without forcing opaque application updates — but it increases the testing surface for IT organizations that run validated AI workloads at scale. Community reporting has flagged both dramatic performance gains in real user scenarios and occasional friction when engine caching or driver expectations differ across devices. Treat these updates as runtime dependencies rather than innocuous background patches.

---

Bottom line​

KB5079259 updates the NVIDIA TensorRT‑RTX Execution Provider to v1.8.24.0 on qualifying Windows 11 26H1 PCs and will be delivered automatically via Windows Update once the device has the latest 26H1 cumulative update. For most RTX PC users, this is a straight win: better, faster on‑device inference that’s maintained by Microsoft and NVIDIA together. For IT professionals and organizations that deploy validated inference workloads, the update is a reminder to formalize tests for Execution Provider updates, verify driver compatibility, and plan cache/rollback strategies before broad rollout. (support.microsoft.com)
If you rely on specific model behavior, run controlled benchmarks with your actual models and measure results after the update before approving it widely — that is the only way to reliably confirm that the new EP improves performance for your real‑world workloads.

---

Conclusion
The arrival of KB5079259 is part of a larger, deliberate shift: Windows is now a living on‑device AI platform where vendor EPs evolve independently and automatically. That modularity unlocks faster innovation for developers and better out‑of‑the‑box AI experiences for users, but it also makes disciplined testing and update governance essential for organizations that depend on predictable inference behavior. Treat the TensorRT‑RTX update like any other runtime dependency: validate, measure, and plan for rollback — and then benefit from the performance that a tightly integrated NVIDIA runtime can deliver on RTX hardware. (support.microsoft.com)

---

Source: Microsoft Support KB5079259: Nvidia TensorRT-RTX Execution Provider update (1.8.24.0) - Microsoft Support