Tag: AI Agents

How to Prepare for Google Search as a Task-Completing Agent

If your SEO strategy ends when somebody clicks a result, you are preparing for an older version of Search. A task-completing system may use your content to compare options, resolve constraints, choose a next step and initiate an action. Your page is no longer competing only to be read. It is competing to be useful inside a larger job.

This does not mean abandoning rankings, traffic or conventional SEO. It means adding a second standard: can Google understand what your business offers, determine when it is appropriate and move a user toward a safe, verifiable outcome?

The search result is becoming part of the workflow

Traditional search usually separates discovery from execution. You search for information, open several pages, make sense of them and complete the task somewhere else. Agentic search compresses those stages. Google’s stated direction is for more information-seeking queries to become agentic, with Search coordinating long-running work and multiple concurrent threads.

Think about a request such as, “Find accounting software suitable for a small Canadian consultancy, compare the plans and help me arrange a demonstration.” An ordinary results page can supply links for each part. A task-oriented system has to preserve the user’s requirements while it researches vendors, rules out unsuitable choices, explains trade-offs and hands the user into an action.

That changes the unit of optimization. A keyword is one expression of demand. A task includes the desired outcome, the constraints, the decisions that must be made, the evidence needed to make them and the action that finishes the job.

Question: What does the user need to know?
Qualification: Which options fit the user’s location, situation, budget, timing or technical requirements?
Decision: What evidence separates an appropriate choice from an inappropriate one?
Action: What can the user book, buy, configure, submit or request?
Verification: How does the user know the action succeeded, and how can it be changed or reversed?

People are already using AI Mode for deep-research queries that stretch beyond the old one-query, one-answer pattern. That is the immediate signal to act on. You do not need to predict every interface Google will release. You need to make your public information dependable enough to support a multi-step decision.

Search and Gemini are also expected to coexist, overlapping in some uses while diverging in others. Do not reduce your plan to optimizing for one chatbot response. Your information may be encountered through a conventional result, an AI-generated answer, a research workflow or an action-oriented experience. The underlying facts should remain consistent across all of them.

Optimize the complete task, not just its opening query

An isometric workflow follows a user request through comparison, constraint checking, availability, verification, and a completed outcome.

Start with one task that matters to your audience and your business. Avoid broad goals such as “learn about payroll” or “rank for payroll software.” Use an observable outcome: “Determine whether this payroll service supports my type of company and begin the correct signup process.”

Then create a task map. This is more useful than a keyword cluster because it exposes the information gaps that can stop an agent or a person from proceeding.

Write the outcome in the user’s language. State what will be decided or completed, not what content will be consumed.
List the required inputs. Identify the details that change the answer, such as location, organization type, compatibility, eligibility, timing or service area.
Break out the decisions. Record every choice the user must make before acting. A product tier, appointment type or implementation route may each require a separate decision.
Assign evidence to each decision. Decide which page supplies the specification, policy, price, limitation, comparison or proof needed at that point.
Define the action and handoff. Make clear where the user can start, what information will be requested and what happens after submission.
Document failure and recovery paths. Explain what to do when the user is ineligible, an option is unavailable, a form fails or an action must be cancelled.

The recovery path matters because task completion is not the same as pushing every visitor toward conversion. A reliable system must also recognize when your offer does not fit. If exclusions are buried in terms, an agent may recommend the wrong route and the user will discover the problem late. Put decisive limitations beside the claims they qualify.

Next, label the role of every page in the task. One page may establish eligibility, another may compare options, another may explain a procedure and another may host the transaction. A page can serve more than one role, but each role should be explicit. If your team cannot agree on what a page contributes to the task, an automated system is unlikely to infer it reliably.

Build pages an agent can interpret and use

An agent-ready page is not a page written for robots. It is a page on which the decisive facts are clear, scoped and consistent. Good structure helps people and machines for the same reason: neither should have to reconstruct a critical condition from vague marketing language.

Task layer	What must be resolved	What to improve on the site
Intent	The outcome the page supports	Use a descriptive title, a direct opening answer and a clear statement of who the page is for.
Qualification	Whether the offer fits the user’s constraints	State eligibility, locations, dependencies, exclusions and prerequisites beside the relevant offer.
Decision	Why one option should be chosen over another	Use comparable attributes, defined terms and evidence tied to specific claims.
Action	How to begin or complete the next step	Name the action precisely, disclose required inputs and explain what happens after it is submitted.
Verification	Whether the action succeeded	Provide an explicit confirmation state, reference information and a route for correction or cancellation.
Machine interpretation	Which entities and relationships the content describes	Use accurate structured data that matches the visible page and the site’s canonical facts.

Several practical rules follow from this model.

Put the decisive answer before the supporting narrative

If a service is available only in particular locations, say that near the service description. If a plan requires another product, state the dependency beside the plan. If the next step is a consultation rather than an immediate purchase, label it accurately. Do not make the reader decode “Get started” to discover what will actually happen.

Turn implied knowledge into explicit facts

Businesses often assume that visitors understand their terminology, market, service boundary or product hierarchy. An agent cannot safely rely on that assumption. Define ambiguous terms, attach units to measurements, give conditions to claims and distinguish facts about the company from facts about a particular offer.

Consistency is more important than repetition. If a product name, service area, policy or plan description differs across a landing page, help page and checkout flow, decide which version is canonical and correct the others. Structured data should reflect that same version.

Use JSON-LD as a factual layer, not a persuasion layer

Choose Schema.org types and properties that match what is visibly present. Identify the organization, offer, product, service, person, place or event only when the page genuinely describes that entity. Connect related entities where the relationship is real. Keep names, URLs, identifiers and offer details aligned with the canonical content.

Do not add unsupported properties because they look advantageous, and do not mark up claims that a visitor cannot verify on the page. JSON-LD can make a fact easier to interpret; it cannot turn an incomplete, stale or contradictory claim into a trustworthy one.

Design the action boundary deliberately

Research and execution carry different risks. Reading a comparison is low commitment. Sending personal information, placing an order or booking an appointment is not. If your task ends in an action, make the commitment point unmistakable.

Show what will be submitted or purchased before confirmation.
Separate required inputs from optional ones.
Display material conditions before the final action, not only after it.
Explain whether the action is immediate, pending review or merely a request.
Provide a correction, cancellation or support route where the action permits one.
Return a clear success or failure state instead of leaving the user to infer the result.

These are conversion fundamentals, but they become more important when software may coordinate the handoff. Ambiguous buttons, silent form failures and hidden conditions do not merely reduce conversion. They make the task unsafe to delegate.

Audit task readiness before agent traffic becomes measurable

A digital inspection agent scans the modular elements of a webpage while a human specialist supervises from a control station.

You may not be able to isolate every agent-assisted visit or decision in your reporting. You can still measure whether your site is ready to participate. Treat readiness as a content, data and workflow quality problem.

Use a simple zero-to-two audit for each important task. This is a prioritization method, not a search-engine score:

0 — Missing or contradictory: the task cannot proceed without guessing, or two public pages give incompatible answers.
1 — Inferable: the answer exists, but the user must combine pages, interpret vague wording or uncover a condition late.
2 — Explicit and usable: the answer is clear, appropriately qualified, current and connected to the correct next step.

Score the task across six dimensions: outcome definition, qualification facts, decision evidence, action path, confirmation or recovery, and measurement. Do not obsess over the total. A zero in any dimension identifies a broken link in the workflow and deserves attention before cosmetic content changes.

Run the audit from the public site, without internal knowledge. Give a team member the task and its constraints. Ask them to find the right option, explain why it fits, begin the action and identify how they would reverse or correct it. Record every point where they have to guess. Those guesses become your content and workflow backlog.

Measure the workflow in stages so a completed task is not reduced to a pageview:

Discovery: Did the relevant landing page become visible for the task?
Qualification: Did the visitor reach the eligibility, specification, policy or comparison information needed to proceed?
Action: Did the visitor start and complete the intended form, booking, configuration or transaction?
Failure: Where did validation errors, unavailable options or unclear requirements stop progress?
Outcome quality: Did the action lead to confirmation, or did it create cancellations, corrections and avoidable support work?

This measurement model also protects you from a misleading success signal. More action starts are not helpful if users are being routed into an unsuitable option. Pair completion data with failure, cancellation and correction data so you can distinguish task volume from task quality.

Key takeaways

Optimize for a defined user outcome, not only the keyword that begins the journey.
Map qualification, decision, action and verification as separate stages, then assign each stage to reliable public information.
State decisive constraints beside the claims they limit. Do not hide eligibility, dependencies or exclusions at the end of the path.
Keep visible content, structured data and transactional interfaces consistent about the same entities and offers.
Treat confirmation, correction and cancellation as part of task completion, not as support details.
Audit every task for missing or contradictory information before trying to infer performance from agent-specific traffic.

Choose one commercially important task this week. Write its outcome, inputs, decisions, evidence, action and recovery path on a single page. Then follow it through your public site and fix the first place where a user has to guess. That work will improve the experience now, while giving agentic Search cleaner material to use as it moves from answering questions toward completing jobs.

References

Search Engine Land — Sundar Pichai: Google Search will become an agent manager

April 7, 2026

Is Your Website Ready for AI Agents? A Practical Audit

You can have a fast, attractive website that still leaves an AI system guessing. A person may work around a price that appears late, two conflicting policy pages, an unlabeled button, or a confirmation shown only through a visual change. A machine may stop, cite the wrong fact, or repeat an action because it cannot tell whether the first attempt worked.

The goal is not to rebuild your site for bots at the expense of people. It is to make public information retrievable, meaning explicit, and actions safely bounded. That is the practical response to the shift toward machine-led website visits. This audit shows you where to look and what a passing result should look like.

Audit the journey, not the bot name

Agent readiness is broader than allowing a particular crawler through robots.txt. An AI search system may retrieve a page to answer a question, compare facts across pages, send a person to a landing page, or help a signed-in user complete a task. Each journey fails differently.

Start with the intent that matters, then follow it from request to outcome. Choose priority journeys from three groups: finding an answer, making a decision, and taking an action. Write the expected result before you test so that a plausible but incorrect response does not pass by accident.

