Siri AI vs Google Gemini: What Powers Apple's New Assistant?
The simple answer: Apple's new Siri is not the normal Google Gemini chatbot wearing an Apple interface. Siri AI is an Apple-controlled assistant built from several Apple Foundation Models, local search systems, app-action frameworks and Private Cloud Compute. Google supplies important model and cloud technology underneath that stack.
The technical answer is more interesting. Apple has disclosed a five-model AFM 3 family, including a 3-billion-parameter dense model, a 20-billion-parameter sparse on-device model, multiple server models and a high-end reasoning model hosted through an expanded Private Cloud Compute architecture on Google Cloud. This Apple Siri AI Gemini comparison starts with the easy explanation, then follows a request through retrieval, model routing, tool calling, execution and privacy controls.
Source: Apple Newsroom
The answer in 30 seconds
- Gemini is a foundation, not the complete Siri product. Apple and Google say the next Apple Foundation Models are based on Gemini models and Google cloud technology.
- Siri AI is a routed system. A request can use local models, local indexes, app tools or a larger model through Private Cloud Compute.
- Apple has five disclosed AFM 3 models. Two run on supported devices and three run on servers for heavier reasoning, multimodal work and image generation.
- Personal context is primarily a retrieval problem. Siri does not need to memorize an entire inbox inside model weights; it can search indexed content and pass only relevant results into the active model context.
- Actions are typed tools, not unrestricted screen automation. App Intents, App Entities and schemas describe what an app allows Siri to find or do.
- The regular Gemini app is broader as an AI workspace. It offers long-form research, model selection, files, coding, generative media, connected Google services and agent workflows.
First separate the names people mix together
Most confusion comes from treating four different layers as if they were the same product. They are not.
| Name | What it actually is | Who controls the user experience |
|---|---|---|
| Gemini models | Google's family of multimodal foundation models and agent-capable model services. | Google controls the base model platform; partners can build products on top. |
| Gemini app | Google's consumer chatbot and agent interface for conversation, research, files, media creation and connected apps. | Google. |
| Apple Foundation Models | Apple's task-optimized model family, custom-built with Google technology and deployed across Apple devices and Private Cloud Compute. | Apple controls model selection, deployment, safety layers and integration. |
| Siri AI | The complete assistant product: speech, interface, system orchestrator, personal-context retrieval, app tools, models and response rendering. | Apple. |
A useful analogy is a car platform. Gemini technology is part of the engine and manufacturing platform. Apple Foundation Models are Apple's tuned powertrains. Siri AI is the finished vehicle, including steering, brakes, dashboard, safety logic and access to the rest of the operating system.
What actually happens when you ask Siri something?
In plain English: Siri first works out what you want. It then decides whether it can answer locally, needs information from your device, has to call an app action, or requires a larger cloud model. The result may combine several of those paths.
Technically: Apple publicly names a system orchestrator, on-device Foundation Models, the Spotlight index, an App Toolbox, App Intents, onscreen awareness and Private Cloud Compute. Apple does not publish a complete production trace for every request, so the following sequence is a technically grounded reconstruction of the disclosed components rather than a claim that every prompt follows one fixed pipeline.
- Input acquisition: Siri receives speech, typed text, selected content, a screenshot, camera input or another supported modality.
- Intent and context analysis: The system identifies whether the request is conversational, informational, personal, visual or action-oriented.
- Context retrieval: Local tools can search Spotlight-indexed content, resolve people, inspect onscreen content or request structured information from an app.
- Model selection: The orchestrator chooses an on-device or server model according to capability, latency, hardware, privacy boundary and task complexity.
- Tool planning: If the request requires an action or private fact, the model can generate structured arguments for an approved tool instead of guessing.
- Execution and validation: The operating system or app performs the action under normal permissions and returns a typed result.
- Response generation: The model combines tool output, retrieved context and world knowledge into the final answer or follow-up question.
Source: apple.com
The important component is the orchestrator. It connects models with Spotlight retrieval, app capabilities and Private Cloud Compute instead of expecting one giant model to perform every task by itself.
Why orchestration matters more than the chatbot model
A language model can produce convincing text, but an operating-system assistant must deliver correct state changes. “Move my meeting to 15:00” is not merely a writing task. The assistant has to identify the right event, resolve the time zone, check permissions, call the calendar action, handle conflicts and confirm what changed.
This separates semantic planning from deterministic execution. The model interprets language and proposes a structured action. A conventional software component validates and executes it. That design is generally safer and easier to test than allowing a model to freely manipulate interfaces with simulated taps.
Inside Apple's AFM 3 model family
In plain English: Apple does not use one Siri model. Small and fast tasks stay local, stronger Apple silicon can unlock a much larger local model, and difficult requests can move to privacy-protected server models.
Apple disclosed five third-generation Foundation Models on June 8, 2026. They share a common training foundation but are specialized for different hardware and workloads.
| Model | Where it runs | Published architecture details | Best-fit workload |
|---|---|---|---|
| AFM 3 Core | On device | Approximately 3 billion parameters, dense architecture. | Fast language tasks, lightweight reasoning and system features on supported hardware. |
| AFM 3 Core Advanced | On the most capable Apple silicon systems | 20 billion total parameters, sparse; activates roughly 1 to 4 billion parameters depending on the request. | Advanced local multimodal work, expressive voice, dictation and stronger reasoning without sending the task to a server. |
| AFM 3 Cloud | Private Cloud Compute on Apple silicon | Server model based on an upgraded Parallel-Track Mixture-of-Experts architecture. | General server-side reasoning and multimodal requests requiring more capacity than local models. |
| ADM 3 Cloud (Image) | Private Cloud Compute | Dedicated image-generation and editing model with task-specific adapters. | Image Playground, Genmoji and advanced image-editing workflows. |
| AFM 3 Cloud Pro | Private Cloud Compute on NVIDIA GPUs in Google Cloud | Apple's most capable disclosed server model, optimized for complex reasoning and agentic tool use. | Longer, more difficult requests involving planning, multi-step tools or complex reasoning. |
How can a 20-billion-parameter model run on a consumer device?
Simple explanation: the complete model does not have to be active in memory at once. Apple stores the full expert pool in flash storage and loads only the parts needed for the current request into faster memory.
Technical explanation: AFM 3 Core Advanced uses a sparsely activated architecture built around Instruction-Following Pruning. A lightweight dense routing block chooses a fixed subset of experts during prompt processing. Shared experts remain active, while request-specific routed experts are loaded from NAND into DRAM. Apple says the selection can be updated periodically during token generation.
This is different from a conventional token-level mixture-of-experts model that may make routing decisions at every layer for every token while all experts remain readily addressable in accelerator memory. NAND has much lower bandwidth than DRAM, so Apple shifts more routing work to the prompt level and reduces weight movement. The result is a 20-billion-parameter model whose active compute footprint can be closer to 1, 2 or 4 billion parameters for a given workload.
What “based on Gemini” does and does not prove
The January 2026 Apple-Google statement says the next generation of Apple Foundation Models would be based on Google's Gemini models and cloud technology. Apple later called the five AFM 3 models custom-built in collaboration with Google. That confirms a deep technical relationship, but it does not mean Apple is exposing the public Gemini app model endpoint directly.
Apple has not publicly released the complete recipe showing which Gemini checkpoints, architectural components, training infrastructure, distillation stages or post-training datasets map to each AFM 3 model. It has disclosed that the family shared a common initial foundation, was trained at scale on cloud TPU accelerators, then specialized and optimized for Apple silicon or NVIDIA GPUs. Claims beyond that would be speculation.
Personal context: Siri is closer to private RAG than model memory
In plain English: Siri can answer questions about your emails, messages, files and photos by searching for relevant items when needed. It does not need to permanently bake your private data into the model.
The technical pattern resembles retrieval-augmented generation, or RAG:
- Your apps donate searchable metadata and entities to Core Spotlight.
- The model decides that a personal search tool is required.
- It generates a semantic or structured query over the local index.
- Spotlight returns candidate items or identifiers.
- The app can hydrate selected results with full metadata when compact index data is insufficient.
- The model reasons over the small retrieved set and generates an answer grounded in those items.
Apple's developer documentation shows that SpotlightSearchTool can perform semantic search, structured filtering over dates, people and locations, and even multi-stage search-and-computation pipelines. The model may call the tool more than once before answering. Guidance profiles can reduce the available search schema for smaller on-device contexts, improving efficiency and lowering the chance of irrelevant queries.
This architecture has two practical advantages. First, the model context contains only the information needed for the current request instead of an entire mailbox or photo library. Second, indexed data remains governed by app sandboxes, operating-system permissions and explicit developer integrations.
App Intents: how Siri turns language into safe actions
In plain English: an app tells Siri what it is allowed to do and what data objects it understands. Siri then fills in the required fields from natural language.
Technically: App Intents exposes actions, entities, queries and schemas as typed interfaces. An app can define an intent such as creating a task, an entity such as a project, and a query that resolves project names. Siri's model can generate structured arguments, but the app still owns validation and execution.
| Layer | Example | Why it matters |
|---|---|---|
| Natural-language request | “Move tomorrow's design review to 3 PM and tell Sarah.” | Human-friendly but ambiguous input. |
| Entity resolution | Resolve “design review,” “tomorrow” and the correct Sarah. | Prevents the model from acting on the wrong object. |
| Structured intent | UpdateEvent(eventID, startTime, attendees) |
Converts free text into typed fields. |
| Permission and validation | Calendar access, conflict checks and app-specific constraints. | Keeps policy enforcement outside probabilistic text generation. |
| Execution result | Updated event identifier or a recoverable error. | Gives the model a factual result to explain instead of inventing success. |
Google Gemini also supports function calling, structured outputs and tool orchestration. The difference is product scope. Gemini's developer platform can call custom APIs, Google Search, URL context, code execution, file search and other tools. Siri's privileged advantage is that Apple can expose operating-system and app actions through a native permission model across iPhone, iPad, Mac, Watch and Vision Pro.
Source: apple.com
Siri AI now supports richer conversations, but the visible chat is only the front end. The more important technical distinction is its ability to combine web knowledge, private retrieval and approved app actions in one system flow.
Siri AI vs the regular Gemini chatbot: technical comparison
| Technical dimension | Siri AI | Google Gemini app |
|---|---|---|
| Primary optimization target | Low-friction assistance inside an operating system. | General-purpose conversational, research, creation and agent workflows. |
| Model exposure | Model choice is mostly hidden behind Apple's orchestrator. | Users may see model or mode choices, plan limits and specialized features. |
| Execution boundary | Native OS frameworks, App Intents, Spotlight and Apple-controlled tools. | Google Connected Apps, Gemini agents, browser or app integrations and developer-defined tools. |
| Personal data retrieval | Local indexes and app-provided entities can ground responses in device data. | Connected Google services and account-level personalization can provide cloud context. |
| Long-form research | Can answer broad web questions, but the product is optimized around assistance and actions. | Deep Research and agent modes are designed for multi-step web investigation and report generation. |
| Context handling | Uses task-specific retrieval and model routing; exact public limits depend on model and hardware. | Gemini APIs support very large contexts, while consumer-app limits depend on model, plan and feature. |
| Real-time voice | Integrated into Apple speech, dictation, device controls and cross-device interfaces. | Gemini Live supports low-latency multimodal conversation, camera and screen interaction. |
| Developer abstraction | Foundation Models framework, App Intents, Core Spotlight and system model providers. | Gemini API, Interactions API, Live API, function calling, structured output and built-in tools. |
| Failure emphasis | Wrong entity resolution or action planning can be more damaging than a weak paragraph. | Research accuracy, source quality, tool trajectory and long-context consistency are central risks. |
Conversation state and memory are implemented differently
A chatbot conversation appears to “remember,” but several different mechanisms can create that effect:
- Context window: previous messages are included in the current inference request.
- Server-side conversation state: the service stores earlier turns and retrieves them using a conversation identifier.
- Long-term memory: selected preferences or facts are stored separately and injected into later chats.
- Retrieval: relevant data is searched from an external index and added only when needed.
Siri AI combines conversational history, iCloud synchronization and retrieval from Apple-controlled indexes. The regular Gemini product combines chat history, optional personalization and Connected Apps. On the developer side, Google's Interactions API can store an interaction and continue it through previous_interaction_id; developers can also set store=false and manage context themselves. That API behavior should not be confused with the exact implementation of every consumer Gemini chat, but it shows the platform-level difference between stateful cloud sessions and Apple's local-first retrieval approach.
Source: apple.com
Spotlight is more than a launcher in the new architecture. It can act as a retrieval layer that gives the model narrow, relevant context without exposing an entire local data collection to every prompt.
Private Cloud Compute: what changes when local hardware is not enough?
In plain English: difficult requests can be sent to a more powerful server, but Apple designed that server so the request is processed temporarily, cannot be casually inspected by administrators and is accepted by the device only after cryptographic verification.
Technically: Private Cloud Compute is built around five stated requirements: stateless computation, enforceable guarantees, no privileged runtime access, non-targetability and verifiable transparency. Apple says PCC nodes have no general-purpose remote shell, no ordinary interactive debugging path and no general-purpose logging mechanism that could accidentally capture user content.
The 2026 expansion adds PCC capacity on Google Cloud for AFM 3 Cloud Pro. Apple says the implementation uses NVIDIA Confidential Computing, Intel CPUs with TDX and Google's Titan security chip. Critical hardware is tracked in a cryptographically verifiable append-only ledger. Components capable of exposing user data are rooted in at least two independent roots of trust, and attested keys are isolated in a dedicated confidential virtual machine.
| PCC property | What it means technically | Why a user should care |
|---|---|---|
| Stateless computation | Request data is intended only for the active inference and is not retained after completion. | Personal content should not become a persistent cloud-side conversation database. |
| No privileged runtime access | No administrator shell or unrestricted debugging mechanism is available on production nodes. | Internal access should not provide an easy bypass around the privacy boundary. |
| Attestation | The client verifies approved software and hardware state before trusting a node. | A device should reject infrastructure that is not running an authorized, inspectable build. |
| Non-targetability | The service is designed to make it difficult to route a particular person's requests to a compromised node. | Attackers should not be able to select one user for silent inspection. |
| Verifiable transparency | Production software binaries and security material are made available for external research. | Apple's claims can be tested more directly than a closed “trust us” cloud service. |
These are architectural claims and controls, not a guarantee that every Siri answer is correct or that no implementation bug will ever exist. PCC protects inference data handling; it does not eliminate risks such as mistaken entity resolution, malicious content in retrieved documents, compromised user accounts or an app exposing overly broad actions.
How Gemini's cloud architecture differs
In plain English: the Gemini app is a cloud AI service tied to a Google account and optional connected services. Its strength is breadth: very large context, web tools, files, code, media generation and long-running agents. The trade-off is a more conventional cloud data model that users and organizations must configure correctly.
Google's current developer stack centers on the Interactions API for multimodal prompts, structured outputs, tool orchestration and agents. It can maintain server-side state, expose execution steps and run long tasks in the background. Gemini 3-class models can combine Google Search grounding, URL context, code execution, file search and custom function calls in one workflow. Gemini Live uses a stateful WebSocket connection for continuous audio, images and text, with interruption support and low-latency voice output.
The consumer Gemini app adds product-level features such as Deep Research, Gemini Live, Gems and connected Google services. Zerlo's Gemini Gems guide explains its reusable custom-assistant layer, while the Gemini API key guide covers the developer entry point.
Source: blog.google
The Gemini app exposes a broader AI workspace: research, live multimodal conversation, files, generative media and agents. Siri hides more of the model stack because its main job is to mediate the operating system.
Privacy comparison: local-first orchestration vs account-centered cloud AI
| Question | Siri AI | Gemini app |
|---|---|---|
| Where can inference run? | On device or through Private Cloud Compute. | Primarily in Google's cloud services; some device-specific Google features may use local models. |
| How is personal context obtained? | Local indexes, app entities, onscreen context and user-authorized tools. | Chat history, personalization and Connected Apps under Google Account settings. |
| Is cloud request data intended to persist? | Apple says PCC computation is stateless and personal data is not stored. | Gemini activity can be stored in the user's account when Keep Activity is enabled; controls and retention depend on product and account type. |
| Can humans inspect content? | Apple says PCC prevents privileged access to request data and publishes software for research verification. | Google's consumer privacy documentation explains that some data may be reviewed under applicable settings and policies. |
| Can connected apps retain received data? | Normal app storage and permissions still apply after Siri performs an action. | Google notes that connected services or third parties can retain data they receive under their own policies. |
For a deeper account-level review, see Zerlo's guide to Google Gemini privacy and data controls. The central distinction is not “Apple has data, Google has none” or the reverse. It is how much processing occurs locally, which service stores conversational state, which permissions are active and whether connected apps receive a copy of the information.
Latency, energy and reliability trade-offs
A technically superior model is not automatically a superior assistant. The system must balance model quality against response time, memory pressure, battery use, network conditions and action risk.
| Path | Main advantage | Main limitation | Typical failure mode |
|---|---|---|---|
| Small on-device model | Low network latency, privacy and offline capability. | Smaller context and weaker complex reasoning. | Oversimplified answer or incorrect tool choice. |
| Sparse advanced on-device model | Higher local quality without loading every parameter into DRAM. | Available only on sufficiently capable hardware; flash-to-memory movement still has a cost. | Thermal, memory or latency pressure on difficult requests. |
| Private Cloud Compute model | More compute and stronger reasoning under Apple's privacy design. | Requires network access and secure routing to an attested node. | Network timeout, service unavailability or fallback to a reduced local answer. |
| Gemini cloud model or agent | Large context, broad tools, web grounding and long-running workflows. | Cloud latency, account policy and product limits. | Tool loops, source-selection errors, stale connected-app data or incomplete long-running tasks. |
Security risks both architectures still face
Prompt injection through retrieved content
An email, webpage or document can contain instructions aimed at the model rather than the user. A secure assistant must treat retrieved text as untrusted data, keep system policy separate and restrict which tools can be called. Typed tools reduce risk, but they do not remove it if the model is allowed to pass sensitive data into a dangerous action.
Wrong-person and wrong-object resolution
“Send it to Alex” can be more dangerous than a factual hallucination. The assistant must resolve contacts, files and events with enough confidence and request clarification when ambiguity is material. Apple exposes contact resolution and entity schemas for this reason.
Non-deterministic tool trajectories
Two identical requests can produce different model plans. Apple therefore introduced evaluation tooling for agentic flows, while Google exposes tool steps and structured outputs in its developer APIs. Production teams need datasets that test not only final wording but also whether the correct tool was called with the correct arguments.
Permission expansion
An assistant becomes more useful as more apps are connected, but its blast radius also increases. Least-privilege permissions, confirmation for destructive actions, clear execution receipts and revocable connections are more important than the underlying benchmark score.
Can we say which model is smarter?
Not responsibly from the public data alone. Apple has published internal human-preference improvements for AFM 3 models against its previous generation, including gains in instruction following, image understanding, dictation and text-to-speech. Those are useful generational measurements, but they are not a neutral head-to-head benchmark against the current consumer Gemini model.
Google publishes extensive capability information for Gemini models and offers broader developer access, but the exact model, routing policy, system prompt, tools and product limits used by the Gemini app can change. A fair comparison would need identical prompts, identical tool access, equivalent context, the same language, repeated trials and separate scoring for factuality, action success, latency and privacy cost.
The more defensible conclusion is architectural:
- Siri AI is optimized for personal, contextual and executable tasks inside Apple's ecosystem.
- The Gemini app is optimized for broad cloud intelligence, research, creation and agent workflows.
- Apple's Gemini-derived models can be technically related to Google's models while producing a very different user experience.
Which one should you use?
| Your task | Better starting point | Reason |
|---|---|---|
| Find a detail in Mail and turn it into a reminder | Siri AI | Local personal-context retrieval plus native action execution. |
| Edit, share or act on content already visible on an Apple device | Siri AI | Onscreen awareness and operating-system integration. |
| Research a complex topic across many sources | Gemini | Deep Research and long-running cloud agent workflows. |
| Analyze large files, code or multimodal documents | Gemini | Large cloud contexts and explicit file, code and tool capabilities. |
| Build an iPhone app feature that works offline | Apple Foundation Models framework | Direct access to the on-device system language model and Apple-native tools. |
| Build a cross-platform cloud agent | Gemini API | General API access, tool orchestration, server state and broad multimodal services. |
FAQ
Is Siri AI literally running the same model as the Gemini app?
No. Apple says its AFM 3 family was custom-built with Google and based on Gemini technology, but Siri uses Apple-specific models, routing, privacy infrastructure, retrieval systems and app tools. Apple has not published a one-to-one mapping between a consumer Gemini app model and each AFM 3 model.
Does every Siri request go to Google Cloud?
No. Apple describes two on-device models and local components such as the Spotlight index and App Toolbox. More demanding requests can use Private Cloud Compute. AFM 3 Cloud Pro adds PCC capacity on Google Cloud, but Apple says devices trust only cryptographically approved PCC software and Apple retains control of that software.
What is the difference between AFM 3 Core and AFM 3 Core Advanced?
AFM 3 Core is a dense model with roughly 3 billion parameters. AFM 3 Core Advanced has 20 billion total parameters but uses sparse activation, loading approximately 1 to 4 billion parameters for a request. The advanced model is limited to Apple's most capable silicon systems.
Why does Apple store model experts in flash memory?
Keeping all 20 billion parameters active in DRAM would require too much fast memory for a consumer device. Apple stores the larger expert pool in NAND and moves selected experts into DRAM according to prompt-level routing decisions. This allows a larger total model while limiting the active memory footprint.
Is Siri's personal context the same as training on my data?
No. Retrieval uses relevant personal items at inference time to answer a request. Training changes model weights. Apple says it does not train its Foundation Models on users' private personal data or private interactions. Retrieved content can still be sensitive, so permissions and tool boundaries remain important.
Can Siri AI work offline?
Some tasks can run with on-device models and local tools, but broad web knowledge and high-complexity reasoning may require a network connection. The exact fallback behavior depends on the feature, device and request.
Is Gemini better for developers?
It depends on the deployment target. Gemini offers a broad cross-platform cloud API with large contexts, built-in tools and agents. Apple's Foundation Models framework is more attractive for private on-device features, Apple-native app actions, Spotlight retrieval and deep operating-system integration.
Which assistant is more private?
Siri AI has the stronger local-first and verifiable confidential-compute architecture on paper. Gemini provides detailed account controls and enterprise protections, but the consumer app is fundamentally more cloud- and account-centered. The practical result still depends on settings, connected apps, account type and the sensitivity of the task.
Bottom line
The technically correct answer to “What powers Apple's new assistant?” is not simply “Google Gemini.” Siri AI is powered by Apple's AFM 3 model family and an Apple-controlled orchestration layer. Gemini technology contributes to the model foundation and Google Cloud contributes infrastructure for the most demanding Private Cloud Compute path, but Apple controls retrieval, permissions, app actions, deployment and the assistant interface.
For non-technical users, the difference is straightforward: Siri is designed to understand and act inside Apple devices, while Gemini is designed as a broad AI workspace. For technical readers, the decisive distinction is the architecture around the model: sparse on-device inference, local RAG through Spotlight, typed App Intents, dynamic model routing and an attested stateless cloud boundary versus a general cloud agent platform with large contexts, persistent sessions and a wider tool ecosystem.