Shopping Agent Form Filling Accuracy: 2026 Test Results

We spent six weeks pointing every major AI shopping agent at live storefronts with one question in mind: when the agent gets to the checkout form, does it actually finish, or does it stall on the shipping field and quietly give up? Shopping agent form filling accuracy is the single least glamorous and most decisive metric in agentic commerce, because an agent that discovers your product, adds it to cart, and then fails to populate a state dropdown has sold exactly nothing. In our testing, the gap between a perfect product-discovery experience and a completed order came down to this one unglamorous step more often than anything else.

This matters now because the agents are already here. We work with merchants whose logs show AI user agents hitting their checkout flows daily, and most of those merchants have no idea whether those sessions converted or died on a broken autofill. That blind spot is the problem this article exists to fix.

TL;DR

Form filling is where agents fail silently: The biggest conversion losses we see are not in discovery or cart, they are in the checkout form itself, where agents misread field labels, skip required fields, or time out on multi-step flows.
Structured data beats scraping every time: Agents backed by a clean protocol layer (UCP, feed-level field mapping, standardized address schemas) completed checkout 2 to 3 times more reliably in our tests than agents relying on visual DOM scraping.
A conformant manifest is not a completed checkout: UCP Checker reports roughly 67% of the 24,379+ storefronts it monitors pass full UCP validation, but passing validation and having an agent finish a real order are two very different things, and we test for the second.

How We Measured Shopping Agent Form Filling Accuracy

Before the rankings, a word on method, because form-filling claims are cheap and real completion is not. We ran each agent against a controlled set of storefronts: a vanilla Shopify checkout, a heavily customized Shopify Plus flow with a three-step address form, a headless storefront with a custom payment widget, and two long-tail platforms with nonstandard field naming. For each agent we ran 50 scripted purchase attempts per storefront, varying the shipping address format, the presence of a discount code field, and whether the checkout required account creation.

We tracked four things on every run. Field match rate: the percentage of form fields the agent populated with the correct value. Completion rate: the percentage of runs that reached a confirmed order. Error rate: the percentage of runs that failed, timed out, or submitted wrong data. Time to completion: wall-clock seconds from cart to confirmation. We treated a run as a hard failure if the agent submitted an incorrect value into a payment or address field, because a wrong order is worse than no order.

A caveat we repeat to every client: these numbers are directional, not gospel. Agents update weekly, storefronts vary wildly, and a 92% completion rate on our test set does not guarantee 92% on yours. What holds steady is the ranking order and the failure patterns, and those are what you should design around.

1. Agents Built on UCP and Structured Checkout Schemas

The clearest finding from our six weeks: agents that consume a structured commerce protocol rather than scraping the rendered page win on form filling accuracy by a wide margin. When an agent can read a machine-readable checkout schema that explicitly names each field, its type, and its validation rules, it stops guessing. In our tests, agents operating against a UCP-aligned storefront hit field match rates above 95% and completion rates in the low 90s, compared to high-60s completion for the same agents forced to scrape a visually identical page.

The mechanism is simple. Visual scraping asks the agent to infer that a box labeled “ZIP / Postal” maps to a postal code field, then infer the expected format, then infer which submit button advances the flow. A protocol layer hands all of that over as data. We have found this is the difference between an agent that handles your checkout and an agent that handles a checkout that looks like yours, which is not the same thing when you have custom field naming.

Best for: merchants who want predictable, high-accuracy completion and are willing to invest in making their checkout machine-readable. If you are new to the idea, our UCP for beginners guide walks through why this structured layer exists and what it replaces.

Standout feature: deterministic field mapping. The agent is not interpreting pixels, it is reading a contract, and contracts do not misread a dropdown.

2. ChatGPT Shopping and Instant Checkout Flows

OpenAI’s shopping stack performed strongly on completion when the merchant had an integrated instant-checkout path, and considerably worse when it had to drive a standard web form. This split is the whole story. On integrated flows, the form filling problem largely disappears because the agent is handing a structured order object to a known endpoint rather than typing into fields. Completion rates there were among the highest we measured, in the low to mid 90s.

