KB5067462 Intel Image Processing AI Update for Copilot+ on Windows 11

Microsoft has issued KB5067462, a targeted Image Processing AI component update that advances the Intel-specific imaging stack on Copilot+ PCs to Image Processing version 1.2509.1022.0, delivered automatically through Windows Update for devices running Windows 11, version 24H2 that already have the latest cumulative update installed.

Background / Overview​

The Image Processing AI component is one of Microsoft's modular AI subsystems that supplies shared image pre‑ and post‑processing primitives — scaling metadata, denoising, foreground/background segmentation and related transforms — used by built‑in experiences such as Photos, Paint Cocreator, thumbnail generation and Windows Studio Effects. These modular components are shipped as separate KB packages so Microsoft can iterate more quickly on per‑silicon optimizations and bug fixes without waiting for a full OS feature update.
This particular release, KB5067462, updates Intel‑powered Copilot+ PCs to Image Processing 1.2509.1022.0 and explicitly replaces the prior Intel component package published under KB5066122. The update is distributed automatically via Windows Update and will appear in Settings → Windows Update → Update history as “2025‑09 Image Processing version 1.2509.1022.0 for Intel‑powered systems (KB5067462).” The KB also reiterates the prerequisite that the device must already have the latest cumulative update (LCU) for Windows 11, version 24H2 installed before this component will apply.
Microsoft’s strategy of componentizing AI functionality is now the canonical delivery model for Copilot+ features: on‑device models and execution providers are pushed as small, vendor‑targeted updates (Intel, AMD, Qualcomm, etc.), enabling frequent tuning and hardware‑specific fixes. Public release notes for these component updates are typically concise — Microsoft labels them as “includes improvements” — leaving exact implementation details sparse in the KB itself. For that reason, independent context from Microsoft’s release history and press coverage helps frame operational expectations.

---

What KB5067462 actually contains — the factual summary​

• Applies to: Copilot+ PCs running Windows 11, version 24H2 (all SKUs listed in the KB).
• Component name & version: Image Processing version 1.2509.1022.0 for Intel‑powered systems.
• Delivery method: Automatic via Windows Update (also visible in Update history after installation).
• Prerequisite: Must have the latest cumulative update (LCU) for Windows 11, version 24H2 installed.
• Replacement: This package replaces KB5066122 (the previous Intel Image Processing component release).

Important factual note: Microsoft’s KB text does not publish a line‑by‑line engineering changelog, per‑operator details, or CVE mappings for the component update. The public entry is intentionally high level and functions as a distribution notice rather than a technical diff.

---

Why this update matters for Copilot+ PCs​

Copilot+ PCs are explicitly positioned to run richer on‑device AI experiences by offloading inference to a machine's NPU (neural processing unit) when present. Image pipeline quality — super‑resolution, background replacement, live video effects, generative erase and segmentation — depends on both model artifacts and the underlying runtime/execution provider that schedules work across CPU/GPU/NPU. Small changes to the Image Processing component or the execution provider can therefore have visible, user‑facing effects: crisper upscales, fewer segmentation halos, lower latency for interactive edits, or improved robustness for malformed inputs.
From a developer and ISV perspective, Windows exposes execution providers (for example, Intel’s OpenVINO provider on Windows) that let ONNX models and Windows AI APIs use accelerated device paths. Updates to Image Processing and the execution provider can change performance characteristics, operator placement, numeric precision/quantization behavior and error handling, so applications that bundle or depend on on‑device models should revalidate after component updates.

---

What we can reasonably infer — and what we cannot verify​

Because the KB is terse, the industry must infer likely targets for the update from the component’s role and prior release patterns:

• Likely improvements (evidence‑based inferences)
• Algorithmic tuning for upscaling, anti‑aliasing and denoising — reducing visible artifacts during Super Resolution and other transforms.
• Better mask quality for foreground/background segmentation — improved hair and fine‑edge handling used in virtual backgrounds and Photos/Studio Effects.
• Performance and dispatch optimizations — better NPU/CPU scheduling, memory footprint reductions and multi‑threading improvements to lower latency and energy per inference.
• Stability and input hardening — improved parsing, input validation and error handling in image decoders to reduce crashes and mitigate malformed‑file issues.
• What remains unrevealed (and thus must be treated as unverified)
• Exact code diffs, operator‑level changes, weight‑level model updates, or measurable before/after performance figures (for example, “X% faster on device Y”) are not published in the KB. Any claim that ascribes specific numerical gains, fixed CVEs, or training data provenance to this KB should be flagged as speculative until Microsoft or the silicon vendor publishes supporting engineering notes or a security advisory.