Journey	What the machine needs	What failure looks like
Answer or cite	A public, stable page with a direct answer and enough context to interpret it	The answer is absent from the retrieved HTML, buried in an image, or contradicted elsewhere
Compare and decide	Consistent names, identifiers, attributes, prices, conditions, and limitations	The same offer has different facts across the page, structured data, and linked policies
Act and confirm	Clearly labeled controls, explicit prerequisites, bounded permissions, and a machine-readable result	The agent cannot identify the correct control, understand an error, or confirm whether the action succeeded

For each journey, name the authoritative page, the facts that must be preserved, the actions that are permitted, and the state that proves completion. This turns an abstract AI-readiness project into a set of testable requirements.

Make important pages retrievable without guesswork

A page is not agent-ready merely because it looks correct in your browser. Your browser may have cookies, cached scripts, a logged-in session, and enough processing time to assemble the page after the initial response. A fresh machine client may have none of those advantages.

Test every priority URL from a clean, logged-out session. Inspect the returned HTML as well as the rendered screen. The page title, primary heading, main answer, relevant entity name, and essential links should be available without requiring a person to reveal them through hover effects, tabs, or visual-only controls. When a fact is central to the page, do not assume every client will execute and wait for the same JavaScript path as a full browser.

Confirm that the preferred URL returns a successful response and does not enter a redirect loop, soft-error state, consent loop, or challenge page.
Review robots.txt, meta robots directives, and the X-Robots-Tag together. An accidental conflict can make an otherwise public page unavailable. Robots directives are discovery instructions, not security controls, so private information still belongs behind real authentication.
Use one canonical URL for each primary resource. Internal links, canonical tags, redirects, and the XML sitemap should agree on that URL.
Keep the sitemap focused on live, canonical pages that you actually want discovered. Remove obsolete, redirected, private, and erroring URLs rather than asking machines to sort through them.
Link important pages through ordinary crawlable navigation. Descriptive link text such as “Enterprise pricing” carries more meaning than repeated links labeled “Learn more.”
Provide an HTML version of essential facts that otherwise live only in an image, video, downloadable document, or interactive widget.
Test firewall, bot-management, content-delivery, and rate-limit rules with a fresh client. Record whether a failure comes from the application or from an infrastructure layer in front of it.
Never weaken authentication to make an agent test pass. Keep protected data protected and expose only the public information or authorized interface the task genuinely requires.

A useful retrieval record includes the requested URL, response status, final URL after redirects, declared canonical, applicable robots directives, and whether the required facts appeared in the response. A screenshot can confirm appearance, but it cannot replace those checks.

Make the page’s meaning explicit in content and JSON-LD

An abstract machine agent connects directly to a central web page shown in visible-content, semantic, and linked-data layers within an orderly site structure.

Once a machine can retrieve a page, it still has to identify what the page describes and which claims belong together. Ambiguity usually enters through inconsistent naming, missing qualifiers, stale duplicates, and structured data that says something different from the visible page.

Give each priority page a clear job. Put the direct answer near the point where the page establishes the question or offer, then supply the evidence, conditions, and alternatives a reader needs. Do not force the machine to combine fragments from a feature grid, tooltip, footer, and separate policy page just to understand the basic proposition.

Name the entity in full before relying on abbreviations or pronouns. If two products, locations, plans, or organizations have similar names, state the distinction on the page.
Attach qualifiers to the claim they modify. Geography, currency, billing period, eligibility, availability, effective date, tax treatment, shipping limits, and plan restrictions should not be left to implication.
Use stable identifiers where your operation already has them, such as a product code, plan name, location identifier, or internal service name. Keep the same identifier across templates, feeds, and structured data.
Choose an authoritative home for reusable facts such as the legal organization name, support contact, returns policy, or service-area definition. Other pages should link to or consistently reproduce that truth.
Update, redirect, remove, or clearly label stale pages. Two accessible pages that make incompatible claims create an interpretation problem even when only one appears in navigation.
Show ownership and maintenance information where it helps a reader judge the claim, such as an author, responsible team, publication date, or last reviewed date. Do not add decorative dates that are unrelated to a substantive review.

Use JSON-LD to restate and connect meaning that is already visible. Select the most specific appropriate schema type for the resource, such as Organization, Product, Service, Article, or BreadcrumbList. Treat the type as a description of the actual page, not as a keyword target.

Make names, URLs, prices, availability, dates, and identifiers agree with the visible content.
Give important entities stable @id values and reuse those identifiers when another object refers to the same entity.
Connect related objects deliberately. An article’s publisher, a product’s brand, and a service’s provider should resolve to the organization you actually mean.
Include only properties you can support and maintain. An empty or guessed field adds ambiguity rather than clarity.
Validate syntax after template changes, then inspect the generated object for meaning. Syntactically valid markup can still describe the wrong entity or carry stale values.
Do not use structured data to make claims that a person cannot verify on the page. Markup cannot repair inaccessible, contradictory, or inaccurate content, and it does not guarantee inclusion in an AI answer.

The final check is simple: read the visible page and the JSON-LD side by side. If they would lead a careful reader to different conclusions, the page is not ready.

Treat agent actions as controlled transactions

A transaction object passes through guarded verification, review, execution, and confirmation chambers while a duplicate action token is diverted into a holding loop.

Retrieving a shipping policy is a read. Changing an address, booking an appointment, placing an order, publishing content, or deleting data is a write. Your design should preserve that boundary even when the same assistant handles both parts of the journey.

Public facts should not require authentication without a business reason. Actions that expose personal data or change state should require an authenticated, authorized user. Do not create a machine-only shortcut around the permission model used by your human interface.

Use real links, buttons, and form controls with persistent programmatic names. An icon, color change, or visual position alone is not a dependable instruction.
Give every field a label and every validation failure an actionable message. State what is missing or invalid and preserve valid input so the task can continue.
Show prerequisites and consequences before submission. Required documents, inventory constraints, cancellation terms, units, time zones, and final charges belong before the committing action.
Require review or explicit user confirmation before consequential actions involving payment, publication, deletion, cancellation, or a binding reservation. Automation is not a reason to remove a safety boundary.
Make retries safe. If a client repeats a request after a timeout, the system should not silently create duplicate orders, bookings, messages, or records.
Return an unambiguous result after submission. The response should state whether the action succeeded, failed, remains pending, or requires another step, along with the relevant record or transaction identifier.
Keep errors distinct from success states. A generic page refresh, disappearing modal, or disabled button does not prove what happened.
Apply the least privilege needed for the requested task. Scope credentials, sessions, and connected tools so that a narrow action does not grant unrelated access.
Log enough context to investigate a failure or duplicate action, while avoiding unnecessary capture of personal data, credentials, or sensitive form contents.

Test consequential paths in a staging environment or with a non-destructive mode whenever possible. If a production check could charge money, delete data, publish material, or create a real reservation, use an authorized test path rather than discovering the guardrails through a live transaction.

Measure readiness from fetch to business outcome

Referral traffic is useful, but it is not a complete AI-search scorecard. A system may use your information without sending a click, while a detected visit may still land on an inaccurate or unusable page. Keep the stages separate so you know which problem you are fixing.

Availability: Can a clean client retrieve the preferred page, and are canonical and robots signals aligned?
Comprehension: Can the required answer and its qualifiers be extracted from the visible content? Do the structured data and page agree?
Representation: Does a fixed set of relevant prompts produce an accurate description, mention, or citation on the AI surfaces you monitor? Record the prompt, surface, location or account context, date, output, and cited URL so later checks are comparable.
Referral: Which detectable AI referrals reach the site, where do they land, and do they engage with the intended next step? Treat missing referral data as unknown, not as proof that your content was never used.
Outcome: Do those visits or assisted journeys produce the qualified lead, completed task, sale, subscription, support resolution, or other result the page exists to support?

Create a worksheet with a row for each priority intent. Include the authoritative URL, approved answer, required fields, expected entity, permitted action, passing condition, owner, last test date, observed output, and remediation status. A useful AEO system of record should show where performance is strong and why, not merely accumulate screenshots and isolated visibility scores.

Establish a baseline before changing templates or access rules. Rerun affected journeys after changes to navigation, rendering, structured data, robots directives, authentication, forms, firewall policy, or core content. Keep the prompt and acceptance criteria fixed when you want a meaningful comparison; create a new test when the underlying intent changes.

Key takeaways

AI-agent readiness has four practical layers: retrieval, interpretation, safe action, and measurement.
A passing visual check is not enough. Inspect the response, redirects, canonical, robots directives, rendered content, and required facts.
Visible content and JSON-LD must describe the same entity with the same claims, identifiers, and qualifiers.
Read access and write access need different controls. Consequential actions require authorization, confirmation, retry protection, and an explicit final state.
Measure fixed intents across availability, comprehension, representation, referral, and outcome instead of treating traffic as the whole result.
Technical readiness improves eligibility and reduces ambiguity, but it cannot guarantee ranking, citation, recommendation, or agent selection.

Start with a revenue page, a policy page, and a consequential conversion path. Fetch them logged out, compare their visible facts with their JSON-LD, complete the permitted action in a safe environment, and record every point where the result becomes ambiguous. Fix those failures before expanding the audit across the rest of the site.

References

April 1, 2026

How to Build Search Visibility for AI Agents and Answers

You can rank in conventional search and still be absent when an AI system assembles an answer. The missing piece is often not another keyword. An agent has to reach your content, isolate the relevant passage, connect it to the right entity and decide that the claim is clear enough to reuse.

Treat that sequence as a visibility pipeline. When you control access, extraction, delivery and measurement separately, you can diagnose why a page is missing instead of making broad content changes and hoping one of them works.

Key takeaways

Set separate policies for model-training crawlers and agents that retrieve information for live answers. Blocking a vendor name broadly can block the function you actually want.
Make the core answer understandable in raw HTML, then use semantic sections and accurate structured data to reduce extraction ambiguity.
Keep titles, canonicals, essential metadata and critical structured data early in the HTML response. A page that renders correctly in your browser can still present an incomplete document to a crawler.
Use pull crawling for durable pages, push discovery for important updates, machine-readable delivery for structured facts and MCP access when an agent genuinely needs current data.
Measure bot access, extracted content, citation share and business outcomes as separate signals. Referral traffic alone cannot tell you whether generative visibility improved.