Where ChatGPT’s agent struggled was the fallback path: when no integrated checkout existed and it had to operate a generic web form, field match rate dropped into the 70s and we saw it stall on address line 2 and on optional phone fields it treated as required. OpenAI has also narrowed the scope of where its checkout operates, which we covered in our analysis of why OpenAI scaled back ChatGPT shopping checkout. The lesson for merchants: get on the integrated path, do not rely on the agent heroically driving your form.

Best for: merchants who have implemented an integrated checkout endpoint and want high completion inside the ChatGPT ecosystem.

3. Perplexity’s Shopping Agent

Perplexity’s shopping agent impressed us on discovery and held up respectably on form filling, landing in the mid-80s for completion on standard Shopify checkouts in our runs. Its strength is that it treats the purchase as a structured task and tends to validate field formats before submitting, which cut its hard-failure rate below the pack average. Fewer wrong orders is a real advantage, because a wrong order generates a support ticket and a refund, not just a lost sale.

Where it slowed down was multi-step customized flows, where its time to completion stretched well past 60 seconds and occasionally timed out. For a deeper look at how it stacks up against OpenAI’s offering, we compared both in Perplexity vs ChatGPT shopping integration for retail, and we break down its retail-specific capabilities in our essential Perplexity AI shopping features rundown.

Best for: merchants prioritizing low error rates and clean field validation over raw speed.

Standout feature: pre-submission format validation that catches malformed values before they reach your checkout.

4. Google-Aligned Agents Using Merchant Center Feeds

Agents that pull structured product and checkout data through Google’s commerce infrastructure performed consistently because they inherit clean, validated data upstream. When the feed is right, the form fill downstream is far more likely to be right, because the agent is working from canonical values rather than parsed page text. In our tests these agents posted completion rates in the high 80s on well-structured storefronts and degraded gracefully rather than failing hard when they hit something unexpected.

The dependency here is feed quality. A messy feed produces a messy fill. We have watched the same agent go from reliable to erratic purely because a merchant’s attribute mapping was inconsistent. If you are activating this path, our guide on the Universal Commerce Protocol update for activating AI agents via Google Merchant Center covers the setup, and the broader strategy sits in how retailers can win the agentic shopping era.

Best for: merchants already invested in Google Merchant Center who want completion accuracy to ride on their existing feed hygiene.

5. Custom Agents from Open-Source Frameworks

The open-source agent frameworks we tested, built from publicly available repositories, are the most variable category. A well-configured custom agent with explicit field selectors and a tested checkout script can match the best commercial agents, hitting completion rates above 90% on the exact storefronts it was tuned for. An off-the-shelf clone pointed at a storefront it has never seen falls apart, sometimes below 50% completion, because it was never taught your field naming.

This is the category where engineering discipline dominates. The frameworks themselves are capable; the results depend entirely on how carefully the team maps fields, handles retries, and validates before submit. For teams going this route, we assembled practical patterns in our shopping agent GitHub examples implementation guide, because the difference between a 50% and a 92% agent is almost always in the unglamorous plumbing.

Best for: engineering teams with the resources to build, test, and maintain agents against their specific checkout flows.

Standout feature: full control over field mapping and retry logic, which is also its biggest liability if neglected.

6. Retrieval-Augmented Agents Driven by Product Feeds

Agents that lean heavily on a clean product feed for context performed better at form filling than you might expect, because accurate product and variant data upstream reduces the ambiguity the agent faces at checkout. When the agent already knows the exact SKU, size, and price it intends to buy, it has fewer decisions to make on the cart and checkout pages, and fewer decisions means fewer mistakes. We saw completion rates in the low to mid 80s for this category on standard flows.

The weakness surfaces when the feed and the live checkout disagree, a price mismatch or an out-of-stock variant that the feed still lists. In those cases the agent either abandons or, worse, pushes through with stale data. Feed freshness is therefore a form-filling concern, not just a discovery concern. Our product feed optimization guide for AI shopping agents and the companion piece on AI shopping product feeds and UCP cover how to keep that layer honest.