---

Strengths: What KB5067462 brings to users and IT​

• Agile iteration: Componentized delivery enables Microsoft to iterate quickly on model and runtime behavior for specific silicon families without bundling changes into a larger OS feature update. This reduces time‑to‑fix for both quality and operational issues.
• On‑device privacy and latency: Improvements that keep more of the image‑processing pipeline on the device reduce cloud round‑trips — a privacy and latency win for interactive features like Super Resolution and background removal.
• Hardware‑aware tuning: Vendor‑specific packages let Microsoft optimize for Intel NPU and GPU characteristics, which can yield better battery life and thermals when inference paths are correctly offloaded.
• Operational visibility: The update appears in Settings → Windows Update → Update history with a clear version string, which helps admins inventory and track component versions across a fleet.

---

Risks and operational caveats​

• Opaque changelogs: The KB’s brevity means auditors and compliance teams lack granular detail about what changed. For environments that require precise CVE mapping or forensic traceability, this is a material limitation.
• Driver/firmware coupling: Execution‑provider and image component updates frequently interact with GPU/NPU drivers and OEM firmware. Mismatched drivers are the most common source of regressions after component updates. Ensure OEM‑recommended driver and firmware versions are aligned prior to broad rollout.
• Rollback complexity: Component updates distributed through Windows Update are not always trivially uninstallable via the GUI. Rolling back may require system restore, image recovery or uninstalling the LCU that enabled the component; maintain tested recovery images.
• Subtle output deltas: Even minor numeric or precision changes (quantization parameters, kernel selection) can alter downstream outputs (segmentation thresholds, mask edges, color interpolation). For workflows that rely on pixel‑perfect or deterministic outputs, revalidation is essential.
• Version fragmentation and inventory overhead: Vendor‑targeted packaging (Intel, AMD, Qualcomm) increases the number of moving parts for an IT admin managing a heterogeneous fleet; tracking component versions explicitly becomes necessary.

---

Recommended rollout and validation plan (practical checklist)​

For home users, power users and IT administrators, adopting a staged validation approach minimizes risk while letting you realize the benefits of the update.

• Verify prerequisites
• Confirm devices are Copilot+ certified and running Windows 11, version 24H2 with the latest cumulative update installed. The component will not install otherwise.
• Build an inventory and pilot ring
• Create a small, representative pilot of devices spanning OEMs, CPU/GPU/NPU variants, and firmware revisions. Include devices without NPUs too to confirm graceful fallbacks.
• Coordinate firmware and driver updates
• Align GPU, camera and NPU runtimes to OEM recommended versions before mass rollout to minimize regressions from driver/component mismatches.
• Run targeted functional acceptance tests (48–120 hours)
• Photos: Super Resolution, Erase/Fill, Restyle and batch processing.
• Video calls: background replacement, blur, Studio Effects in Teams and third‑party conferencing apps across lighting conditions.
• Capture: Windows Hello enrollments and camera pipelines to ensure biometric flows are unaffected.
• Collect telemetry and sample repro steps
• Use Event Viewer, Reliability Monitor, WER and OEM logs. Save representative image/stream samples that reproduce any anomalies for OEM or Microsoft escalation.
• Stage the rollout
• Move from small → medium → broad deployment; monitor for new issues over several business cycles (7–14 days). Be prepared to pause or rollback if systemic regressions surface.
• Rollback readiness
• Maintain valid system images/pre‑update images and document rollback procedures (system restore, LCU uninstall, or full image recovery). Test rollback at least once.

---

Developer and ISV guidance​

• Retest ONNX models and client integrations: If your app bundles ONNX models or depends on Windows AI APIs, revalidate latency, throughput and output fidelity with the OpenVINO Execution Provider (Intel) or equivalent provider enabled. Small runtime changes can alter quantization and threshold behavior in post‑processing.
• CI changes: Add device‑level validation to CI pipelines where practical — include long‑run and real‑world image workloads to catch regressions introduced by runtime or driver updates.
• Implement robust fallbacks: Detect model/feature availability at runtime and fail gracefully when the component is absent or when an execution provider fails to initialize, ensuring consistent user experiences across device classes.
• Refrain from treating component updates as purely backward‑compatible: Test negative cases and edge‑conditions (small, malformed image inputs, unusual metadata) that historically have tripped parser or decoder regressions.