Build a five-entry visibility pipeline

Traditional search workflows often compress discovery, indexing and ranking into one mental model. Generative systems add retrieval, passage extraction, entity annotation and answer assembly. Your content can enter that process through five distinct routes.

Entry route	What it does	Where it fits
Pull crawling	A crawler discovers and fetches a public URL on its own schedule.	Evergreen pages, documentation, category hubs and other durable web content.
Push discovery	You notify a participating system that a URL is new or has changed.	Pages whose value depends on being discovered soon after publication or revision.
Push data	Machine-readable facts are delivered directly instead of relying only on page extraction.	Structured catalogs, feeds and other data with a defined receiving system.
MCP access	An agent requests current information through a Model Context Protocol connection.	Data that changes too quickly to be represented reliably by an occasional crawl.
Ambient entry	A system recommends or introduces information without a conventional explicit search query.	Brand and entity discovery influenced by consistent, well-annotated information.

These routes are complementary, not maturity levels. An evergreen explainer usually needs a clean crawl path more than an MCP server. A changing first-party dataset may need a direct machine interface because a cached page can become stale between fetches. Map each important content type to the least complicated route that preserves its accuracy.

All five routes eventually depend on annotation: the system has to associate a fact with the correct organization, product, person, place or topic. That is why delivery alone is insufficient. Conflicting names, unclear ownership, inconsistent dates or schema that disagrees with visible copy can weaken the content after it has been successfully fetched.

Separate training permission from live-answer retrieval

The label AI bot hides several different jobs. The same provider may use one user agent for model training and another for retrieval or search. Current crawler distinctions include separate training, crawling and live-search identities:

OpenAI: GPTBot is associated with training, while OAI-SearchBot is associated with search and retrieval.
Anthropic: ClaudeBot is associated with training; Claude-User and Claude-SearchBot serve retrieval or search functions.
Perplexity: PerplexityBot is the crawler identity, while Perplexity-User is associated with user-driven searching.

Decide what you want before editing robots.txt. For each user agent, record whether public editorial pages, product information, support documentation and downloadable resources should be accessible. Make the training decision independently from the retrieval decision. A company can decline training access while still choosing to make public pages available to a search-oriented agent.

A narrowly scoped rule can look like this:

User-agent: GPTBot Allow: /public/ Disallow: /private/

Do not use robots.txt to protect confidential information. It is a crawler directive, not an authentication system. Private, customer-specific and administrative content needs server-side access control whether a path is disallowed or not.

After deployment, inspect server logs by user agent. Confirm that the intended crawler reaches the intended URLs, receives a successful response and can fetch resources needed to interpret the page. A syntactically tidy policy is not evidence that the access path works.

Use llms.txt as a map, not a dependency

The emerging llms.txt convention can give agents a concise map of important links, while llms-full.txt can aggregate larger amounts of text into one machine-oriented resource. Adoption is not universal, so neither file should be the only way to discover or understand your content.

If you publish llms.txt, generate it from the same canonical content inventory used by your sitemap and navigation. Include public, authoritative URLs rather than every filtered, duplicated or campaign-specific variation. Keep the file synchronized when pages move or claims change. It does not override robots.txt, authentication, canonical signals or the content of the page itself.

Make each page fragment-ready

A digital page separates into modular content cards while an AI lens selects one card and links it to a network of entities.

An agent rarely needs every sentence on a long page. It needs a passage that answers the current question without losing essential qualifications. Your job is to make that passage easy to locate and safe to reuse.

Build each important section in this order: state the answer, name the entity it applies to, add the condition or limitation, then provide the supporting explanation. Put exceptions beside the claim they qualify. If a warning appears several sections later, extraction can separate it from the advice it was meant to constrain.

Use a descriptive heading that reflects the question or decision addressed by the section.
Answer immediately beneath that heading instead of opening with scene-setting copy.
Name the product, organization, method or audience inside the passage. Avoid relying on vague references such as it, they or this solution when the fragment could be retrieved alone.
Keep definitions stable. Do not alternate between near-synonyms if they could make one entity look like several unrelated entities.
Use lists for steps and criteria, and tables only when rows and columns express a real comparison.
Link supporting detail close to the claim it supports rather than collecting all evidence in an unrelated footer.

Semantic HTML helps establish those boundaries. Use <article> for the primary work, <section> for coherent subtopics and <aside> for genuinely supplementary material. This does not guarantee selection, but it gives crawlers a clearer representation than a page composed entirely of generic containers.

Structured data should agree with the visible page. Use the schema type that matches the content, identify the same entities named in the copy and omit properties you cannot support on the page. JSON-LD can reduce ambiguity; it cannot repair an unclear claim or turn unsupported markup into trustworthy information.

Put critical information within the fetched bytes

Payload order matters when a crawler stops before the document ends. Googlebot fetches up to 2MB for an individual non-PDF URL, with the HTTP response headers included in that limit. When an HTML response exceeds the threshold, the downloaded portion is passed to indexing and the Web Rendering Service as though it were the complete file. Bytes after the cutoff are not fetched, rendered or indexed. PDFs have a higher 64MB limit.

The Web Rendering Service can fetch referenced resources separately and execute JavaScript like a modern browser, so external scripts and styles do not consume the parent HTML document’s byte allowance. That is a reason to remove oversized inline payloads, not a reason to hide the central answer behind unnecessary client-side execution.

Do not generalize Google’s exact limits to every AI crawler. Use them as a concrete reminder that a page visible in your browser is not necessarily the same document a bot received or completed.

Inspect the raw server response as well as the rendered page.
Place the title, canonical link, essential meta tags and critical structured data early in the HTML.
Move large CSS and JavaScript payloads into external resources where appropriate.
Remove duplicated navigation, serialized application state and other bulky inline material that delays the primary content.
Verify that the central answer appears without requiring a click, expansion control or user-specific session.
Compare raw and rendered text so you know what depends on JavaScript.

Response performance belongs in the same audit. When a server cannot deliver resources efficiently, fetchers may slow their activity to avoid adding load, which can reduce crawl frequency. Review latency alongside status and crawl counts instead of interpreting fewer requests as a content-quality judgment.

Add push paths where freshness changes the answer

Publishing and waiting remains reasonable for stable content, but it is incomplete when discovery speed or data freshness affects whether an answer is useful. Add proactive delivery in layers, after the public URL and its canonical content are sound.

Preserve the pull foundation. Give every durable page a crawlable canonical URL, sensible internal links and an accurate sitemap entry. Push mechanisms should supplement this foundation.
Notify systems about meaningful URL changes. Bing’s IndexNow can accelerate discovery by telling participating systems that content is new or updated. Treat the notification as an entry signal, not a substitute for a fetchable and interpretable page.
Provide machine-readable data when a receiver supports it. Use a structured feed or direct data connection for facts that should not depend on extracting prose. Define one authoritative source so the feed and public page do not contradict each other.
Use MCP for genuinely current interactions. An MCP connection is justified when an agent needs information that could become stale between crawls. Specify what each tool exposes, which fields are authoritative, how errors are represented and who may call it. Do not create an MCP layer merely to duplicate static editorial pages.
Strengthen the inputs to ambient discovery. Keep names, descriptions and relationships consistent across your first-party content and machine-readable outputs. Ambient recommendations are not a submission box you can force; they depend on whether systems can confidently recognize and contextualize the entity.

Use a freshness test when choosing the route: if an older value would make the answer materially wrong, evaluate direct data or MCP access. If the information remains accurate until the next normal crawl, keep the architecture simple and focus on extraction quality.

Centralize the underlying data before adding several delivery methods. Otherwise a page, feed and agent tool can expose three different versions of the same fact. Faster delivery only makes that inconsistency spread sooner.

Measure access, citations and outcomes separately

Three parallel visual channels depict content access, citation connections, and human outcomes using abstract gateways, fragments, and symbols.

A click-only dashboard cannot explain generative visibility. An answer may cite you without sending a visit, retrieve your page without using it or mention your brand while linking elsewhere. A practical GEO technical audit combines citation share, log analysis and zero-click behavior rather than collapsing them into one traffic number.

Access: Group server requests by user agent. Record which important URLs were requested, whether they were allowed, how the server responded and whether latency changed.
Extraction: Compare the raw response with the rendered page. Confirm that the answer, entity name, qualifications, canonical and structured data are present and mutually consistent.
Interpretation: Check whether headings, visible copy, schema and linked canonical resources describe the same entity and claim. Flag conflicting names, dates, ownership or status.
Visibility: Maintain a fixed set of representative questions. Citation share is the portion of checked answers that cite your domain or a tracked URL. Record the engine, model, query, cited page and claim so later checks remain interpretable.
Outcome: Track identifiable AI referrals and their business actions, but keep citations as a separate measure. No referral does not prove that the system ignored you; the generated answer may have satisfied the user without a click.
SEO context: Compare changes in AI visibility with domain metrics, backlink profiles, keyword research and organic-search data. This helps distinguish an agent-access problem from a broader authority, demand or search-performance problem.

The combination of signals points to the next action. No crawler requests usually directs you toward discovery or access controls. Successful fetching with no usable passage points toward rendering or extraction. Clear extraction with weak citation presence points toward annotation, relevance or authority. More citations without more referrals may reflect zero-click use rather than failure.

Keep the prompt set and measurement method stable while evaluating a change. If you replace the questions, engines and success definition at the same time, the before-and-after comparison cannot tell you which intervention mattered.

Start with one content cluster tied to a real business or reputation goal. Verify crawler policy, raw HTML, semantic sections and structured data; then add IndexNow, a structured feed or MCP only where the content’s freshness requires it. Record access and citations before and after the change. Once that evidence chain works, make it part of the publishing workflow for every similar page.

References

March 31, 2026

How to Measure AI Agent Traffic and Attribute Conversions

Your analytics dashboard may show a human arriving at checkout while missing the machine that found the product, compared the options, and initiated the journey. It may also show nothing at all when an agent completes an action without running your client-side analytics code.

You can close that gap, but not with a new referral channel alone. Reliable AI agent attribution starts in server and CDN logs, continues through first-party action events, and ends with an attribution model that distinguishes direct execution from assistance and unlinked automation.

