Will AI Agents Replace Apps? What Carl Pei Gets Right and Wrong

Carl Pei (Nothing’s CEO) says smartphone apps are going to disappear, replaced by AI agents.

It sounds like a hot take, the kind that lands well in interviews and gets clipped into a headline. But it also points at something real that’s already happening in software: the UI is slowly shifting from “open the app, find the feature” to “state intent, let the system orchestrate”.

Not everywhere. Not all at once. But enough that founders and operators should probably stop treating it as sci fi.

Here’s the useful framing.

Apps are a packaging decision. They are a container for workflows, permissions, identity, and UI. Agents are a routing decision. They sit above containers and pick which tools and steps to use based on what the user wants.

So the question is not “do apps die”. The question is “when does the container stop being the primary interface”.

And if the interface changes, distribution changes with it. Discovery changes. Retention changes. SEO changes. Even pricing changes, eventually.

This matters a lot if you build software. And it matters a lot if you build software that depends on being found, like anything SEO adjacent.

For context, the specific claim comes from this report on Pei’s comments: apps are going to disappear in an AI future. I’ll treat it seriously, but not literally.

The strongest version of Pei’s argument (and why it resonates)

The best case for “agents replace apps” goes like this:

1. Most user goals are not “use App X”. They’re “book a flight”, “edit a photo”, “send an invoice”, “publish a blog post”.
2. Apps force you to translate goals into navigation. Find the right icon, open the right screen, fill the right form, remember where settings are.
3. Agents reverse that. You state the goal and the system figures out the steps.

When that works, it feels magic. It’s not even about speed, it’s about not context switching. No menu diving. No remembering which tool does what. No “wait where is the export button”.

And the truth is, app navigation has been getting worse for years. More features, more settings, more tabs, more “AI” buttons that do different things, more random onboarding modals. Some products became forests of UI.

So yes, people want an abstraction layer.

But abstraction layers don’t eliminate the layers underneath. They just hide them until something breaks.

Where AI agents will genuinely replace apps (first)

This is where I think Pei is mostly right.

1. Simple, repeatable, multi step chores

Anything that looks like:

• Copy data from A to B
• Reformat this into that
• Create a thing, then send it, then log it
• Summarize, extract, classify, route

These are agent shaped problems. Especially when there’s a clear definition of “done”.

Examples you can feel in daily work:

• “Take these meeting notes, turn them into tasks, assign owners, schedule follow ups.”
• “Pull last month’s Stripe data, generate a revenue report, email it to finance.”
• “Turn this YouTube video into a blog post and publish it with the right tags.”

That last one is already a product category. And it’s a hint: agent workflows start by eating the boring glue work, not the creative core.

2. Workflows that already hop across apps

If a workflow touches five apps today, the user doesn’t love those apps. They tolerate them.

Agents win when they reduce app switching. That includes things like:

• Travel planning (search, compare, book, calendar, email confirmations)
• Recruiting (source, outreach, scheduling, ATS logging)
• Content ops (research, outline, draft, optimize, publish, internal links, refresh)

This is where “agent as interface” becomes compelling because the agent becomes the new home screen. The place you start and end.

3. Cases where UI is basically a form

If the app is a fancy wrapper around a predictable input output pipeline, agents will eat it faster. The UI is not the moat.

A lot of “micro SaaS” fits here. Not all. But many.

There’s also a related idea that keeps showing up: thin AI wrappers versus real product depth. If you’ve been watching this trend, this piece is worth reading: AI wrappers vs thick AI apps. Because agents will crush wrappers first. Anything that can be replaced by a tool call plus a prompt is living on borrowed time.

Where apps will persist (for a long time)

This is where Pei’s framing gets shaky.

1. High frequency, high control interfaces

Some experiences need direct manipulation. People want control, not delegation.

• Pro video and audio editing
• Design tools
• Complex spreadsheets and modeling
• CAD, 3D, architecture tools
• High performance gaming

You can add agents inside these apps. Great. But the app is the instrument. The user is playing it. They don’t want a concierge, they want a piano.

Even in “normal” consumer life, there are moments like this. Camera apps. Messaging. Maps while driving. If latency is critical, if the UI is physical muscle memory, agents have less leverage.

2. Trust and liability domains

Healthcare, finance, legal, security, enterprise admin. You can have agent assistance, but full delegation is slow because the cost of mistakes is high and accountability gets weird.