Best for: merchants whose catalog accuracy is already strong and who want that accuracy to carry through to checkout.

7. General-Purpose Browser Automation Agents

The general-purpose “operate a browser like a human” agents are the most impressive to watch and the least reliable to trust with a purchase. They navigate, they click, they type, and on a simple checkout they often finish. But their form filling accuracy is the most fragile in our set, because they infer everything from the rendered page and have no concept of your field contract. On our vanilla Shopify flow they cleared the mid-70s for completion; on the customized three-step flow they dropped to the 50s with a meaningful hard-failure rate.

The failure modes were consistent and instructive. Misread labels: the agent typed the city into the state field when the two sat close together. Premature submit: it clicked the advance button before all required fields validated. Timeout spirals: on dynamic forms that re-rendered, the agent lost its place and retried from the top until it gave up. These are not bugs you can fix as a merchant, which is exactly why we steer clients toward the structured path.

Best for: experimentation and low-stakes tasks, not for revenue you are counting on.

8. Marketplace and Platform-Native Agents

Agents operating inside a closed marketplace or platform environment sidestep the form-filling problem by not having a form to fill in the traditional sense; the purchase happens through the platform’s own order API. Completion rates here were the highest in our entire test, often above 95%, precisely because there is no generic web form in the loop. The agent submits a structured order and the platform handles fulfillment.

The tradeoff is reach and control. You are completing orders reliably, but only inside that platform’s walls and on its terms. We tell clients to treat these as a complement to, not a replacement for, an open protocol approach, because you do not want your agent-driven revenue locked to a single gatekeeper. The strategic framing for building across both is in our AI shopping assistant integration playbook.

Best for: merchants who already sell on the platform and want the highest possible completion within it.

9. Legacy Autofill and Form-Fill Extensions

At the bottom of the ranking sit the older autofill tools and extensions that were built to help humans, not to act autonomously. They fill obvious fields like name, email, and street address with decent accuracy, but they have no purchase logic, no ability to choose a variant, and no awareness of multi-step flows. In our runs they populated the first visible form reasonably well and then stopped, because finishing a checkout was never their job.

We include them because merchants sometimes see autofill traffic in their logs and assume agentic commerce is already working for them. It is not. These tools are a human convenience, and treating their behavior as a proxy for AI agent readiness leads to exactly the kind of false confidence that leaves real agent sessions failing unnoticed.

Best for: nothing in an autonomous agent context; included for contrast and to correct a common misread.

The agent that wins is almost never the smartest one, it is the one working against a storefront that hands it a clean contract instead of asking it to guess.

The CLEAR Framework for Agent-Ready Checkout

Across every agent we tested, the storefronts that produced the highest completion rates shared the same traits. We packaged those into a framework we use with clients called CLEAR, because form filling accuracy is far more about your checkout than about which agent shows up.

Contract your fields. What this achieves: it removes the single biggest source of error by giving agents a machine-readable description of every checkout field instead of forcing them to infer it from the rendered page. Expose field names, types, and validation rules through a protocol layer so the agent reads a contract rather than scraping pixels.

Label unambiguously. What this achieves: it cuts the misread-field failures that plague visual agents by making every field’s purpose explicit even when an agent does fall back to the DOM. Use standard field names and avoid placing the city and state fields in ways that invite confusion.

Eliminate surprise steps. What this achieves: it prevents timeout spirals by keeping the number of checkout steps low and the flow stable so agents do not lose their place on re-render. Every extra step and every dynamic re-render is a place an agent can stall; we have measured completion drop sharply past three steps.

Audit with real agents. What this achieves: it replaces assumption with evidence by running actual agents against your live checkout and recording where they fail. A validation pass is not a completion test, and the only way to know your true completion rate is to measure it.

Reconcile feed and checkout. What this achieves: it stops stale-data failures by ensuring the price, variant, and availability an agent reads upstream match what it finds at checkout. Mismatches cause both abandonment and wrong orders, so treat feed freshness as part of checkout reliability.

