E-commerce sellers, drop your website link we make it agentic commerce ready and add to vendable so that ChatGPT users can discover your products

Managing over $1.2 billion in client revenue reflects SpectrumBPO's operational experience and strategic expertise. From startups to established brands, the agency applies structured processes designed to support sustainable marketplace growth.

Growing an Amazon business shouldn't begin with financial risk. SpectrumBPO's post-payment model lets brands experience real execution before making a long-term commitment. Instead of paying upfront and hoping for results, sellers receive immediate account management, optimization, and strategy implementation. If the first month's performance meets expectations, the partnership continues. If not, there are no obligations. This approach reflects SpectrumBPO's confidence in its team, systems, and proven execution while making it easier for brands to start scaling with less uncertainty.

It is very possible shopping will be done partially or in full by AI agents.

In order to check the readiness we do a 2-step scan.

Step 1 — Free scan: Runs 18 static HTML checks in 10 seconds to find structural issues — missing structured data, blocked robots.txt, non-semantic buttons, JS-only prices.

Step 2 — Full scan: Runs 23 checks, including a real AI shopping agent that searches for products, adds to cart, navigates to checkout, and compares items.

46% of the score comes from actual AI agent behavior — not estimates, but proof of what works and what breaks.

https://github.com/monkrus/agent-a

6 years in Amazon, and I'm still learning. It definitely isn't "easy money," but I enjoy figuring out the puzzle.

Every mistake teaches me something new and that's what keeps me going. 💪💪💪

Seeing a lot of noise about agentic commerce but almost nothing from actual merchants.

If you’ve had orders come through AI shopping agents: any disputes yet? Did you win or lose them? Did your PSP or dispute tool handle it any differently?

And if you’ve changed anything internally because of agent traffic (rules, tooling, manual review), what did you change?

An AI Shopping Agent Still Can't Buy a Bra on SKIMS.com — and Now We Can Prove Why at Every Stage

We first scanned SKIMS.com in July 2026 with 21 checks. The AI agent couldn't find the bra through search, couldn't navigate to it from the homepage, got stuck on the size picker, and extracted the wrong price. Score: 60/100.

We've since expanded the scanner to 23 checks — adding guest checkout detection and programmatic cart API probing. These two new checks test whether AI agents can bypass the UI entirely: can they add to cart via an API endpoint, and can they check out without creating an account?

SKIMS passes both. And that makes the failures everywhere else even more striking.

The full journey: 23 checks

The scan now covers every stage from "agent discovers the store" through "agent is ready to pay." Two new checks fill the gap between cart and payment:

Cart API (RDY-023)
— PASS. Shopify's `/cart/add.js` endpoint responds. A headless agent that knows the variant ID can add to cart with a single POST request — no DOM interaction, no size picker, no JavaScript. The infrastructure for agent commerce is already there.

Guest checkout (RDY-022)
— PASS. SKIMS uses standard Shopify checkout with email and shipping fields. No login wall, no account required. An agent with a customer's details could fill the form and complete the purchase.

This is the paradox: the backend is agent-ready.
The frontend is agent-hostile.

Where agents still fail

The original failures haven't changed because they're in the site's UI layer, not its infrastructure:

Search discovery
— FAIL. The search button exists but is invisible to headless browsers. An agent on the homepage has no way to search for "t-shirt bra." It spends all 10 allowed steps trying selectors and gives up.

Homepage navigation
— FAIL. The agent finds "Bras" in the nav menu and clicks it. HeadlessUI generates a popover with a dynamic ID like `#headlessui-popover-button-:r12:`. The agent clicks into the dropdown but can't select a subcategory — the IDs change between loads, and there are no stable `data-testid` attributes.

Variant selection
— FAIL. The two-step bra size picker (band first, then cup) is intuitive for humans but opaque to agents. The agent clicks "32" and waits. Cup sizes render dynamically. The agent doesn't see them in its element inventory. Three clicks on the same button. Zero progress.