Also, permissions.

The permission model for agentic software is still awkward. Do I really want an agent to have full access to email, calendar, bank accounts, CRM, cloud files, and the ability to transact?

Some users will. Many will not. Enterprises will demand audit trails, policies, approvals, role based access. That’s app territory, or at least “thick platform” territory.

3. Offline and edge cases

Agents lean on models, connectivity, tool integrations, and standardization. Edge cases are where apps still shine.

If you’re on a plane, in a basement, in a low connectivity market, or just in a weird scenario, apps that can run locally and reliably still win.

4. People like predictable UI when they’re stressed

This is underrated.

When you’re in a hurry, stressed, or doing something important, you don’t want to negotiate with an agent. You want a known path.

“Tap this, then that.”

Natural language is flexible, but flexibility can become ambiguity. That’s not always what users want.

The real shift: apps become components, not destinations

If you want the cleanest mental model, it’s this:

• Apps don’t disappear.
• Apps get demoted.

They become capabilities that get invoked.

Instead of “open HubSpot”, you get “create a deal for Acme, log the call notes, schedule next steps”. HubSpot is still there. The agent just touches it on your behalf.

Instead of “open WordPress”, you get “publish this post, add internal links, set the featured image, schedule for Tuesday”. WordPress still runs your site. The agent orchestrates.

Instead of “open an SEO tool”, you get “find keywords, draft a brief, write the article, optimize it, publish it, then monitor performance”. The SEO tool becomes a workflow engine behind the scenes.

This is why the interface shift is also a distribution shift. Users stop browsing app icons and start relying on the orchestrator’s defaults.

What happens to software discovery when agents sit in the middle

This is the part founders should sweat a little.

Historically, discovery looked like:

• App store search and rankings (consumer)
• Google search (everybody)
• Category sites, marketplaces, review sites
• Word of mouth, social, YouTube
• Integrations pages, partner ecosystems

In an agent led world, discovery becomes more like:

• The agent’s tool registry and preferences
• Which vendors are “allowed” in the agent’s environment
• Which tools are cited, recommended, or auto selected
• Which brands are embedded into default workflows

And this is where power concentrates. Whoever controls the agent layer controls a lot of downstream demand.

Not all of it. But enough.

Distribution becomes “defaultness”, not “awareness”

If the agent always chooses Tool A for a job, Tool B can be the better product and still lose. Because it never gets called.

So the new distribution fight becomes:

• being present in tool catalogs
• being easy to integrate
• being safe to call
• being the “known good” choice for the agent
• being semantically legible (the agent understands what you do, precisely)

In other words, you are not only marketing to humans now. You are marketing to machine decision systems too.

Retention shifts from UI stickiness to workflow stickiness

A lot of SaaS retention is UI habit. The user knows where everything is. They have their dashboards, their saved views, their rituals.

In an agentic layer, retention looks different:

• Are you part of the default workflow?
• Does the agent keep choosing you because results are measurably better?
• Do you have proprietary data, feedback loops, or performance guarantees?
• Are you the easiest option with the least risk?

This is why shallow products are in trouble. If your value is mostly “a UI that makes GPT useful”, you are exposed. The orchestrator will just do it itself.

Agent native UX changes product strategy (even if you still ship an app)

If you’re building software right now, the question isn’t “should we build an agent”.

It’s “how do we become agent addressable”.

Practical implications.

1. You need an API that is actually usable by an agent

Not a “developer API” that assumes a human reading docs carefully. An agent needs:

• clear, deterministic actions
• structured outputs (JSON, schemas, predictable fields)
• strong error messages
• idempotency and safety controls
• permission scopes that map to real tasks

If your API is messy, agents will fail, and the orchestrator will prefer someone else.

2. Your product needs a capability map

Humans can infer what your product does from a UI. Agents need explicit capability descriptions.

Think of it like a menu, but machine readable:

• what you can do
• what inputs you need
• what outputs you produce
• constraints, pricing boundaries, rate limits
• quality signals

3. Observability becomes a distribution weapon

In an agentic world, the orchestrator can measure outcomes.

If you help the orchestrator see that you are faster, cheaper, more accurate, more reliable, you win more calls.

So build:

• outcome logging
• quality metrics
• evaluation hooks
• proofs of work

This is not just “nice engineering”. It is marketing, but through performance.

What this means for SEO like discovery in agentic ecosystems

SEO is not going away. It’s just mutating.

