Agent Experience (AX): Guida Definitiva all’AI Agent Site UX 2026

Guida tecnica 2026 all’AI Agent Site UX e all’Agent Experience (AX): come progettare siti pronti per ChatGPT Agent, Operator, Claude Computer Use, Gemini Agent e Perplexity Comet. ARIA agentico, deterministic identifiers, WebMCP, Schema.org Action, llms.txt, payment delegation, 7 metriche AX, codice integrale e mini case study.

Pubblicato il · 37 min di lettura

Agent Experience (AX): la Guida Definitiva all’AI Agent Site UX 2026

TL;DR — In sintesi

  • L’Agent Experience (AX) è la nuova disciplina di design che ottimizza il sito per la nuova classe di visitatori del web: gli agenti AI autonomi (ChatGPT Agent, OpenAI Operator, Claude Computer Use, Gemini Agent, Perplexity Comet).
  • Gli agenti vedono il sito attraverso tre modalità complementari: screenshot, DOM e accessibility tree. Il costo computazionale varia di un fattore ~25× tra le modalità: chi non ottimizza brucia token (e budget).
  • L’AX include — ma non si limita a — l’accessibilità: AX ⊇ A11y. Ogni miglioramento per gli screen reader è un miglioramento per gli agenti, ma serve di più: deterministic identifiers, ARIA agentico, schema.org Action, WebMCP, llms.txt, idempotency.
  • Le 7 metriche AX che proponiamo come standard per il mercato italiano: Robot Success Rate (RSR), Robot Abandonment Rate (RAR), Time-to-Action (TTA), Agent Conversion Rate (ACR), A11y Tree Depth Score, Action Discoverability Index (ADI), Token Cost per Task (TCpT).
  • Lo stack pagamenti agentici 2026 (ACP, UCP, AP2, x402, Shop Pay for Agents, Mastercard Agent Pay) ha già processato oltre $11B nel solo Q4 2025 via Stripe Agent Toolkit. Chi non si attrezza, sparisce dalle ricerche transazionali.
  • Questa guida supera il riferimento web.dev (~600 parole, 8 raccomandazioni base) con 17 capitoli, 9 tabelle, 12 esempi di codice integrali, una formula proprietaria di Agent Score e un mini case study sul sito davideminetti.it.

Introduzione: il web ha un nuovo visitatore (e non è umano)

Per oltre trent’anni il web design ha avuto un solo destinatario: l’essere umano. Hover effect, animazioni, micro-interazioni, dark mode, parallax, tipografia espressiva — tutto pensato per occhio, cervello e mano di una persona seduta davanti a uno schermo.

Nel 2026 questa premessa non è più sufficiente. Quando un utente apre ChatGPT e scrive “Trovami i tre migliori hotel a Roma per il 12 giugno e prenota il più conveniente con cancellazione gratuita”, non è più lui a navigare i siti: è il suo agente AI autonomo che apre Booking, Trivago e Expedia, confronta i risultati, compila il form e completa il checkout. L’utente vede solo il riassunto finale.

Questa nuova classe di visitatori richiede una nuova disciplina di design, che chiamiamo Agent Experience (AX). Non è un’evoluzione cosmetica della UX: è un cambio di paradigma altrettanto profondo di quello desktop → mobile del 2010-2015 [1].

Il documento di riferimento del settore — l’articolo “Build agent-friendly websites” pubblicato su web.dev da Kasper Kulikowski e Omkar More il 1° aprile 2026 [2] — affronta il tema in modo introduttivo, con 8 raccomandazioni di base. Ottimo punto di partenza, ma profondamente insufficiente per chi vuole davvero dominare la nuova era. In questa guida andiamo molto oltre.

Per una panoramica strategica complementare, parti dalla nostra Guida Completa AI SEO 2026 e poi torna qui per la parte operativa di runtime UX.

In questo articolo scoprirai:

  1. Le tre modalità con cui un agente vede il tuo sito e quanto costano in token.
  2. 20 principi di design AX (gli 8 di web.dev più i 12 avanzati che proponiamo come standard).
  3. Codice integrale per deterministic identifiers, ARIA agentico, Schema.org Action, WebMCP, llms.txt, form idempotenti e streaming SSE.
  4. Stack completo dei pagamenti agentici 2026 (ACP, UCP, AP2, x402, Shop Pay for Agents, Mastercard Agent Pay).
  5. 7 metriche AX coniate per il mercato italiano + formula di Agent Score proprietaria.
  6. Confronto operativo dei 5 framework agent: Stagehand, Skyvern, Browser-Use, OpenAI Operator API, Anthropic Computer Use.
  7. Mini case study con audit before/after della pagina /servizi di davideminetti.it.
  8. Roadmap in 21 passi per portare il tuo sito in produzione AX-Ready entro 90 giorni.

Pronti? Si parte.


1. Cos’è la AI Agent Site UX e perché è diversa dalla UX classica

1.1 Definizione operativa di Agent Experience (AX)

Definiamo Agent Experience (AX) come l’insieme di principi, pattern e contratti machine-readable che permettono a un agente AI autonomo di percepire, comprendere ed eseguire azioni su un sito web in modo affidabile, idempotente e con il minimo costo computazionale.

Tre sono le parole chiave:

  • Affidabile — l’agente completa il task senza fallimenti per cause prevenibili (layout shift, identifier instabili, modali invisibili).
  • Idempotente — se l’agente ritenta un’operazione, il risultato non si duplica (es. ordine inviato due volte).
  • Minimo costo computazionale — la stessa operazione richiede pochi token. Questo è l’aspetto più sottovalutato: oggi un task vision-mode costa ~$0.08, mentre un task DOM-only ben strutturato costa ~$0.005. Su scala, è un fattore 16× sui costi infrastrutturali [3].

1.2 La nuova classe di visitatori: zero-party, first-party, third-party agent

Seguendo la tassonomia introdotta da web.dev [4], distinguiamo tre tipologie di agente che possono visitare un sito:

Tipo agenteOrigineEsempioImplicazioni AX
Zero-partyCodice che il sito stesso ospita in paginaChatbot di assistenza incorporato (Vercel AI SDK, Intercom Fin)Stato interno controllato; AX = qualità del prompt e dei tools esposti
First-partyAgente fornito dal vendor della piattaformaShopify Sidekick, Salesforce Agentforce, HubSpot BreezeConoscenza profonda del dominio; AX = struttura dei dati e degli eventi
Third-partyAgente esterno, opera per conto dell’utenteChatGPT Agent, OpenAI Operator, Claude Computer Use, Gemini Agent, Perplexity CometConoscenza zero del dominio; AX = tutto il contratto pubblico (DOM, ARIA, schema, llms.txt, MCP)

Il caso più impegnativo — e quello su cui questa guida si concentra — è il third-party agent: arriva senza alcun contesto preesistente, ha solo ciò che il tuo sito espone pubblicamente.

1.3 Cosa cambia rispetto alla UX classica

DimensioneUX classica (utente umano)Agent Experience (agente AI)
Canale percettivo principaleVista + udito (assistive tech)Screenshot + DOM + accessibility tree
Tolleranza all’ambiguitàAlta (l’umano deduce dal contesto)Bassa (un’azione ambigua → fallimento)
Velocità di lettura~250 parole/minMigliaia di nodi DOM in millisecondi (limitata da token, non da occhi)
Tolleranza al layout shiftFastidiosa, non bloccanteBloccante (lo screenshot non corrisponde più al DOM)
Comprensione di metafore visiveEccellenteInaffidabile (un’icona senza aria-label è opaca)
Memoria di sessioneCookie + localStorageToken di contesto LLM (limitato e costoso)
PagamentoCarta + 3DS + step-up biometricoMandate Token + delegated payment + step-up condizionato
Modello di erroreRiprova manualeRetry automatico con idempotency key
Costo per interazione~0 (post-acquisizione)$0.005-$0.08 a task in token LLM

Questa tabella spiega perché un sito brillante per umani può essere funzionalmente rotto per gli agenti, e viceversa. La buona notizia: ottimizzare per l’AX non penalizza la UX umana, anzi la potenzia, perché impone rigore semantico.

1.4 AX ⊇ A11y: la grande convergenza

Il principio più importante di tutto questo articolo è una proprietà insiemistica. L’Agent Experience contiene strettamente l’Accessibility:

Ogni sito accessibile è (parzialmente) agent-ready. Ogni sito agent-ready è (interamente) accessibile.

Uno screen reader e un agente AI hanno lo stesso bisogno: interpretare il significato delle interazioni senza affidarsi al pixel. Le differenze:

  • Lo screen reader ascolta in tempo lineare; l’agente “sfoglia” l’intero a11y tree in parallelo.
  • Lo screen reader non vede mai screenshot; l’agente sì (a costo elevato).
  • Lo screen reader segue il DOM order; l’agente può saltare ovunque.

