The lobster moment
If you have been anywhere near X recently, you have seen the lobster.
OpenClaw is a local-first personal agent you run on your own hardware. It connects to the services you already use, and it shows up where you already talk: WhatsApp, Slack, Telegram, iMessage, and more.
What makes OpenClaw powerful is the combination of three things:
Lives where you already are (WhatsApp, Slack), so talking to it is effortless.
Has broad access to your services, so it can actually act on what you ask.
Rides on top of frontier LLM models, which have gotten reliable enough to make calling those services consistently work.
The energy around the 🦞 is that this is the JARVIS moment everyone’s been waiting for - A personal agent that actually does things.
So naturally, people jump to the next step: “can my lobster buy things for me?
And the momentum just accelerated: OpenAI acqui-hired OpenClaw creator Peter Steinberger to lead their next generation of personal agents. OpenClaw will move to a foundation as an open-source project with OpenAI's support. It's a signal that the major platforms see personal agents - and their commerce potential - as a strategic priority.
What “agentic checkout” looks like in practice
So what does agentic shopping actually look like with the lobster? Here are some prompts you might send your lobster:
“Find me Nike Air Max 90 in size 10 and buy them for me”
“Book me the cheapest direct flight from TLV to NYC on March 15”
“Reorder my usual coffee beans from Amazon”
Let’s ignore the UX question for a moment - most shopping requires rich visual interfaces for browsing, comparing, and deciding, and a text conversation compresses all of that into a straw.
But if you know exactly what you want, an agent could theoretically handle the purchase. The question is: how does it actually complete the order technically and pay?
There are two ways currently that an OpenClaw agent could complete a transaction:
Guest checkout injection. The agent opens a merchant’s website in a browser, navigates to the product, adds it to cart, and fills in the checkout form with your payment credentials - name, card number, CVC, shipping address - just like a human would. This is essentially credential injection: the agent pretends to be you, typing into form fields (Visa Intelligence Commerce is useful here, as it provides network tokens that can be injected into guest checkouts instead of raw payment credentials. This is more secure than the agent going around the internet injecting your credit card into arbitrary forms).
Card on file. Because the lobster sits inside your browser session, it might already be authenticated with your accounts - your Amazon login, your saved Shopify credentials. The credit card is already stored in your account, so pressing ‘Buy’ is all it takes to place an order.
Both approaches share the same underlying mechanic: a browser agent interacting with interfaces that were designed for humans. And that’s where the problems begin.
Where it breaks
There are unsolved challenges with each method. Let’s start with guest checkout.
Guest Checkout Injection: Slow, Fragile, and Nowhere Near Consumer Grade:
In this scenario, a browser agent interacts with a web page in one of two ways, either by taking screenshots and using a vision model to interpret what’s on screen - identifying buttons, form fields, links by analyzing pixels - or by parsing the page’s underlying HTML structure and reasoning over it programmatically. In both cases, the agent is doing the same thing, looking at a checkout page, finding the card number field, typing in your credentials, and clicking “Place Order.” This is Computer-Use Agent (CUA) territory - the same approach that powered OpenAI’s Operator (which has been retired eventually into ChatGPT Agent which is also a product with low usage).
The issue is that web was built for humans, and browser agents perform badly in this environment. Browser agents today remain highly unreliable at these tasks, and unlike LLMs - which have been improving at a breathtaking pace - browser automation hasn’t seen anywhere near the same rate of progress.
Amazon processes checkout at an estimated 99.9999% reliability. That’s the bar consumers expect from modern e-commerce, while browser agents are operating at roughly 30% - 70% on web task benchmarks. That’s a big gap. And this isn’t the kind of gap you close with a better model or a few more months of training, as there is is an architectural mismatch - browser agents are trying to force a machine through an interface that was designed to keep machines out.
Card on File: The Merchant Can’t Tell Who’s Clicking:
The second approach actually works too well. The agent is already logged into your Amazon account, your credit card and shipping address is on file (i.e. payments jargon for stored). It just needs to click “Buy Now.” No credential injection and no filling out forms. From a pure automation standpoint, this is the easiest path.
But here’s the dilemma: Amazon often can’t tell the difference between you and your lobster. A well-configured agent using your authenticated session looks exactly like you. From the merchant’s perspective, this is a high-risk transaction: there’s plenty of room for mistakes and mispurchases, and the agent is pulling the user out of the carefully designed shopping experience and into an uncontrolled flow the merchant never built for.
One possible solution is adding 2FA authorization to each transaction, forcing the user back into the UI to confirm the purchase. This at least reduces the risk of mispurchases. But adding 2FA challenges to every order hurts real humans too- every extra verification step reduces conversion. Amazon didn’t spend a decade perfecting one-click checkout just to add friction back in because bots learned to click the same button.
This is an impossible position for merchants - they can’t let unidentified agents run loose on their platform, but they also can’t challenge every transaction without punishing their actual customers. Amazon made its stance explicit when it sued Perplexity in November 2025 over its Comet browser. The core accusation: Comet’s agents were shopping on Amazon without identifying themselves as bots, violating the platform’s terms of service. Amazon’s message was clear - if you’re an agent acting on behalf of a user, you identify yourself and let the merchant decide whether to allow it. Using a human’s authenticated session without the merchant’s knowledge isn’t a clever workaround. It’s a terms of service violation that Amazon is willing to litigate over.
So what’s the fix?
If browser agents can’t reliably use guest checkouts and merchants won’t accept unidentified bots clicking through their checkout - what’s the alternative?
Stop trying to force agents through human interfaces and give them their own door. A dedicated API layer where agents interact with merchant systems programmatically. The agent calls a structured endpoint, the merchant responds with product data and checkout options, and payment flows through a secure token.
This is exactly what the major platforms are now building.
- OpenAI’s Agentic Commerce Protocol (ACP), co-developed with Stripe, already powers Instant Checkout in ChatGPT - agents call merchant endpoints directly using scoped payment tokens, no raw card numbers exchanged.
- Google launched its own Universal Commerce Protocol (UCP) with Shopify, Wayfair, and Target.
- WebMCP, announced by Google and Microsoft, lets websites expose structured actions like add to cart directly to browser agents - no scraping required.
All three share the same insight: the future of agentic commerce isn’t smarter bots navigating human interfaces - it’s dedicated interfaces agents can use natively.
With Steinberger’s acqui-hire, the path becomes clear: OpenAI now owns both the agent (OpenClaw) and the commerce protocol (ACP). It’s not hard to imagine OpenClaw connecting to merchants directly through ACP - giving millions of users a personal agent with a built-in wallet that can transact natively, no browser hacking required. That’s the full stack of agentic commerce under one roof.
The hard part is not the protocol-It’s adoption
ACP, UCP, and WebMCP are architecturally sound - but they still need the same thing every open standard has ever needed: critical mass. For agentic commerce to truly work, the entire internet needs to adopt these protocols and others that will emerge.
That’s a task that requires decentralized coordination across millions of merchants - slow, messy, and hard. But the incentive is there: AI-driven retail traffic jumped 4,700% year-over-year in 2025 (Adobe), AI tools influenced 20% of all global online retail sales during the 2025 holiday season (Salesforce), and Morgan Stanley forecasts agentic shoppers will control $385 billion in U.S. spending by 2030 (AI Magazine).. Merchants who don’t open a door for agents risk becoming invisible on the fastest-growing acquisition channel in a decade.
So where does that leave OpenClaw and the lobster army? In a transitional period. Browser agents will keep getting incrementally better, and for simple, repeat purchases - reordering your coffee beans, rebooking your usual flight - they might be good enough in the short term. But consumer-grade agentic commerce at scale requires merchants to open dedicated doors for agents. That’s a multi-year adoption curve, not a software update - but it’s one that’s already underway.
Thanks for reading! If you want to read more strategic analysis on the edge of agentic commerce, subscribe below: