AI Agents Replacing Apps? What Carl Pei Gets Right About the App-Less Smartphone Future

At SXSW, Nothing CEO Carl Pei said the quiet part out loud. The smartphone, as we know it, is basically a grid of apps. And he thinks that grid disappears.

Not in a “next year everything is magic” way. More like, the center of gravity shifts from apps you open to agents you talk to, and the phone becomes an intent machine. You say what you want, it does the work across services, and you stop bouncing between icons like it is 2014 forever.

TechCrunch covered the comment and the broader point pretty cleanly here: Nothing CEO Carl Pei says smartphone apps will disappear as AI agents take their place.

Now the useful question for product teams is not “will apps die.” It’s: what has to be true for an agent first phone to be better than a great set of apps, and what do we need to rebuild in UX, APIs, permissions, and trust for that to happen.

Let’s get grounded.

The real problem with the app grid (it’s not aesthetics, it’s switching cost)

Most of us don’t open an app because we love the app.

We open it because we have an intent. “Book a flight.” “Send that money.” “Share those photos.” “Track this order.” The app is just the container where that intent can be fulfilled.

The issue is that the container model forces you to do a bunch of human busywork:

• Context reconstruction: every app starts from scratch. You re enter the same details. Dates, addresses, preferences, loyalty numbers, the “use my saved card” dance.
• Cross app stitching: many real world tasks are multi app by nature. Plan a weekend trip and you are in messaging, maps, calendar, email, airline, hotel, notes, maybe a spreadsheet if you are that kind of person.
• UI hunting: even if you know the app, you are still scanning for the right tab, the right settings, the right filter. That is time and attention.
• Decision fatigue: you aren’t just choosing a restaurant. You are choosing a restaurant and the place to search and which review source you trust and whether the reservation app will glitch.

When people say “apps are inefficient,” it’s not that tapping is hard. It’s that you are acting as the integration layer.

That was fine when software was dumb and humans were the best routers. It’s less fine when a decent agent can route across tools faster than you can.

What an agent interface is actually doing (and why it’s different from a chat box)

A lot of agent demos still look like “chat, but with plugins.” That’s not the thing Carl Pei is pointing at. The deeper change is that the interface becomes:

• Intent first (what outcome you want)
• Plan aware (the agent decomposes tasks)
• Action taking (it doesn’t stop at advice)
• Stateful (it remembers context and preferences)
• Cross service (it uses multiple systems without you opening them)

In classic UX, we design screens for humans to click. In agent native UX, we design capabilities for machines to call, plus a thin layer for humans to supervise.

That changes the design center from “how do I make this button discoverable” to “how do I make this action safe, legible, reversible, and auditable.”

Which is… not how most consumer apps are built today.

Why current app UX is optimized for humans, not outcomes

Human interfaces are basically compromises. We show a lot of options, make things browsable, keep people oriented, and avoid surprising them.

Agents don’t need most of that. They need:

• clean, deterministic actions
• stable schemas
• clear constraints
• structured outputs
• reliable error states
• permission boundaries
• and fast execution

Think of the difference like this.

A human wants a map with buttons. An agent wants a function:

find_restaurants(location, cuisine, budget, open_now) -> ranked_list[]

A human wants a checkout screen. An agent wants:

create_order(items, address_id, payment_method_id, tip, substitution_rules) -> order_id

So if apps “disappear,” it’s not that companies vanish. It’s that the front end becomes optional, and the back end capability layer becomes the product.

And that’s both exciting and terrifying if you currently own an interface.

The missing plumbing: APIs, permissions, and identity that are agent friendly

If you are a founder or product lead, here’s the uncomfortable truth. Most modern apps are not remotely ready to be driven by agents in a high trust way.

An agent first smartphone future requires at least five things to be true.

1) Capability based APIs (not just “public endpoints”)

Agents need capabilities that are:

• scoped (can do X but not Y)
• composable (small actions that chain)
• predictable (same input, same behavior)
• well documented (machines still need specs)

A lot of “APIs” out there are either too low level, too brittle, or too tied to human flows. If your “book” flow only exists as a series of UI screens, the agent ends up doing computer vision on your app like a robot intern. That’s not the future you want.

2) Delegated authorization that doesn’t turn into a security nightmare

We already have OAuth, tokens, device auth. But agent delegation adds nuance:

• Can the agent read my data but not act?
• Can it act up to a dollar limit?
• Can it act only with confirmation?
• Can it act for specific merchants, categories, or time windows?
• Can I revoke it cleanly and see what it did?

This looks more like “capability tokens” and policy engines than the usual “accept permissions” modal people ignore.

3) A system level permission layer that is consistent across services

Right now permissions are per app and mostly static. Agents will require permissions that are:

• task based (“for travel booking, you may access calendar and email confirmations”)
• time bound (“for the next 30 minutes”)
• event bound (“only for this trip”)
• auditable (“show me what was accessed and why”)

If this sounds like enterprise IAM… yes. Smartphones are drifting into enterprise grade permission complexity, but for consumers. The UX for that has to be radically better than what IT admins tolerate.

4) Identity, receipts, and proof of action

If an agent cancels your hotel, you need proof. If it sends money, you need a receipt trail. If it posts on your behalf, you need a “who authorized this” record.

So an agent first system needs:

• action logs (human readable)
• cryptographic signing or at least tamper resistant logs
• dispute flows (“that wasn’t me”)
• and a clear mapping from user intent to executed steps

Without this, adoption hits a ceiling fast. People will try it for low stakes tasks and then stop.

5) Standardized “handoff” when automation fails

Even the best agent fails. When it does, it needs a clean handoff:

• show the current state
• show what it tried
• ask a precise question
• let the user take over in a normal UI without losing context

Today, most failure modes are like, “Sorry, I can’t do that.” That is not a product.

Where reliability and trust still break (and why that matters more than model IQ)

Everyone wants to talk about model intelligence. In practice, the blockers are usually boring:

Hallucinated steps and phantom confirmations

Agents sometimes imply they did something when they only planned it. Or they “confirmed” a booking that never happened because an API call failed and the model filled the gap conversationally.

In an app, failure is explicit. In a chat, failure can be masked by fluent language. That is a huge trust problem.

Edge cases and policy ambiguity

A human app flow forces explicit choices. An agent tries to infer.

Example: “Book me a hotel near the venue.”

Near how near. Walkable. Cheapest. Quiet. Refundable. Breakfast. Loyalty brand. You probably have preferences, but unless the agent has them, it guesses. Guessing is fine until it costs you money.

So agent UX needs preference capture that does not feel like a settings prison. Lightweight, progressive, context aware.

Non deterministic integrations

Even if your model is good, your toolchain might not be. Third party APIs rate limit, return partial results, or change fields. Agents must become robust to integration drift.

This is why agent products end up building a lot of boring middleware: retries, idempotency, schema validation, fallbacks, monitoring. The “AI” is only one slice.

Confirmation fatigue

The safe version of agents asks you to confirm everything. That quickly becomes worse than apps.

The useful version confirms only at the right moments:

• high risk actions (payments, cancellations, posts)
• irreversible actions
• ambiguous intent situations

Everything else should be silent but logged. That’s the balance.

The social trust layer: people blame the agent, not themselves

When you tap the wrong thing in an app, you kind of accept blame. When an agent does it, you blame the agent. And then you stop using it.

So product teams need to design for accountability and user confidence, not just completion rate.

What categories will go agent first first (and which won’t)

Not everything becomes “app less” at the same speed. The first movers tend to be areas where:

• tasks are repetitive
• outcomes are clear
• data is structured
• value of time saved is high
• and failures are recoverable

Here’s a realistic breakdown.

Likely early winners

1) Scheduling and coordination
Calendar, email threads, rescheduling, finding mutual availability. This is already painful and cross app by default.

2) Travel planning and booking
Flights, hotels, ground transport, itinerary updates. It’s a mess today. Agents can reduce the switching, and the value is obvious.

3) Personal admin
Renewals, refunds, subscription management, warranty claims, bill negotiation. People hate this stuff. If an agent can do it reliably, it wins.

4) Shopping reorders and routine purchases
Groceries, household supplies, repeating orders. Low cognitive load, high repetition.