Today, SEO is about ranking pages. In the near future, it’s also about being the answer that agents cite, and the tool that agents choose.

This site has been covering that shift from a few angles already:

• AI search is changing site navigation and UX digs into how users stop clicking through menus and start asking.
• Generative engine optimization: get cited by AI is a practical starting point for the “be cited” game.

The key point: when an agent answers on behalf of the user, the interface is no longer your website. The interface is the response.

So you need to win in three layers:

Layer 1: classic search visibility (still pays the bills)

Google is not dead. Organic traffic still matters. But SERPs are getting more cluttered, summaries are eating clicks, and users are satisficing earlier.

You still need rank ready pages. But you also need pages that are easy to extract, quote, and trust.

Layer 2: citation and “assistant recall”

Agents and AI search systems cite sources when they’re confident. They also develop a kind of brand memory, loosely. If your content becomes a frequent, reliable source, you get pulled in more often.

That means:

• clear authorship and expertise signals
• crisp definitions and structured explanations
• original data, frameworks, or examples
• pages that answer specific intents cleanly

Layer 3: tool selection, not link selection

This is new.

If the agent is choosing tools, you need to show up as a tool, not just as a blog.

That can mean:

• integration listings
• tool landing pages that describe actions, inputs, outputs
• documentation that is machine readable and current
• pricing and constraints that are transparent

This is also where “SEO for agents” starts to look like product led distribution again, except the “user” is partially an AI.

If you want a simple heuristic, it’s this.

Humans browse. Agents select.

What software teams should do now (a realistic checklist)

None of this requires betting the company on an “agent app”. But it does require rethinking how you get discovered and used.

1. Build for intent based entry points

Even if you keep your app UI, add entry points that match intents:

• “Generate X”
• “Audit Y”
• “Fix Z”
• “Compare A vs B”
• “Create a plan”

Your navigation is for humans. Your intent pages are for humans and machines.

If you’re doing content, don’t just publish thought leadership. Publish executable how tos that map to actions.

2. Treat your content as a tool surface

This is where a lot of teams miss it.

Your blog is not just marketing. In an AI mediated world, your blog becomes part of the agent’s working memory. It’s training data for decision making. Not literally training the model in most cases, but shaping what it retrieves and trusts.

So content needs to be:

• structured
• unambiguous
• updated
• grounded in reality

If you’re using AI to scale content, you have to be careful with sameness and fluff. There’s a good internal framework here: how to make AI content original (SEO framework). Because agent systems will learn to ignore generic pages faster than humans do.

3. Make your product legible to machines

Add:

• schema markup where it fits (software app, FAQs, how tos)
• clean headings and summaries
• consistent terminology
• public changelogs for major behavior changes
• docs that explain what the product does in plain language, not just feature lists

Agents need clarity. Confusion kills selection.

4. Automate the parts that can be automated, but keep human checkpoints where it matters

A lot of teams are trying to “agentify” everything at once. That can backfire.

A better approach: automate repeatable steps, and put human review at risk points.

This is the philosophy behind most real automation wins anyway. If you want a practical view, this is worth a read: AI workflow automation: cut manual work and move faster.

5. Prepare for a world where your UI is optional

Ask: if the user never opens your app, can they still get value?

• Can they trigger key actions via API?
• Can results be delivered where they already are (email, Slack, docs, CRM)?
• Can your system run as a background service?

This is uncomfortable if you’re used to measuring engagement by time in app. But it’s the direction.

So will AI agents replace apps?

Not fully.

Apps will persist where:

• direct manipulation matters
• trust and liability require control
• offline and reliability matter
• users want predictability

But agents will absolutely replace a lot of app usage. Especially for cross app workflows, routine chores, and anything that feels like navigating a form factory.

Pei is right about the interface trend. He’s wrong if “disappear” is taken literally.

The bigger, more actionable takeaway is this:

The new battleground is not the home screen. It’s the orchestrator.

And if that’s true, software teams need to care about a new kind of discoverability. Not just ranking in Google. Not just being in the app store. But being the source agents cite and the tool agents choose.

If you’re tracking this shift and you want a practical way to keep up, that’s basically what we do at SEO Software. It’s an AI powered SEO automation platform, yes. But more broadly, it’s a front row seat to how content, distribution, and product discovery change when the interface becomes an assistant.

If you want one place to follow software discoverability in the AI agent era, start there.