The agentic commerce future that the industry has been envisioning, where AI agents discover, evaluate, negotiate, and transact on a consumer’s behalf, requires capabilities that no single layer of technology provides. The protocols emerging today (Mastercard’s Verifiable Intent, Visa’s Trusted Agent Protocol, Google’s UCP and AP2, among others) are building the transactional foundation. They address authorization, agent identity, checkout mechanics, and payment coordination. These represent genuine progress.
But protocols alone do not get us to the experience the industry has been describing. The agentic commerce vision also requires persistent memory, an evolving model of the consumer’s needs and preferences, and cross-application data access. This is the missing context layer. The Operating System level of the consumer’s device has the most direct path to providing it, because the OS controls the permission model and has native access to every app, but the core requirement is the context itself, not the specific architecture that delivers it.
An OS-level agent would have the most direct path to something that no protocol, platform, or chatbot currently provides: access to the consumer’s full device context accumulated over time. Sizing and fit preferences inferred from purchase and return history. Financial position drawn from banking apps. Calendar awareness. Location patterns. Communication context from messages and email. That data already exists on the consumer’s device. The OS controls the permission model and has native access to all of it, though a sufficiently permissioned third-party agent could potentially achieve similar access through APIs and user-granted permissions. The question is when, not whether, an agent layer with this kind of cross-domain context will be able to shape commerce decisions upstream of the transaction.
The difference between an OS-level agent and a cloud-based shopping assistant or chatbot is not sophistication. The difference is context.
Consider the current state of “agentic commerce” from the consumer’s perspective. Today, the experience is a person sitting in front of a laptop, staring at a blank ChatGPT prompt, trying to figure out what to type. This is the equivalent of handing a casual computer user a Unix terminal and expecting them to be productive. The interface demands that the consumer already knows what they want, already knows how to articulate it, and already has the context to evaluate what comes back. Most consumers do not have any of those things. The result is that agentic commerce today is largely a developer and early-adopter phenomenon, not a consumer experience. The OS-level agent changes this fundamentally because it does not start with a blank prompt. It starts with context. It already knows the consumer. It can initiate rather than wait. It can shape the experience around what it has learned rather than requiring the consumer to provide everything from scratch. The gap between the current iteration of agentic commerce and what an OS-level agent enables is not incremental. It is a different category of experience, and the industry needs to be building for and discussing that future state.
The pieces are coming together. In China, Xiaomi, Huawei, and other device makers are developing and rolling out early system-level agent capabilities with native access to on-device data, and the OpenClaw phenomenon demonstrated massive consumer appetite for agent capabilities on personal devices. In the U.S., Apple and Google are building the foundational infrastructure. Apple Intelligence already provides on-device processing, a privacy-preserving cloud compute layer, and a developer framework for third-party integration. Apple has said it is working on a more personalized Siri with context awareness and cross-app task execution, though the rollout has been delayed multiple times. Google is integrating Gemini into Android and actively building commerce-specific agent protocols.
None of these efforts have yet produced the kind of persistent, context-aware commerce agent described in this piece. The scenarios that follow are forward-looking: they illustrate what becomes possible as the transactional protocols and the context layer mature and converge. They are grounded in capabilities that are either shipping, confirmed, or technically feasible extensions of what is in development. The payments industry needs to be discussing what is coming, because the combination of protocol-level building blocks and persistent cross-domain context is what will advance agentic commerce from its current early state toward the experience the industry has been envisioning.
What Changes When the Agent Has Context
The difference between an OS-level agent and a cloud-based shopping assistant or chatbot is not sophistication. The difference is context.
A chatbot or protocol-based agent can respond to a query. It can standardize how a transaction is processed. It can maintain a session-level memory of the current interaction. What it does not currently do is accumulate a persistent, cross-domain understanding of a person over time: their body, their taste, their finances, their calendar, their habits, their location patterns, their communication context. That picture is most naturally assembled on the device, from messages, calendar entries, photos, purchase history, financial apps, health data, and browsing behavior over months and years. The OS level has the most frictionless path to this data because it controls the permission model and has native hooks into every app. A third-party agent could potentially achieve portions of this through user-granted permissions and open data frameworks, but the OS has a structural advantage in breadth and depth of access.
When the agent has that context, the consumer experience changes in ways that differ meaningfully depending on the category, the stakes, and the consumer’s relationship to the purchase. The industry has been discussing agentic commerce as though it is a single model. It is not. The agent’s role, and the degree to which the consumer delegates, varies significantly across purchase types.
The following three scenarios illustrate what this experience could look like as OS-level agent capabilities mature. Each assumes an agent with access to the on-device context described above, operating with the consumer’s permission. These are not descriptions of products available today. They are grounded in capabilities that are in development or are technically feasible extensions of shipping infrastructure, projected forward to show where the consumer experience is heading and what it means for the industry.
High Delegation: The Ride That Books Itself
Maggie has a 10:00 AM meeting across town on a Tuesday. Her calendar shows the meeting, her phone knows her location, and the agent has observed that she expenses weekday rides to her corporate Amex.
The evening before, the agent sends a notification: “You have a 10:00 AM meeting tomorrow. Based on traffic patterns, you should leave by 9:15. Want me to have a ride ready?” Maggie taps yes. The next morning, the agent evaluates Uber, Lyft, and Waymo based on current wait times, fares, and her historical preference for quiet rides (Waymo six of the last eight times). It surfaces a single recommendation. Maggie confirms. The agent books and charges her corporate Amex.
She did not open an app, compare prices, enter a destination, or select a payment method. The agent compressed the entire decision to two confirmations. This works because intent is clear, the purchase does not express identity, and the optimization criteria are quantifiable: speed, cost, reliability, payment routing. Even here, the consumer still authorizes the transaction. The agent recommends; the human approves.
Mid-Delegation: The Sundress for Positano
Maggie is thirty-nine, lives in Las Vegas, and has a trip to Italy coming up in mid-July. She has not decided she needs a new dress. But her calendar shows a week in Positano, her recent browsing has included linen fabrics and summer travel content, and three days ago she saved an Instagram photo of a woman in a floral midi dress on a terrace overlooking the Amalfi coast.
The agent does not need Maggie to type a query. It has already assembled a picture from months of accumulated context. It knows her sizing from past purchases across Nordstrom, Anthropologie, and Reformation: she is petite, typically a size S, and has returned items where the torso ran long. It knows she gravitates toward warm earth tones and muted florals. It knows she typically spends $88 to $168 on a dress. It knows her financial position: mid-pay-cycle, moderate credit card balance, with a $350 hotel deposit cleared two days ago.
Maggie opens her phone on a Saturday morning. The agent surfaces a prompt: “Your Italy trip is four weeks out. Based on your recent saves and the forecast for Positano in July, would you like to explore some outfit options?” She taps yes.
The agent shows a curated set across multiple merchants, filtered to her preferences and size. Options where her size is out of stock are never shown. Over one or two rounds of refinement, Maggie narrows to three options. The agent surfaces constraints she had not thought to specify: one merchant has her size at a local store for try-on, another ships in 3 days, a third ships from Portugal with a timeline that is tight for the trip.
Then the agent introduces financial context: her Amex has a $22 statement credit at Anthropologie through the end of the month, and the Reformation purchase would earn 3x points on her Chase Sapphire. The agent is doing cross-issuer math that Maggie would never do herself, because the information is scattered across three card apps, none of which know she is shopping for a dress.
At no point did Maggie visit a merchant’s website, type a search query, or compare shipping policies across tabs. The agent identified a latent need, curated options from context no single merchant has in aggregate, and surfaced payment optimization. The human retained final judgment.
Compound Intent: The Disneyland Trip
When Maggie tells her agent “We want to take the kids to Disneyland over spring break,” the agent hears five or six separate purchases: flights, hotel, park tickets, rental car, dining. Four tickets, a hotel for five nights, flights, and meals can reach $5,000 to $7,000.
The agent decomposes this into sub-decisions, each with its own constraints. Family of four propagates across every component. A budget ceiling attaches to the whole trip and the agent tracks spend against it as each piece is resolved. It already holds the inputs: family composition from contacts, spring break dates from the school calendar, budget constraints from financial data, kids’ ages for ticket pricing tiers.
The payments orchestration is where this scenario becomes most concrete. The agent knows the Amex earns 5x on airfare, so it routes flights there and notes that accumulated points could cover one ticket. Park tickets are the largest line item, and the agent identifies a BNPL option Maggie has used before, recommending installments and showing the monthly cost. The hotel does not accept Amex, so the agent routes that to her Mastercard at 2x on travel. For dining, it factors in restaurants where her Amex dining credit applies.
The agent presents a trip summary: total cost, spending breakdown across cards, points offsets, installment schedule, and net out-of-pocket. Maggie adjusts the hotel choice, confirms the rest, and the agent executes across four merchants using three payment methods and two payment structures.
No single bank app, merchant checkout, or payment processor has this unified view today. The OS-level agent has the most direct path to assembling it, though the real requirement is the cross-domain context access itself, wherever it is managed.
In Part 2 of this series, we examine why the agent’s role varies significantly by purchase category, where the context layer is being built today, and how far along it actually is.