In pratica, se hai investito sull’accessibilità WCAG 2.2 AA, hai già coperto il 60% della Agent Experience. Ti restano un altro 40%: identifier deterministici, contratti di azione (Schema.org Action / WebMCP), file di metadati per agenti (llms.txt, agent-card.json), idempotency, payment delegation. È quello che vedremo nei prossimi capitoli.


2. Le tre modalità con cui un agente vede il tuo sito

2.1 Screenshot mode (vision)

L’agente cattura un’immagine raster della pagina renderizzata e la passa a un modello di visione (GPT-4o vision, Claude Opus 4, Gemini 2.5 Pro). Il modello identifica bounding box, OCR il testo, riconosce icone.

  • Pro: cattura indizi visivi (colore di un pulsante “Acquista”, prossimità tra prezzo e CTA, evidenza dei messaggi di errore).
  • Contro: lento e costoso (ordini di grandezza ~$0.05-$0.10 per screenshot HD), fragile (un layout shift invalida la coordinata cliccata).

Quando è davvero utile: quando il DOM non riflette la UX (es. canvas, mappe, video player custom).

2.2 DOM mode (HTML parsing)

L’agente scarica l’HTML, ne ricostruisce il DOM, naviga gli attributi (id, class, data-*, role, aria-*), interpreta la nidificazione.

  • Pro: economico (~$0.005 per pagina con DOM moderato), preciso, auto-documentante.
  • Contro: ignora il rendering condizionale CSS/JS (tutto ciò che è nascosto da display: none o caricato in lazy via Intersection Observer non c’è).

2.3 Accessibility Tree mode

È la API nativa di Chromium Accessibility.getFullAXTree: distilla il DOM ai soli elementi semanticamente rilevanti con role, name (label calcolato), description, state. È la stessa rappresentazione che usa uno screen reader.

  • Pro: il più economico in token (~$0.003 a pagina), già “interpretato” dal browser, immune al rumore CSS.
  • Contro: richiede un browser controllabile (Chromium DevTools Protocol o Puppeteer); non visibile da semplice fetch.

Per un’introduzione approfondita all’a11y tree consigliamo l’articolo ufficiale Google [5]; per la sua applicazione SEO classica vedi la nostra guida sull’architettura del sito per AI.

2.4 Hybrid mode: il default 2026

Tutti i grandi agenti commerciali del 2026 (Operator, ChatGPT Agent, Claude Computer Use, Gemini Agent) operano in modalità ibrida: usano l’a11y tree per l’inventario delle azioni possibili, il DOM per estrarre dati densi (tabelle, prezzi, descrizioni), lo screenshot solo quando le altre due modalità falliscono (es. canvas).

Questa cascade explica una regola pratica: se un’azione è raggiungibile dall’a11y tree, il costo cognitivo (e in token) per l’agente crolla del 90-95% rispetto al fallback su screenshot.

2.5 Matrice costi/precisione

ModalitàCosto medio per taskPrecisione (success rate WebArena)Latenza mediaQuando dominare
Screenshot only$0.08038%8-12 sMai come default; backup di ultima istanza
DOM only$0.00552%1-2 sPagine information-rich (blog, news, doc)
A11y tree only$0.00347%0.8-1.5 sPagine action-rich (form, checkout, dashboard)
Hybrid (a11y + DOM + screenshot fallback)$0.01274%2-4 sDefault produzione 2026

I numeri di costo derivano da benchmark pubblici di Browserbase su Stagehand e Computer Use [3]; i success rate sono allineati con i risultati pubblicati su WebArena/Mind2Web 2.0 [6].

2.6 Cosa significa per il tuo sito

Tre conseguenze operative:

  1. Investi prima sull’a11y tree: è la modalità più economica e quella che gli agenti consultano per prima.
  2. Il DOM deve essere autosufficiente: niente prezzi renderizzati solo da JavaScript dopo IntersectionObserver, niente label costruite via ::before { content: }.
  3. Lo screenshot deve essere un’ancora di salvataggio, non il canale primario. Se il tuo sito è leggibile solo dallo screenshot, stai pagando 16× il dovuto.

3. I 20 principi della Agent Experience: dagli 8 di web.dev ai 12 avanzati

Web.dev propone 8 raccomandazioni introduttive [2]. Le riportiamo qui (P1-P8) e aggiungiamo i 12 principi avanzati (P9-P20) che riteniamo standard professionale 2026.

3.1 Principi base (P1-P8) — adattati da web.dev

  • P1 — Visibilità dell’azione. Ogni azione necessaria al percorso utente deve essere immediatamente visibile nel viewport iniziale o raggiungibile con scroll lineare. Niente azioni nascoste dietro hover, drag, gesture su mobile.
  • P2 — Stabilità del layout. Cumulative Layout Shift (CLS) ≤ 0.1, e in più: posizione reproducible dei CTA primari tra navigazioni (l’agente memorizza coordinate).
  • P3 — No ghost overlay. Vietati overlay trasparenti che catturano click; cookie banner che bloccano interazioni; modali con pointer-events: none mal gestiti.
  • P4 — HTML semantico autentico. <button>, <a href>, <form>, <select>, <input> invece di <div onclick>. Se proprio devi usare un <div> interattivo: role="button" + tabindex="0" + handler tastiera.
  • P5 — cursor: pointer. Indicatore visivo riconosciuto in screenshot mode.
  • P6 — <label for> collegato. Ogni <input> ha una <label> esplicitamente collegata (non solo placeholder).
  • P7 — Hit area > 8 px². L’area visibile dell’elemento interattivo deve essere maggiore di 8 pixel quadrati per essere catturata dal vision model. Linea guida WCAG 2.2 di “target size” ne raccomanda 24×24 px.
  • P8 — Coerenza tra screen, DOM e a11y tree. Le tre modalità devono raccontare la stessa storia. Se vedi un pulsante in screenshot ma non nel DOM, hai un problema.

3.2 Principi avanzati (P9-P20) — standard professionale

  • P9 — Deterministic identifiers stabili tra deploy. data-action, data-agent-action, data-testid con naming dominio.verbo (vedi Cap. 4).
  • P10 — ARIA agentico completo. aria-busy, aria-live, aria-controls, aria-expanded, aria-labelledby (vedi Cap. 5).
  • P11 — File well-known per agenti. /llms.txt, /.well-known/agent-card.json, /.well-known/ucp-capabilities.json, /robots.txt esteso (vedi Cap. 6).
  • P12 — Schema.org Action su ogni entità transazionale. BuyAction, OrderAction, ReserveAction, SearchAction con EntryPoint esplicito (vedi Cap. 7).
  • P13 — Esposizione WebMCP per azioni complesse. API dichiarativa o imperativa via navigator.modelContext (vedi Cap. 8).
  • P14 — Idempotency keys su tutte le mutazioni. Header Idempotency-Key lato API e data-idempotency-key lato bottone (vedi Cap. 9).
  • P15 — Streaming response per task lunghi. SSE o WebSocket invece di long polling, così l’agente non timeout (vedi Cap. 9).
  • P16 — Authentication agent-aware. OAuth 2.1 con scope agent:purchase, WebAuthn agentic, step-up condizionato per importi > soglia (vedi Cap. 10).
  • P17 — Payment delegation pronta. ACP, UCP, AP2, x402, Shop Pay for Agents, Mastercard Agent Pay (vedi Cap. 10).
  • P18 — Performance budget agentico. Agent LCP ≤ 2.0 s, Agent INP ≤ 150 ms, Agent DOM Score ≥ 80 (vedi Cap. 11).
  • P19 — Telemetria AX integrata. Eventi GA4 / Plausible / Cloudflare segmentati per User-Agent agent (vedi Cap. 12).
  • P20 — Compliance GDPR per agenti. Art. 22 GDPR, audit trail delle azioni delegate, data residency MCP server (vedi Cap. 15).

I principi P1-P8 sono necessari ma non sufficienti. I principi P9-P20 sono ciò che separa un sito AX-aware da un sito AX-leader nel 2026.


4. Deterministic Identifiers: il pilastro nascosto della Agent Experience

4.1 Perché gli ID stabili sono il problema #1 dei siti SPA moderni

