The Next App Store Might Not Have Apps

A few days ago I saw an announcement that gave me a strange feeling of déjà vu.

Meta had opened the Muse Connector Platform to developers. The pitch is wonderfully simple: you bring the API; Muse brings the agent, browser and context of what the person actually wants. Approved connectors can be discovered inside Muse, and Meta is already thinking about payments and distribution around them.

My first reaction was not, “another AI integration.”

It was: this feels like publishing apps in the early days of the Play Store.

Not because Muse itself is guaranteed to become the next Android. It may or may not. What feels familiar is the shape of the opportunity: a new interaction model is appearing, distribution is still unsettled, the rules are being written, and developers suddenly have a new surface on which to package useful things.

From answers to outcomes

The first mainstream phase of generative AI was mostly about answers. We asked a model to explain something, draft something, summarize something or write some code. Even when the answer was excellent, there was usually a gap between knowing and doing.

An assistant could tell me how to file a claim. I still had to open the website. It could find a restaurant. I still had to make the reservation. It could draft an email. I still had to send it.

That gap is starting to collapse.

Meta describes Muse as an agent that can keep working on tasks, use its own browser and computer, fill forms, make purchases with approval, and continue work in the background. That is a fundamentally different product shape from a chatbot.

The interesting transition is not from “bad AI” to “better AI.” It is from software that tells us what to do to software that can participate in doing it.

Once an agent can act, it needs capabilities. It needs access to calendars, travel systems, stores, financial tools, productivity software, specialized databases and thousands of services that no foundation model can own itself.

That is where developers enter the picture.

The app may become a capability

For the last fifteen years, we have mostly thought about digital products like this:

User → discovers app → installs/signs up → learns interface → performs task

Agentic computing creates another possibility:

User → expresses intent → agent chooses capability → service/API performs task → agent continues

That looks like a small change on paper. I think it could be enormous.

Imagine a traveler saying, “My flight was cancelled. I paid with this card. Figure out what protections I have and what I should do next.”

The best experience may not require the traveler to know which travel-benefits website exists, navigate five menus and translate insurance language. An agent could understand the intent, call a specialized travel-benefits capability, combine the result with flight information and the user’s context, and then help carry the process forward.

In that world, the product is not primarily a screen. The product is a capability the agent knows how to use.

Why this reminds me of early mobile

Early smartphone stores created a peculiar moment. Developers suddenly had distribution to millions of devices, while users were still discovering what a smartphone was useful for. Some early apps were sophisticated businesses. Many were tiny utilities: flashlights, scanners, weather tools, calculators and wonderfully specific little ideas.

The important part was not that every early app became a company. Most did not. The opportunity was that experimentation was cheap while the design space was huge.

Agent ecosystems may create a similar window.

A developer may be able to build a narrow service that does one thing exceptionally well, expose it through an API or agent protocol, and let several AI products become its interfaces and distribution channels.

That changes the startup question from:

“Can I convince someone to download my app?”

to something closer to:

“When a person asks an agent to accomplish this goal, is my capability the best tool for the job?”

Don't build for one agent

This is also why I would be cautious about building a business that exists only as a “Muse connector.” Platforms change. Distribution rules change. Today's exciting agent may not be tomorrow's dominant one.

The more durable architecture is to build an agent-ready service.

                     ┌─ Muse connector
Your domain logic ─ API ─┼─ MCP / agent tool
                     ├─ ChatGPT app
                     ├─ other agent ecosystems
                     └─ your own web/mobile experience

The domain capability stays yours. Agent platforms become adapters and distribution.

This is already broader than one company. Meta says its Muse models can work with MCP servers and custom skills. ChatGPT supports apps and MCP-powered integrations that can expose actions to an AI system. The exact standards and product surfaces will keep changing, but the direction is increasingly visible: agents need a structured way to discover and use outside capabilities.

APIs may become storefronts

For years, APIs were usually something you built after the product became successful. They were infrastructure for partners, enterprise integrations or power users.

I wonder if that order is about to reverse for some products.

A new generation of businesses might begin as:

useful capability → API/tool → agent distribution → richer product/UI

rather than:

website/app → acquire users → build API later

If agents become an important layer between people and services, an API is no longer merely backend infrastructure. It becomes part of how a product is discovered.

The tiny-app opportunity returns

This is the part I find most exciting as a builder.