---

Security, privacy and governance considerations​

• Privacy upside: Local image processing reduces the need to send raw frames to cloud services for many interactive tasks, which lowers exposure of sensitive visual data in many common scenarios. However, the KB does not guarantee fully offline processing for every workflow — some heavy or higher‑value features may still fall back to cloud models depending on licensing, config and device capability. Verify data flows against organizational compliance requirements.
• CVE transparency gap: The KB does not list CVE identifiers or a security changelog. If your compliance posture requires explicit vulnerability mapping, monitor Microsoft security advisories and the Security Update Guide for any accompanying CVE entries, or open a support case for clarification. Until a CVE is published, treat security relevance as possible but unconfirmed.
• Telemetry changes: Component and runtime updates may enable additional diagnostic telemetry for debugging inference failures. Organizations with strict telemetry or data‑control policies should validate and, if necessary, adjust telemetry settings after updates.

---

Real‑world impact — what users will likely see​

For most consumers on qualifying Intel Copilot+ hardware the update will be largely invisible: day‑to‑day interactions should continue, but users may notice incremental improvements in image‑editing flows:

• Slightly faster or cleaner results in Photos Editor features like Super Resolution and Restyle.
• Improved virtual background and Studio Effects with fewer halos or hair clipping in challenging lighting.
• Reduced latency for interactive edits when NPU offload is effective; real gains vary by OEM thermal profiles and drivers.

For power users, creators or enterprises with image‑sensitive pipelines, even small numeric changes in interpolation or mask thresholds can alter workflow outcomes. Those users should test before assuming a drop‑in upgrade.

---

What remains unanswered and how to get clarity​

• Microsoft’s public KB entry intentionally omits operator‑level diffs and performance numbers. If precise engineering detail or a security mapping is required, open a Microsoft support case or coordinate with OEM engineering channels. For high‑assurance environments that need deterministic outputs or traceable security fixes, escalate the request through official support and watch Microsoft’s security advisories for CVEs.
• If you suspect a regression after installation, collect Update history, kernel/app crash dumps and sample inputs, update GPU/NPU drivers to OEM‑recommended versions, and engage vendor support with the collected repro artifacts. Community guidance repeatedly shows driver mismatch as the dominant root cause of post‑update regressions.

---

Bottom line​

KB5067462 advances the Image Processing AI component on Intel‑powered Copilot+ PCs to 1.2509.1022.0, replacing the earlier Intel package and aiming to deliver incremental quality, performance and stability improvements for on‑device image experiences. The update is a routine part of Microsoft’s modular AI delivery strategy and will be applied automatically to eligible devices that already have Windows 11, version 24H2’s latest cumulative update. While most users will see modest improvements, IT teams, developers and creators should validate critical imaging workflows, coordinate driver and firmware updates with OEMs, and maintain rollback plans — because the KB publishes high‑level changes only and does not enumerate the internal engineering details or CVE mappings.

---

For administrators and power users who manage Copilot+ devices: treat this update as a standard component‑level deployment — pilot first, validate imaging and conferencing workflows, update drivers and firmware, capture repro artifacts for any anomalies, and stage the rollout. That operational discipline will capture the benefits while minimizing the risk of unexpected regressions.

---

Source: Microsoft Support KB5067462: Image Processing AI component update (1.2509.1022.0) for Intel-powered systems - Microsoft Support

 

[ChatGPT]

Microsoft has published KB5067463, an Image Processing AI component refresh that advances the AMD-targeted Image Processing package to version 1.2509.1022.0 for Copilot+ PCs running Windows 11, version 24H2 — an incremental, vendor-specific update delivered automatically through Windows Update that Microsoft describes simply as “includes improvements to the Image Processing AI component.”

Background / Overview​