Un agente che ha trovato un pulsante e lo ha cliccato ieri ha bisogno, oggi, di trovare lo stesso pulsante allo stesso modo. Eppure i siti React/Vue/Svelte moderni generano routinariamente:

  • Classi CSS-in-JS hashed (css-1a2b3c4).
  • Class names dinamici Tailwind con varianti (hover:bg-blue-600).
  • ID auto-generati da framework (#headlessui-popover-button-:r3:).
  • Identifier stagionali (add-to-cart-summer-2025).

Tutti questi identifier cambiano a ogni deploy o a ogni A/B test. Per un agente, è come se l’interfaccia mutasse ogni 24 ore.

4.2 Convenzioni di naming proposte

Standardizziamo tre attributi complementari:

AttributoScopoNaming conventionEsempio
data-testidTest E2E (Playwright, Cypress, Selenium)componente-elemento-variantecheckout-pay-button-primary
data-actionAzione applicativa genericadominio.verbo[.qualifier]checkout.pay
data-agent-actionRiservato esplicitamente all’agenteVerbo umano-leggibilepurchase

I tre convivono sullo stesso elemento. Il primo serve ai test interni, il secondo al dominio applicativo (event tracking, A/B), il terzo è un contratto pubblico con gli agenti esterni.

4.3 Esempio integrale di pulsante AX-Ready

<button
  type="submit"
  data-testid="checkout-pay-button"
  data-action="checkout.pay"
  data-agent-action="purchase"
  aria-label="Paga 89,90 € con carta di credito"
  aria-describedby="checkout-pay-help"
  class="btn btn-primary">
  Paga ora
</button>
<p id="checkout-pay-help" class="sr-only">
  Procedendo al pagamento accetti i termini di servizio e l'addebito immediato di 89,90 €.
</p>

Questo singolo bottone è leggibile in modo non ambiguo da:

  • Uno screen reader (NVDA, JAWS, VoiceOver).
  • Un test E2E (page.getByTestId('checkout-pay-button').click()).
  • Un agente (element.dataset.agentAction === 'purchase').
  • Il DOM crawler (parsing <button> semantico).

4.4 Anti-pattern: cosa NON fare

Lista nera:

  • ❌ Affidarsi solo al testo del pulsante (“Compra” può diventare “Acquista” in A/B test).
  • ❌ Affidarsi a class names Tailwind (bg-blue-600 hover:bg-blue-700).
  • ❌ Affidarsi a XPath posizionale (//div[3]/button[1]).
  • ❌ Generare id random a runtime.
  • ❌ Cambiare data-testid a ogni release per “pulizia”.

4.5 Strategia di stabilità tra deploy

Pratica consigliata in produzione:

  1. Versionare i data-action come parte del contratto pubblico (data-action="checkout.pay@v2").
  2. Documentare gli action verb in un file agents.json o nel agent-card.json.
  3. Testare la stabilità in CI: un job che verifica che gli action verb critici esistano dopo ogni deploy.
  4. Deprecare con cura: mai rimuovere un data-agent-action senza fase di compatibilità.

5. ARIA Agentico: il vocabolario semantico per agenti AI

5.1 ARIA non è “solo accessibilità”

ARIA (Accessible Rich Internet Applications) nasce per gli screen reader. Negli ultimi due anni è diventato il dialetto preferito degli agenti AI per leggere lo stato di una UI dinamica. Il motivo: è già integrato nell’a11y tree, parte del browser, gratuito da implementare.

5.2 Tabella di mapping A11y ↔ A-AI

Ecco come ogni attributo ARIA usato per gli umani serve identicamente all’agente:

Attributo ARIAFunzione per umani (screen reader)Funzione per agenti AIEsempio d’uso
roleAnnuncia il tipo dell’elementoCategorizza l’azione possibilerole="button" su un <div>
aria-labelEtichetta letta ad alta voceEtichetta computata nel name dell’a11y treearia-label="Chiudi modale"
aria-labelledbyEtichetta da altro elementoStesso scopoaria-labelledby="title heading"
aria-describedbyDescrizione aggiuntivaHelper text, condizioni d’usoaria-describedby="price-help"
aria-controlsRelazione bottone → pannelloMappa azione → effetto previstoToggle aria-controls="filter-panel"
aria-expandedStato espanso/contrattoStato del menu/accordionHamburger menu
aria-pressedStato pressato (toggle)Stato di un toggle buttonLike button
aria-checkedStato checked (custom checkbox)Stato di selezioneFilter chip
aria-busy="true"“Attendere, sto caricando”L’agente attende, non riprova subitoSubmit form
aria-live="polite|assertive"Annuncia aggiornamenti dinamiciL’agente legge il nuovo contenuto (toast, errori)Notifica successo
aria-invalid="true"“Campo non valido”L’agente sa di dover correggere il valoreValidazione email
aria-disabled="true"“Non interagibile”L’agente non cliccaBottone in attesa di precondizioni
aria-current="page|step"Posizione correnteStato del wizard/breadcrumbStep 2 di 4
aria-required="true"“Campo obbligatorio”L’agente sa di dover compilareForm validation

Lezione: se hai investito su WCAG 2.2 AA, hai già un dizionario semantico ricco da offrire agli agenti. Aggiungere il livello AX significa completare quello che spesso è incompleto in produzione (aria-busy durante async, aria-live per i toast, aria-controls sui toggle).

5.3 Pattern: pulsante che attende risposta async

<button
  data-action="newsletter.subscribe"
  data-agent-action="subscribe_newsletter"
  aria-busy="false"
  aria-controls="newsletter-status"
  id="newsletter-btn">
  Iscriviti
</button>
<div
  id="newsletter-status"
  role="status"
  aria-live="polite"
  class="sr-only-until-active"></div>

<script>
document.getElementById('newsletter-btn').addEventListener('click', async (e) => {
  const btn = e.currentTarget;
  const status = document.getElementById('newsletter-status');
  btn.setAttribute('aria-busy', 'true');
  status.textContent = 'Iscrizione in corso…';
  try {
    await fetch('/api/newsletter', { method: 'POST', /* ... */ });
    status.textContent = 'Iscrizione confermata. Controlla la tua email.';
  } catch (err) {
    status.textContent = 'Errore: riprova tra qualche secondo.';
  } finally {
    btn.setAttribute('aria-busy', 'false');
  }
});
</script>

L’agente che monitora aria-busy attende invece di ri-cliccare in loop. L’agente che monitora aria-live legge il messaggio finale e capisce esito del task. Lo stesso codice serve allo screen reader. Una volta sola, due audience servite.


6. I file well-known per agenti: robots.txt, llms.txt, agent-card.json

6.1 robots.txt esteso 2026

Il vecchio robots.txt non basta più. Nel 2026 è necessario distinguere tre famiglie di bot:

  1. Training bot — scaricano contenuti per addestrare modelli (GPTBot, ClaudeBot, Google-Extended, Applebot-Extended).
  2. Answer-time bot — recuperano contenuto fresco per rispondere a una query in tempo reale (ChatGPT-User, OAI-SearchBot, PerplexityBot).
  3. Agent action bot — agenti autonomi che eseguono azioni per conto utente (Operator, Computer Use, ChatGPT Agent).

Esempio di robots.txt 2026 ben fatto:

# Training bots — scelta strategica brand
User-agent: GPTBot
Allow: /blog/
Disallow: /private/

User-agent: ClaudeBot
Allow: /blog/

User-agent: Google-Extended
Allow: /

User-agent: Applebot-Extended
Allow: /

# Answer-time bots — di solito sempre allow
User-agent: ChatGPT-User
Allow: /

User-agent: OAI-SearchBot
Allow: /

User-agent: PerplexityBot
Allow: /

# Bot scraper non legittimi
User-agent: Bytespider
Disallow: /

User-agent: ClaudeBot-Scraper
Disallow: /

# Sitemaps
Sitemap: https://davideminetti.it/sitemap.xml
Sitemap: https://davideminetti.it/llms.txt

Per l’analisi avanzata di crawl budget e gestione dei bot AI vedi anche Crawl Budget Optimization per bot AI-powered e LLM.

6.2 llms.txt — il “robots.txt per LLM”

llms.txt è una proposta di Jeremy Howard (answer.ai), settembre 2024 [7], oggi adottata da oltre 50.000 siti tra cui Anthropic, Stripe, Cursor, Cloudflare e modelcontextprotocol.io stesso. È un file Markdown a https://example.com/llms.txt che fornisce all’LLM una mappa curata del sito.

# Davide Minetti — Consulente SEO & AI Optimization

> Consulente SEO con focus su Generative Engine Optimization (GEO),
> AI Overviews e Agent Experience. Articoli e servizi in italiano.

## Articoli pillar
- [Guida AI SEO 2026](https://davideminetti.it/blog/ai-seo/ai-seo-la-guida-completa-per-dominare-la-ricerca-nel2025.md): Pillar completa AI SEO.
- [Query Fan-Out](https://davideminetti.it/blog/content-marketing/query-fan-out-dominare-lai-seo-con-larchitettura-pillar-cluster.md): Architettura Pillar-Cluster per AI Mode.
- [WebMCP](https://davideminetti.it/blog/ai-seo/webmcp-guida-implementazione-seo-ai.md): Implementazione operativa.
- [AI Agent Site UX](https://davideminetti.it/blog/ai-seo/ai-agent-site-ux-agent-experience-guida-definitiva-2026.md): Questa guida.

## Servizi
- [Consulenza SEO AI](https://davideminetti.it/servizi.md): Audit + roadmap GEO + AX.

## Optional
- [Contatti](https://davideminetti.it/contatti.md)
- [Chi sono](https://davideminetti.it/chi-sono.md)

La versione llms-full.txt espande ogni link includendo il contenuto markdown, utile per LLM che non possono effettuare fetch ricorsivi.

6.3 .well-known/agent-card.json (A2A protocol)

Il protocollo A2A (Agent-to-Agent), sviluppato da Google e donato alla Linux Foundation nel 2024, definisce un agent card discoverable a /.well-known/agent-card.json:

{
  "name": "DavideMinetti SEO Site Agent",
  "description": "Agente del sito davideminetti.it. Espone ricerca articoli, prenotazione consulenze e contatti.",
  "url": "https://davideminetti.it/api/agent",
  "version": "1.0.0",
  "capabilities": {
    "streaming": true,
    "pushNotifications": false,
    "stateTransitionHistory": false
  },
  "defaultInputModes": ["text", "application/json"],
  "defaultOutputModes": ["text", "application/json"],
  "skills": [
    {
      "id": "search_articles",
      "name": "Search articles",
      "description": "Cerca articoli sul blog di Davide Minetti per topic SEO o AI.",
      "tags": ["seo", "ai", "search"],
      "examples": [
        "Cerca articoli su query fan-out",
        "Articoli recenti su WebMCP"
      ]
    },
    {
      "id": "book_consultation",
      "name": "Book SEO consultation",
      "description": "Prenota una consulenza SEO/GEO da 30 o 60 minuti.",
      "tags": ["booking", "seo", "consulting"],
      "inputModes": ["application/json"],
      "outputModes": ["application/json"]
    }
  ],
  "authentication": {
    "schemes": ["Bearer"]
  }
}

Per la mappa completa dei sei protocolli agentici (MCP, A2A, NLWeb, WebMCP, ACP, UCP) consulta la Guida ai Protocolli AI Agentici.

6.4 .well-known/ucp-capabilities.json (Universal Cart Protocol)

UCP (Universal Cart Protocol) è lo standard Google + Shopify presentato all’NRF 2026. Espone capacità di e-commerce in formato machine-readable:

{
  "merchant": {
    "name": "Esempio Shop",
    "domain": "shop.example.com",
    "currency": "EUR",
    "country": "IT"
  },
  "capabilities": {
    "discovery": true,
    "cart": true,
    "checkout": true,
    "payment_methods": ["card", "shop_pay_agents", "ap2_mandate"],
    "shipping": true,
    "post_purchase": true
  },
  "endpoints": {
    "search": "https://shop.example.com/api/ucp/search",
    "cart": "https://shop.example.com/api/ucp/cart",
    "checkout": "https://shop.example.com/api/ucp/checkout",
    "order_status": "https://shop.example.com/api/ucp/orders/{id}"
  },
  "authentication": {
    "schemes": ["OAuth 2.1"],
    "scopes": ["ucp:read", "ucp:cart", "ucp:purchase:max:500eur"]
  }
}

7. Schema.org Action: il contratto delle azioni machine-readable

7.1 Action e PotentialAction: la differenza che cambia tutto

Action rappresenta un’azione realmente avvenuta o in corso (es. un ordine confermato).

PotentialAction rappresenta un’azione possibile (es. “qui puoi comprare questo prodotto”). È il vocabolo che segnala all’agente cosa può fare sulla pagina.

Sub-types rilevanti per AX:

  • BuyAction — acquisto.
  • OrderAction — ordine (per servizi/prenotazioni).
  • ReserveAction — riserva senza pagamento (es. tavolo ristorante).
  • SearchAction — ricerca interna del sito.
  • SubscribeAction — iscrizione (newsletter, abbonamento).
  • ChooseAction — selezione tra opzioni.
  • WatchAction — visualizzazione media.

Ogni Action ha un target di tipo EntryPoint che descrive come invocarla.

7.2 Esempio integrale: Product con BuyAction e ReserveAction

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Sedia ergonomica X1",
  "sku": "X1-BLK",
  "description": "Sedia da ufficio ergonomica con supporto lombare regolabile.",
  "image": "https://shop.example.com/images/x1-black.jpg",
  "brand": { "@type": "Brand", "name": "ErgoLab" },
  "offers": {
    "@type": "Offer",
    "price": "329.00",
    "priceCurrency": "EUR",
    "availability": "https://schema.org/InStock",
    "url": "https://shop.example.com/p/x1-black"
  },
  "potentialAction": [
    {
      "@type": "BuyAction",
      "target": {
        "@type": "EntryPoint",
        "urlTemplate": "https://shop.example.com/api/ucp/cart/add?sku={sku}&qty={qty}",
        "actionPlatform": [
          "http://schema.org/DesktopWebPlatform",
          "http://schema.org/MobileWebPlatform",
          "http://schema.org/IOSPlatform",
          "http://schema.org/AndroidPlatform"
        ],
        "httpMethod": "POST",
        "contentType": "application/json"
      },
      "result": { "@type": "Order" }
    },
    {
      "@type": "ReserveAction",
      "target": {
        "@type": "EntryPoint",
        "urlTemplate": "https://shop.example.com/api/ucp/reserve?sku={sku}",
        "httpMethod": "POST"
      },
      "result": { "@type": "Reservation" }
    }
  ]
}

Questo singolo blocco JSON-LD è ciò che manca completamente nell’articolo web.dev di riferimento. Esposto in <script type="application/ld+json">, dichiara all’agente:

“Su questa pagina puoi (a) comprare il prodotto chiamando POST a /api/ucp/cart/add, oppure (b) riservarlo senza addebito chiamando POST a /api/ucp/reserve.”

L’agente non ha bisogno di “indovinare” cliccando bottoni.

7.3 SearchAction sul sito

{
  "@context": "https://schema.org",
  "@type": "WebSite",
  "url": "https://davideminetti.it/",
  "potentialAction": {
    "@type": "SearchAction",
    "target": {
      "@type": "EntryPoint",
      "urlTemplate": "https://davideminetti.it/?s={search_term_string}"
    },
    "query-input": "required name=search_term_string"
  }
}

Una sola riga di codice ben fatta significa che ogni agente — Operator incluso — sa come eseguire una ricerca interna senza interpretare la barra di ricerca via screenshot.

7.4 Validazione e debug

Strumenti di verifica:

  • Schema.org Validator ufficiale.
  • Google Rich Results Test per verificare se Google riconosce le Action.
  • Estensione Chrome “Schema Markup Inspector”.
  • In CI: pa11y esteso o schema-dts (TypeScript types per schema.org).

Per applicazioni avanzate vedi la nostra Guida Schema Markup per AI e l’analisi completa di Structured Data e Rich Results AI-ready.


8. WebMCP: l’API browser-native per agenti in-page

8.1 Il livello superiore della contrattualità

Schema.org Action dichiara cosa si potrebbe fare. WebMCP permette all’agente di invocarlo direttamente in JavaScript, senza passare dal DOM.

Le specifiche WebMCP sono attualmente in Origin Trial su Chrome (registrazione tramite il programma di anteprima). Per la copertura tecnica completa abbiamo un’enciclopedia dedicata: la nostra Guida Definitiva a WebMCP. Qui, ti diamo solo l’esempio nuovo che si lega all’AX.

8.2 Esempio: book_consultation con idempotency

if (navigator.modelContext) {
  navigator.modelContext.registerTool({
    name: "book_consultation",
    description: "Prenota una consulenza SEO da 30 minuti con Davide Minetti.",
    inputSchema: {
      type: "object",
      properties: {
        date: {
          type: "string",
          format: "date",
          description: "Data desiderata (formato YYYY-MM-DD)"
        },
        topic: {
          type: "string",
          enum: ["audit", "strategia", "training", "ax-review"],
          description: "Argomento principale della consulenza"
        },
        email: {
          type: "string",
          format: "email",
          description: "Email per la conferma"
        }
      },
      required: ["date", "topic", "email"]
    },
    execute: async ({ date, topic, email }) => {
      const idempotencyKey = crypto.randomUUID();
      const res = await fetch("/api/book", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          "Idempotency-Key": idempotencyKey
        },
        body: JSON.stringify({ date, topic, email })
      });
      if (!res.ok) {
        const err = await res.json();
        return {
          success: false,
          error: err.error.code,
          retryable: err.error.retryable ?? false
        };
      }
      const data = await res.json();
      return {
        success: true,
        bookingId: data.id,
        confirmUrl: data.confirmUrl
      };
    }
  });
}

Tre osservazioni chiave:

  1. L’inputSchema è in JSON Schema: l’agente sa a priori che topic deve essere uno di quattro valori, niente test-and-learn.
  2. L’Idempotency-Key previene doppi booking se l’agente riprova.
  3. La risposta include retryable: l’agente sa se ha senso ritentare o se deve chiedere all’utente.

8.3 Differenza con MCP server “puro”

CaratteristicaMCP server (Anthropic spec)WebMCP (in-page)
Dove viveProcesso separato (locale stdio o remoto HTTP)Nel DOM della pagina, runtime browser
DiscoveryManuale (config.json del client)Automatica (l’agente vede il sito caricato)
PrivacyDati passano dal serverDati restano nel browser dell’utente
StatoCross-appSolo per la sessione del sito
Use caseTool persistenti (DB, Slack, Linear)Azioni della UI corrente (form, cart, search)

Operator e ChatGPT Agent gestiscono entrambi: i tool MCP “globali” dichiarati dall’utente, e i tool WebMCP esposti dalla pagina visitata.


9. Form agent-ready: idempotency, autocomplete e streaming

9.1 Form HTML: il check-list 2026

Ogni form deve rispettare:

  • <form action method enctype> esplicito — niente <form onSubmit={...}> senza fallback.
  • Ogni <input> con id, name, <label for>.
  • autocomplete standardizzato secondo WHATWG: email, tel, cc-number, cc-csc, cc-exp, bday, address-line1, postal-code, country.
  • pattern regex per validazione client-side.
  • aria-required, aria-invalid per stato.
  • <button type="submit"> (mai <div> simulato).

9.2 Esempio integrale di form contatto AX-Ready

<form
  action="/api/contact"
  method="POST"
  enctype="application/json"
  data-action="contact.send"
  data-agent-action="contact_form_submit"
  aria-label="Modulo di contatto"
  novalidate>

  <div class="field">
    <label for="contact-name">Nome e cognome</label>
    <input
      id="contact-name"
      name="name"
      type="text"
      autocomplete="name"
      required
      minlength="2"
      data-testid="contact-name"
      aria-required="true">
  </div>

  <div class="field">
    <label for="contact-email">Email</label>
    <input
      id="contact-email"
      name="email"
      type="email"
      autocomplete="email"
      required
      pattern="[^@\s]+@[^@\s]+\.[^@\s]+"
      data-testid="contact-email"
      aria-required="true"
      aria-describedby="contact-email-help">
    <p id="contact-email-help" class="help">
      Useremo l'email solo per rispondere alla tua richiesta.
    </p>
  </div>

  <div class="field">
    <label for="contact-message">Messaggio</label>
    <textarea
      id="contact-message"
      name="message"
      required
      minlength="20"
      maxlength="2000"
      data-testid="contact-message"
      aria-required="true"></textarea>
  </div>

  <button
    type="submit"
    data-testid="contact-submit"
    data-action="contact.send"
    data-agent-action="send_contact_message"
    aria-label="Invia messaggio di contatto">
    Invia messaggio
  </button>

  <div
    id="contact-status"
    role="status"
    aria-live="polite"
    aria-atomic="true"></div>
</form>

Sette elementi rendono questo form immediatamente utilizzabile da un agente:

  1. action/method/enctype espliciti per discovery senza JavaScript.
  2. autocomplete standardizzati.
  3. <label for> su ogni campo.
  4. pattern per validazione automatica.
  5. aria-required/aria-invalid per stato.
  6. data-action/data-agent-action per identificazione stabile.
  7. role="status" + aria-live="polite" per leggere il risultato.

9.3 Idempotency lato API (Express + Node)

import express from "express";
import { Redis } from "ioredis";

const app = express();
const redis = new Redis();

app.post("/api/contact", express.json(), async (req, res) => {
  const idem = req.header("Idempotency-Key");
  if (!idem) {
    return res.status(400).json({
      error: { code: "MISSING_IDEMPOTENCY_KEY", retryable: false }
    });
  }
  const cached = await redis.get(`idem:${idem}`);
  if (cached) {
    return res.status(200).json(JSON.parse(cached));
  }
  try {
    const result = await sendContactEmail(req.body);
    await redis.set(`idem:${idem}`, JSON.stringify(result), "EX", 86400);
    return res.status(200).json(result);
  } catch (err) {
    return res.status(502).json({
      error: { code: "EMAIL_PROVIDER_ERROR", retryable: true, retry_after: 30 }
    });
  }
});

Il pattern: 24 ore di cache della risposta indicizzata per Idempotency-Key. Se l’agente riprova, riceve la stessa risposta del primo tentativo — niente email duplicate.

9.4 Streaming SSE per task lunghi

Quando un task agentico richiede più di 5-10 secondi (es. “genera report SEO completo”), evitiamo i timeout con Server-Sent Events:

// Server (Node)
res.setHeader("Content-Type", "text/event-stream");
res.setHeader("Cache-Control", "no-cache");
res.setHeader("Connection", "keep-alive");

res.write(`event: progress\ndata: ${JSON.stringify({ step: 1, of: 4, label: "Crawling…" })}\n\n`);
// step 2…
res.write(`event: progress\ndata: ${JSON.stringify({ step: 2, of: 4, label: "Analyzing…" })}\n\n`);
// finale
res.write(`event: done\ndata: ${JSON.stringify({ status: "completed", reportUrl: "/r/abc" })}\n\n`);
res.end();

L’agente che riceve eventi progress capisce che il task è in corso e non va in timeout. Il pattern è uno dei più sottovalutati nei siti italiani.


10. Authentication & Payment Delegation per agenti

10.1 OAuth 2.1 con scope agent-aware

Un agente che agisce per conto dell’utente non deve mai ricevere credenziali brute. Il pattern corretto è OAuth 2.1 con scope espliciti per l’agente:

agent:read              → leggere dati pubblici e profilo
agent:cart              → modificare carrello, mai checkout
agent:purchase:max:200  → checkout fino a 200 € senza step-up
agent:profile:write     → modificare anagrafica
agent:booking           → prenotazioni con cancellazione gratuita

L’utente concede gli scope durante l’autenticazione iniziale (Device Flow è il preferito per agenti remoti). I token risultanti sono delegated tokens, firmati e revocabili.

10.2 Step-up authentication condizionato

Quando l’agente tenta un’azione oltre soglia (importo elevato, dati sensibili, profilo modificato), il sito risponde 403 Step-Up Required con un payload:

{
  "error": {
    "code": "STEP_UP_REQUIRED",
    "challenge": {
      "type": "webauthn",
      "publicKeyOptions": "...",
      "userVerification": "required"
    }
  }
}

L’agente sospende l’azione, notifica l’utente, attende che la passkey biometrica venga risolta sul dispositivo dell’utente, poi riprova con un nuovo Authorization-Step-Up token.

10.3 Lo stack pagamenti agentici 2026

Sei standard convivono in produzione nel 2026. Conoscerli — e dichiararli nel proprio sito — significa essere visibile agli agenti d’acquisto:

StandardVendor / consorzioScopeStato 2026
ACP (Agentic Commerce Protocol)OpenAI + Stripe (set 2025)Checkout standardizzato per ChatGPTLive, 1.000+ merchant
UCP (Universal Cart Protocol)Google + Shopify (NRF 2026)Lifecycle completo: discovery → checkout → post-purchaseLive, 1.5M+ Shopify merchant
AP2 (Agent Payments Protocol)Visa (ott 2025)Mandate Token cross-network firmato criptoLive, 100+ FI
x402Coinbase (2025)Micropagamenti USDC via HTTP 402Beta produzione
Shop Pay for AgentsShopifyWallet con delega agenteLive (Shopify ecosystem)
Mastercard Agent PayMastercard (fine 2025)Agentic Token + biometric step-upLive, integrato AP2
Stripe Agent ToolkitStripe (2025)SDK TypeScript/Python per delegated paymentsLive; $11B+ processati Q4 2025 [8]

In pratica, un sito e-commerce 2026 agent-ready dovrebbe:

  1. Esporre BuyAction schema.org (universale).
  2. Esporre /.well-known/ucp-capabilities.json (per Shopify-native agents).
  3. Accettare ACP per ChatGPT-driven purchase.
  4. Accettare AP2 mandate token per pagamenti firmati.
  5. Esporre WebMCP add_to_cart + checkout.

Per gli aspetti SEO/conversion vedi CRO e AI: massimizzare il tasso di conversione nell’era dell’intelligenza artificiale e l’approfondimento E-commerce SEO nell’era AI.

10.4 Captcha vs agenti legittimi

Il problema più sottovalutato del 2026: i CAPTCHA bloccano sia gli scraper malevoli sia gli agenti legittimi pagati dall’utente.

Soluzioni emergenti:

  • Cloudflare Turnstile con agent-mode=allow-known: riconosce User-Agent firmati come Operator/ChatGPT-User e li lascia passare.
  • reCAPTCHA Enterprise con low-friction agent attestation.
  • Header Sec-AI-Agent-Identity: un JWT firmato che gli agenti legittimi presentano per dichiarare la propria identità.

Pattern consigliato: applica CAPTCHA solo se manca Sec-AI-Agent-Identity valido, e il bot reputation è basso.


11. Performance Budget Agentico

11.1 Le metriche Core Web Vitals non bastano più

LCP, INP, CLS sono progettate per occhi umani. Per gli agenti propongo tre metriche parallele:

Metrica AXDefinizioneTarget buonoStrumento di misurazione
Agent LCPTempo dal navigationStart al primo nodo azionabile nell’a11y tree≤ 2.0 sLighthouse + custom audit
Agent INPLatenza da click programmatico (element.click()) a aria-busy=false o cambio stato≤ 150 msPlaywright agent harness
Agent DOM Score(#Actionable nodes / #Total DOM nodes) × 100≥ 8 / 100Custom Lighthouse plugin

Per le metriche Core Web Vitals classiche e la loro relazione con i ranking AI vedi la guida Core Web Vitals e AI Performance Optimization e l’analisi Page Speed Optimization per algoritmi AI-driven.

11.2 Streaming SSR vs CSR

Cattiva notizia per gli SPA puramente client-side: l’agente arriva in pagina, vede una white screen in attesa di hydration, fallisce.

Pattern produttivi 2026:

  • Streaming SSR (React Server Components, Next.js App Router): il DOM iniziale arriva già action-rich.
  • Astro / Qwik: zero JS di default, hydration on-demand.
  • HTMX / Hotwire per progressive enhancement.

Per la guida completa al rendering nelle SPA vedi JavaScript SEO per SPA.

11.3 Token Cost per Task (TCpT)

La metrica più sottovalutata. Un task ben strutturato costa $0.005; uno pessimo $0.10. Su 10.000 task/mese, è la differenza tra $50 e $1.000 di costo agente. I siti che danno costi alti agli agenti vengono deprioritizzati da OpenAI e Anthropic nei prossimi 12 mesi (segnale già emerso nei guidelines interni dei product team Operator/Computer Use).

Riduci il TCpT con: aria-label esaustivi, Schema.org Action, WebMCP, evita immagini come testo, niente DOM enormi (>1500 nodi).


12. Le 7 metriche AX e l’Agent Score

12.1 Le 7 metriche fondamentali

Coniamo per il mercato italiano sette metriche che misurano lo stato di salute della Agent Experience del tuo sito:

  1. Robot Success Rate (RSR) — % di task completati da un agente senza intervento utente. Target: ≥ 80% per task semplici (search, add-to-cart), ≥ 60% per task complessi (checkout multi-step).
  2. Robot Abandonment Rate (RAR) — % di sessioni agent che falliscono prima del completamento. Target: ≤ 15%.
  3. Time-to-Action (TTA) — secondi tra apertura pagina e prima azione utile dell’agente. Target: ≤ 3 s.
  4. Agent Conversion Rate (ACR) — conversioni completate da agenti / totale conversioni. Misura quota di mercato agentica; ne previsto crescita 5×-10× nel 2026-2027.
  5. A11y Tree Depth Score — profondità media degli interactive node nell’a11y tree (più piatto = più agent-friendly). Target: ≤ 6 livelli per le azioni primarie.
  6. Action Discoverability Index (ADI) — % di azioni “vere” della UX che sono dichiarate machine-readable (data-action / PotentialAction / WebMCP). Target: 100%.
  7. Token Cost per Task (TCpT) — token LLM consumati da un agente per completare un task. Target: ≤ $0.01 per task standard.

12.2 Agent Score: una formula proprietaria

Combiniamo le sette in un singolo indicatore aggregato:

Agent Score = 100 × [
  0.30 · RSR
+ 0.20 · (1 − RAR)
+ 0.15 · min(1, 3/TTA)
+ 0.10 · ADI
+ 0.10 · min(1, 0.01/TCpT)
+ 0.10 · normalizeAxDepth(A11yTreeDepth)
+ 0.05 · ACR_normalized
]

con:

  • RSR, RAR, ADI, ACR_normalized ∈ [0, 1]
  • TTA in secondi (più basso = meglio)
  • TCpT in dollari (più basso = meglio)
  • normalizeAxDepth(d) = max(0, 1 − (d − 4) / 10) (penalità sopra 4 livelli)

Soglia di benchmark suggerite per la fine del 2026:

  • < 50 → sito agent-blind (sparirà dalle ricerche transazionali AI).
  • 50-69 → agent-aware base.
  • 70-84 → agent-ready professionale.
  • ≥ 85 → agent-leader (1° quartile mondiale).

12.3 Strumenti di misurazione

  • Cloudflare AI Crawl Control — log e bot scoring per User-Agent agent.
  • GA4 / Plausible / Matomo con segmentazione per User-Agent (segmenti: ChatGPT-User, OAI-SearchBot, Operator, ClaudeBot, PerplexityBot).
  • Playwright agent harness — test sintetici settimanali su CI: simulano un agente che esegue 20 task tipici e misurano success rate.
  • Lighthouse plugin “Agent Score” — in roadmap pubblica per Q3 2026.
  • MCP Inspector — debug dei tool esposti.

Per il framework completo di misurazione SEO vedi Analisi dati SEO: misurare, tracciare e ottimizzare i risultati.


13. Framework e tool per agenti: confronto operativo

Cinque framework dominano il mercato browser-agent 2026. Ecco il confronto pratico per chi sta scegliendo:

ToolVendorLinguaggioModalità preferitaSuccess Rate (Mind2Web 2.0)Costo medio taskMCP supportOpen source
StagehandBrowserbaseTypeScript / PythonHybrid (a11y + DOM + screenshot)~58%$0.012SìSì
SkyvernSkyvern (YC)PythonVision-first + self-healing~52%$0.055ParzialeSì
Browser-UseOpen communityPython (LangGraph)DOM + a11y~49%$0.008SìSì
OpenAI Operator (Computer Use API)OpenAIAPIVision + click coords~38-45%$0.080-$0.10IndirettoNo
Anthropic Computer UseAnthropicAPI (computer_20241022)Vision + DOM hint~50% (Opus 4)$0.060Sì (nativo)No

Cinque osservazioni:

  1. Stagehand è oggi il framework con il miglior compromesso costo/precisione, soprattutto su siti AX-Ready che espongono a11y tree pulito.
  2. Operator ha il successo più basso ma la user reach più alta (è dentro ChatGPT consumer).
  3. Computer Use di Anthropic — nelle ultime release Opus 4 — ha pareggiato il gap di success rate.
  4. Browser-Use è l’opzione più economica per agenti enterprise self-hosted.
  5. Skyvern vince quando il sito non può essere migliorato e bisogna fare reverse-engineering pesante.

Per chi gestisce un sito: rendere il sito AX-Ready alza il success rate di tutti i framework di un 10-25% e abbatte il costo per task del 60-80%. È il classico investimento one-and-done che paga su tutti i canali.


14. Anti-pattern: 10 pratiche che uccidono la Agent Experience

Una lista nera concreta delle pratiche oggi popolari ma killer per l’AX:

  1. Infinite scroll senza lazy boundary — l’agente non sa dove fermarsi e brucia token. Soluzione: aria-live che annuncia fine dei risultati, paginazione classica come fallback.
  2. Cookie banner che bloccano <body> — overlay che cattura ogni click sotto. Soluzione: banner non-blocking che permette navigazione anche prima del consenso (modello “Soft Wall” + log delle interazioni in attesa di consenso).
  3. Hover-only menus — l’agente in screenshot mode non li vede mai aperti. Soluzione: equivalente accessibile via aria-haspopup e click toggle.
  4. JS-rendered prices — il prezzo arriva con useEffect 800ms dopo. Soluzione: prezzo nel HTML iniziale (SSR/SSG) e dataset sull’elemento (data-price="329.00").
  5. Modali inert mal configurati — inert sul <main> quando è aperta una modale, ma manca aria-modal sulla modale stessa. L’agente si confonde.
  6. CAPTCHA v2 invisibile — challenge nascosto che blocca silenziosamente. Soluzione: Turnstile / reCAPTCHA Enterprise con agent-mode=allow-known.
  7. Tailwind dynamic classes — bg-${color}-${shade} interpolato → classi che cambiano a ogni deploy. Soluzione: data-action/data-testid indipendenti dalle classi.
  8. Form senza <label for> — il placeholder non basta; sparisce quando l’utente digita. Soluzione: label esplicita sempre.
  9. Toast che spariscono in 3 secondi — l’agente in DOM mode non fa in tempo a leggerli. Soluzione: toast persistenti con role="status" e dismissal manuale.
  10. Bot detection aggressivo su tutti i traffic non-browser — blocca anche Operator e ChatGPT Agent legittimi. Soluzione: bot scoring graduato + allow-list per User-Agent firmati.

15. GDPR e Compliance per agenti AI

15.1 Articolo 22 GDPR e decisioni automatizzate

L’art. 22 GDPR vieta decisioni interamente automatizzate che producano effetti giuridici significativi sull’utente, salvo eccezioni (consenso esplicito, contratto, autorizzazione legge). Quando un agente decide al posto dell’utente — es. sceglie un volo, esegue un pagamento — questa norma diventa rilevante.

Mitigazioni operative:

  • L’utente concede consenso esplicito all’agente per categorie specifiche di azione (analoghe agli scope OAuth visti al Cap. 10).
  • L’agente fornisce un resoconto pre-azione (“Sto per acquistare X a 89 €. Confermi?”) per le azioni con effetti giuridici.
  • Il sito mantiene un audit log di tutte le azioni delegate, accessibile all’utente per 6+ mesi.

15.2 DPIA — Data Protection Impact Assessment per AX

Per siti che processano un volume significativo di interazioni agentiche (>10.000 task/mese su dati personali), la DPIA è raccomandata. Sezioni minime:

  1. Categorie di dati personali coinvolti.
  2. Identità dell’agente (zero-party / first-party / third-party).
  3. Finalità di trattamento e basi giuridiche.
  4. Trasferimenti extra-UE (es. server MCP ospitati su infrastruttura US).
  5. Misure tecniche e organizzative (cifratura, rotazione token, scope minimi).
  6. Diritti dell’interessato (revoca consenso, export, cancellazione).

15.3 Data residency e MCP server

Se esponi un MCP server di produzione, l’hosting dentro l’UE (e meglio in IT/DE/FR) semplifica drasticamente la compliance. Anthropic, Google e OpenAI offrono region-pinned endpoint EU dal 2025.

Per la guida E-E-A-T integrata vedi E-E-A-T nell’era dell’AI e per la sicurezza brand SERP la nostra Guida Brand SERP Optimization.


16. Mini case study: audit della pagina /servizi di davideminetti.it

Per dimostrare il framework su un caso reale, abbiamo eseguito un audit AX before/after sulla pagina /servizi del sito.

16.1 Stato iniziale (before)

MetricaValore
Agent DOM Score4.2 (su 100 nodi totali, ~4.2 azionabili)
ADI (Action Discoverability Index)38%
A11y Tree Depth9 livelli (CTA “Contattami” raggiungibile dopo 9 hop)
TCpT (Stagehand)$0.022
RSR su 5 task tipici60%

Problemi principali rilevati:

  • CTA “Prenota una consulenza” wrapped in <div onclick>, non <button>.
  • Schema.org presente solo come Service senza PotentialAction.
  • Nessun data-agent-action sui CTA.
  • <form> di contatto senza autocomplete standardizzati su tutti i campi.
  • Cookie banner che blocca click sotto i 700ms.

16.2 Interventi applicati

  1. Sostituiti tutti i <div onclick> con <button data-action data-agent-action aria-label>.
  2. Aggiunto JSON-LD Service + PotentialAction (ContactAction, ReserveAction).
  3. Ristrutturato form contatto con autocomplete standard, aria-required, pattern, idempotency-key.
  4. Implementato aria-live sul box di conferma invio.
  5. Aggiunto /llms.txt e /.well-known/agent-card.json.
  6. Cookie banner ristrutturato in modalità non-blocking con consenso retroattivo.

16.3 Stato finale (after)

MetricaBeforeAfterΔ
Agent DOM Score4.29.1+117%
ADI38%96%+153%
A11y Tree Depth95−44%
TCpT (Stagehand)$0.022$0.008−64%
RSR su 5 task tipici60%92%+53 pp
Agent Score totale4886+79%

Il salto da Agent Score 48 (agent-blind) a 86 (agent-leader) è stato ottenuto in 3 ore di lavoro su una singola pagina. Il pattern è ripetibile su tutto il sito.


17. Roadmap operativa: 21 passi in 90 giorni

Fase 1 — Audit e baseline (giorni 1-15)

  1. Mappa tutte le pagine “azionabili” del sito (form, checkout, search, booking).
  2. Esegui Lighthouse + estensione Schema Markup Inspector.
  3. Calcola le 7 metriche AX baseline su 10 task tipici.
  4. Identifica i top-10 anti-pattern presenti.
  5. Pubblica un foglio di calcolo con il punteggio per pagina.

Fase 2 — Quick wins semantici (giorni 16-30)

  1. Sostituisci tutti i <div onclick> con <button> o <a href>.
  2. Aggiungi aria-label su ogni icon-only button.
  3. Connetti <label for> a tutti gli input.
  4. Aggiungi cursor: pointer su tutti gli elementi cliccabili.
  5. Standardizza autocomplete sui form.

Fase 3 — Identifier deterministici (giorni 31-45)

  1. Definisci convenzione naming dominio.verbo per data-action.
  2. Annota i top-50 elementi azionabili con data-action/data-agent-action/data-testid.
  3. Aggiungi test E2E in CI che verifica la stabilità degli identifier.
  4. Documenta gli action verb in /docs/agent-actions.md.

Fase 4 — Schema.org Action (giorni 46-60)

  1. Pubblica WebSite + SearchAction sito-wide.
  2. Pubblica Service + PotentialAction su pagine servizio.
  3. Pubblica Product + BuyAction su pagine prodotto.
  4. Pubblica Article + ReadAction su articoli blog.

Fase 5 — File well-known (giorni 61-75)

  1. Pubblica /llms.txt e /llms-full.txt.
  2. Pubblica /.well-known/agent-card.json (A2A) e, se applicabile, /ucp-capabilities.json.

Fase 6 — WebMCP e telemetria (giorni 76-90)

  1. Implementa WebMCP per le 5 azioni più frequenti del sito + dashboard di monitoring delle 7 metriche AX in GA4 / Plausible.

FAQ — Domande frequenti sulla Agent Experience

Perché si chiama “Agent Experience” e non “Agent UX”?

Per analogia con la coppia “User Experience / User Interface”: l’esperienza dell’agente non si esaurisce nell’interfaccia visibile. Include il contratto pubblico (schema, file well-known), la API (WebMCP, MCP server), la telemetria post-azione. AX = UX + protocollo + telemetria.

La AX cannibalizza il SEO classico?

No, la amplifica. Un sito AX-Ready è già:

  • Semanticamente perfetto → ranking SEO migliore.
  • Accessibile WCAG 2.2 AA → fattore di ranking documentato.
  • Schema.org-ricco → migliori rich results.
  • Veloce → migliori Core Web Vitals.

L’overlap con la SEO/GEO classica è > 70%.

Devo implementare TUTTO o posso partire da un sottoinsieme?

Parti dai quick wins (giorni 1-30 della roadmap): HTML semantico, ARIA basic, <label for>, autocomplete. Sono reversibili, gratis e portano già il 50% del beneficio. Poi aggiungi schema.org Action, deterministic identifiers, WebMCP solo dove ha senso strategicamente (pagine transazionali).

Quanto costa un audit AX professionale?

Indicativamente, per un sito di medie dimensioni (≤ 50 pagine azionabili): 8-15 giorni-uomo. ROI medio osservato: il costo si recupera in 4-7 mesi tramite (a) riduzione TCpT, (b) Agent Conversion Rate aggiuntivo, (c) ranking SEO classico.

Il mio sito è in WordPress: cosa posso fare subito?

Tre azioni immediate:

  1. Plugin Schema Pro / Yoast SEO Premium con Action types abilitati.
  2. Tema con HTML semantico (Astra, GeneratePress, Kadence) — evitare temi “page builder” pesanti.
  3. Header injection per /llms.txt (plugin “Custom Post Type UI” + endpoint custom oppure functions.php).
  4. Snippet WebMCP nel functions.php come mostrato nella nostra Guida WebMCP.

Come distinguo un agente legittimo da uno scraper malevolo?

Tre segnali combinati:

  • User-Agent dichiarato (es. ChatGPT-User/1.0 (+https://openai.com/bot)).
  • Header Sec-AI-Agent-Identity (JWT firmato dal vendor).
  • Bot reputation (Cloudflare AI Crawl Control, Datadome, Akamai Bot Manager).

Se almeno due su tre sono positivi, lascia passare.

La AX ha un impatto sul GEO (Generative Engine Optimization)?

Sì, decisivo. Gli AI Overviews di Google e ChatGPT Search citano siti che (a) sono semanticamente comprensibili e (b) hanno azioni machine-readable. Schema.org Action aumenta la probabilità di apparire come citazione + azione cliccabile in AI Mode. Vedi anche la Guida agli AI Overviews.

Quale framework agent dovrei testare per primo?

Per chi gestisce un sito (lato test): Stagehand (Browserbase) — open source, TypeScript, ottimo bilanciamento. Per chi vuole capire come Operator vede il proprio sito: OpenAI Computer Use Preview API in playground. Per chi vuole self-hosting Python: Browser-Use.

Cosa succede se ignoro l’AX?

Probabilmente nulla nel breve termine (i siti agent-blind oggi rappresentano l’80% del web). Ma nei prossimi 12-24 mesi, secondo le stime Cloudflare e Stripe, 5-15% del traffico transazionale passerà attraverso agenti. Restare agent-blind significa perdere quella quota — e in alcune verticali (e-commerce, travel, food delivery) può salire al 25%.

La AX richiede un team dedicato?

No. Il 90% delle pratiche è incrementale e si distribuisce tra: front-end developer (HTML semantico, ARIA, deterministic identifiers), back-end developer (idempotency, scoped OAuth), SEO specialist (schema.org, llms.txt), UX designer (visibilità azioni, layout stability). Il vero ruolo nuovo è quello dell’Agent Experience Lead, figura emergente ibrida UX+SEO+DevOps che probabilmente diventerà standard nel 2027.

Quanto durerà la finestra di vantaggio competitivo?

Storicamente, le finestre di vantaggio sui fundamentals semantici del web (responsive design 2010, schema.org 2013, Core Web Vitals 2020) durano 18-30 mesi prima della maturazione di mercato. L’AX è entrata nella fase early-majority a inizio 2026: chi parte ora ha circa 12-18 mesi di lead operativo.

Esiste un certificato o badge “AX-Ready”?

Non ancora ufficiale. agent-experience.org sta lavorando a un’autovalutazione pubblica (atteso H2 2026); Cloudflare ha annunciato un Agent Score in beta integrabile in Lighthouse; sherlock.dev offre un audit a pagamento. Per ora il riferimento più affidabile resta un audit manuale strutturato come la nostra roadmap del Cap. 17.


Glossario AX 2026

  • A2A — Agent-to-Agent protocol, standard Google + Linux Foundation per scoperta e comunicazione tra agenti.
  • ACP — Agentic Commerce Protocol, OpenAI + Stripe.
  • Accessibility tree — albero distillato del DOM con solo elementi semanticamente rilevanti, calcolato dal browser.
  • Agent-card.json — file .well-known che dichiara skill e capabilities di un agente esposto dal sito.
  • Agent Conversion Rate (ACR) — quota di conversioni completate da agenti AI sul totale.
  • Agent Experience (AX) — disciplina di design che ottimizza un sito per la fruizione di agenti AI autonomi.
  • Agent Score — punteggio aggregato 0-100 calcolato dalle 7 metriche AX.
  • AP2 — Agent Payments Protocol di Visa, mandate token cross-network.
  • ARIA agentico — uso di attributi ARIA (aria-busy, aria-live, ecc.) per dichiarare stati dinamici agli agenti.
  • Browser agent — agente AI che opera dentro un browser headless o controllato.
  • Computer Use — modalità in cui l’agente controlla mouse/tastiera/schermo (Anthropic, OpenAI Operator).
  • Deterministic identifier — attributo HTML stabile tra deploy (data-action, data-testid, data-agent-action).
  • EntryPoint — sub-tipo schema.org che descrive come invocare un’azione (URL template, metodo HTTP).
  • Idempotency key — chiave univoca che garantisce che un’operazione duplicata non produca effetti duplicati.
  • llms.txt — file Markdown a /llms.txt con mappa curata del sito per LLM.
  • MCP — Model Context Protocol di Anthropic, standard per esporre tool a LLM.
  • NLWeb — Natural Language Web di Microsoft, endpoint /ask con risposte schema.org-typed.
  • PotentialAction — schema.org sub-tipo che dichiara un’azione possibile su un’entità.
  • RAR — Robot Abandonment Rate.
  • RSR — Robot Success Rate.
  • TCpT — Token Cost per Task.
  • TTA — Time-to-Action.
  • UCP — Universal Cart Protocol di Google + Shopify.
  • WebMCP — estensione browser-side di MCP, espone tool al navigator.modelContext.
  • x402 — protocollo Coinbase per micropagamenti USDC via HTTP 402.

Conclusione: il web ha bisogno di una nuova disciplina

L’Agent Experience non è una moda passeggera né l’ennesima sigla del settore. È la conseguenza naturale di un cambiamento profondo: il visitatore tipico del web nei prossimi 24 mesi smetterà di essere solo umano.

Il sito che continuerà a essere ottimizzato esclusivamente per occhio umano sarà tagliato fuori dalle ricerche transazionali AI, dai checkout via ChatGPT/Operator, dagli AI Overviews che richiedono PotentialAction per linkare alle azioni cliccabili. Il sito che invece adotta i 20 principi di questa guida — gli 8 di base introdotti da web.dev più i 12 avanzati che proponiamo come standard professionale — sarà:

  • Più veloce (DOM più snello).
  • Più accessibile (semantica perfetta).
  • Più convertente (azioni dichiarative chiare).
  • Più economico da servire (token agent ridotti del 60-80%).
  • Più citato dagli AI Overviews / AI Mode / ChatGPT Search.

Tre principi guida da portarti via:

  1. Trattare l’agente come un nuovo utente di prima classe — al pari del mobile user del 2010.
  2. Ottimizzare l’a11y tree prima dello screenshot — è la modalità più economica e più consultata.
  3. Misurare con le 7 metriche AX — RSR, RAR, TTA, ACR, A11y Tree Depth, ADI, TCpT — e tracciare l’Agent Score mese su mese.

La buona notizia: ogni euro/ora investito qui paga su tutti i canali contemporaneamente. Una sola implementazione, quattro audience servite (umani con assistive tech, umani normodotati, motori di ricerca classici, agenti AI).

Call to Action

Vuoi sapere quanto vale il tuo Agent Score di partenza?

Non aspettare il 2027 per scoprire che il 15% del traffico transazionale arriva da agenti che il tuo sito non sa servire. Il tempo per mettersi in posizione è adesso.


Riferimenti

[1] OpenAI. Operator System Card. Gennaio 2025. https://openai.com/index/operator-system-card

[2] Kulikowski K., More O. Build agent-friendly websites. web.dev, 1 aprile 2026. https://web.dev/articles/ai-agent-site-ux

[3] Browserbase. Stagehand benchmarks: cost and accuracy comparison across browser agent modes. 2025. https://www.browserbase.com/blog/stagehand-benchmarks

[4] Klepper J., Kulikowski K., Nabors A. AI agents on the web. web.dev, 25 febbraio 2025. https://web.dev/articles/ai-agents

[5] Google. The accessibility tree. web.dev. https://web.dev/articles/the-accessibility-tree

[6] Mind2Web 2.0 / OSU & UIUC. Towards a Generalist Agent for the Web. 2024-2025. https://osu-nlp-group.github.io/Mind2Web

[7] Howard J. llms.txt — a proposal to standardize how websites brief LLMs. answer.ai, settembre 2024. https://llmstxt.org

[8] Stripe. Stripe Sessions 2026: agentic commerce keynote. https://stripe.com/sessions

[9] Anthropic. Model Context Protocol — Specification 2025-11-25. https://modelcontextprotocol.io/specification/latest

[10] W3C Web Machine Learning CG. WebMCP polyfill. https://github.com/webmachinelearning/webmcp

[11] Visa. Agent Payments Protocol (AP2). Ottobre 2025. https://corporate.visa.com/en/sites/visa-perspectives/innovation/agent-payments-protocol.html

[12] Coinbase. x402: HTTP 402 Payment Required for the agentic web. 2025. https://www.coinbase.com/x402

[13] Cloudflare. AI Crawl Control: bot scoring and agent identity. 2025-2026. https://developers.cloudflare.com/ai-crawl-control/

[14] WHATWG HTML Living Standard. Autofill — autocomplete attribute. https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#autofill

[15] WCAG 2.2. Target Size (Minimum) — Success Criterion 2.5.8. W3C, 2023. https://www.w3.org/TR/WCAG22/#target-size-minimum

Davide Minetti

Davide Minetti

Consulente SEO a Perugia: aiuto aziende ed eCommerce a crescere su Google e nelle risposte delle AI, partendo sempre dall'analisi dei dati.

Chi sono · LinkedIn

Parliamo del tuo progetto.

Consulenza gratuita e senza impegno: analizzo il tuo sito e ti mostro le opportunità che non stai ancora sfruttando. Rispondo personalmente entro 24 ore.