Key takeaways

Measure AI agents at the HTTP request layer. A request that does not execute your analytics script cannot create a normal browser event.
Separate training crawlers, real-time retrieval systems, and task-performing agents. They represent different intent and should not share one conversion rate.
Do not trust a user-agent string by itself. Combine it with published network information, request behavior, authentication state, and your own event data.
Use distinct attribution states for agent-executed, agent-assisted, discovery-only, and unresolved activity. Do not force uncertain traffic into a conversion channel.
Instrument forms, account actions, carts, and orders on the server. Page requests show access; confirmed business events show outcomes.

Classify traffic by the job the machine is doing

An automated request is not automatically a prospective customer. A model-training crawler collecting material, an answer engine retrieving a current page, and an agent submitting a form can all request the same URL. Their commercial meaning is entirely different.

This distinction matters because machine activity is growing faster than human activity. HUMAN Security measured more than a quadrillion interactions from 2022 through 2025. In that dataset, automated traffic increased 23.5% in 2025 while human traffic increased 3.1%. AI-driven traffic rose 187%, and activity associated with AI agents and agentic browsers rose by nearly 8,000%. Those figures come from aggregated, anonymized customer data, so treat them as a market signal rather than a forecast for your site.

Traffic class	Likely job	What to measure	Attribution treatment
Training crawler	Collect content for later model development	Pages fetched, bytes served, crawl frequency, response status	Content access, not a visit or conversion
Real-time retriever or scraper	Fetch current information for an answer or comparison	Landing routes, freshness-sensitive pages, response success, repeat retrieval	Discovery activity unless a handoff can be observed
Task-performing agent	Navigate or take an action for a user	Workflow steps, authenticated state, form or cart events, confirmed outcome	Direct or assisted attribution when the evidence supports it
Unverified automation	Unknown, mislabeled, or potentially hostile activity	Behavior pattern, network identity, rate, errors, security challenges	Keep unattributed until verified

Training crawlers still represented 67.5% of measured AI traffic, while real-time scrapers grew by nearly 600% in 2025. That mix explains why a large increase in AI-labelled requests does not necessarily produce leads or revenue. Start by assigning each request to a functional class; calculate commercial performance only for traffic capable of participating in a user journey.

Task-performing agents deserve special attention because their behavior is moving deeper into sites. In 2025, 77% of observed agentic activity occurred on product and search pages, nearly 9% involved account-level interactions, and more than 2% reached checkout. If you monitor only editorial URLs, you will miss the requests closest to a business outcome.

Create at least two classification fields in your data: agent_type for the machine’s apparent job and verification_status for the strength of the identification. Keep the values independent. A request can look transactional while its claimed identity remains unverified.

Build an evidence chain from request to outcome

A continuous glowing trail links an incoming machine request to a gateway, server records, an action event, and a completed purchase.

Attribution becomes credible when you can follow an agent from an incoming request to a server-confirmed action. A dashboard label such as “AI traffic” is not enough. You need a chain of evidence that survives redirects, browser changes, authentication, and the absence of JavaScript events.

Capture the request before classifying it

Preserve the raw evidence in your CDN, load balancer, or application logs before a bot filter removes it. For each relevant request, capture:

A UTC timestamp and a unique request ID.
The HTTP method, normalized route, response status, and response size.
The full user-agent value as received, plus the parser’s normalized result.
The source network information needed for verification.
Referrer and origin headers when present, without treating their absence as proof of anything.
Whether a first-party session was present or created.
A pseudonymous account or customer identifier when the request was legitimately authenticated.
The resulting application event, such as search performed, form accepted, cart updated, or order confirmed.

Do not log authorization headers, passwords, payment details, complete form bodies, or sensitive query-string values for the sake of attribution. Strip or tokenize sensitive fields before they reach the analytics store. The useful connection is between a request identifier and a confirmed event, not between a marketing report and a copy of the user’s private data.

Instrument the business action on the server

A page view tells you that an agent requested a page. It does not tell you that a form was accepted, an account changed, or a payment completed. Emit a first-party server-side event only after the application confirms the action.

Give that event its own ID and record the initiating request ID, event time, action type, outcome, and any internal transaction or lead identifier. If the event represents money, use the same finalized value your order system recognizes. Failed submissions and abandoned workflows belong in diagnostic reporting, not completed-conversion totals.

Make an agent-to-human handoff observable

Many useful agent journeys will not end inside the agent. The machine may find a product or prepare a configuration, then send the user into a browser to review, authenticate, or pay. Standard last-click attribution can give the browser all the credit because the earlier agent request had no ordinary campaign parameter or client-side session.

When you control the handoff, attach an opaque, first-party handoff token to the destination URL. The token should identify a journey record, not expose an email address, prompt, account number, or other personal data. Expire it, prevent it from granting access, and associate it with the eventual conversion only after your server validates it. If the user is already authenticated, an internal pseudonymous account key can provide the connection without placing identity in the URL.

If you cannot observe a deterministic handoff, do not manufacture one from matching timestamps or similar page paths. You may analyze those patterns in aggregate, but label the result as discovery influence rather than an assisted conversion.

Recognize Google-Agent without weakening security

An abstract automated agent passes through layered identity checks at a secure gateway while unverified requests are blocked.

Google-Agent creates a useful distinction between continuous crawling and a request made while an AI system performs a user-initiated task. Google introduced it for agents hosted on its infrastructure, including experimental systems such as Project Mariner, and provided network ranges for desktop and mobile agent activity.

That identity gives you a better starting signal, not a substitute for authentication. User-agent strings are supplied by the requester and can be copied. Never allow an account action, bypass a challenge, or relax a security rule solely because a request calls itself Google-Agent.

Use confidence-based verification

Apply the same verification pattern to Google-Agent and any other named agent:

Match and preserve the claimed user-agent identity.
Compare the source with the provider’s published network information and keep that information current.
Check whether the request pattern is consistent with the claimed function, including the routes, methods, timing, and workflow sequence.
Record the result as verified, probable, or unverified rather than reducing all three states to a boolean bot flag.
Apply normal authorization, rate limiting, abuse detection, and transaction controls regardless of the identity label.

This approach is more defensible than a single allowlist. It also reflects how large-scale AI traffic was classified: user-agent strings were combined with infrastructure signals and activity characteristics because self-reported bot identities do not capture every AI-driven request reliably.

Test the paths that matter

Review your CDN and web application firewall logs for named agents before changing any rule. Then test product search, detail pages, forms, sign-in, account functions, cart operations, and checkout with non-production accounts and non-chargeable test transactions where your systems support them.

Look for redirects that loop, challenges that cannot be completed, required state that disappears between requests, and successful browser screens backed by failed server actions. Keep intentional security denials in place. The goal is to remove accidental incompatibility, not to give automated clients a privileged route into sensitive workflows.

Report agent contribution without false precision

Your reporting should tell operators what happened and tell decision-makers how certain the attribution is. One blended “AI conversions” number cannot do both.

Use four mutually exclusive outcome states:

Agent-executed: A verified or explicitly qualified agent request is linked to a server-confirmed conversion that the agent performed.
Agent-assisted: An observable first-party handoff or authenticated journey connects agent activity to a later human conversion.
Discovery-only: An agent retrieved relevant content, but no deterministic connection to an individual outcome exists.
Unresolved automation: Automation was detected, but its identity, purpose, or relationship to an outcome remains uncertain.

Do not add agent-executed and agent-assisted credit if they describe two stages of the same conversion. Keep a deduplicated conversion ID, choose a primary status, and retain the touch sequence separately for analysis.

Your operational dashboard should cover three layers. The access layer needs request volume by agent type, verification state, route group, response status, and security disposition. The workflow layer needs starts, successful steps, failures, and confirmed completions for each key action. The business layer needs deduplicated leads, orders, revenue where applicable, and the four attribution states above.

Choose an assistance window that reflects your actual buying cycle and publish that rule beside the metric. There is no defensible universal window in the available evidence. A short handoff into checkout and a long enterprise evaluation should not inherit the same arbitrary assumption.

Establish the baseline even if named-agent volume is initially small. A rise in training access may affect infrastructure cost and content-control decisions without changing revenue. A rise in verified product-search and account activity deserves workflow testing. Repeated checkout attempts with no confirmed outcomes point to a technical or security investigation, not automatically to weak demand.

Start with one path that matters commercially: discovery, a product or service page, and its next meaningful action. Join the request logs to one server-confirmed outcome, preserve uncertainty as an explicit field, and make that narrow chain trustworthy before expanding it across the site. That gives you a measurement system you can extend as agents become more capable, without rewriting history around traffic you never truly identified.

References

March 26, 2026

Google Ads Developer AI Updates: A Practical Playbook
You do not need another AI announcement in your backlog. You need to know whether Google’s direction changes what your advertising team should build, who should control it, and how much authority an AI agent should receive.

The immediate answer is not to rebuild your Google Ads integration around agents. Treat the update as an architectural signal: prepare for AI systems to propose and invoke advertising actions, but keep permissions, validation, approvals, execution, and audit controls outside the model.

The update is a learning channel, not an API release

Google has introduced Ads DevCast as a bi-weekly pilot hosted by Cory Liseno from its Advertising and Measurement Developer Relations team. Its technical scope includes Google Ads, Google Analytics, and Display & Video 360. Google is also inviting feedback while the pilot develops.

That positioning matters. Ads Decoded, hosted by Ginny Marvin, addresses campaign strategy. Ads DevCast is intended for the people building, configuring, debugging, and governing the systems beneath that strategy. Subscribe the technical owner of your advertising stack, not only the person who manages campaigns.

A new developer show does not, by itself, change an endpoint, schema, authentication flow, or deprecation date. Do not turn an episode into a production migration ticket merely because an idea sounds important. Use three separate lanes:
- Discovery: Use Ads DevCast to notice technical themes, emerging capabilities, and the problems Google expects developers to encounter.
- Verification: Confirm implementation details in the relevant official API documentation, release notes, schemas, and account controls before changing code.
- Delivery: Create an engineering task only after you can name the affected platform, resource, operation, permission, test case, and rollback path.
This distinction prevents two common errors. One is ignoring a directional signal until it becomes an urgent implementation problem. The other is treating a discussion of future architecture as though it were a released feature with stable production behavior.

