LLMs Are Becoming the New OS Layer: What Builders and Product Leaders Need to Know

Over the last year, LLMs have reshaped how we build software, but until now, it hasn’t reshaped how we reach users. New product experiences are everywhere, yet distribution still hinges on search, app stores, and social feeds. 

That’s about to change. In late September and early October 2025, OpenAI quietly shipped a trifecta of features – Instant Checkout, Apps in ChatGPT, and AgentKit – that signal the arrival of an LLM platform and the beginning of new distribution channels. This post explains what happened, why it matters, and how to build for it – drawing inspiration from Brian Balfour’s analysis of platform shifts.

From searching and clicking to asking and acting

1. Instant checkout: Shopping with LLMs

On September 29, 2025, OpenAI activated Instant Checkout inside ChatGPT. Users in the U.S. can now buy goods from Etsy sellers directly inside a chat conversation, with Shopify merchants coming soon. When a user asks for gift ideas, ChatGPT surfaces unsponsored product recommendations. If an item supports Instant Checkout, a “Buy” button appears; tapping it shows an order summary, shipping details, and payment options. The order is processed by the merchant’s existing systems, while ChatGPT acts as the user’s personal shopping agent. There are no fees for users; merchants pay only a small fee on completed purchases.

This entire flow runs on the Agentic Commerce Protocol (ACP), an open standard co‑developed with Stripe. ACP defines a secure way for AI agents and merchants to exchange orders and payments. If a merchant already uses Stripe, enabling agentic payments takes as little as a line of code. For non‑Stripe processors, shared payment token and delegated payments specs make it easy to join. The key insight: the checkout page disappears. Discovery, selection, and purchase collapse into a single conversational thread.

2. Apps in ChatGPT: The LLM apps platform

A week later, on October 6, 2025, OpenAI launched Apps in ChatGPT and a preview Apps SDK. Developers can now build apps that live entirely inside ChatGPT: when a user invokes an app by name (“Spotify, make a playlist for my party”), ChatGPT surfaces an interactive card or full‑screen view: 

Apps can render familiar UI elements – maps, playlists, design canvases – right in the conversation. Early partners include Booking.com, Canva, Coursera, Expedia, Figma, Spotify, and Zillow, with more on the way.

Apps in ChatGPT are built on the Model Context Protocol (MCP), an open standard that defines how AI models connect to external tools and data. The Apps SDK extends MCP to let developers specify both the logic (what actions the app can perform) and the interface (how those actions appear in chat). Because it’s built on an open standard and designed for portability, your app code can, in principle, run on other assistants that embrace MCP.

For users, the experience is seamless: tag the Booking.com app in ChatGPT and hotel options appear; ask to design a poster and Canva pops up. For developers, the distribution potential is significant: apps appear contextually where they’re most useful.

3. AgentKit: Building and evaluating agents

On the same day, OpenAI also introduced AgentKit, a suite of tools that makes it easier to build, deploy, and improve AI agents. Key components include:

• Agent Builder — a visual canvas for designing multi-step agent workflows with drag-and-drop nodes. Teams report orchestration time dropping from months to hours.

• Connector Registry — a central place to manage data sources and tool connectors across OpenAI products, including Dropbox, Google Drive, and third-party MCP connectors.

• ChatKit — a toolkit to embed LLM-based agent experiences in your own product.

• Evals & RFT — expanded evaluation tools and Reinforcement Fine-Tuning to test agents on datasets, optimize prompts, and train models to call the right tools at the right time.

Taken together, AgentKit turns agent development into a design-first process: you drag nodes, connect data sources, and deploy an agent; you instrument it with evals; you refine with fine-tuning; all within one platform. This lowers the barrier to building reliable, multi-step agents that can orchestrate actions across apps and services.

The App-Hop tax (and how the new paradigm kills it)