The Image Processing AI component is a modular piece of Windows that supplies low-level image analysis and transform primitives used by system features and first‑party apps: image scaling (super‑resolution), denoising, foreground/background separation (segmentation), thumbnail generation, and other preprocessing steps that higher-level features — Photos, Paint’s Cocreator, Windows Studio Effects and accessibility/image‑description flows — rely on. Microsoft ships these AI subsystems as updatable components so improvements can be delivered more frequently than in full OS feature releases.
This KB is explicitly restricted to Copilot+ PCs — devices that meet Microsoft’s NPU baseline and OEM enablement — and specifically to AMD‑powered Copilot+ machines. Copilot+ hardware requires an onboard Neural Processing Unit (NPU) capable of roughly 40+ TOPS to enable the full set of on‑device AI features; that hardware gating explains why Microsoft issues vendor‑specific component builds rather than a single universal binary.

---

What KB5067463 actually says​

• Applies to: Windows 11 (version 24H2) on Copilot+ SKUs (Home/Pro, Enterprise/Education, SE, Multi‑Session, IoT Enterprise).
• Component name & version: Image Processing component, 1.2509.1022.0 for AMD‑powered systems.
• Delivery: Automatic via Windows Update. The update requires that devices already have the latest cumulative update (LCU) for Windows 11, version 24H2 installed; otherwise it won’t apply.
• Replacement: Microsoft lists this package as replacing the earlier AMD Image Processing component release (KB5066123).
• Public changelog: Microsoft’s public KB entry contains only the brief summary “includes improvements to the Image Processing AI component” and does not publish a line‑by‑line engineering changelog, performance numbers, or CVE mappings. Treat micro‑level claims about model weights, operator changes, or security fixes as unverified unless Microsoft or an OEM publishes additional details.

---

Why this matters (technical and user impact)​

• Faster iteration cadence for on‑device AI
  By decoupling imaging models and runtime logic into separately updateable components, Microsoft can ship targeted fixes and tuning more quickly than via a full OS feature update. That agility benefits everyday imaging workflows and shortens time‑to‑fix for regressions.
• Visible improvements in everyday features (typical, incremental)
  Users on qualifying AMD Copilot+ devices should expect incremental gains in scenarios such as Photos super‑resolution, background replacement or blur during video calls, and thumbnail/preview generation. In prior component updates the observable deltas tended to be modest but measurable: crisper upscales, fewer segmentation artifacts, and slightly reduced inference latency for NPU‑backed operations. Outcomes are highly device‑ and driver‑dependent.
• Privacy and latency advantages from on‑device inference
  Where inference is offloaded to an on‑device NPU, raw image data remains local, reducing the need to call cloud services for many interactive flows and lowering round‑trip latency for effects like Live Background Removal and Super Resolution. This is a material UX and privacy advantage for sensitive content and offline scenarios.
• Narrow scope but broad ripple effects
  Even though the KB targets a single component, that component sits between OS imaging APIs, vendor runtimes, ISP firmware, and OEM camera tuning — so modest internal changes can affect many consumer and enterprise surfaces (Teams/Zoom Studio Effects, Photos edits, Windows Hello camera flows, thumbnailing services).

---

Technical expectations (inferred, not fully enumerated)​

Microsoft’s short public note leaves engineering detail to inference. Based on the role of the Image Processing AI component and patterns from earlier updates, reasonable evidence‑based expectations include:

• Performance and runtime tuning for AMD NPUs: better scheduling, operator fusion, quantization adjustments or memory optimizations that reduce inference latency and NPU memory footprint. These changes reduce perceived lag in interactive tasks but are workload‑dependent. Unverified until Microsoft publishes specifics.
• Improved foreground/background segmentation: edge fidelity, hair handling, seam smoothing and anti‑aliasing refinements that reduce halos and mis‑classification in background blur and virtual backgrounds. Plausible, but not publicly confirmed in this KB.
• Input hardening and parsing robustness: extra validation and error handling when decoding image formats and metadata to reduce crashes and mitigate malformed‑file attack vectors. Component updates historically include this class of fixes. No CVE mapping is present in the KB; treat security claims cautiously.
• Device/driver compatibility adjustments: tweaks to how the Windows AI stack interacts with AMD drivers or Vitis AI runtimes, which can improve offload behaviour but also create compatibility fragility if drivers are out of date.

Because Microsoft does not publish a detailed engineering changelog for this KB, the above are technically inferences grounded in prior patterns and the component’s function. Flag any micro‑architectural claims as unverified unless Microsoft or AMD publishes deeper release notes or CVE advisories.

---

Practical guidance — what end users should do​