The agentic shift changes your control plane

The first episode, titled “MCPs, Agents, and Ads. Oh My!”, presents an “agentic shift” in which AI agents become important users of advertising APIs. Treat that as Google’s direction of travel, not as evidence that every advertiser should give an agent unrestricted control of live campaigns.

Model Context Protocol, or MCP, is relevant because it gives AI systems a common way to discover and invoke tools. A consistent tool interface can make an API easier for an agent to reach. It does not make the requested action correct, authorized, affordable, or reversible.

The safest mental model is simple: the agent is a planner and operator working inside a control system. It is not the control system. A production workflow should separate intent from execution:
1. Observe: Retrieve only the account and campaign data needed for the task.
2. Propose: Produce a structured change showing the target resource, current value, proposed value, rationale, and expected scope.
3. Validate: Check the proposal against the API schema, account state, internal policy, and allowed operations.
4. Approve: Require the appropriate human or policy-based approval before any consequential write.
5. Execute: Pass the approved action to deterministic code that calls the advertising API.
6. Verify: Read the affected resource again, record the result, and surface any difference between the approved proposal and the final state.
Put hard limits outside the prompt

A prompt can tell an agent not to make risky changes. It should not be the only thing preventing them. The enforceable rules belong in the gateway between the agent and the ad platform.
- Allowlist the accounts, resource types, fields, and operations the agent may access.
- Use read-only access by default and grant write access per workflow rather than per agent.
- Reject requests that omit the target account, current state, proposed state, or approval record.
- Place budget, bid, scheduling, targeting, and deletion constraints in code or platform policy.
- Use idempotency or equivalent duplicate protection where the operation supports it.
- Log the request, tool call, actor, approval, API response, and resulting resource state.
- Maintain a tested way to reverse mutable changes and a separate recovery procedure for actions that cannot be cleanly undone.
This is a money-sensitive system. An agent with broad write access can alter live delivery before a person notices the mistake. For any action that can increase spend, narrow reach, pause revenue-producing activity, remove data, or change measurement, use a preview-and-approval flow until you have evidence that a more automated policy is safe for that exact operation.

Turn each episode into an engineering decision

A bi-weekly technical program can quickly become background noise unless someone owns the intake process. Give one person responsibility for converting each relevant item into a decision, including a deliberate decision to take no action.
1. Capture the claim precisely. Write down the named product, capability, resource, or workflow. Avoid tickets such as “investigate AI for ads” because they have no testable boundary.
2. Classify its status. Mark it as a concept, directional signal, pilot, documented capability, released change, or deprecation. Do not let enthusiasm silently upgrade its maturity.
3. Map the affected surface. Identify whether it touches Google Ads, Google Analytics, Display & Video 360, or more than one system. Then name the relevant integration, credential, data flow, and owner.
4. Verify implementation facts. Check the authoritative documentation for availability, supported operations, permissions, quotas, version requirements, and known limitations.
5. Record the decision. Choose watch, prototype, adopt, migrate, or reject. Include the evidence needed to revisit that choice.
Your decision record does not need to be elaborate. It should include the topic, status, affected system, documentation link, owner, next review trigger, test environment, approval requirement, and rollback method. That is enough to distinguish a useful technical signal from an unverified idea circulating in team chat.

Use a prototype when the value is plausible but the operational risk is unclear. Start with a read-only workflow that answers one bounded question, then let the agent draft a change without executing it. Compare its proposal with the decision a qualified operator would make. Only after that should you test an approved write in a controlled account or environment.

Because Ads DevCast is a pilot seeking community input, document where explanations leave an implementation gap. Useful feedback is specific: name the platform, operation, missing detail, and decision you could not safely make. That gives Google a clearer request than a general demand for more examples.

Your ownership model must evolve with the integration

Google is broadening the frame from a specialist Ads Developer Community toward a wider Ads Technical Community. That makes room for marketers to perform more technical work without waiting for a full development cycle. It does not erase the need for engineering ownership; it changes where the handoffs occur.

Before connecting an agent to advertising tools, assign these responsibilities by name:
- Business owner: Defines the campaign objective and decides which tradeoffs are acceptable.
- Platform owner: Controls credentials, permissions, API configuration, and production access.
- Workflow owner: Defines the agent’s tools, inputs, outputs, validation rules, and failure behavior.
- Approver: Reviews consequential changes and has enough context to reject a technically valid but commercially poor action.
- Incident owner: Can stop execution, assess affected resources, restore safe state, and preserve the audit trail.
Do not collapse all five roles into “the AI team.” The business owner knows what should happen. The platform owner knows what can happen. The workflow owner controls how a request becomes an API call. The approver evaluates the actual change. The incident owner handles the moment when the system behaves differently from the plan.

This division also makes low-code and agent-assisted work more practical. A marketer can describe or initiate a task without receiving unrestricted platform access. Engineering can provide constrained tools and reusable policies instead of implementing every request from scratch. The speed comes from a safer interface between roles, not from removing the roles.

Key takeaways for your next working session
- Use Ads DevCast as a technical discovery channel; verify every implementation detail in authoritative product documentation.
- Treat Google’s agentic direction as a reason to prepare your architecture, not as permission to automate every campaign action.
- Keep the agent focused on observation and structured proposals before granting narrowly scoped write capability.
- Enforce permissions, spend constraints, approvals, logging, and recovery outside the model and its prompt.
- Assign business, platform, workflow, approval, and incident ownership before connecting an agent to a live advertising account.
- Convert each relevant update into a recorded decision: watch, prototype, adopt, migrate, or reject.
Start with one existing Google Ads workflow that consumes too much operator time but has a clear input and output. Draw the six stages from observation through verification. Mark every place where a bad decision could affect spend, delivery, measurement, or data. Those marks define the controls your agent needs before it gets write access.

Then build the smallest read-only version and require a structured proposal. That gives you a concrete way to evaluate Google’s agentic direction without betting a live account on an immature design.

References
- CrushPress.AI — Unlock AI Insights with Google’s New Ads DevCast for Developers
March 20, 2026

SEO After the Click: Winning AI Search and Agent Traffic

You can rank first and still lose the recommendation. A buyer asks an AI assistant for a shortlist, gets a synthesized answer, and never reaches the search result where you lead. Your competitor appears because its name, category, capabilities, and reputation are easier to retrieve and corroborate across the web.

That does not make SEO obsolete. It changes the job. You still need pages that rank, but you also need a brand that AI systems can identify, trust, describe accurately, and use when helping someone make a decision.

Key takeaways for AI search and agent traffic

Keep investing in technical SEO, content quality, and organic rankings. They support retrieval even when the final answer appears somewhere other than a conventional results page.
Give every important product, service, person, and claim one clear source of truth on your site. Make your schema markup and JSON-LD agree with the visible page.
Build independent corroboration. Repeated claims on your own domain are messaging; consistent mentions across credible publishers and communities create consensus.
Audit ChatGPT, Perplexity, Gemini, and Google AI Overviews with the questions customers actually ask. Record accuracy, citations, competitors, and whether your brand appears at all.
Separate AI referrals, brand mentions, and agent requests in your reporting. A crawler request is infrastructure activity, not proof of attention or revenue.

The optimization target has split into three outcomes

Traditional search optimization concentrated on discoverability, ranking, and the click. AI-mediated discovery adds two more requirements: corroboration and actionability. A useful strategy addresses all three instead of renaming ordinary SEO as GEO and leaving the workflow unchanged.

AI can make structured technical work faster, but automation still depends on clean data, precise instructions, expert review, and strategic judgment. Your advantage will not come from producing more machine-written pages than everyone else. It will come from making better decisions about which facts deserve to be published, how they should be represented, and where they need independent support.

Retrieval: can the system find and understand the right page?

Create one authoritative page for each decision-critical subject. A service page should state what the service is, who it is for, what problem it addresses, where it is available, and what its important limitations are. An expert profile should use the same name, role, and area of expertise that appear on the content attributed to that person.

Use stable language for your category. If the homepage calls you an AI visibility platform, a product page calls you an answer marketing suite, and an external profile calls you an SEO automation tool, a machine has to decide whether those descriptions refer to the same thing. Choose a primary category, explain adjacent terms, and use that relationship consistently.

Treat schema markup and JSON-LD as a map of facts that a visitor can verify on the page. Markup should reinforce identity, relationships, authorship, and the subject of the page. It should not contain a more flattering or more complete version of the business than the visible content does. Structured data can reduce ambiguity, but it cannot manufacture third-party trust or guarantee inclusion in an AI answer.

Do not confuse a carefully written title with control over the final interface. Google has tested AI-driven headline rewrites in search, so your title and headings must communicate the subject clearly even when the displayed wording changes. Optimize the underlying meaning, not only the snippet you hope to see.

Corroboration: can the system verify the claim elsewhere?

Your website can establish what you say about yourself. It cannot independently prove that customers, specialists, publishers, and communities recognize you in the same category. AI systems that synthesize answers can compare multiple sources, so a claim supported across independent domains is more defensible than a claim repeated across several pages you control.

This is why rankings and AI visibility can diverge. A page may perform well in a conventional result while the brand behind it remains absent from synthesized recommendations. The missing ingredient is often not another keyword variation. It is distributed evidence.

Actionability: can an assistant help the user decide what to do?

An agent may need more than a persuasive description. It may be comparing price, quality, suitability, availability, prerequisites, or efficiency. Those decision facts should be explicit, current, and easy to distinguish from promotional claims.

State what the offering does and what it does not do.
Name the customer, use case, geography, or prerequisite that determines fit.
Publish current pricing when it is genuinely public. If pricing requires a quote, explain the pricing model and the information needed to obtain one.
Use consistent labels and units when presenting plans, features, limits, or performance evidence.
Give the user a clear next step on the same page: buy, book, apply, request a quote, check availability, or read the relevant documentation.

These details help humans as much as machines. The difference is that an agent may discard a vague brand claim before a person ever sees it. As automated comparison grows, brand familiarity alone may be a weaker shortcut than a clear match on price, quality, and suitability.

Build consensus beyond your own domain

