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
One thing survives an agent that a pixel does not: the server request itself.
If your server logs the inbound request — the full URL, the headers, 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.
It’s worth being precise about what UTMs do and don’t contribute here, because this is where a lot of advice goes wrong.
A query string is genuinely durable. If a URL carries utm_source and utm_campaign, those values arrive intact whether a human or an agent requests the page — no JavaScript, no cookies. But that only helps for links you actually authored and placed somewhere: an ad you bought, a newsletter you sent, a partner page you supplied. An agent that finds you mid-task arrives at your bare canonical URL, exactly like an AI citation does. There’s no link of yours in that path to have tagged.
And the tempting workaround — publishing your canonical URL with parameters baked in so agents pick them up — backfires the same way it does for AI citations: every human visitor from every other source lands on the same tagged address and gets mislabeled. You’d be corrupting the majority of your traffic to instrument a minority of it.
So the durable pattern is: keep tagging the links you genuinely place, capture every inbound request server-side, and reconcile the eventual conversion against that captured 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 on a link you placed | Yes | Part of the URL you authored |
| UTMs on an agent-discovered visit | N/A | It arrived at your bare canonical URL |
| 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:
- Capture inbound requests server-side, with the full URL and headers, so a visit is recorded even when the tag doesn’t fire. This is the one that matters most.
- Keep tagging the links you genuinely place — ads, newsletters, partner pages — with consistent UTMs. Leave your canonical URLs bare.
- 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
- How to track ChatGPT, Perplexity, and Gemini traffic
- Why your AI traffic shows up as Direct / None — and how to fix it
- There is no UTM convention for AI search — and that’s the right answer
- Use AI to generate and govern your UTM taxonomy
- Tracking AI-generated ad campaigns without breaking your UTMs
- GA4 now has a native AI Assistants channel
- llms.txt and UTMs: why you shouldn’t tag the links AI assistants read