• Let Windows Update install the component automatically if your device is a Copilot+ AMD system and is already on Windows 11, version 24H2 with the latest LCU. Confirm the update appears in Settings > Windows Update > Update history as “2025‑09 Image Processing version 1.2509.1022.0 for AMD‑powered systems (KB5067463).”
• After installation, validate core imaging workflows:
• Run a Super Resolution upscale in Photos.
• Test background blur / virtual background in Teams (or your conferencing client) and inspect hair/edge behavior.
• Open a range of image formats (JPEG, HEIF, PNG) and confirm thumbnail generation and edits behave as expected.
• Confirm Windows Hello camera enroll and login if your biometric pipeline uses the same imaging stack.
• Report regressions with concrete repro steps using Feedback Hub; provide sample images and timestamps for Microsoft/OEM diagnostics. Community experience from earlier component rollouts shows early reports can speed follow‑up.

---

Practical guidance — what IT admins and power users should do​

• Verify prerequisites:
• Ensure target machines are Copilot+ certified and running Windows 11, version 24H2 with the latest cumulative update installed. Microsoft will not install the component without the LCU.
• Create a pilot ring:
• Deploy KB5067463 to a representative set of devices (7–20 machines) covering major OEMs, firmware revisions, and GPU/NPU combinations before broad rollout. Driver mismatches are the most common root cause of post‑update regressions.
• Align drivers and firmware:
• Update AMD chipset, GPU, and any NPU runtime drivers to OEM‑recommended versions prior to mass deployment. Many reported regressions in past component updates were due to stale or mismatched drivers.
• Acceptance test suite (minimum checks):
• Photos: super‑resolution, erase/restore, restyle.
• Conferencing: background removal/blur and Studio Effects under varied lighting.
• Windows Hello: camera enroll/login.
• Third‑party apps: any business apps that rely on Windows.AI or system imaging APIs.
• Telemetry and monitoring:
• Watch Event Viewer, Reliability Monitor, and WER buckets for LiveKernelEvent IDs, camera process faults, or driver crashes. Capture crash dumps and repro logs for OEM/Microsoft escalation if issues surface.
• Rollback planning:
• Component updates delivered via Windows Update may not be trivially removable. Prepare rollback procedures (system restore points, known‑good system images, or DISM servicing pipelines) before broad deployment. Test your rollback in a lab image.

---

Troubleshooting checklist (concise)​

• If the update doesn’t appear: confirm Copilot+ hardware status, LCU presence, and that Windows Update is configured to allow feature/component updates.
• If imaging features degrade after install:
• Reboot fully and confirm OS build & component listing in Update history.
• Update or roll back AMD chipset/GPU drivers via Device Manager or vendor installers.
• Run Windows Update Troubleshooter and collect WindowsUpdate.log.
• Use Event Viewer and Reliability Monitor to capture Faulting Application events and LiveKernelEvent IDs, and gather crash dumps for vendor support.
• If severe regressions block workflows: use system restore or an enterprise servicing image to revert; open a Microsoft or OEM support case with crash data and repro samples.

---

Strengths — why component updates like KB5067463 are strategically important​

• Faster fixes and tuning: Componentized delivery lets Microsoft iterate on models and runtimes independently of OS feature updates, shortening time‑to‑fix.
• On‑device privacy: Keeping inference local prevents frequent transmission of raw images to cloud services for many routine operations, reducing surface area for data exposure.
• Vendor‑aware optimization: Per‑silicon builds allow Microsoft to tune for AMD Ryzen AI and its runtime peculiarities, which can yield better power/latency outcomes on qualifying hardware.

---

Risks and caveats — what to watch for​

• Opaque release notes: Microsoft’s KBs typically summarize with “includes improvements” and do not publish full engineering changelogs or CVE listings for component updates. Security teams that require CVE mappings for audit should treat these KBs cautiously and open a support case if they need explicit mapping.
• Driver/firmware coupling: Changes in the execution provider or runtime behavior can expose mismatched drivers or OEM firmware bugs. The most common source of regressions historically has been driver stack mismatches, not the component itself. Align drivers before wide deployment.
• Rollback complexity: Windows Update–delivered components can be harder to remove than standalone packages; restoring a prior state often requires system images or servicing tooling. Prepare and test rollback options.
• Behavioral deltas: Small numeric changes (quantization, kernel selection, precision) can subtly change outputs — e.g., segmentation masks or super‑resolution artifacts — which may break automated image‑processing pipelines or QA tests that rely on bit‑exact behavior. Test automated workflows that depend on deterministic outputs.
• Telemetry and compliance: While on‑device inference reduces cloud transit for raw images, updates may simultaneously enable additional diagnostic telemetry for debugging inference failures. Organizations with strict telemetry controls should validate settings post‑update.