Retrieval-augmented systems assemble context from material they can find and then generate an answer from that context. When multiple credible sources associate the same entity with the same category or capability, the repeated relationship becomes easier to use. When your site is the only place making the connection, your brand looks like an unsupported outlier.

The gap between rankings and citations can be substantial. One reported estimate places approximately nine out of ten pages cited by ChatGPT outside the top 20 organic results. Treat that figure as a directional warning rather than a universal rule: a first-page position does not automatically confer visibility in every AI system, and an AI citation does not require a top-20 ranking in every case.

Start with a claim inventory. For every claim that could affect selection, write down the exact proposition you need the market to understand:

Identity: the brand, product, person, or organization being discussed.
Category: the primary market or problem to which the entity belongs.
Fit: the customer, situation, or constraint for which it is appropriate.
Capability: the outcome it can produce, with material limits attached.
Evidence: the data, method, example, credential, or customer experience that supports the capability.
Currency: the date, edition, plan, location, or version to which a changeable fact applies.

For each proposition, mark where it appears on your site and where an independent source supports it. A capability mentioned on six owned pages still has only owned support. A trade publication, podcast, customer discussion, expert quotation, industry directory, or community recommendation adds a different kind of evidence.

Links remain useful, but they are not the only signal worth pursuing. Unlinked brand mentions and diverse publisher coverage can also strengthen entity recognition. The practical implication is that digital PR, expert participation, and reputation work now belong inside the search strategy rather than beside it.

The strongest consensus assets give other people a reason to refer to you. Original data, a proprietary survey, a transparent methodology, a useful public tool, or a genuinely qualified expert can earn citations without requiring every mention to repeat a marketing line. Make the underlying evidence easy to inspect and the responsible person easy to identify.

Communities require a different approach. Answer the actual question, disclose your relationship to the brand, and accept that the product may not be the right recommendation. Planted praise and repetitive link drops can create reputation problems rather than consensus. A natural recommendation from an established participant is valuable precisely because you cannot manufacture it on demand.

Consistency does not mean forcing every publisher to copy your wording. It means that independently written descriptions resolve to the same underlying facts. If credible sources disagree about your category, current features, leadership, or availability, repair the source-of-truth page first and then correct the most consequential external records.

Audit AI visibility by failure mode

Do not begin with another content calendar. Begin with the answers your prospects already receive. An AI visibility audit should tell you whether the problem is retrieval, entity clarity, corroboration, positioning, factual accuracy, or attribution.

Build prompts from real decisions. Include category discovery, problem-to-solution questions, comparisons, use-case constraints, reputation questions, and branded fact checks. Examples include: What are the leading providers in this category? Which option fits this constraint? What do people say about this brand? Is this product suitable for this use case?
Use the same prompt set across relevant surfaces. Check ChatGPT, Perplexity, Gemini, and Google AI Overviews where an overview appears. Keep the wording stable so you are comparing the answer, not your own prompt variations.
Capture evidence, not impressions. Record the date, surface, prompt, whether the brand appeared, the exact category and attributes assigned to it, competing brands, cited domains, factual errors, and the action offered to the user.
Classify the failure. Map each weak answer to a specific cause before creating or editing content.
Fix the smallest responsible layer. Correct dangerous or commercially significant errors first. Then repair the owned source of truth, clarify entity relationships, and pursue external corroboration for claims that remain unsupported.

Observed pattern	Likely gap	First move
Your brand is absent and the relevant owned page is unclear or incomplete	Retrieval or entity clarity	Create or revise the authoritative page; align visible facts, headings, internal references, schema markup, and JSON-LD
Competitors appear through several independent domains while your claims exist only on your site	Consensus	Develop evidence worth citing and earn coverage, expert mentions, customer discussion, or community recognition
Your brand appears with an outdated feature, category, person, or location	Conflicting or stale facts	Correct the owned source of truth and then prioritize the external pages that repeat the error
Your brand appears for branded prompts but not for category or use-case prompts	Weak category association	Clarify the primary category and publish decision-focused content that connects your entity to the relevant problem
Your brand is described accurately but sessions do not rise	Zero-click behavior or attribution	Measure mentions, branded demand, direct visits, and self-reported discovery before declaring the work ineffective

A single favorable response is not a durable ranking. Generated answers can vary by system, context, and timing. Preserve your prompt set and evidence so the next audit can show whether a correction persisted, whether citations diversified, and whether competitors displaced you.

Do not reduce the audit to a brand mention count. A recommendation in the wrong category can be worse than an omission, and an accurate mention supported by an irrelevant page may be fragile. Read the claim, the context, and the cited evidence together.

Measure human demand and machine activity separately

Clicks remain commercially important, but they no longer describe the entire discovery path. Organic click-through rates have declined in reported data for queries displaying AI Overviews since mid-2024, with declines also reported for some queries without AI answers. That is not a reason to abandon search performance reporting. It is a reason to stop using sessions as the sole measure of visibility.

Agent traffic creates a separate measurement problem. Cloudflare CEO Matthew Prince has said bots represented roughly 20% of web traffic for a long period and projected that bot activity could exceed human activity by 2027. The date is a forecast, not a settled timetable. The operational point is more durable: an agent can retrieve far more pages than a person considering the same decision, so request volume may grow without an equivalent rise in human sessions.

Use four reporting layers and resist combining them into one traffic number:

Search performance: rankings, impressions, click-through rate, organic sessions, and conversions. Keep these metrics because search engines remain a retrieval and demand channel.
Answer visibility: the share of your tracked prompts that mention the brand, the share that cite a useful owned or earned page, descriptor accuracy, competitor share of voice, and the diversity of domains supporting decision-critical claims.
Agent access: identifiable automated requests, requested URLs, response status, response volume, and infrastructure cost. Separate useful retrieval from errors, loops, and repeated fetching.
Business outcomes: qualified leads, sales, branded search, direct visits, AI referral sessions when a referrer is exposed, and self-reported discovery from forms or sales conversations.

Give each visibility metric a stable denominator. Mention coverage can be calculated as tracked prompts in which the brand appears divided by all prompts checked. Descriptor accuracy can be calculated as correct brand appearances divided by all brand appearances reviewed. Citation coverage can track how often a relevant owned or earned page supports the answer. Keep the prompt set stable between reporting periods, and document additions instead of quietly changing the test.

Agent requests should never be reported as visits, engagement, or purchase intent. If automated requests rise while answer visibility, branded demand, and qualified outcomes remain flat, you may have a cost increase rather than a marketing gain. If mentions improve while referral sessions decline, inspect branded search, direct demand, and lead-source responses before concluding that AI visibility has no value.

The economic response also depends on your business model. Publishers supported by advertising face a direct problem because bots do not consume ads like people do. Unique reporting, original data, access controls, and possible licensing arrangements may become more important, although licensing is not a guaranteed substitute for audience revenue. Lead-generation and commerce sites have a different priority: publish accurate selection facts and make the next human action unmistakable.

Before changing crawler permissions or rate limits, identify which automated systems request which pages, what those requests cost, and whether they contribute to discovery. Blocking broadly can reduce infrastructure load but may also reduce retrieval. Allowing unrestricted access may raise server costs or content-rights concerns. Treat access as a joint technical, commercial, and legal policy rather than a reflexive SEO setting.

Your next move should happen before you approve another batch of content. Choose one revenue-critical topic, run the same decision prompts across the major AI surfaces, and classify the first failure you find. Fix the source-of-truth page if the facts are unclear; build independent evidence if the facts are clear but unsupported; improve the decision path if the recommendation is accurate but unusable.

The durable SEO plan is not a choice between rankings and AI visibility. Rankings support retrieval, distributed evidence supports inclusion, and clear decision facts support action. Build those layers deliberately, and you will be prepared whether the next visitor arrives as a person, through an AI answer, or behind an agent.

References

March 20, 2026

Harness Google Search Console Data with Profound Agents

I’m excited to share that I can now effortlessly integrate Google Search Console data directly into any of my Profound Agents. This powerful combination, uniting Search Console insights with Profound’s answer engine data, is transforming how I handle reporting, content creation, monitoring, and optimization.

Staying on the Profound platform makes the entire process seamless, allowing me to focus on what truly matters—building and optimizing my digital strategies without the hassle of platform switching.

Inspired by this post on Try Profound Blog.

March 20, 2026

Google’s Universal Commerce Protocol: A Retailer Playbook

If you run ecommerce SEO, product feeds, or shopping infrastructure, your next visibility problem may not begin on a search results page. It may begin when an AI shopping agent tries to identify the right variant, confirm that it is available, calculate the correct price, and place it in a working basket.

Google’s Universal Commerce Protocol, or UCP, is intended to connect those steps. Your practical task is to make product and customer data usable across discovery, selection, and checkout without assuming that protocol adoption will automatically produce rankings, recommendations, or sales.

UCP moves product visibility closer to the transaction

Traditional search optimization prepares a page for a person to discover and visit. Agentic commerce adds another route: software may evaluate products, assemble a purchase, and act for the shopper. UCP is an open, modular standard for connecting retailers with AI-driven shopping experiences.

That does not make product pages irrelevant. It changes where accuracy has to survive. A persuasive description cannot compensate for an unavailable variant. Valid page markup cannot repair a cart that calculates the wrong price. A feed can expose a product, but the transaction can still fail if customer benefits disappear after identity linking.

This gives you four connected layers to manage:

Page content and structured data explain the product in a crawlable, understandable form.
Catalog data supplies current commercial facts such as price, inventory, and available variants.
Cart logic turns selected items into a valid basket.
Identity and account logic determine whether the shopper receives eligible benefits.

Keep these layers aligned, but do not treat them as interchangeable. UCP is not merely another name for JSON-LD, a product feed, or an ad format. It reaches into live commerce functions that page-level optimization alone cannot perform.

Google has said it plans to use UCP capabilities in AI-enhanced experiences across Search and the Gemini app. That establishes a direction, not a promise that every retailer, market, capability, or product will receive the same access or exposure. Build readiness around documented availability and your own eligibility rather than an assumed rollout.

Map each UCP capability to a real retail responsibility

The useful way to evaluate UCP is capability by capability. Each one touches a different system, failure mode, and internal owner.

