Edge AI's 48-hour platform war: Microsoft Foundry Local ships while Apple prepares Core AI at WWDC

What Microsoft actually shipped

Foundry Local reached general availability in April, but the Build 2026 update is what makes it a platform story rather than a developer preview. The runtime loads in-process — no daemon, no local HTTP server required — through native SDKs for Python, JavaScript, C#, and Rust. Models download from Microsoft's Foundry Catalog on first run, cache locally, and route through ONNX Runtime with automatic execution-provider selection: NVIDIA CUDA on discrete GPUs, Qualcomm and AMD NPUs on Copilot+ PCs, Intel OpenVINO where available, and CPU fallback everywhere else.

The WinML 2.0 upgrade matters for Windows specifically. Previous Foundry Local builds depended on the Windows App SDK bootstrap; v1.2 removes that step so Python and Electron apps get NPU acceleration without asking users to install extra runtimes. Microsoft's pitch is deliberately boring in the best way: same OpenAI request/response format you already use in the cloud, swapped to local inference with one SDK import. That design targets the exact pain point Perplexity highlighted at Computex — hybrid pipelines where cheap local models handle routine queries and frontier APIs handle hard ones.

Catalog coverage today skews small: Phi, Qwen, Mistral, DeepSeek, GPT-OSS variants, and Whisper for transcription. These are not GPT-5-class models. They are the workhorses enterprises actually want at the edge — summarization, classification, PII redaction, and live captioning — without sending every keystroke to a vendor whose unit economics depend on token volume.

What Apple is expected to unveil Monday

Apple's counter-move has been telegraphed for months: Core AI replaces Core ML as the primary framework for generative workloads on iOS 27, iPadOS 27, and macOS 27. Where Core ML optimized classical prediction tasks — image classifiers, recommendation models — Core AI is built for transformer inference, multimodal inputs, and routing between on-device Foundation Models and licensed cloud backends. Early reporting suggests MCP (Model Context Protocol) compatibility, which would let third-party apps connect external models through a standardized host interface rather than bespoke SDK integrations.

The consumer headline is Siri rebuilt on a custom Gemini-derived model. The developer headline is different: a two-tier stack where Apple gives away its own on-device LLM through Foundation Models while charging — terms still unknown — for Extensions that surface third-party AI inside system surfaces. Apple's Platforms State of the Union at 1:00 p.m. PT Monday is where pricing, API scope, and migration paths from Core ML should land. Until then, Foundry Local is shippable today; Core AI is promise with a beta timestamp.

Apple's advantage is integration depth. A Core AI call can theoretically reach the Neural Engine, GPU, and Apple's Private Cloud Compute in one Swift API — no driver hunting, no ONNX export headaches, no wondering whether your quantized Qwen build runs on M-series versus A-series silicon. Microsoft's advantage is reach. Foundry Local runs on Windows, Linux, and macOS today, which means a healthcare charting app, a factory-floor diagnostic tool, and a creative-suite plugin can share one inference codebase across fleets that will never standardize on a single OS.

Why the timing collides with enterprise budgets

The edge platform war is not academic. CIOs spent the first half of 2026 watching token bills spike as coding assistants and search copilots rolled out company-wide. Model routing — sending easy tasks to cheap models and hard tasks to frontier ones — became procurement doctrine almost overnight. Foundry Local and Core AI attack the same line item from opposite directions: eliminate the API call entirely for workloads that fit in 3–8 billion parameter boxes.

The hardware backdrop sharpens the trade-off. Microsoft's Copilot+ PC push and NVIDIA's RTX Spark workstations target developers who want local agents with GPU headroom. Apple's M-series Macs already ship with unified memory pools that make 7B-parameter inference practical without discrete cards. Neither stack yet runs 70B models on a laptop battery; both are good enough for the 80% of enterprise tasks that are not creative writing marathons.

