Apple's Rebuilt Siri: Onscreen Awareness & the Agentic OS

By Deepak Bagada, CEO at SaaSNext & Principal AI Architect.

Last verified: August 2026 - WWDC 2026, iOS 26 / Apple Intelligence R2, App Intents

Siri Is No Longer an Assistant. It Is the OS.

At WWDC 2026 Apple did something it has not done in a decade: it rebuilt Siri from the ground up and changed what an operating system is for. The new Siri is not a better voice assistant bolted onto iOS. It is the agentic OS layer itself - a system that can see what is on your screen, hold a real back-and-forth conversation, remember personal context across sessions, and take actions inside your apps. The announcements landed as four headline capabilities, and each one is a small architectural earthquake for the industry.

The rebuilt Siri matters far beyond Apple's installed base because it sets the consumer expectation for what an operating system should do. Everyone else has to match onscreen awareness and in-app action within a release or two, and the enterprise equivalent - agents that can operate your actual software - is being specified in the workflows that keep showing up in our AI news coverage.

The Four Pillars of the Rebuild

Onscreen awareness. Siri can now read what is on your display - an email, a webpage, a chat thread, a photo - and reason about it. This is the difference between a query bot and an agent. Ask "what address is in this email and add it to the meeting invite," and Siri both extracts the fact and performs the action. The implementation is classic Apple: most parsing happens on-device, with a vision-language model operating on a live snapshot plus accessibility-tree context, and nothing leaves the device unless the task requires Private Cloud Compute.

Back-and-forth conversation. The new Siri keeps multi-turn context in a structured conversation state, so you can say "send it to Sarah" without repeating what "it" refers to. Under the hood this is a conversation-state machine with typed slots - no longer a stateless query-respond-query loop. Apple's engineering emphasis is on reliable reference resolution, because that is what makes a voice agent feel like a conversation rather than a series of commands.

Personal context. Siri now maintains an on-device personal knowledge graph - your contacts, calendar, messages, locations, and preferences - available as grounding context for every request, with the privacy guarantees Apple has bet its brand on. It is a local memory layer, not a cloud profile, which is the single most important architectural difference between Siri and cloud assistants.

Actions inside apps. This is the agentic core. Apps expose intents through App Intents, and Siri composes them. Opening a ride-sharing app, booking, and messaging the driver are not three separate voice commands; they are one agentic task assembled from the app's intent graph.

The Architecture: An Agentic OS

The simplest way to understand the rebuild is that iOS has acquired an agent runtime with the same shape as the rest of the industry - perception, memory, planning, tools - but with Apple's hardware-and-privacy constraints defining every design decision.

The perception layer combines the on-screen snapshot, the accessibility tree, and audio input. The memory layer is the on-device personal context store, synced through Apple's encrypted sync so it survives device upgrades. The planning layer is a small on-device reasoning model that decides which app intents to invoke and in what order. The tool layer is App Intents - a typed, declarative contract apps use to expose actions. When a task exceeds on-device capability, the system routes it to Private Cloud Compute, which runs a larger model in a verifiable enclave with no data retention. The result is an agent whose tool surface is literally every app on the device.

A minimal App Intent that exposes an action to Siri looks like this:

import AppIntents

struct ScheduleMeetingIntent: AppIntent {
    static var title: LocalizedStringResource = "Schedule a meeting"

    @Parameter(title: "Subject")
    var subject: String

    @Parameter(title: "Time")
    var time: DateComponents

    @MainActor
    func perform() async throws -> some IntentResult {
        try await CalendarStore.shared.insert(
            subject: subject,
            date: time
        )
        return .result(dialog: "Meeting scheduled for \(time) with \(subject).")
    }
}

The intent declares its parameters and its action; Siri handles the natural-language parsing, the slot filling, the confirmation dialog, and the execution. This is the pattern every iOS app will follow within two release cycles, and it is why "app ecosystem" is Apple's moat in the agentic race: no competitor has tens of thousands of developers exposing typed actions.

Benchmarking the Assistants

Here is how the rebuilt Siri compares to the field in August 2026:

The table exposes the strategic trade. Siri's strengths are latency, privacy, and depth of app integration. Its weaknesses are the ones that plagued Siri for years: the on-device model's raw reasoning is thinner than a frontier cloud model, which is why complex tasks get routed to Private Cloud Compute and why Apple is still behind on open-ended research-style queries. The rest of the field has the opposite shape - deeper reasoning, weaker system integration.

The Unit Economics of an On-Device Agent

Apple's architecture is not just a privacy stance; it is a cost model. Every cloud assistant inference runs on someone's GPUs. For a platform doing billions of assistant queries a day, the difference between on-device and cloud inference is the difference between a rounding error and a bill that eats the entire product line.

Model the numbers at a representative scale. A small on-device model - roughly 3 billion parameters - executes a typical request for about $0.0001 in electricity and amortized silicon per inference. A frontier cloud model executes the same request for about $0.02 on current 2026 pricing. Now put that over a day of a billion simple requests (reminders, timers, lookups):

That is a roughly $20 million-a-day gap in variable cost at the high-volume end. The real numbers are lower because Apple routes only a subset of traffic and negotiates hardware at scale, but the order of magnitude is correct: on-device inference is a two-orders-of-magnitude unit-economics advantage that cloud-first competitors cannot replicate without either eating the cost or monetizing the data - which is exactly what Apple will not do. Apple's hardware program (its own silicon with built-in neural engines) is the enabler: amortized per-device cost replaces per-request metering, which is the classic console-vs-PC economics applied to AI.

What the Rebuild Means for Developers

For developers, the rebuild changes the integration contract. An app that wants to be "Siri-able" needs typed intents, not keyword heuristics. The practical shift: expose the ten actions your users actually want to do as App Intents, add confirmation dialogs, and let the OS handle the language. The same intent surface is reusable across Shortcuts, focus modes, and now Siri - one contract, many entry points.

The bigger implication is competitive. When the operating system becomes the agent, the app becomes a tool provider. Distribution shifts from "user opens your app" to "the OS invokes your intent." That is a huge opportunity for apps with unique capabilities and a real threat for apps that only exist as destinations. The enterprises building agent-first products should watch this closely - the mobile agentic OS will become the reference pattern for how their own software gets automated, and the workflows we document are converging on the same intent-first shape, as covered in the workflows library.

The Takeaway

Apple's rebuilt Siri is the first mass-market proof that the agent is the OS, not a feature of it. Onscreen awareness, conversational memory, personal context, and in-app actions form a coherent runtime that happens to sit under Apple's privacy brand. The unit economics seal the argument: on-device agents win on cost by two orders of magnitude, and the only way to match them is to either give up privacy or give up margin. For the rest of the industry, the message is simple - if your agent cannot see the screen and act inside the app, it is not an agent yet.