Capability	What it enables	What you should verify	Likely owner
Catalog	Access to current product information, including pricing, inventory, and variants	Stable identifiers, variant mapping, update freshness, and agreement between catalog, product page, and checkout	Merchandising, feed operations, or commerce platform team
Cart	Multiple products from one retailer can be assembled into one basket	Add, update, remove, reprice, and out-of-stock behavior across a multi-item order	Ecommerce engineering
Identity linking	Eligible benefits such as member pricing and free shipping can continue across connected experiences	Authentication, consent, entitlement rules, session handling, and safe failure behavior	Identity, security, loyalty, and legal or privacy teams
Modular adoption	A retailer or platform can adopt selected capabilities instead of implementing everything at once	A rollout sequence tied to system readiness and a clear dependency map	Commerce product owner or program lead

The capability names do not answer every implementation question. For example, knowing that an agent can create a cart does not by itself define how your taxes, promotions, substitutions, shipping restrictions, or returns work. Treat those as test cases that need authoritative documentation and validation in your own stack. Do not invent behavior from the protocol’s high-level description.

Modularity is especially important for planning. You do not need to frame UCP as an all-or-nothing rebuild. If your identity system is not ready, that does not erase the value of repairing catalog inconsistencies. If your catalog cannot reliably distinguish variants, however, adding an agent-facing cart simply moves bad data closer to checkout.

Audit product data as if it were the storefront

An unbranded jacket, variant swatches, packaging, inventory objects, and a magnifying lens are arranged for a detailed product data audit.

An agent cannot walk a virtual aisle and infer that a stale price is probably wrong. It receives representations of your inventory and has to make decisions from them. Because the catalog capability is designed to expose real-time pricing, inventory, and variant information, conflicting product facts become a commercial problem, not merely a feed-cleanup task.

Start with one product family that has meaningful variation. A product with size, color, configuration, or member pricing will reveal more than a simple item with one price and one stock state. Trace it through every system an agent-assisted purchase could touch.

Resolve the identity chain. Confirm that the parent product, each purchasable variant, the catalog record, the product page, and the cart line resolve to the intended item. A parent identifier should not silently stand in for a specific variant at purchase time.
Name the source of truth for each commercial fact. Decide which system owns price, sale price, inventory, variant attributes, and account benefits. If two systems can overwrite the same fact, document precedence and failure handling.
Compare anonymous and authenticated states. Check whether public pricing, member pricing, shipping benefits, and eligibility rules remain distinguishable. The agent should not present a conditional benefit as universal.
Test change propagation. Change a price or inventory state in the owning system and observe every downstream representation. Record your actual delay and failure points rather than relying on the intended architecture.
Inspect contradictions. Compare the catalog, rendered product page, structured data, basket, and logged-in experience. Any disagreement can lead to a poor recommendation, a rejected add-to-cart action, or an unpleasant price change at checkout.
Log failed and stale updates. A synchronization process that usually works is not enough. Your team needs a way to identify which products failed, when the last successful update occurred, and which downstream surfaces may still carry old information.

This is also where SEO, GEO, and feed teams should coordinate. Keep descriptive content and structured data consistent with commercial systems, but do not add unsupported claims to markup merely to make the product look more complete to an AI system. The safest machine-readable answer is the same answer the shopper will receive in the cart.

Do not call the audit complete because a sample record validates syntactically. A valid record can still identify the wrong variant, carry an old price, or point to inventory that cannot be purchased. Validation checks form; transaction tests check truth.

Roll out the smallest capability you can verify end to end

A coffee maker follows one illuminated path through catalog, inventory, basket, payment, and delivery modules while unused modules remain dark.

Catalog readiness is usually the sensible first workstream because cart and identity experiences depend on accurate merchandise data. That is a sequencing recommendation, not a protocol requirement. Your architecture may justify a different order, but every pilot should have one defined capability, one accountable owner, and an observable pass or fail condition.

Choose a bounded product set. Select products that expose the problems you need to solve, including variants or conditional benefits, while keeping the pilot small enough to inspect manually.
Capture a baseline. Record current catalog mismatches, failed add-to-cart actions, unavailable variants presented as purchasable, and benefit-entitlement failures. Without a baseline, protocol activity can look like progress while customer-facing accuracy remains unchanged.
Define acceptance tests before integration. Write expected results for price changes, inventory changes, variant selection, multi-item baskets, account linking, and entitlement loss. Include negative cases, not just a successful purchase.
Test the cart as a changing object. The new cart capability is intended to let agents place multiple products from one retailer into a single basket. Verify what happens when quantity changes, one line becomes unavailable, a promotion expires, or the shopper switches variants.
Isolate identity testing. Identity linking can preserve member pricing and free shipping, but it also touches account access and personal data. Use controlled test accounts and obtain security, privacy, and legal approval before exposing real customer identities. The specific downside of rushing this step is not just a broken discount; it can be unauthorized account access or inappropriate data sharing.
Monitor outcomes by failure stage. Separate catalog retrieval, variant resolution, cart creation, cart mutation, authentication, entitlement, and checkout failures. A single conversion total will not tell you which capability needs repair.

Your ownership model matters as much as the integration. Feed operations can correct a variant mapping but should not define authentication policy. SEO can identify contradictions visible to search systems but should not own checkout integrity. Ecommerce engineering can make a cart function without knowing whether member benefits are represented correctly. Put these teams behind one shared test plan rather than handing UCP to whichever team first notices it.

Google has also indicated that it plans to simplify UCP onboarding through Merchant Center. Use that as a reason to prepare your data and test cases, not as a reason to assume that implementation is already automatic. When onboarding becomes available to you, confirm supported capabilities, required fields, market coverage, permissions, and reporting from the documentation presented in your account.

Most importantly, do not report UCP adoption as an SEO win by itself. There is no basis here for calling it a guaranteed ranking factor or recommendation boost. Measure what you can actually observe: eligibility, accurate product representation, successful basket creation, preserved benefits, completed purchases, and the failure rate at each handoff.

Key takeaways

UCP connects product discovery with live commerce functions; it is broader than page markup, feeds, or advertising alone.
Catalog accuracy is foundational because price, inventory, and variant errors can follow an agent directly into the cart.
Cart, catalog, and identity linking should be treated as separate capabilities with separate owners and tests.
Modular adoption lets you start with a bounded capability instead of waiting for a complete commerce-stack rebuild.
Identity linking requires controlled testing and security, privacy, and legal review before real customer accounts are involved.
Protocol adoption does not establish a ranking or recommendation benefit. Evaluate transactional accuracy and measurable outcomes.

Your best next step is concrete: take one high-value product family with variants, compare its catalog record, product page, structured data, cart, and logged-in benefits, then document every contradiction. That exercise will tell you whether your first UCP project is an integration project or, more likely, a product-data repair project that needs to happen before integration can deliver anything useful.

References

CrushPress.AI — Google Revolutionizes Shopping with AI-Powered Protocol Updates

March 19, 2026

Google Workspace Integration for AI Agents: A Safe Rollout

You want an AI agent to use the briefs, reports, presentations, and messages already inside Google Workspace. The difficult part is not giving it access. It is deciding what the agent may read, what it may prepare, and what it may change without turning a convenient workflow into an uncontrolled one.

The safest useful integration starts with one bounded job. Give the agent the minimum context needed for that job, send its output to a review destination, and add approval exactly where an action becomes consequential. Once that path works reliably, you can expand it without guessing which permission or instruction caused a problem.

Choose the job before you connect the apps

Google Workspace access can cover several materially different capabilities. An agent may be able to send email and create or retrieve documents. It may also be able to read or write spreadsheet data and extract context from presentations. That does not mean every workflow needs all of them.

Start by placing the proposed workflow in one of three operating modes:

Context mode: The agent retrieves approved material and uses it to answer a question, summarize a campaign, or prepare an analysis. It does not change Workspace data.
Draft mode: The agent creates a new review artifact, such as a status report, content brief, proposed spreadsheet update, or email copy. A person decides whether the draft moves forward.
Action mode: The agent changes a shared spreadsheet, updates a working document, or sends a message. The result affects other people or systems immediately.

Use the lowest mode that completes the job. If a content strategist only needs a brief assembled from an approved deck and a campaign document, the agent does not need Gmail sending or spreadsheet write access. If an account lead needs a weekly report, the agent can read the relevant sheet and create a new review document without editing the underlying data.

This distinction prevents a common design mistake: treating app access as the workflow. Connecting Docs, Sheets, Slides, and Gmail tells you where the agent can operate. It does not define what a successful task looks like, which material is authoritative, or who is accountable for the final action.

Give every agent workflow an explicit contract

A limited set of files enters an AI drafting sandbox, where the resulting draft is held for human review before a closed action gate.

An instruction such as “prepare the client update” leaves too much unresolved. The agent still has to infer which client, which files, which reporting period, which template, and whether “prepare” means draft or send. A workflow contract removes those decisions from the model.

Define these elements before granting access:

Trigger: State what starts the workflow. It could be a direct request, a defined status in a tracker, or another unambiguous event.
Input boundary: Name the folders, documents, presentations, spreadsheet tabs, or approved messages the agent may use. “Search the drive” is not a useful boundary.
Authority order: Tell the agent which artifact wins when two files disagree. For example, an approved messaging document may take precedence over an older presentation.
Transformation: Describe the work to perform: extract facts, compare values, draft copy, populate a template, or identify missing information.
Output destination: Specify whether the result belongs in a new document, a review queue, a designated spreadsheet area, or a proposed email.
Approval rule: Identify which person or role must approve the result before it is sent or written into a shared source of truth.
Failure behavior: Tell the agent to stop and report missing, conflicting, or ambiguous inputs instead of filling gaps with plausible text.

A bounded reporting workflow might read like this: use only the named campaign sheet and approved strategy documents; create a new status report in the review location; show which artifacts supplied each material claim; list missing fields separately; do not edit the source sheet or send any message.

That contract is more valuable than a long general prompt. It gives you observable checkpoints. If the result is wrong, you can determine whether the problem came from retrieval, conflicting context, transformation, or an unauthorized action. Without those boundaries, every failure looks like a vague “AI problem.”

Treat reading, drafting, and committing as different risks

