Apple still has a real shot at AI, but only if Siri becomes an operating system feature

OpenAI’s move to let third-party apps run inside ChatGPT brought back an old idea: the app icon may not matter much if one assistant window can handle travel, playlists, shopping, and work. If that shift sticks, the home screen stops being the main way people get things done.

Apple has a credible answer here, despite its AI misfires. It isn’t trying to stuff the whole app economy into a chatbot. It’s trying to expose apps to the OS through App Intents, with Siri and Apple Intelligence routing requests. That sounds wonky. It matters. If Apple can make it work, it keeps control of the mobile stack without pushing users into a chat box for everything.

OpenAI and Apple are building different runtimes for software.

OpenAI wants the assistant to be the entry point

The ChatGPT model is easy to grasp. A user connects a service, deals with auth and permissions, maybe gets dragged through 2FA, then asks for something in plain language. The model decides when to call an app, fills in parameters from the prompt, runs the action, and sends the result back in the thread. Sometimes it kicks the user to the native app with a deep link.

From a developer’s side, the appeal is obvious:

• one conversational shell across platforms
• faster iteration than App Store release cycles
• easier distribution if ChatGPT already has the user’s attention

It also gives OpenAI a lot of control. The assistant becomes the place where the task starts, often where it finishes, and always where the app gets reduced to a tool call.

Users may like that reduction. Developers probably won’t. If every service gets boiled down to “books flights” or “makes playlists,” the model owns the relationship and the app becomes back-end plumbing.

There are technical limits too. The current assistant runtime still leans toward single-app at a time. Fine for “create a playlist in Spotify.” Much less convincing for jobs that need comparison, trust, and coordination across sources. “Find me the cheapest direct flight next Tuesday, compare baggage rules, add the best option to my calendar, then message my team” gets messy fast in a chatbot. A system that understands permissions, local context, and app boundaries has a better shot.

Prompting is still fragile, no matter how often people claim that problem is basically solved. Tool selection is better. Wording still matters. Parameter extraction still breaks on edge cases. Auth state still derails flows. If every meaningful action depends on a cloud model sitting in the middle, latency and reliability stop being back-end concerns. They become product problems.

Apple is betting on intents as a UI layer

Apple’s approach is different. Rather than pulling apps into one assistant shell, it wants apps to expose structured capabilities to the operating system through AppIntents. Siri and Apple Intelligence then turn natural language into typed, permissioned calls.

That fits mobile better than Apple usually gets credit for.

A typical AppIntent declares a title, parameters, entities, and a result type. In practical terms, a developer can define actions like “create playlist,” “send invoice,” or “log workout” with real structure behind them. The assistant still has to interpret language, but it has stronger guardrails. It can resolve entities, fill slots, validate input, and call an action the OS already understands.

That helps with one of the biggest weaknesses in LLM interfaces: ambiguity. Free-form prompts are flexible. They’re also sloppy. Typed parameters are boring, which is exactly what you want when the action changes your calendar, moves money, or edits customer data.

Apple also has a better place to do orchestration. A lot of context resolution can stay on device. Contacts, calendars, messages, photos, local app state, and user habits already sit inside Apple’s permission model. That gives Apple a cleaner route to genuinely personal context than a cloud assistant that has to stitch data together across APIs and logins.

Privacy matters here, but so does speed. If Siri can resolve “schedule lunch with Sam next week after my dentist appointment” using local indexes and app entitlements, the trip is shorter and there are fewer ways for it to break. Apple still needs cloud fallback in some cases, but the foundation is the OS, not a remote chat session.

That’s Apple’s opening. OpenAI has the stronger assistant brand. Apple has the stronger runtime position.

Why developers should care

If you build iPhone apps and still treat Siri support as a nice extra, that view is getting stale.

In an intent-driven system, the valuable unit stops being the screen. It becomes the capability. Users may never open your app for the thing they care about most. They may ask Siri, type into system search, run a shortcut, or trigger your app from another app. If your core jobs aren’t exposed clearly, your app can stay installed and still fade into the background.

That shifts product design in a few ways.

The best features need schemas

A feature that only exists behind navigation and custom UI is harder for an assistant to use. A feature defined as an intent with clear parameters is callable, composable, and easier to surface.

Think in verbs:

• create a report
• summarize a meeting
• invoice a client
• save an expense
• open the latest project
• send the selected file to a teammate

If your app does any of those things, the question is simple: can the assistant invoke them safely, with enough structure to avoid dumb mistakes?

Results have to chain

A lot of apps are going to struggle here. Assistant workflows only hold up if the output from one step is usable in the next.

That means returning stable identifiers, URLs, compact summaries, and typed entities instead of dumping back a blob of text. It also means actions should be idempotent when possible. If the assistant retries after a timeout, “create invoice” can’t quietly create two invoices.

This is unglamorous engineering work. It still matters.

Observability gets harder

Traditional mobile analytics focus on sessions, screens, taps, and retention funnels. An intent-first world needs different metrics:

• resolution failures
• missing parameter prompts
• handoff rates to full UI
• retry patterns
• latency by intent type
• permission denial points

You also need that visibility without hoovering up private user data. Apple’s model pushes teams toward privacy-preserving analytics whether they want it or not. That’s probably healthy. It also makes debugging more painful.

Cross-app composition is where this gets real

The flashy promise is assistants chaining actions across apps. Sometimes that works. Sometimes it’s pure demo bait.

Apple has a better chance than ChatGPT because the OS already controls permissions, entitlements, app identity, and local context. In theory, that makes flows like “find the cheapest flight, add it to my calendar, then send it to my team in Messages” a lot more workable.

In practice, these flows break at the weakest link. One app returns vague data. Another requires confirmation in a custom view. Another doesn’t expose the right entity model. One slow network call drags the whole thing down. The assistant ends up looking dumb even when the model understood the request.

That’s why typed intent systems matter. They force discipline. They also create friction for developers who are used to shipping loose APIs and letting the UI paper over the mess.

If Apple wants Siri to stop feeling brittle, this is the path. Better contracts between apps and the system.

OpenAI still has the easier distribution story

ChatGPT already teaches people to start with a text box. It runs across platforms. It can ship new app integrations without waiting for OS adoption curves. For developers, that makes it an attractive channel even if the UX is cramped and the business model is still murky.

Apple’s route depends on Apple shipping the missing pieces, developers exposing real capabilities through App Intents, and Siri getting good enough that people trust it with compound tasks. That’s a long list for a company that has already wasted time on delayed AI features.

Apple can still get AI right. The path is narrower than it should be.

Siri has to become a reliable intent broker, not a personality layer. Apple Intelligence needs less showing off and more slot filling, disambiguation, and safe execution. And developers need to treat intents as a first-class product surface, not a voice feature for hobbyists.

If Apple pulls that off, it doesn’t need to win the chatbot race. It can win the runtime underneath it. For the mobile app economy, that’s the fight that matters.

What to watch

The caveat is that agent-style workflows still depend on permission design, evaluation, fallback paths, and human review. A demo can look autonomous while the production version still needs tight boundaries, logging, and clear ownership when the system gets something wrong.