We tend to make startup ideas unnecessarily heavy. Brand. Landing page. authentication. dashboard. onboarding. mobile app. growth strategy. Months can disappear before learning whether anyone needs the underlying capability.

An agent ecosystem encourages a different experiment: build one useful ability.

Can it compare a messy set of benefits? Reconcile an awkward document? Monitor something that changes? Prepare a specialized filing? Find an obscure match? Translate domain rules into a concrete next action?

If the agent already supplies conversation, context and increasingly the browser/computer itself, the developer can spend more time on the piece that is genuinely differentiated.

That question feels more interesting to me right now than “what AI app should I build?”

But distribution will not be magically fair

There is a tempting story here: build a good API, agents discover it, customers arrive. Reality will be messier.

Agent platforms will need to decide which tools they trust, which ones they recommend, what permissions they receive, how results are ranked, how payments work and how malicious or low-quality tools are kept out. Meta already describes review for functional, security and legal requirements before Muse connectors enter its directory.

This creates new versions of old platform questions. Who controls discovery? Can a developer build a direct relationship with the customer? What happens when the platform builds the same capability? Can a service explain why an agent chose it? What is the business model when the human never visits the website?

And there is a deeper engineering problem: an agent that can take actions is more dangerous than one that only generates text. Authentication, least-privilege permissions, confirmations, auditability, prompt-injection resistance and reversible actions become product features, not security footnotes.

So I do not think “agents are the new app stores” means easy money.

I think it means a new distribution layer is forming, and developers should learn its primitives early.

What becomes valuable?

If conversational agents increasingly own the generic interface, I suspect differentiation moves toward a few things: proprietary or difficult-to-assemble data; domain expertise encoded into reliable rules; access to real-world services; trust and authorization; exceptional execution of a narrow workflow; and APIs that make their capabilities easy for machines to understand and safely invoke.

Beautiful UI will still matter. Humans are visual creatures, and many tasks are better represented by a map, dashboard, editor or timeline than a paragraph of chat. Even Muse talks about generating rich artifacts rather than forcing everything into text.

But the interface may become more fluid. Sometimes the product will be a website. Sometimes an agent conversation. Sometimes an interface generated specifically for one task.

The underlying capability becomes the constant.

A developer's advantage

There is another reason this moment feels different from previous AI waves.

You do not necessarily need to train a frontier model to participate.

The large platforms are spending extraordinary resources on models, browsers, computer use, memory, orchestration and safety. A small developer can stand on top of that work and contribute something much narrower: an API with deep knowledge of one problem.

That is a familiar pattern in computing. Operating systems made desktop software possible. Smartphones packaged sensors, connectivity and distribution so developers could build apps. Cloud platforms removed the need to own servers.

Agent platforms may package reasoning + context + interface + execution, leaving developers to provide specialized capabilities.

If that happens, the leverage could be remarkable.

What I plan to do with this

I do not want to merely watch this shift and write predictions about it.

I want to experiment.

For projects I build, I increasingly want to ask whether the core value can be exposed cleanly as an API or tool — independent of the website around it. I want to understand connectors, MCP-style interfaces, agent permissions and what makes a capability genuinely useful when another AI is the one calling it.

I also want to resist the temptation to spend months polishing one grand idea. This feels like a period for small bets: build, expose, publish, learn, repeat.

Maybe none of today's agent platforms becomes the “Play Store of AI.” Maybe the ecosystem remains fragmented. Maybe browsers themselves become the platform. Maybe protocols make the concept of a single store less important.

That uncertainty is exactly why experimentation matters.

The next icon might be invisible

The mobile revolution taught developers to think in icons on a home screen.

The agentic era may teach us to think in verbs.

Book. Compare. Verify. File. Analyze. Negotiate. Monitor. Claim. Build.

A user may never know the name of every service involved. They may simply ask for an outcome, while an agent assembles the right capabilities behind the scenes.

That is simultaneously exciting and uncomfortable. It challenges how products earn attention, how brands work, how developers get paid and even what we mean by an “app.”

But when I saw developers being invited to bring their APIs into an agent that already has a browser, context and the ability to act, I could not shake the feeling.

We may be looking at another early app-store moment.

Except this time, the next great app might not look like an app at all.

Sources & further reading: Muse Connector Platform · Meta: Introducing Muse · How We Designed Muse · MCP apps in ChatGPT