Siri's AI rewrite ships: what Apple's on-device model means for devs

What happened

Apple's Apple Intelligence page — the landing surface for the revamped Siri — hit Hacker News and rode to 490 points, which is unusual heat for a marketing URL. The interest isn't the page; it's that the page now describes a Siri that, after years of being the punchline of every AI demo, finally has a coherent developer story.

The shape: a small on-device model handles the common path, a larger model running in Private Cloud Compute handles the hard path, and third-party apps plug in through App Intents — the same framework Shortcuts uses, repurposed as the public surface for Siri's semantic understanding. Apple isn't shipping a chat API. They're shipping a routing layer that decides when your app's verbs are the right answer to a user's request.

The interesting move isn't the model. It's that Apple skipped the chatbot UI entirely and made the OS the agent. Where Google and Microsoft put a text box in front of you, Apple put App Intents behind everything — Spotlight, Siri, the Action Button, system-wide writing tools. Your app's surface area grew by a dozen entry points overnight, whether you wanted it to or not.

Why it matters

The honest read on Siri-as-it-was: it was an embarrassment. The honest read on this version: it might still be an embarrassment in the demos, but the architecture underneath is the first serious answer to a question nobody else is asking out loud — what does an AI assistant look like when the assistant doesn't own the conversation?

OpenAI, Anthropic, and Google all have the same shape: a chat surface, a context window, and tool calls. The user talks to the model. The model talks to your app. You pay per token. Your app is a tool — meaning a function the model can call when it feels like it. Discovery happens through the model's prompt.

Apple's bet is structurally different. The model never sees a chat window in the consumer flow; it sees an intent, resolves it against the App Intents registry, and hands control to your code. Your app isn't a tool the model considered — it's the verb the user invoked, with the model acting as a dispatcher. The economics flip with it: no per-token cost to you, no rate limit you have to defend against, no prompt injection vector through user chat (because there is no user chat). What you give up is generality. Siri won't improvise. If you didn't register the intent, the door doesn't exist.

The community reaction on HN split roughly three ways. The cynics noted that Apple promised this exact developer story at WWDC 2024 and shipped roughly half of it; the on-device personalization features slipped twice. The pragmatists pointed out that App Intents has been quietly shipping for three years through Shortcuts, and the apps that invested early (Things, Bear, Drafts, OmniFocus) already have a working Siri integration that just got smarter for free. The skeptics asked the obvious question: if the on-device model is small enough to run on an iPhone 15 Pro, how good can it actually be at intent resolution against an app catalog of two million entries? Apple's published numbers don't answer that. They show benchmark wins on summarization and rewriting — useful, but not the same problem.

The Private Cloud Compute story is the part that deserves more engineering attention than it's getting. Apple's claim is that requests routed to the cloud run on hardened Apple silicon servers with no persistent storage, attested boot, and a public transparency log of the images that can serve traffic. Security researchers were given image access ahead of launch. This is the first time a major vendor has tried to make remote inference cryptographically verifiable rather than contractually private. If it holds up under adversarial review, it becomes the template every regulated industry asks their LLM vendor to copy. If it doesn't, expect a very loud postmortem.

What this means for your stack

If you ship an iOS or Mac app and you haven't shipped App Intents yet, the cost of the gap just went up. Every AI surface Apple builds for the next half-decade — Siri, Spotlight, system writing tools, whatever they call the Vision Pro assistant — routes through the App Intents registry. Not being in the registry is the new not-being-indexed-by-Google. The work isn't trivial — you have to model your app's verbs as `AppIntent` types with typed parameters and a `perform()` method — but it's a one-time investment that compounds across every Apple surface.

For backend teams, the calculus is different. If your iOS app does inference today by hitting a Claude or GPT endpoint, the question is whether Apple's on-device model is good enough for your hot path. The answer is almost certainly yes for summarization, rewriting, and classification, and almost certainly no for anything that needs current knowledge or long-context reasoning. The right architecture for most apps is now a two-tier inference stack: Apple's local model for the 80% of requests where latency and privacy matter and quality is adequate, your cloud model for the 20% where it isn't. That cuts your token bill in a way nothing else will.

For anyone building a productivity app, automation tool, or anything with a clear command surface, the strategic question is whether Siri becomes a real distribution channel this cycle or remains the running joke it has been since 2011. The honest answer is: we don't know yet, but the cost of betting on "yes" is lower than it has ever been, and the cost of betting on "no" is now that you have to build your own AI surface from scratch while your competitors get Apple's for free.

Looking ahead

The interesting test isn't the keynote demo — those always work. It's whether independent developers report, six months from now, that Siri can reliably resolve user requests against their App Intents in production, with real users speaking real sentences in real accents. Apple has shipped the architecture. They have not yet shipped the proof that the architecture works at the long tail of language. If they do, the consumer AI assistant race quietly turns into a question about which OS your users already carry — and the answer to that question was settled a decade ago.