A summary can be corrected before anyone uses it. A sent email or an incorrect update to a shared spreadsheet can affect colleagues, clients, and downstream work immediately. Your controls should become stricter as the agent moves from observing information to committing a change.

Operating mode	Agent behavior	Sensible default control
Read	Retrieve approved documents, presentation context, or spreadsheet values	Limit retrieval to named locations and require a record of the artifacts used
Draft	Create a new review document containing proposed copy, analysis, or changes	Write only to a designated review destination and mark the result as a draft
Commit	Send a message or alter shared working data	Validate the target, require explicit approval, and record the completed action

Keep the permission set aligned with the mode. A read-only research workflow should not retain write access “in case it is useful later.” An agent that drafts outreach copy does not need permission to send it. A reporting agent should not be able to edit every spreadsheet merely because its assigned report uses one of them.

For workflows that eventually need action access, put the approval gate after the draft is visible but before the change is committed. The reviewer should be able to inspect the destination as well as the content. Correct copy addressed to the wrong recipient is still a failed action. Correct data written into the wrong tab or field can be equally disruptive.

Use these controls at the action boundary:

Restrict access to the smallest useful set of folders, files, spreadsheets, and communication functions.
Prefer creating a new review artifact over overwriting an existing one.
Show the intended recipients, file, tab, and destination before approval.
Require a fresh approval when the content or destination changes after review.
Record what the agent read, what it produced, who approved it, and what action followed.
Maintain a clear way to pause the workflow and revoke its access when behavior is unexpected.

Do not use a broad permission as a substitute for workflow design. If the connector cannot isolate the resources or actions your job requires, keep the workflow in draft mode. Manual transfer is safer than granting access whose consequences you cannot bound.

Make Workspace context precise and auditable

A person selects a few relevant workspace items for an AI assistant while excluded files remain outside the access boundary and an audit trail leads to a secure archive.

Connecting an agent to more files does not automatically improve its answer. Extra context can introduce duplicate documents, outdated messaging, conflicting numbers, and material that belongs to a different client or campaign. Retrieval needs its own design.

Build a small context map for each workflow. Name the approved inputs, what each one contributes, and how conflicts should be handled:

Documents: Identify the approved brief, policy, template, or messaging file. Do not rely on a title that could match several drafts.
Presentations: Specify the deck and the parts relevant to the task. If the workflow depends on notes, links, or material outside visible slide text, verify that the integration actually exposes it before relying on it.
Spreadsheets: Name the tab and fields the agent should interpret. Explain unusual headers, calculated fields, status values, and blank cells instead of expecting the agent to infer their business meaning.
Email: Separate retrieving approved correspondence from sending a new message. Define which conversations may supply context and which addresses may receive output.

A spreadsheet deserves particular care. It may look structured to a person while still being ambiguous to an agent. Repeated header rows, unlabeled columns, free-form notes, mixed date formats, and formulas beside manual values can all change what a cell means. Clean the specific input area or provide an explicit field map before using it for an automated decision.

Require the output to preserve a source trail. For a report or brief, the agent should name the document, deck, or spreadsheet area behind each material section. It should also flag conflicts instead of silently choosing whichever version it retrieved first. This makes review faster and gives you a practical way to correct the context map.

A useful instruction pattern is: Use only the listed Workspace artifacts. For each material claim, identify the artifact that supports it. If approved inputs conflict or required information is absent, place the issue in a review list and do not resolve it by assumption.

That requirement matters for content and search workflows. An agent can assemble a polished brief from weak or outdated inputs just as easily as it can assemble one from approved material. Fluency is not provenance. Before a draft enters your publishing, SEO, AEO, or GEO process, a reviewer should be able to see which business facts and positioning statements shaped it.

Key takeaways

Start with one bounded business job, not a blanket connection to every Workspace app.
Choose context, draft, or action mode and grant only the access that mode requires.
Define the trigger, approved inputs, authority order, output destination, approval rule, and failure behavior before launch.
Put human approval immediately before an email is sent or shared data is changed.
Require a source trail so reviewers can connect the agent’s output to the document, presentation, or spreadsheet data behind it.
Expand access only after the existing workflow is reliable, reviewable, and easy to stop.

Use a controlled rollout sequence

Your first workflow should be useful but recoverable. A strong starting point is a context or draft task that reads from a small approved collection and creates a new review document. A poor starting point is autonomous external email or unrestricted editing of a shared operational spreadsheet.

Map the manual task. Write down what starts it, which artifacts a person consults, what judgment is required, and where the finished work goes.
Remove unnecessary access. If an app or folder does not contribute to that exact path, leave it disconnected.
Run in context mode. Check whether the agent retrieves the correct material and reports conflicts or missing information.
Add a review artifact. Let the agent create a new document or other staged output without altering the underlying sources.
Evaluate human corrections. Separate factual corrections from tone changes and formatting preferences. Factual corrections indicate a context or interpretation problem.
Add one action boundary if needed. Introduce a single approved send or write operation, with the destination visible before commitment.
Expand one dimension at a time. Add another data source, destination, or action only after you can explain the current workflow’s behavior.

Measure reliability, not activity

Counting generated documents or processed requests tells you how busy the integration is, not whether it is helping. Track signals that expose the quality of the workflow:

Completion without repair: Did the workflow reach the intended review destination without someone rebuilding the result?
Correction burden: Which facts, recipients, destinations, or spreadsheet interpretations required human changes?
Context accuracy: Did the agent use only the approved artifacts and identify conflicting information?
Action accuracy: When an action was approved, did it affect the intended message, file, tab, or field?
Traceability: Can a reviewer reconstruct the inputs, output, approval, and final action?
Safe stops: Did the agent halt when information or authority was missing instead of improvising?

Pick one recurring workflow and write its contract before connecting anything else. If you cannot state exactly what the agent may read, where it may write, and when it must stop, keep the task in draft mode. That boundary gives you a useful integration now and a defensible path to broader automation later.

References

March 16, 2026

AI Assistants Dominate 56% of Global Search: New Study Unveils

I recently came across an intriguing study that shows AI tools are now responsible for generating 45 billion monthly sessions globally. This accounts for an impressive 56% of all search engine activity, according to Graphite.io CEO Ethan Smith.

The analysis combines web and mobile app usage across leading AI platforms and suggests that AI activity matches 56% of global search use and 34% in the U.S.

The surge is particularly evident in mobile applications like ChatGPT, Gemini, Perplexity, Grok, and Claude.

Why it matters: AI is broadening the horizons of discovery, rather than limiting the demand for search. Since 2023, combined usage across search engines and AI assistants has increased by 26% globally. It’s clear that having visibility in both LLMs and traditional rankings is crucial.

Key insights: The report dives into the performance of the top five LLM products—ChatGPT, Gemini, Perplexity, Grok, and Claude—and compares them to the biggest search engines. Here are some standout insights:

AI platforms generate 45 billion monthly sessions worldwide.

Within the U.S., AI accounts for roughly 5.4 billion monthly sessions.

An astounding 83% of global AI usage takes place within mobile apps (75% in the U.S.).

ChatGPT is leading the charge, representing 89% of AI sessions globally.

When looking at search-like prompts, AI usage constitutes 28% of the global search and 17% within the U.S.

The report leaves out prompts in the “doing” or “expressing” categories. According to OpenAI, around 52% of prompts focus on seeking information, akin to traditional search queries.

Reading between the lines: Most forecasts comparing AI and search focus only on website traffic, often just Google.com and ChatGPT site visits. This approach overlooks much of AI’s impact.

The research suggests these comparisons undervalue AI activity by a factor of 4-5 times because a significant chunk occurs on mobile apps.

The analysis takes into account various LLMs and search engines, rather than only comparing Google and ChatGPT.

What to keep an eye on: Google remains a dominant force in discovery, but the report estimates its share of search-related activity has declined from 89% in 2023 to 71% by the fourth quarter of 2025.

While global AI usage seems stabilized since July 2025, the U.S. usage is still on a rapid climb—up about 300% year over year by December 2025.

The full report. For more depth, you can read the analysis titled AI Is Much Bigger Than You Think.

Inspired by this post on Search Engine Land.

March 9, 2026

Tag: AI Agents

The search result is becoming part of the workflow

Optimize the complete task, not just its opening query

Build pages an agent can interpret and use

Put the decisive answer before the supporting narrative

Turn implied knowledge into explicit facts

Use JSON-LD as a factual layer, not a persuasion layer

Design the action boundary deliberately

Audit task readiness before agent traffic becomes measurable

Key takeaways

References

Audit the journey, not the bot name

Make important pages retrievable without guesswork

Make the page’s meaning explicit in content and JSON-LD

Treat agent actions as controlled transactions

Measure readiness from fetch to business outcome

Key takeaways

References

Key takeaways

Build a five-entry visibility pipeline

Separate training permission from live-answer retrieval

Use llms.txt as a map, not a dependency

Make each page fragment-ready

Put critical information within the fetched bytes

Add push paths where freshness changes the answer

Measure access, citations and outcomes separately

References

Key takeaways

Classify traffic by the job the machine is doing

Build an evidence chain from request to outcome

Capture the request before classifying it

Instrument the business action on the server

Make an agent-to-human handoff observable

Recognize Google-Agent without weakening security

Use confidence-based verification

Test the paths that matter

Report agent contribution without false precision

References

The update is a learning channel, not an API release

The agentic shift changes your control plane

Put hard limits outside the prompt

Turn each episode into an engineering decision

Your ownership model must evolve with the integration

Key takeaways for your next working session

References

Key takeaways for AI search and agent traffic

The optimization target has split into three outcomes

Retrieval: can the system find and understand the right page?

Corroboration: can the system verify the claim elsewhere?

Actionability: can an assistant help the user decide what to do?

Build consensus beyond your own domain

Audit AI visibility by failure mode

Measure human demand and machine activity separately

References

UCP moves product visibility closer to the transaction

Map each UCP capability to a real retail responsibility

Audit product data as if it were the storefront

Roll out the smallest capability you can verify end to end

Key takeaways

References

Choose the job before you connect the apps

Give every agent workflow an explicit contract

Treat reading, drafting, and committing as different risks

Make Workspace context precise and auditable

Key takeaways

Use a controlled rollout sequence

Measure reliability, not activity

References