Agent-Ready Apps
Did Apple just kill the App Store?
Short answer: no. The viral posts overshoot. But the direction behind them is real: assistants and agents are becoming a new way users reach your app, and apps that stay invisible to that layer will lose ground.
The claim going around
After WWDC 2026, posts started circulating that Apple had ended the app era: no more App Store, no more UI, an OS run entirely by an autonomous agent. Some quote sources that do not exist. If you read one of these and felt the ground move, take a breath. That is not what Apple announced.
What Apple actually announced at WWDC 2026
The keynote on June 8, 2026 announced the direction: image understanding for the on-device model, and a model-flexible protocol that lets apps swap in Claude, Gemini, or another provider. The engineering substance for agent-readiness came in the developer sessions during the week: agentic tool calling, dynamic profiles for orchestrating sub-agents, and context management. Watch Build agentic app experiences with the Foundation Models framework first, then the companion session on the framework update. That the decisive detail lives below keynote level is itself a hint: this is a platform evolving, not an App Store funeral.
And note the tense: none of it has reached users yet. It is in developer beta now and ships with iOS 27, expected September 2026. You can build against it today. Your users get it in the fall.
- An expanded Foundation Models framework: apps get direct access to the on-device Apple Intelligence model, now with image understanding and tool calling
- Access to Private Cloud Compute for heavier tasks
- Deeper App Intents, so Siri and Apple Intelligence can find and trigger what your app can do
The App Store still exists. Apps still exist. Screens still exist. The keynote did not remove any of that. It gave your app new surfaces: the assistant, the system-wide AI features, and the agent layer.
The real shift: from screens to callable capabilities
Here is the part the viral posts get right, buried under the hype. Across platforms, the same pattern is forming. Users increasingly ask an assistant, and the assistant calls app capabilities directly:
- iOS: App Intents make your app's actions visible to Siri and Apple Intelligence
- Android: App Actions and App Functions do the same for Google's assistant and Gemini
- AI clients: MCP lets Claude, ChatGPT, and other agents use your product's capabilities. OpenAI's Apps SDK, the way into ChatGPT, is built on MCP
An app that only has screens is invisible on every one of these surfaces. The agent does not scroll your UI. It calls tools. If your capabilities are not exposed as well-described actions, the agent routes around you, or answers with a competitor that did the work.
Does the app disappear behind the gateway?
It is the obvious next question: if an Agent Gateway can serve agents straight from the backend, a website plus an API could carry the whole connection. So why keep the app?
Because the installed app gains a second job: it is the connector between the phone’s AI and your organization’s systems. App Intents and on-device Apple Intelligence only work through an installed app. And the app remains the authenticated, consented surface where a human approves what an agent proposes.
Take a mobile operator. The assistant asks for the customer’s remaining data volume, and the gateway answers it from the operator’s systems. The tariff change that follows still gets confirmed by the customer in the app. The app shifts from the destination for every interaction to the trust anchor and on-device connector. It does not vanish. It specializes.
What agent-ready means
Being agent-ready is concrete engineering, not a rebrand:
- Your core user flows exist as intents or tools, with clear names, inputs, and outputs
- Consent and scoped permissions decide what an agent may see and do
- Writes need confirmation; reads can be generous
- An audit trail records what acted, on whose behalf, and when
- Fallbacks keep the human path first-class
The honest timeline
Nobody can tell you whether agent-mediated usage dominates in two years or five. You do not need to know. The cost asymmetry decides: exposing your core flows as intents and tools today is incremental work on an app you already have. Retrofitting it later, under pressure, while competitors already answer inside the assistants, is not. Prepare your app for agentic use now, or spend the next years as a laggard.
The next step
Start small: pick the two or three actions your users would most plausibly ask an assistant for, and ship them as App Intents and App Actions. When several AI clients and partners should use your product through one safe action layer, that is an Agent Gateway. And if the feature itself should run on the phone, see on-device AI.
Frequently asked questions
Did Apple remove the App Store at WWDC 2026?
No. The App Store, apps, and app UIs all still exist. WWDC 2026 announced expansions of the Foundation Models framework and App Intents, in developer beta now and shipping with iOS 27. That gives apps new AI surfaces. It does not replace them.
What does agent-ready mean for an app?
Your app exposes its capabilities as well-described actions that assistants and agents can call: App Intents on iOS, App Actions on Android, MCP for AI clients like Claude and ChatGPT. With consent, scoped permissions, and confirmation before anything is written.
Do we need an Agent Gateway to become agent-ready?
Not on day one. Most teams start with a few App Intents or App Actions for their core flows. An Agent Gateway becomes worth it when several AI clients and partners should use your product through one safe action layer.
Do apps disappear once agents can call services directly?
No. An Agent Gateway can serve agents straight from your backend, so in theory a website plus an API could carry the whole connection. In practice the installed app stays and gains a second job: it is the connector between the phone’s AI and your systems. App Intents and on-device Apple Intelligence only work through an installed app, and the app remains the authenticated surface where a human approves what an agent proposes. A mobile operator is a good example: the assistant asks for the remaining data volume, the gateway answers it from the operator’s systems, and a tariff change still gets confirmed by the customer in the app.