For years, the software world has focused on building better apps; but not better flows. Every task today is scattered across multiple interfaces, each demanding logins, redirects, and micro-transactions of user effort. The friction between intent (“booking a dentist appointment”) and execution (“actually getting it done”) is invisible but enormous. This inefficiency has a name: the App-Hop Tax.

LLMs have encyclopedic brains but toddler hands. Say you need to find an in-network dentist, book a cleaning, pay the copay, and add the appointment to your calendar. Today, you might ping your insurance portal to check coverage, hop to Zocdoc to find dentists, log in to a provider portal to book a slot, use Apple Pay to hold a deposit, then copy-paste the confirmation into your expense tool and calendar. Five apps. Four logins. Three copy-pastes. One headache. This gap between a user’s intent and final execution is the App-Hop Tax. Every hop is a login, a copy-paste, or a Face ID loop. Multiply by billions of users and you get the largest hidden cost in consumer tech.

Now imagine doing the same job in one thread: “Find a dentist in-network for Wednesday after 5 PM, hold a deposit if needed, book the appointment, handle the intake, expense it, and add it to my calendar.” In a LLM-native flow, the agent verifies your plan, shows available slots, asks for Face ID to put a refundable deposit on your card, runs the intake questions, books the slot, files the expense, and updates your calendar & reminders — all inside the thread. No tabs. No forms. No “what’s my copay?” guesswork. That’s the promise of LLM as an OS layer.

A new distribution shift (and the familiar platform cycle)

In an essay about platform shifts, Brian Balfour observes that major technology shifts (like the internet or mobile) only become transformative when distribution catches up. The internet enabled websites in the early 1990s, but it wasn’t until Google that websites reached users at scale. Mobile apps launched with the iPhone, but the true distribution shift didn’t happen until Facebook introduced mobile ads in 2012. 

The LLM boom gave us new ways to build (chatbots, agents), but until now, there has been no new channel to reach people. ChatGPT’s apps and commerce features are the first signs of that channel. Instant Checkout already enables purchases inside ChatGPT, and Apps let people book hotels, design, and plan travel in-thread. LLM is becoming the OS layer, orchestrating apps, data, and payments through natural language.

Balfour also warns that every platform follows a predictable cycle: open the gates, grow through third‑party contributions, then close and monetize. Facebook’s developer platform did this; so did Apple’s App Store and Google search ads. OpenAI is currently in the open → grow phase, inviting developers to build apps and agents through open standards like MCP and ACP with effectively “free” distribution to millions of users. If history is a guide, rules and rents come later. That’s not cynicism; it’s the clock you should build against.

The next frontier: Browsers, voice, and AR

AI-native browsers push the LLM OS into the web itself. Rather than bolt an assistant onto legacy browsers, new entrants build the browser around conversational assistance and automation: 

• Comet (Perplexity) emphasizes answer-first search and a sidecar assistant

• Dia (The Browser Company) embeds an assistant in the address bar with extendable skills 

• ChatGPT Atlas (OpenAI) integrates ChatGPT with an Ask sidebar, smart New Tab, write-anywhere helpers, optional memories, and a preview Agent mode for end-to-end tasks.

If LLM is the OS layer, the browser becomes its window manager, where conversation, context, and action converge. For builders, that means your verbs (via MCP/ACP) can travel across LLMs and AI browsers with minimal rework.

Voice & AR turn one-thread jobs hands-free and heads-up. Voice makes confirmations simple; smart glasses make them glanceable. As voice joins chat, the app icon matters even less. Building for chat now prepares you for flows that live on wrists, in cars, and on lenses.

Conclusion: Now is the time to innovate

ChatGPT’s new features mark the start of the distribution shift in AI. For developers and product leaders, this is the moment to experiment, learn, and build before the platform closes its gates.

In the next post, we’ll dive into how to design, build, and measure for the LLM-native OS; from crafting one-thread jobs to exposing verbs via open protocols like MCP and ACP.

Stay tuned for Part 2: How to Build for the LLM-Native OS.