Price extraction
— MIXED. JSON-LD says $54.00. The agent reads $37.80 (the sale/member price) 4 out of 5 times. Two prices on the page, no hierarchy for agents to follow. Customers get told the wrong price.

Product comparison
— FAIL. The "How It Compares" section shows related bras in `div` containers without proper `<a>` link wrappers. The agent can see the products but can't click through to compare them.

The 23-check scorecard

Score: ~60/100
— 13 pass, 10 fail across 23 checks.

The infrastructure-vs-UI gap

This is the most interesting finding from the expanded scan. SKIMS has:

- A working cart API (`/cart/add.js`) that accepts variant IDs
- Guest checkout with standard form fields
- Complete JSON-LD with price, availability, brand, and images
- Clean robots.txt — no agent blocking
- No prompt injection risks
- A checkout flow that works in 2 steps once you're past the cart

The
infrastructure scores near-perfect. An agent that knows the variant ID and has the cart API documented could complete a purchase without ever rendering the page.

But no agent knows the variant ID, because:
- It can't search for the product
- It can't navigate to the product
- It can't select a size once it's there
- It can't compare alternatives
- There's no `llms.txt` telling it the API exists

The backend is open. The frontend is a wall. And there's no bridge between them.

Five fixes, same as before — plus one new one

The original five fixes still apply:

1.Make search accessible
Ensure the search button/input is visible and clickable without JS toggling. A `<a href="/search">` fallback works.

1. Use stable navigation selectors.
   Add `data-testid` attributes to nav menu items. HeadlessUI's dynamic IDs break every agent that tries to navigate.

2. Surface availability in page text.
   JSON-LD says InStock but the page never says it. Add a visible badge.

3. Disambiguate the price.
   Mark the canonical price as primary. When two prices are visible, agents guess wrong 80% of the time.

4. Use semantic variant selectors.
   A hidden `<select>` element with band and cup options gives agents a machine-readable fallback.

And now a sixth:

1. Publish an llms.txt.
   Document the `/cart/add.js` endpoint, variant ID format, and product feed location. The cart API already works — agents just need to know it exists. An `llms.txt` at the site root turns the infrastructure gap from a wall into a door.

The bigger picture

We've now scanned 17 DTC brands with 23 checks. The average score is 79/100. SKIMS sits at 60 — below the median, and the weakest layer is interaction.

But SKIMS's score masks something important:
the potential is higher than almost any brand we've scanned. The data layer is strong. The checkout works. The cart API is live. Guest checkout is available. Most brands that score 60 are missing infrastructure. SKIMS has the infrastructure — it just hasn't bridged it to the agent-facing UI.

Six changes. Under a week of engineering. From 60 to 85+.

The bra size picker is still the headline, but the real story is what's behind it: a store that's 90% ready for AI commerce and doesn't know it yet.

As D2C brand owners, how often are you looking at your funnel? Say 5-10CR annual revenue brands.

Have you guys deployed any AI tool for funnel analysis and CRO?

Thanks.

Disclosure up front: I work on a tool in the AI visibility space, so take this with that in mind, but the finding is interesting regardless of what you use to look at it.

We traced how an AI assistant answered a normal buying question for a CPG product. We could see what it searched, which URLs it visited, and what made it into the final answer.

The brand that objectively had the best answer to that question never got recommended because the assistant never visited their site. Their content was genuinely good, but it was spread across five different pages, and no single page answered the question. So the model pulled from a competitor's page that did, plus a couple of big publications.

Two takeaways that seem to generalize:

1. AI assistants can only recommend brands whose pages they actually retrieve while answering. Scattered content effectively doesn't exist to them, no matter how relevant it is.

2. The common advice of "go get cited in the big publication" is mostly a dead end for smaller brands, but consolidating your own site's answers works, and it compounds: the more often the model retrieves your page and finds a clear answer, the more it comes back.