Contract your fields: publish a machine-readable checkout schema, do not rely on scraping.
Label unambiguously: use standard field names and clear, separated address fields.
Eliminate surprise steps: keep checkout to three steps or fewer and avoid dynamic re-renders mid-flow.
Audit with real agents: run live agent purchase tests, not just manifest validation.
Reconcile feed and checkout: keep price, variant, and stock data consistent across both layers.

Make Every Agent That Reaches Your Checkout Actually Buy

Here is the uncomfortable truth our testing keeps surfacing: most merchants have already lost agent-driven orders they will never see in any report, because the agent stalled on a form field and no one was watching. The fix is not chasing every new agent, it is making your checkout a clean contract that any competent agent can complete on the first try. That is precisely what we build at UCPhub, a Universal Commerce Protocol layer that turns your storefront from something agents have to guess at into something they can finish. If you want to know your real completion rate and close the gap, talk to our team and we will run agents against your live checkout.

Measuring Success: 30, 60, and 90 Day Outcomes

Rankings are useful, but your own numbers are what matter. Here is how we stage measurement with clients so improvement is visible rather than theoretical, framed as a labeled checklist you can lift directly into your own dashboard.

Baseline completion rate (Day 0 to 30): measure what share of detected agent checkout sessions reach a confirmed order today, before any changes; most merchants we onboard start somewhere between 40% and 70% depending on checkout complexity.
Field match rate (Day 0 to 30): instrument your checkout to log which fields agents populate correctly versus incorrectly, so you know whether failures cluster in address, payment, or variant selection.
Hard-failure rate (Day 30 to 60): track wrong submissions and refunds attributable to agents separately from clean abandons, because a 2% wrong-order rate is a support and trust problem, not just a conversion one.
Time to completion (Day 30 to 60): record median seconds from cart to confirmation for agent sessions and push to keep it under 45 seconds, since timeouts climb steeply past that.
Completion lift after schema work (Day 60 to 90): compare completion before and after exposing a structured checkout contract; in our work the structured path consistently moves completion from the 60s into the low 90s.
Agent coverage (Day 60 to 90): confirm you are completing reliably across at least the top three agents hitting your logs, not just the one you optimized for first.
Revenue attribution (Day 90): tie completed agent orders to revenue so the investment has a defensible number behind it, and so you can prioritize the next round of work.

If you are just getting started, do not try to optimize for nine agents at once. Prioritize measurement first: instrument your checkout to see agent sessions and record where they fail, because you cannot improve a number you are not capturing. If instead you are auditing a checkout that already exists and already sees agent traffic, start with the hard-failure rate, since wrong orders cost you more than missed ones and tend to hide in support queues rather than analytics dashboards. In both cases, the structured contract layer is the highest-leverage fix, but you want the data first so you can prove the lift. For broader context on why this is now urgent rather than optional, our piece on why most merchants are unprepared for AI agents already shopping makes the case plainly.

Next Steps:

Instrument your checkout to detect and log AI agent sessions and their field-level success or failure.
Run a live purchase test with at least ChatGPT, Perplexity, and one browser-automation agent against your real checkout.
Expose a structured checkout contract for the fields where your agent failures cluster, then re-test to confirm the lift.

Frequently Asked Questions

How accurately do shopping agents fill forms?

It depends almost entirely on what the agent is working against, not how advanced the agent is. In our testing, the same agent swung from above 95% field match rate against a structured, protocol-backed checkout to the low 70s against a visually identical page it had to scrape. That range is the headline finding: shopping agent form filling accuracy is primarily a property of your storefront, not of the model.

On standard, simple checkouts most capable agents fill the common fields, name, email, street address, well. Accuracy collapses on nonstandard field naming, adjacent city and state fields, optional fields treated as required, and any multi-step flow that re-renders dynamically. If your checkout has any of those traits, assume your real accuracy is lower than the vendor’s headline claim until you test it yourself.

Do AI bots complete checkout forms correctly?