---

Independent context and corroboration​

• Microsoft’s AI component release index documents Image Processing component updates as a cadence of vendor‑targeted packages and is a reliable cross‑check for component versions and release dates. The Microsoft Learn release table documents numerous Image Processing and Phi Silica entries and shows the pattern of staged per‑vendor updates.
• Industry coverage and community testing of earlier component rollouts confirms the pattern: small but meaningful quality and performance gains are typical, yet driver mismatches and OEM firmware differences remain the dominant source of post‑update issues. Windows Central and other outlets have reported staggered feature availability and the need for per‑vendor alignment when Copilot+ features expanded to AMD and Intel hardware.
• Community and forum analyses published around prior Image Processing KBs provide practical pilot and rollback guidance that matches enterprise best practices: pilot small, align drivers/firmware, monitor telemetry, and prepare tested rollback images. Those discussions are consistent with Microsoft’s public wording — minimal changelog detail, automatic Windows Update delivery, and LCU prerequisites.

---

Verification notes and unresolved items​

• Verified, directly from Microsoft: KB5067463 exists, is titled “Image Processing AI component update (1.2509.1022.0) for AMD‑powered systems,” is scoped to Copilot+ PCs running Windows 11, version 24H2, is delivered automatically via Windows Update, requires the latest 24H2 cumulative update, and replaces KB5066123. Confirmed on the Microsoft Support KB page.
• Cross‑checked with Microsoft’s AI component release index and with independent press coverage showing the same componentized strategy for on‑device AI. These corroborate the update model and the expected per‑vendor cadence.
• Unverified details: the KB does not list a per‑item changelog, performance numbers, model weight changes, or CVE identifiers. Any claims that KB5067463 changes specific model weights, introduces a new algorithm, or remediates CVEs are not verifiable from the public KB and should be treated as speculative until Microsoft or AMD publishes additional technical notes or security advisories. Flag such claims and request official mapping if compliance or forensics require it.

---

Final assessment and recommendations​

KB5067463 is a routine but strategically relevant update in Microsoft’s on‑device AI servicing model. For most owners of qualifying AMD Copilot+ PCs, allowing Windows Update to install the component will be the low‑touch path that likely yields small, practical improvements: crisper upscales, fewer segmentation artifacts, and modest latency reductions for NPU‑backed image ops. The trade‑off is operational: enterprise administrators and power users must treat such updates as platform‑touching changes — test in pilot rings, align AMD/OEM drivers and firmware, monitor telemetry for at least a week after deployment, and maintain rollback images.
Recommendations (short checklist):

• Confirm device is Copilot+ and running Windows 11 24H2 with latest LCU installed.
• Update AMD chipset/GPU/NPU drivers and OEM firmware before applying the component.
• Pilot the update on a small, representative fleet for 7–14 days and validate Photos, Studio Effects, Windows Hello, and any image‑dependent business apps.
• Capture and preserve repro steps, sample images, and crash dumps for any regression and escalate to OEM/Microsoft with supporting traces.
• If audit or compliance requires explicit CVE mappings, open a support case: the KB does not contain CVE identifiers.

KB5067463 typifies Microsoft’s move to modular, vendor‑aware AI servicing: it’s an operational step forward for on‑device experiences and privacy, but it demands the same discipline organizations apply to firmware and driver rollouts. For consumers on qualifying AMD Copilot+ hardware, let Windows Update do its job — but validate your workflows and keep your vendor drivers current.

---

In short: KB5067463 (Image Processing 1.2509.1022.0 for AMD) is a targeted, automatic component refresh that should deliver incremental image‑processing improvements on AMD Copilot+ PCs, but it comes without a public engineering changelog — pilot, verify, and keep drivers aligned before broad rollout.

---

Source: Microsoft Support KB5067463: Image Processing AI component update (1.2509.1022.0) for AMD-powered systems - Microsoft Support