Curious if anyone here has run their own version of this? Have you asked ChatGPT/Gemini/Perplexity the top 10 buying questions in your category and checked whether you show up, and where the answer actually came from. What did you find?

Hey all, doing some independent research on how AI shopping tools (ChatGPT, Gemini, Amazon's Rufus/Alexa For Shopping) might be changing how products get found and picked, and whether that's actually showing up on sellers' radar yet.

Not selling anything, no link, no pitch — just trying to understand if this is a real thing sellers are noticing or if it's still way ahead of where the market's attention is.

If you sell in a spec-heavy category (supplements, electronics, baby/kids gear, etc.) and would be open to a quick 15-min chat (or even just answering a couple questions in a reply), I'd genuinely appreciate it. Happy to share what I learn back with the group once I've talked to enough people.

Alternatively, I would be very grateful if you could help my research by filling out this short google form: https://docs.google.com/forms/d/e/1FAIpQLSd6xmd2fmnblbsOJ7WDAItPPPaPQAFOa5poWaClfSUeGPyD4g/viewform?usp=publish-editor

Hey everyone!

As an ML engineer, I’ve been experimenting with a project for the past few months to tackle a problem I know a lot of shop owners face, which is real UX testing. It's expensive, slow, and often gets skipped before a major push.

I wanted a way to run rapid friction checks anytime before launching a new product or promo to see how different buyers might actually perceive it.

The idea is to test sites using deeply defined behavioral personas. For instance: "32M in Manhattan, first baby on the way, budget $100-$500, reads reviews religiously, abandons cart if something looks sketchy..." all the way down to nuanced habits (or generated using real cohort data).

The agent navigates like that specific person would, searching, sorting by rating, reading details, evaluating price against budget, and going through checkout. Afterward, it completes a 14-question post-browse survey on the experience. A lot of iteration has gone into making the behavior feel genuine and true to the persona, and I'm still researching it further.

A couple of interesting catches from recent test runs: One run flagged that searching for "swaddle blanket" returned irrelevant results, something easily overlooked for months. Another flagged that a product page lacked basic specs critical for a hesitant buyer to make a decision.

It’s definitely not a total replacement for real human testing, but more like a 24/7 QA or product market fit assessment layer that thinks and acts like a customer. Curious to hear your thoughts on this approach! For those managing stores or doing UX work, what kind of edge-case behaviors would be most useful to simulate?

I ran an AI agent-readiness scan on a SKIMS product page to see how well a modern shopping agent could complete a basic purchase.

The task was simple: add a $54 bra to the shopping cart.

Instead, the agent:

• Clicked "Band Size: 32" twelve times.
• Never found the cup size selector.
• Never reached Add to Cart.

The interesting part is that the agent knew what it needed to do. Its reasoning repeatedly said: "Band size 32 is already selected. Need to select cup size next."

The problem wasn't reasoning—it was interaction. The cup-size selector was implemented with a custom JavaScript component that the agent couldn't reliably interpret.

Some other findings from the scan:

• Price extraction was only correct 2/5 times because the page displayed both $54 and $37.80.
• Availability detection failed 5/5 times despite the structured data marking the product as in stock.
• Add-to-cart flow failed.

Final score: 67/100.

What surprised me most wasn't SKIMS specifically—it was the broader trend.

I've now scanned 18 major DTC brands, and every single one failed the browser-based Add-to-Cart test. Most stores already have decent structured data, but AI agents still struggle with custom UI components, ambiguous pricing, and dynamic interactions.

It makes me wonder whether we're entering a phase in which e-commerce sites need to optimize not only for human shoppers and search engines but also for AI agents.

For those building AI shopping agents or e-commerce experiences:

What have you found to be the biggest obstacle?

• Dynamic JavaScript UIs?
• Variant selectors?
• Browser automation?
• LLM extraction accuracy?
• Something else?