We sent an AI agent to buy on 4 SaaS. All 4 got lost before checkout.

We pointed an LLM agent at the pricing page of four popular SaaS products with one task: buy the Pro plan. Notion, Linear, Figma, Vercel. The agent used Playwright to see the DOM, a Groq-hosted Llama 3.3 70B to decide what to click, and a plan-act-observe loop. This is the same behavioural probe we ship at agentfix.pro/api/probe.

Four probes, zero purchases. None of them reached a checkout screen. Each failed differently, but the underlying pattern is one and the same: a modern SaaS pricing page is optimised for humans skimming with intent, and an agent with a literal "buy" task walks straight into the free-tier funnel.

The bench

• Notion – https://www.notion.so/pricing
• Linear – https://linear.app/pricing
• Figma – https://www.figma.com/pricing/
• Vercel – https://vercel.com/pricing

Intent for every run: buy. Model: llama-3.3-70b-versatile via Groq. Timeout: 180s per probe. Stop condition: agent self-reports stuck, hits 15 turns, or the orchestrator times out. Data collected on 2026-07-09 from agentfix.pro/api/probe (endpoint is public preview, source in agentfix-oss-scanner).

Disclaimer up front. Real agents do not buy SaaS today. This is an illustrative walkthrough of what a modern LLM sees when a pricing page is its whole world. If the DOM is confusing to the model, it is also confusing to any future agent that a buyer sends on their behalf.

Notion: 2 turns, wrong CTA, browser wall

The agent read the pricing page, then clicked the button labelled Get Notion free. That is the top-right free-signup CTA, not the paid checkout. The page redirected to app.notion.com/unsupported-browser.html. Turn 2 the agent tried to move on and reported Unsupported browser, cannot proceed. Total wall time: 8.7 seconds.

Two failure modes stacked. First, the model could not tell the free signup CTA apart from a paid checkout CTA. Second, once redirected, the automation-friendly path (Playwright headless Chromium) got served a hardened unsupported-browser page. The agent had no way back to the pricing tiers.

Linear: 2 turns, wrong CTA, dead end on signup

Same problem, one step deeper. The agent clicked Get started at turn 1. Landed on linear.app/signup. Turn 2 the model reported no interactive elements visible and stopped. Duration: 14.9 seconds.

Linear's signup page renders its actual auth widget through client-side JavaScript that Playwright headless Chromium can see pixel-wise but does not surface as accessible interactive elements the LLM can click. From the model's side, the page is a wall. No paid tier ever came into view.

Figma: 6 turns, loop between free and paid, TPD kill

The worst run. The agent clicked Get started for free at turn 1. The page swapped in a plan selector, so at turn 2 the agent picked Select Starter plan. Nothing happened (Starter is free, the flow does not go to checkout). Turn 3 the agent went back to Get started for free. Turn 4 it actually picked Select Professional plan, the right tier for a buy intent, but nothing happened again, because the tier card is a signup gate, not a checkout. Turn 5 the model emitted an invalid action. Turn 6: back to Select Starter plan.

The loop ate 61.5 seconds and pushed the orchestrator past the Groq daily token budget (100,000 TPD on the free tier), which killed the run with a 429. In production that is a paid-inference bill for zero purchase intent detected. Static scan grade for figma.com/pricing the same day: C (21/34 signals).

Vercel: 1 turn, signup wall, TPD kill

The agent clicked Start a free trial at turn 1 (again, the free CTA rather than the paid Pro tier). Landed on vercel.com/signup?plan=pro&next=/dashboard. Turn 2 never happened. The orchestrator hit the same Groq daily token 429 that killed Figma. Duration before kill: 10.1 seconds. No checkout screen ever reached. Same failure mode as Notion and Linear: the free-trial CTA is the visual anchor, and the paid tier lives one label deeper than the agent looked.

Framer, the fifth site in our bench, could not even get a first turn. The daily token budget was already exhausted by then. Its pricing page scored C (21/34) on the static scan, so we know what the probe would have found before it started.

The common failure mode

Four different SaaS, four different code bases, one identical agent failure. Every pricing page in the bench treats the free tier as its dominant call-to-action. Human buyers know how to skip that CTA and hunt for the paid card. An LLM with a literal buy intent does not. It reads a button that says the word free and, being trained on the plainest possible semantics, clicks it.

The static scan predicts most of this without ever booting a browser. Every site in the bench is missing structured pricing signals that would let an agent bind intent to the correct tier:

• No Product / Offer JSON-LD on the pricing page. An agent has to infer tier from the visible headline.
• No aria-label distinguishing free vs paid tier cards. Both sit in the DOM as generic buttons.
• No /.well-known/agent-card.json or MCP server card that could redirect an agent to a machine-first purchase flow.

Same scan tells us where each site actually loses points. Grade breakdown from agentfix.pro/api/scan on 2026-07-09:

• Notion – D (18/34 signals)
• Linear – D (18/34 signals)
• Figma – C (21/34 signals)
• Vercel – C (22/34 signals)
• Framer – C (21/34 signals)

None of them scored A or B. Every one is missing structured pricing signals in the same three or four categories, which is exactly what steered every probe into the free-signup funnel.

Why static scan catches most of it

The behavioural probe is honest and expensive. Playwright browser, LLM turn budget, at least ten seconds of wall time per run, plus the inference bill. The static scan runs in about three seconds, costs nothing, and catches the structural gaps that would send the behavioural probe off-course in the first place.

Four of the five failures we saw in the probes trace back to missing static-scan signals: schema for pricing tiers, ARIA labels on tier cards, MCP or A2A agent card at /.well-known/, and a machine-parseable pricing feed. The fifth failure (Notion's unsupported-browser gate) is a deployment-level policy call, not a signal a scan can fix. Fine. Four out of five is still the cheap way in.

What to do about it

1. Ship Product and Offer JSON-LD on the pricing page. One block per tier. Include priceSpecification, billingIncrement, and a stable @id the agent can key into intent.
2. Set aria-label on every tier card that says which tier it is. Not Get started. Something like Select Starter tier (free) vs Select Pro tier ($20/mo).
3. Publish a minimal MCP server card at /.well-known/mcp.json pointing at your pricing API, and an A2A agent card at /.well-known/agent-card.json so agents can skip the DOM entirely.
4. If your pricing page hard-redirects on unsupported browser, have a plain HTML fallback that still exposes the tier data. Agents will not upgrade Chromium for you.

TL;DR

We ran four SaaS pricing pages through a behavioural probe with a buy intent. All four failed before checkout. Every one of them steered the agent into the free-tier signup funnel, because the DOM does not label paid vs free at the tier-card level and there is no structured pricing data an agent can bind intent against. The static-signal scan at agentfix.pro flags four of the five failure modes in three seconds without booting a browser.

Scan your site free at agentfix.pro. If it grades below B, our Fix Packs from $29 ship the missing files so a real agent can find your paid tier.