5) Knowledge work workflows on mobile
Summarize docs, draft emails, pull notes, create tasks, update CRMs. This overlaps with the “AI productivity” category already trending. If you want a broader view of tools people are using now, Junia has a useful roundup here: best AI productivity apps.

Slower to shift (because the UI itself is the product)

Social apps
Discovery, feeds, creation, community. You can add agent helpers, but the “app” is the experience.

Games and entertainment
Same thing. The interface is the content.

High stakes finance
Some actions will go agent assisted, but full delegation is slower because of fraud, compliance, and user fear.

Creative tools
Agents can help, but creators often want direct manipulation. At least until multimodal agents feel like an extension of your hands.

So yes, the app grid may shrink. But a more honest version is: many apps become back end services plus optional experiences.

What product teams should do now (so you’re not the company that gets agent commoditized)

If your company currently “owns” a workflow through a mobile UI, the risk is that agents turn your UI into a detail, and your service into a line item.

That’s not automatically bad, but you need a strategy.

Build an agent ready capability layer

Start by mapping your core user outcomes into discrete actions:

• read data
• search
• create
• update
• transact
• cancel
• refund
• export
• share

Then create stable, well scoped endpoints for those actions with clear error semantics. Make them easy to call. Make them safe.

If you do this right, you can become the default provider in an agent ecosystem instead of getting routed around.

Decide where you want to be in the stack

You have three positions:

1. System agent (OS level, assistant layer)
   Hard, but powerful. Apple, Google, maybe a few challengers.
2. Domain agent (travel agent, shopping agent, finance agent)
   Very winnable if you own deep data and can execute.
3. Tool provider (best execution engine for a narrow job)
   Underrated. If you are Stripe in a world of agents, you still win.

Most startups should aim for 2 or 3, not 1.

Design “supervision UX” not “navigation UX”

If agents do more, your UI shifts from “browse screens” to:

• set preferences
• review proposed plans
• approve actions
• view logs
• handle exceptions

That’s a different product. The best agent first companies will make supervision feel calm, not like babysitting.

Get serious about trust instrumentation

You will need:

• action logs users can understand
• replayable steps
• “why did you do that” explanations tied to data sources
• failure analytics
• and safety policies that are testable (not vibes)

Treat it like fintech. Even if you aren’t fintech.

Agent first UX still breaks today, in very specific ways

To keep this from turning into hype, here are the most common “agent UX” failure points you can actually test for.

• Ambiguous intent: user asks a thing that has hidden constraints, agent doesn’t ask enough questions.
• Over asking: agent asks too many questions and becomes slower than apps.
• Tool mismatch: agent selects the wrong integration because similarity matching is sloppy.
• Partial completion: agent does steps 1 to 3 then stops without a clear next action.
• Silent failure: the worst one. It says it did it. It didn’t.
• No escape hatch: user can’t take over easily.

If you’re building agents, build a checklist around these. Run usability tests where people try to do real tasks, on a deadline, with distractions. That is where agents get exposed.

So… is Carl Pei right?

Mostly, yeah. Not literally “apps vanish.” But the direction is right: the icon grid is not sacred. It’s just a historical artifact of how we had to operate software.

In an agent native world:

• intent becomes the entry point
• apps become capability providers
• UI becomes supervision and exception handling
• and distribution shifts from app stores to agent recommendations and default routing

For founders and growth operators, this changes go to market too. You might be optimizing for “agent discoverability” the way we used to optimize for App Store search. Different keywords, different funnels, different trust signals.

And for product teams, the work is clear. Make your service agent callable. Make it safe. Make it legible.

One practical note if you publish analysis like this (speed matters)

These platform shifts move fast, and the teams that win mindshare tend to publish early, publish clearly, and update often. If you’re doing that kind of content ops, Junia AI is built for it. It’s an AI powered SEO content platform for long form articles, with workflow features like scoring, internal linking, and faster production when the news cycle spikes.

If you want to go deeper on the tooling side, a couple relevant reads:

• AI SEO tools for how teams are actually scaling search content with AI
• AI article writers if you’re comparing platforms for long form output and editing workflows

Because yes, agents may replace apps. But in the meantime, attention is still routed through content. And being the team that explains the shift clearly is, quietly, a distribution advantage.