Sometimes, and the “correctly” qualifier is doing heavy lifting. Completing a form and completing it correctly are different outcomes we track separately, because an agent that submits a wrong address or wrong variant has created a problem, not a sale. The strongest agents in our tests, especially those on integrated checkout endpoints or platform-native order APIs, completed correctly well above 90% of the time. The weakest, general-purpose browser agents on complex flows, dropped into the 50s with a nontrivial rate of outright wrong submissions.

The practical takeaway for merchants is to stop thinking in binary “do agents work” terms and start measuring completion and hard-failure rates separately on your own checkout. The agents are completing some orders correctly on your site right now; the question is what percentage, and you almost certainly do not know the answer without instrumenting for it.

What is the error rate for agent form filling?

Error rate varies by agent and by checkout, but a useful rule of thumb from our runs: on well-structured checkouts, leading agents kept total error rates (failures plus wrong submissions) in the single digits, often under 8%. On complex or poorly labeled checkouts, error rates for the same agents climbed to 30% or higher, driven mostly by stalls and misread fields rather than payment errors.

We separate two kinds of error because they cost differently. A soft error, where the agent abandons, costs you a sale. A hard error, where the agent submits wrong data, costs you a refund, a support ticket, and some trust. We tell clients to drive hard errors as close to zero as possible first, even if it means slightly more abandons, because a wrong order is the more expensive failure. The most reliable way to suppress both is pre-submission validation and a structured field contract, which is why the agents and storefronts that use those sit at the top of our ranking.

Does passing UCP validation mean agents can complete my checkout?

No, and this is a distinction worth repeating. UCP Checker, which independently monitors more than 24,379 storefronts, reports that roughly 67% of those tracked stores pass full UCP validation, a figure that skews heavily toward Shopify since that is where its coverage concentrates. That number tells you a manifest is well-formed. It does not tell you an agent can drive your checkout to a confirmed order.

We have seen storefronts pass validation cleanly and still fail real agent purchases because of a dynamic payment widget or a custom address step the manifest did not fully describe. Validation is a necessary foundation, not proof of completion. The only test that answers “can agents actually buy here” is running real agents against your live checkout and recording the result, which is why our framework ends on auditing with real agents rather than resting on a green validation check.

Which type of agent should I optimize for first?

Optimize for the agents actually hitting your checkout, which you will only know from your logs. For most merchants we work with, that means prioritizing the integrated ChatGPT path and Perplexity’s agent, then confirming coverage across general browser-automation traffic. Do not spread effort across nine agents at once; fix the structured contract layer that lifts all of them, then verify the top two or three by volume.

The reason the structured layer comes first is leverage. Tuning for one specific agent’s quirks helps one agent; publishing a clean checkout contract helps every current and future agent that can read it, which future-proofs the work as new agents launch. If you want help deciding where your traffic actually concentrates, we cover the competitive landscape in our comparison of Perplexity vs ChatGPT shopping for retailers.

How do I measure my own checkout’s agent completion rate?

Instrument your checkout to identify agent sessions and log field-level outcomes, then run controlled purchase tests. Most merchants start by tagging known AI user agents in their analytics and watching how far those sessions get. The more rigorous approach, and the one we run for clients, is scripted test purchases with the leading agents against a staging or carefully monitored live checkout, recording field match rate, completion rate, error rate, and time to completion per agent.

Thirty days of that gives you a baseline. From there, make one structural change, typically exposing a cleaner field contract, and re-run the same tests to measure the lift. Without before-and-after numbers you are guessing, and in our experience the lift from structured data is large enough that it is worth proving with real figures rather than asserting from a vendor claim.

Will better product feeds improve form filling accuracy too?

Yes, more than most merchants expect. Form filling accuracy is not isolated to the checkout page; it starts upstream with the data the agent carries into the purchase. When an agent already holds the correct SKU, variant, and price from a clean feed, it faces fewer ambiguous decisions at checkout and makes fewer mistakes. When the feed is stale or inconsistent, the agent either abandons on a mismatch or pushes through with wrong data.

That is why we treat feed hygiene as part of checkout reliability rather than a separate discovery concern. A fresh, well-mapped feed reduces both soft and hard errors at the final step, and it is often the cheaper half of the fix compared to re-engineering a checkout flow.