For twenty years, attribution has rested on a quiet assumption: a human clicks, a browser loads, a pixel fires. Break that chain and most analytics stacks go dark. Agentic traffic — AI agents that browse, compare, and increasingly buy on a person’s behalf — breaks the chain in several places at once.
This is not a far-future problem you can shelve. Assistants from OpenAI and others already navigate sites, fill carts, and complete tasks while the human watches a summary. The mechanics of how that traffic lands in your reports are worth understanding now, before the volume grows.
What an agent actually does to the click
A traditional paid click is legible. Someone taps your Google ad, arrives with a gclid in the URL, a referrer of google.com, and a browser that runs your tag. Last-click attribution has something to grab.
An agent acting on a user’s behalf scrambles most of that:
- No ad click. The agent often arrives at your site through a direct fetch or a link it found mid-task, not through your paid placement. The
gclidorfbclidthat would normally ride along is simply absent. - No referrer, or a useless one. Many agent requests carry no
Refererheader, or one that points to the assistant’s own infrastructure rather than a page a human browsed. In GA4 that frequently lands as(direct) / (none)— the same bucket we cover in Why your AI traffic shows up as Direct / None. - No client-side execution, sometimes. Some agents render JavaScript; some fetch raw HTML and never run your tag at all. When the tag doesn’t fire, your client-side analytics never sees the visit.
- Conversion at a distance. The human who started the task may convert hours later, on a different device, after the agent surfaced your product. The session that “converted” and the session that discovered you are not the same session — and last-click stitches them together wrong, or not at all.
The net effect: a real, qualified visit that influenced a purchase shows up as anonymous, sourceless, or invisible. Multiply that across a category where agent-mediated shopping becomes routine and your “direct” bucket quietly swells with traffic that was anything but direct.
Why last-click and pixels were always fragile here
Pixel-based attribution measures one thing well: a browser that ran your code did something. It infers everything else — source, medium, campaign — from signals that travel with that browser. Strip the browser, or strip the signals, and the pixel has nothing left to infer from.
Agents strip both. A headless fetch has no cookies you set last week, no gclid you can decode, and no guarantee it will execute the conversion pixel even if it does complete a purchase. The model that powers last-click — “credit the last touch that had a recognizable source” — assumes the last touch is recognizable. Agentic traffic routinely isn’t.
This is the same structural weakness that ad blockers, ITP, and consent gating have been exposing for years. Agents just push it to its conclusion: a buyer who never personally loads your page in a tracked browser.
What actually survives
Two things survive an agent that a pixel does not.
UTMs on links you control. A query string is part of the URL. If your link carries utm_source, utm_medium, and utm_campaign, those values arrive intact whether a human or an agent requests the page — no JavaScript required, no cookie required. The agent can ignore them, but it can’t strip them from a link you authored. This is the durable signal: tag every link you place where an assistant might surface it, using a consistent convention. See a UTM convention for the AI search era for the taxonomy.
Server-side capture. If your server logs the inbound request — the full URL with its UTMs, the user agent, the timestamp — you have a record of the visit even when the client tag never ran. The server sees the request the moment it lands, before any JavaScript decides whether to execute. That request log is the one place agentic traffic can’t hide.
Put those together and the durable pattern is: tag the link, capture it server-side, and reconcile the eventual conversion against that captured first touch rather than against a last-click session that may not exist.
| Signal | Survives an agent? | Why |
|---|---|---|
gclid / fbclid | Usually no | Agent doesn’t click your paid placement |
| Client-side pixel | Often no | Tag may never execute on a headless fetch |
| Referrer header | Frequently no | Absent or points to assistant infra |
| UTMs in the URL | Yes | Part of the link you authored |
| Server request log | Yes | Captured before any JS runs |
Bot or buyer? You still have to tell them apart
Not every agent request represents a human intent to buy. Crawlers index, preview bots fetch link unfurls, and price-monitoring scripts hammer product pages with no human behind them. Lumping all non-browser traffic into one “AI” bucket is as misleading as ignoring it.
The practical split is by user agent and behavior. Declared assistant and crawler user agents (the ones platforms publish) can be segmented or filtered. An agent completing a checkout flow on a user’s behalf is a different animal from a crawler that fetches one page and leaves — and your reporting should treat them differently. Server-side capture gives you the raw user-agent string to make that call; a client pixel often never sees the request at all.
Don’t over-rotate, though. Today, most of your buyers are still humans in browsers. The point is not to rebuild everything around agents — it’s to make sure the durable signals (tagged links, server-side capture) are in place so that as the agent share grows, those visits land somewhere intelligible instead of vanishing into (direct) / (none).
Where to start
You don’t need an agent strategy. You need an attribution foundation that doesn’t assume a cooperative browser:
- Tag every external link you control with consistent UTMs, including the ones you expose to assistants.
- Capture inbound requests server-side, with the full URL, so a visit is recorded even when the tag doesn’t fire.
- Segment declared agent and crawler user agents so human and machine traffic don’t blur together.
- Reconcile conversions against the captured first touch, not a last-click session that an agent may have skipped.
Server-side capture is exactly the gap AnyTrack (anytrack.io) is built to close — recording the touch at the server so the eventual conversion has something real to attribute back to, even when the click never ran your pixel.
More in this series
- Track AI traffic from ChatGPT, Perplexity, and Gemini
- Why your AI traffic shows up as Direct / None — and how to fix it
- A UTM convention for the AI search era (GEO/AEO)
- Use AI to generate and govern your UTM taxonomy
- Tracking AI-generated ad campaigns without breaking your UTMs
- Should AI referral traffic get its own channel in GA4?
- llms.txt and UTMs: tagging the links AI assistants cite