Compliance teams notice the split too. Foundry Local's in-process design keeps data on-device by architecture — no network socket unless you opt in. Apple's Private Cloud Compute promises the same for Apple-hosted models, but Extensions that hand queries to OpenAI or Google reintroduce subprocessors your DPA may not cover. A hospital choosing Foundry Local for triage summaries and Apple Foundation Models for patient-facing iPad apps is a plausible 2026 architecture. A hospital assuming “Apple = private” without reading Extensions settings is a compliance incident waiting for Monday's release notes.

Developer decision matrix (pre-beta)

Until Apple posts Core AI documentation, treat the matrix below as hypothesis — but Foundry Local is GA, so the Microsoft column is actionable today.

• Cross-platform desktop app (Win + Mac + Linux). Foundry Local is the only serious option. Export your model to ONNX, bundle the SDK, ship. Revisit Core AI only for a native Swift companion app.
• iOS-first consumer app with AI features. Wait 48 hours. If Core AI beta compiles and Foundation Models covers your use case, build there; Apple's App Store discovery for Extensions-compatible apps may matter more than raw inference speed.
• Enterprise fleet on Copilot+ Windows. Foundry Local + WinML 2.0 is the path of least resistance. IT can push models through existing device-management channels without waiting for Apple's September hardware cycle.
• Hybrid cloud + edge (the Perplexity pattern). Both platforms support OpenAI-shaped APIs, which means your routing layer can stay vendor-neutral at the interface. The implementation fork is still real — two SDKs, two quantization pipelines, two QA matrices.

Teams already on Core ML should not panic-migrate. Apple has signaled coexistence during transition; our MCP explainer covers why protocol-level interoperability may matter more than framework branding once Extensions ship. The mistake to avoid is building a second inference stack before reading Monday's migration docs — duplicate runtimes bloat installers and confuse security reviewers.

What investors should watch (without the hype)

Public markets will treat WWDC as a Siri story. The edge platform war is a margin story for Microsoft and a lock-in story for Apple. Every inference call moved from Azure OpenAI to Foundry Local is revenue Microsoft trades from cloud tokens to Windows ecosystem stickiness — a swap the company may gladly make as investors question AI ROI. Every app that routes through Core AI instead of a standalone ChatGPT SDK is distribution Apple can tax, bundle, or gate — the same playbook that made In-App Purchase the App Store's economic engine.

Neither company wins the whole edge market. The likely equilibrium looks like browsers versus native apps: ONNX-based runtimes dominate cross-platform and regulated verticals; Apple's stack dominates premium consumer experiences on devices people already carry. The 48-hour news cycle makes it feel like a duel. The five-year outcome is probably a split map — which is exactly why developers shipping in June 2026 should decide based on where their users live, not which keynote had better lighting.

Monday checklist

• 10:00 a.m. PT — Apple keynote. Listen for Core AI naming, Foundation Models API changes, and whether Extensions open to all developers day one or stay invite-only.
• 1:00 p.m. PT — Platforms State of the Union. Pricing, deprecation timeline for Core ML, and any MCP documentation links. This session matters more than the stage demo.
• Afternoon — iOS 27 beta 1. If import CoreAI compiles, benchmark against a Foundry Local Qwen build on the same M-series Mac. Latency and memory footprint tell you which stack fits your app.
• Before September ship dates. Revisit hybrid routing budgets. Local inference only saves money if you actually turn off cloud fallback for tasks the small model handles reliably.

Sources: Microsoft — Foundry Local GA (Apr 9, 2026); Microsoft — Foundry Local 1.2.0 / WinML 2.0 (Build 2026); Microsoft Learn — Foundry Local architecture; GitHub — microsoft/Foundry-Local (v1.2.1, Jun 5, 2026); The Star — WWDC 2026 preview (Jun 7, 2026). Related on Solana Garden: Core AI developer platform, model routing and enterprise costs, hybrid local-cloud inference, MCP explained.