Technical Audit test reference

What it checks. Verifies that the "Master" URL specified in your canonical tag is actually eligible to be indexed by search engines.

Why it matters

This test verifies that the "Master" URL specified in your canonical tag is actually eligible to be indexed by search engines. In SEO, pointing a canonical to a non-indexable page is a "Signal Conflic"' that breaks your site's authority. For AI agents, this is a "Ground Truth Paradox": the agent cannot verify your preferred data source if that source is marked as private or restricted.

If the test fails

When you instruct Google to consolidate all "link juice" into a page that it isn't allowed to index, Googlebot triggers a Logic Error. It will often ignore your canonical tag entirely and guess which page should be the master. This leads to Ranking Fragmentation, where your traffic is split across multiple weak URLs instead of one strong, authoritative page. AI scrapers rely on the canonical tag to identify the "Definitive Version" of your expertise. If the canonical points to a non-indexable URL, the AI triggers a "Data Verification Failure." To avoid ingesting unofficial content, the agent may skip the page entirely, leaving your "Expert Sentiment" out of AI-generated summaries and answers.

How to fix it

Audit Your Targets: Check the destination URL of your canonical tags. Ensure that the target page does NOT contain a noindex tag and is NOT blocked in your robots.txt file. Match Status Codes: The canonical target must return a 200 OK status code. If it redirects or returns a 404, the canonical signal is broken. Align Meta Robots: Ensure your page-level instructions are in sync. If a page is meant to be the "master," it must be both indexable and canonicalized to itself. By maintaining Canonical Logic Integrity, you ensure a clear path of authority for both search engines and AI agents.

What it checks. Checks if your Canonical Tags contain a "URL Fragment".

Why it matters

This test checks if your Canonical Tags contain a "URL Fragment". In SEO, search engines ignore fragments when deciding which page to index. For AI agents, this is a "Data Anchor" issue. Adding a fragment can make the agent think the content is only a small piece of a page rather than the whole authoritative source.

If the test fails

A canonical tag is supposed to point to the "Clean version" of a URL. If you include a fragment (e.g., yoursite.com/page#section1), Google will typically strip the fragment away. However, it can lead to Indexing Inconsistency, where Google isn't sure if you want the whole page indexed or just that specific section, potentially weakening the ranking power of the overall URL. AI scrapers use URLs as unique IDs in their "knowledge graphs." If your "Master link" includes a fragment, the AI may trigger a "Duplicate ID Error." It might end up treating "page#section1" and "page#section2" as two different pages, causing it to over-read your site and potentially dilute your "Expert Sentiment" across multiple fragmented entries.

How to fix it

Strip the Fragments: Ensure your canonical tags point to the base URL only (e.g., https://example.com/services/ instead of https://example.com/services/#consulting). Use Absolute Paths: Always use the full website address in your canonical tags to avoid any guessing by the bots. Check Social/Jump Links: Sometimes, SEO plugins accidentally grab a "Jump Link" from a table of contents and turn it into the canonical. Ensure your software is set to use the primary page URL only.

What it checks. Verifies that the destination of your Canonical tag is an indexable, live page.

Why it matters

This test verifies that the destination of your Canonical tag is an indexable, live page. A Canonical tag's purpose is to pass authority, if it points to a page that is blocked by robots.txt, marked as "noindex", or returning an error (404/500), the signal is broken.

If the test fails

The page contains an "Invalid Authority Path." By pointing your canonical link to a non-indexable page, you are effectively telling search engines: "The master version of this content is a page you aren't allowed to see." This signal conflict confuses indexing algorithms, often causing them to ignore your preferred URL and pick a random, less-optimized version instead.

How to fix it

Audit the destination URL listed in your Canonical tag. Ensure the target page returns a 200 OK status code and does not contain a "noindex" meta tag.

What it checks. Confirms that the page’s Canonical tag points to itself (Self-Referencing).

Why it matters

This test confirms that the page’s Canonical tag points to itself (Self-Referencing).

If the test fails

The page has a "Mismatched Identity." This happens when a page accidentally points its canonical tag to a different URL (like the homepage or an older version). This is a "De-indexing Trigger": you are telling search engines NOT to rank the current page. As a result, this page will likely disappear from search results, and its SEO value will be sent elsewhere, making the content invisible to searchers.

How to fix it

Update the Canonical tag so that it matches the current page's full URL exactly

What it checks. Verifies that the page contains exactly one canonical tag.

Why it matters

This test verifies that the page contains exactly one canonical tag. While having one is essential, having two or more creates a logic error. When a search engine encounters multiple canonical instructions, it typically ignores all of them and reverts to its own "guessing" logic, which often leads to the wrong version of your page being indexed.

If the test fails

Detected "Canonical Redundancy." Multiple rel="canonical" tags are present, likely caused by overlapping SEO tools. This ambiguity triggers Indexing Instability, where search engines may de-rank the page due to conflicting master URL declarations. For 2026 AI scrapers, this creates an "Ambiguity Loop" that blocks the page from being verified as a primary reference.

How to fix it

Audit the page's <head> and remove any duplicate <link rel="canonical"> entries. Ensure that only one tag exists and that it points to the correct, absolute URL of the page.

What it checks. Checks for non-standard or "illegal" attributes inside the Canonical tag.

Why it matters

This test checks for non-standard or "illegal" attributes inside the Canonical tag. A Canonical tag should only contain the destination URL. In SEO, adding extra attributes like rel='noindex' inside a canonical tag is an invalid implementation. For AI agents, this is a "Logic Syntax Error": the agent cannot process the instruction if the 'Master Link' code is technically malformed.

If the test fails

When Google encounters an invalid attribute inside a canonical tag, it often treats the entire tag as Broken. This means your a"Master" signal is lost. If you have five versions of a page and the canonical is ignored, Google might index the "junk" version (like a search results page or a session ID URL) instead of your clean, high-value page. AI scrapers rely on "Strict Parsing." If they see an attribute they don't recognize inside a canonical tag, they may trigger a "Processing Exception." To avoid ingesting incorrect'data, the AI agent might skip the page entirely, preventing your "Expert Sentiment" from being used in AI-generated answers and summaries.

How to fix it

Clean the Tag: Ensure your canonical tags look exactly like this: <link rel='canonical' href='https://example.com/page/' />. Separate Your Instructions: If you need to tell a bot not to index a page, use a separate Meta Robots tag. Never try to combine "noindex" or "nofollow" inside the canonical link itself. Audit Automated Tools: Some older SEO plugins or custom scripts accidentally inject "tracking" attributes into the canonical tag. Ensure your code generation is clean and follows modern W3C standards.

What it checks. Checks for the presence of a Canonical Link in the page's <head>.

Why it matters

This test checks for the presence of a Canonical Link in the page's <head>.

If the test fails

The page lacks a "Technical Identity Signature." Without a canonical declaration, search engines may treat minor URL variations (like example.com/page?ref=social) as entirely separate pages. This leads to "Authority Dilution," where your SEO strength is split across several versions of the same content, preventing the page from reaching its full ranking potential and confusing AI agents trying to find the primary source.

How to fix it

Implement a self-referencing canonical tag within the <head> section of the HTML. The tag should look like this: <link rel="canonical" href="https://poliris.io/exact-page-path/" />. Ensure every page on the site points to its own preferred Master address.

What it checks. Reports checked URLs that resolve to a different canonical page.

Why it matters

Reports URLs that were excluded from the page audit because their canonical declaration points elsewhere or conflicts.

If the test fails

Non-canonical URLs can waste search-engine crawl budget and split indexing signals even though they should not be audited as independent pages.

How to fix it

Update internal links and sitemap entries to point directly to each preferred canonical URL, then remove conflicting canonical declarations.

What it checks. Ensures that any URL that does not exist on your server correctly returns a "4xx status code" (usually a 404: Not Found).

Why it matters

This test ensures that any URL that does not exist on your server correctly returns a "4xx status code" (usually a 404: Not Found). In SEO, this prevents search engines from indexing "ghost" pages. For AI agents, this is a "Data Integrity" signal: it tells the machine exactly where your content ends so it doesn't waste resources trying to learn from non-existent data.

If the test fails

If a broken link returns a "200 OK" (meaning the page is fine) but shows a "Page Not Found" message, Google gets confused. This is called a "Soft 404." Google will continue to crawl these dead pages, wasting your Crawl Budget and potentially lowering the overall ranking of your real content because your site looks messy and poorly maintained. AI scrapers prioritize "Information Density." If an AI agent hits a broken link that doesn't return a 404, it might accidentally index the text on your error page as if it were part of your main content. This leads to Knowledge Pollution, where the AI associates your brand with "Page Not Found" errors instead of your "Expert Sentiment." This lowers your scrapability score because the machine cannot trust your server's signals.

How to fix it

Configure your server to handle missing data with technical precision: Correct Headers: Ensure your server is set to return a true 404 (Not Found) or 410 (Gone) status code for any URL that doesn't exist. Custom 404 Page: Create a helpful, branded 404 page that directs users back to your active content, but ensure the underlying code still reports a 404 error to the bots. Monitor Crawl Errors: Regularly check your Search Console for "Soft 404" warnings to keep your site's roadmap clean.

What it checks. Checks your server headers for a defined "Content-Security-Policy." In SEO, a secure site is a trusted site: Google rewards domains that prioritize user safety.

Why it matters

This test audits your server headers for a defined "Content-Security-Policy." In SEO, a secure site is a trusted site: Google rewards domains that prioritize user safety. For AI agents, this header acts as a "Data Integrity Shield," it proves that the content the agent is scraping hasn't been tampered with by a third-party script.

If the test fails

Without a CSP, your site is an open target for Cross-Site Scripting (XSS) and Clickjacking. If a hacker injects spammy links or redirects into your code, search engines will quickly flag your site as compromised. AI scrapers are highly sensitive to "Malicious Code Injection." If an AI detects unauthorized third-party scripts running on your page, it triggers a "Safety Quarantine": the AI will stop ingesting your "Expert Sentiment."

How to fix it

Deploy a robust CSP header to lock down your site's permissions: Define Trusted Sources: Explicitly list which domains are allowed to load scripts (e.g., your own domain, Google Analytics, etc.). Start with "Report-Only": If you've never used a CSP, start in Content-Security-Policy-Report-Only mode. This allows you to see what would be blocked without actually breaking your site.

What it checks. Checks for the presence of a favicon (frequently a favicon.ico or a linked PNG).

Why it matters

This test checks for the presence of a favicon (frequently a favicon.ico or a linked PNG). In SEO, Google now displays favicons next to search results on both mobile and desktop, they are a key driver of visual trust. For AI agents, the favicon acts as a brand signature that helps identify the source of data in multi-source AI summaries.

If the test fails

When your site lacks a favicon, search engines display a generic "globe" icon next to your listing. This looks untrustworthy and significantly lowers your Click-Through Rate (CTR). When an AI cites your content, the lack of a visual brand anchor makes your information look less official compared to competitors who have a clearly defined visual identity.

How to fix it

Establish a clear visual signature for your domain: Standard Formatting: Use a 32x32 or 48x48 pixel icon. Provide it in multiple formats (ICO, PNG, and SVG) for cross-browser compatibility. Ensure the icon is legible even when shrunk to 16x16 pixels in a browser tab.

What it checks. Checks whether all versions of your domain (WWW vs. non-WWW, HTTP vs. HTTPS)

Why it matters

This test audits whether all versions of your domain (WWW vs. non-WWW, HTTP vs. HTTPS) consolidate into a single, master URL. In SEO, this prevents "Keyword Cannibalization" where your own pages compete against each other. For AI agents, this is a "Deduplication Signal" that ensures the scraper only processes your data once, at the correct address."

If the test fails

Your ranking power is split in half. Instead of one strong page, you have two medium ones. This dilutes your authority and makes it harder to reach the first page of search results. This creates "Path Ambiguity": If the AI sees two versions of your site, it may get confused about which one is the "Source of Truth." This can lead to your content being ignored or labeled as duplicate across different AI summaries.

How to fix it

Force a single "Canonical" identity for your entire domain: Choose Your Master: Decide whether you want to use www or non-www (in 2026, most modern brands prefer the shorter https://domain.com). Server-Side Redirects: Use a 301 (Permanent) Redirect to funnel all other three variants into your chosen master URL. Canonical Tags: Ensure every page has a rel="canonical" tag in the HTML that matches the master URL structure exactly. By unifying your domain, you create a "Singular Access Point" that consolidates all your brand’s power into one address.

What it checks. Checks whether your server automatically pushes users from the "insecure http://" protocol to the secure "https:// version." In SEO, this prevents duplicate content issues between two versions of the same site.

Why it matters

This test audits whether your server automatically pushes users from the "insecure http://" protocol to the secure "https:// version." In SEO, this prevents duplicate content issues between two versions of the same site. For AI agents, this is a "Trust Handshake" that ensures the scraper is always communicating over a verified, tamper-proof connection.

If the test fails

Without this redirect, search engines might see two separate versions of your site: one secure and one not. This leads to Authority Dilution, where your "link juice" and rankings are split between two URLs. The AI may stop the crawl to avoid ingesting potentially hijacked or manipulated data. This keeps your content out of the AI "Knowledge Graph" because the machine cannot verify that you are who you say you are.

How to fix it

Server-Level 301: Use your .htaccess (Apache) or nginx.conf file to set up a permanent 301 Redirect. This tells search engines, "the secure version is the only one that matters." Canonical Consistency: Ensure your rel="canonical" tags all point to the "https:// version." HSTS Implementation: Consider enabling HTTP Strict Transport Security (HSTS), which tells browsers to only ever try to connect to your site via HTTPS in the future.

What it checks. Verifies that your website uses a valid SSL/TLS certificate to encrypt the connection between your server and the visitor.

Why it matters

This test verifies that your website uses a valid SSL/TLS certificate to encrypt the connection between your server and the visitor. In SEO, HTTPS is a confirmed ranking signal and a requirement for a professional web presence. For AI agents, this is a "Safety Filter": secure protocols are required for the agent to safely ingest and store your data.

If the test fails

Google Chrome and other browsers will display a "Not Secure" warning to users before they even see your content. This leads to an immediate "Bounce Rate" spike, as users flee the site out of fear. Furthermore, Google's algorithm penalizes non-secure sites, pushing them to the bottom of the rankings in favor of encrypted competitors. Many AI scrapers operate under "Strict Security Policies." If your site lacks a valid SSL, the AI triggers an Access Block. To prevent "data poisoning" or security leaks, the AI may be programmed to skip non-secure domains entirely.

How to fix it

You must secure your domain with a modern SSL certificate: Install a Certificate Enforce HTTPS: Set up a permanent 301 Redirect so that any visitor trying to access the "http://" version of your site is automatically moved to the secure "https://" version. Update Internal Links: Ensure all your internal links, images, and scripts also use HTTPS to avoid "Mixed Content" errors. By securing your site, you provide a "Protected Path" that both users and AI agents can navigate with total confidence.

What it checks. Monitors the number of links pointing to external domains.

Why it matters

This test monitors the number of links pointing to external domains. While citing sources is important for credibility, exceeding 20 external links on a single page can negatively impact your "Authority Retention."

If the test fails

The page is suffering from "Authority Leakage." When a page has 20+ external links, the "Sentiment" shifts from being an Expert to being a Curator. For an AI agent, this creates a Knowledge Gap.

How to fix it

Audit the external link profile of the page. Consolidate citations into a "References" section or move them to a dedicated resources page. Use internal linking to keep users and AI agents within your own "Knowledge Graph" for as long as possible. Ensure that any necessary external links are set to target="_blank" and use appropriate rel attributes to protect your site’s security and "Access integrity

What it checks. Identifies "Dead Ends" where your content points to an external URL that no longer exists (404 Error).

Why it matters

This test identifies "Dead Ends" where your content points to an external URL that no longer exists (404 Error).

If the test fails

The page is suffering from "External Connectivity Failure." A broken link is a high-friction event that destroys Technical Authority. For an AI agent, this is a "Logic Break," the bot follows a path to verify a fact, hits a 404, and immediately downgrades the Sentiment of your page from "Reliable Source" to "Unverified."

How to fix it

Perform an immediate sweep of all external links. You have three options: Update the Link: Find the new, corrected URL for the resource. Replace the Link: Find a new, high-authority source that supports your claim. Remove the Link: If the resource is no longer necessary, delete the reference to clean up your site’s "Discovery Map."

What it checks. Redirecting internal links can slow your site and reduce PageRank flow.

Why it matters

Internal links that redirect slow down your website and may decrease the amount of PageRank passed to the linked-to pages.

If the test fails

When a bot or user clicks a link that redirects, the browser must perform two or more requests instead of one. This lowers your TTFB (Time to First Byte) and degrades the user experience. For 2026 AI agents, these "hops" are costly. AI scrapers prioritize sites with Flat Architectures. If an AI bot has to follow multiple redirects to reach your content, it may deprioritize your site in its crawl queue, leading to "Discovery Lag."

How to fix it

Fix Legacy Links: Update all internal links to point directly to the final "200 OK" destination URL. If you have renamed a page or moved a category, do not just rely on the server redirect, log into your CMS, find the old links in your page's HTML, and update the href attribute to the new destination. Use absolute URLs to ensure there is no ambiguity.

What it checks. Checks the functional health of your internal navigation.

Why it matters

This test audits the functional health of your internal navigation. It identifies links that point to pages on your own domain that no longer exist (404 Errors).

If the test fails

Internal links are the "Arteries" of your site, when they are broken, the flow of authority and "Crawl Equity' stops abruptly, leaving your site's architecture fragmented.

How to fix it

Perform an immediate audit of all internal 404 errors. You must: Redirect the Link: Use a 301 redirect to point the broken link to the most relevant live page. OR Update the Source: Correct the link at the source (the page it's sitting on) to point to the new URL. OR Remove the Link: If the content is gone and no replacement exists, remove the link entirely to prevent AI agents from wasting their "Crawl Budget" on non-existent pages.

What it checks. Checks the rel attribute within your site's HTML links.

Why it matters

This test audits the rel attribute within your site's HTML links. These attributes act as "Communication Protocols" that tell search engines and AI agents exactly how to treat a connection (e.g., nofollow, sponsored, or author). Valid syntax is required for these bots to follow your instructions.

If the test fails

When "rel" attributes are invalid (e.g., 17 instances of typos like no-follow or unsupported values), you are essentially giving broken directions to the AI. Instead of a clear signal, the AI encounters "Semantic Friction" and must use extra compute power to guess your intent.

How to fix it

Perform a bulk audit of all outbound and internal links to identify the 17 invalid strings. Replace unsupported or misspelled values with W3C-standard attributes (e.g., correcting no-follow to nofollow) e.g rel="noopener noreferrer"

What it checks. Monitors the total number of outbound links (both internal and external) on a single page.

Why it matters

This test monitors the total number of outbound links (both internal and external) on a single page. Search engines and AI agents have a finite "Crawl Budget" and "Authority Reservoir" for any given page. When a page exceeds 500 links, the "Link Equity" (PageRank) passed to each individual destination becomes so diluted it is virtually non-existent.

If the test fails

By spreading your link equity across 500+ destinations, you are telling the AI that nothing on this page is particularly important.

How to fix it

Review the page architecture to consolidate or remove unnecessary links.

What it checks. Ensures every internal link on your site points directly to the "Master" version of a page, rather than a duplicate or a variation.

Why it matters

This test ensures every internal link on your site points directly to the "Master" version of a page, rather than a duplicate or a variation.

If the test fails

Pointing to non-canonical URLs creates a "Split-Signal" effect. For an AI agent, this is a major hurdle in Knowledge Acquisition. The LLM encounters multiple versions of the same content and struggles to decide which one to ingest and cite. This results in "Authority Dilution," where your site's ranking power is fragmented across multiple URL variations instead of being concentrated into a single, high-visibility source of truth.

How to fix it

Perform a site-wide crawl to identify internal links that do not match the destination's self-referencing canonical tag. Update these links to point directly to the master URL. This ensures that 100% of your internal "Link Juice" and AI "Discovery Effort" are focused on the correct, authoritative versions of your content.

What it checks. Checks the relationship between your page content and your robots.txt file.

Why it matters

This test audits the relationship between your page content and your robots.txt file. It identifies instances where you have provided links to URLs that are explicitly "Disallowed" from being crawled.

If the test fails

When you link to a disallowed page, you waste the "Crawl Budget" of AI agents. A bot follows the link (Access), hits the "robots.txt" wall, and is forced to turn back. In the 2026 AI landscape, this is a Technical Credibility Gap, it signals that your site's architecture is fragmented.

How to fix it

Review the robots.txt file alongside your outbound link profile. You have two choices: 1. Remove the link if the destination is truly sensitive or private. 2. Update the robots.txt to "Allow" crawling for those specific paths if you want that content to contribute to your site's authority and AI-visibility.

What it checks. Checks whether a linked page receives at least five dofollow internal links.

Why it matters

Checks whether a linked page receives at least five dofollow internal links. Pages with no inbound internal links are covered by Orphaned Page Detection.

If the test fails

Pages with too few dofollow in-links signal low importance to crawlers, leading to reduced crawl frequency and weaker authority flow. For AI agents, low internal link density reduces perceived reliability and discoverability, increasing the chance the page is skipped or treated as secondary.

How to fix it

Strengthen internal linking to key pages using contextual, dofollow links from high-authority areas (nav, footer, related content). Build a clear link hierarchy so critical pages receive multiple incoming links.

What it checks. Checks the nofollow directive within the meta robots tag.

Why it matters

This test audits the page for the nofollow directive within the meta robots tag. In SEO, nofollow tells search engines not to pass "link juice" or authority to the links on the page. For AI agents, this is a "Path Block": it instructs the agent not to crawl or associate your page with the URLs it links to.

If the test fails

If applied globally to a page, nofollow prevents search engines from discovering and ranking other pages on your site via those links, effectively "starving" your sub-pages of authority. AI agents use links to establish "Topical Clusters." If an AI cannot follow the links on your page, it cannot verify the evidence for your Expert Sentiment found on other pages.

How to fix it

Remove "nofollow" from the Meta Tag immediately. If you need to block specific paid or untrusted links, apply rel='nofollow' to those specific links individually, rather than blocking the whole page.

What it checks. Checks conflicting instructions within the <meta name='robots'> tag or between multiple robots tags.

Why it matters

This test audits the page for conflicting instructions within the <meta name='robots'> tag or between multiple robots tags. For example, a page cannot be both index (please show this) and noindex (do not show this) simultaneously.

If the test fails

Search engines typically default to the most restrictive directive to be safe. If you have both index and noindex, Google will likely de-index the page, causing a total loss of organic traffic for that URL. AI scrapers prioritize "Risk Mitigation." When an agent encounters a contradiction, it flags the page as "Unstable/Conflicting." Because the AI cannot verify its legal right to ingest the data, it will often trigger an "Access Denied."

How to fix it

Consolidate all crawler instructions into a single, clear directive. Audit your CMS or SEO plugins to ensure they aren't injecting secondary, conflicting tags.

What it checks. Checks for the retired noodp and noydir directives, which no search engine honors.

Why it matters

This test checks for the noodp and noydir directives, which suppressed descriptions taken from the Open Directory Project and the Yahoo Directory. Google stopped honoring both in 2011 and the directories themselves have since closed, so the directives do nothing.

If the test fails

Nothing breaks: the directives are ignored. What they signal is a robots tag copied forward from a template that predates 2011 and never audited since, so the directives that do matter on the same page are worth checking too. Leaving them also makes the tag harder to read for whoever edits it next.

How to fix it

Delete noodp and noydir from the tag, then review the remaining directives on the same page, since a tag this old usually carries other assumptions worth revisiting.

What it checks. Checks for the unavailable_after directive, which schedules the page's removal from the index.

Why it matters

This test checks for the unavailable_after directive in the meta robots tag or X-Robots-Tag header. The directive names a date after which the page is dropped from the search index, and it keeps working long after whoever set it has moved on.

If the test fails

The page de-indexes itself on a date nobody is watching, and the traffic loss arrives as an unexplained drop weeks or months later. Because the directive is a scheduled instruction rather than a current state, it survives content refreshes: a page rewritten and relaunched still carries the old expiry unless the tag is removed.

How to fix it

Remove unavailable_after from pages meant to stay indexed. It belongs only on genuinely time-boxed content such as an event or a limited offer, and the date should be reviewed whenever the page is updated.

What it checks. Checks for the noimageindex directive, which removes the page's images from image search.

Why it matters

This test checks for the noimageindex directive in the meta robots tag or X-Robots-Tag header. The directive removes every image on the page from image search while leaving the page itself indexable, so the loss is invisible in ordinary rank reporting.

If the test fails

Every image on the page leaves Google Images, and image-rich results such as product grids and recipe carousels lose their thumbnail. Multimodal AI agents lean on image data to ground a visual answer; with the images withheld the page can be read but not shown, so a competitor's illustrated page is cited in its place.

How to fix it

Remove noimageindex unless the images are genuinely private or licensed against reuse. If only some assets need protecting, move those to a path blocked in robots.txt rather than suppressing the whole page's imagery.

What it checks. Checks for the presence of the noindex directive within the meta robots tag.

Why it matters

This test checks for the presence of the noindex directive within the meta robots tag. In SEO, noindex tells search engines to exclude the page from their search index. For AI agents, this is the "De-listing Command": it ensures that the page's data is not stored, cited, or used to generate answers for users in AI-driven search interfaces.

If the test fails

If this tag is present on a high-value page, that page will generate zero organic traffic, as it is physically removed from the search index. Agents like ChatGPT and Gemini respect the noindex tag as a "Privacy Boundary." While this protects sensitive data, if applied to your expert content, it creates a total Access Blackout. Your brand will never be cited as a source in an AI-generated summary.

How to fix it

Verify that the noindex tag is only applied to utility pages (e.g., login screens, thank you pages, internal search results). Ensure all high-value "Expert Sentiment" pages are set to index to allow for maximum Content Access.

What it checks. This test ensures your Meta Robots directives are placed inside the <head> element. While search engines may sometimes tolerate tags elsewhere, proper placement follows standards, and AI scrapers often look in the header first for indexing instructions.

Why it matters

This test verifies that your Meta Robots directives are located within the <head> element of your HTML. In SEO, while Google is famously forgiving and may find tags in the <body>, it is not a documented standard. For AI agents, this is a "Parser Efficiency" check. Modern AI scrapers often scan the header first and stop if they don't find indexing instructions where they expect them.

If the test fails

If a noindex tag is placed in the <body>, Googlebot usually finds it, but other search engines (like Bing or DuckDuckGo) may miss it entirely. This leads to Unintended Indexing, where private or utility pages you wanted to hide suddenly appear in search results, diluting your brand's authority and creating "thin content" issues. Many AI agents use "Streamlined Parsers" to save on tokens. They read the first 1-2 KB of a page (the <head>) to decide how to handle the data. If your directives are buried deep in the <body>, the agent triggers a "Hierarchy Exception Error." It may proceed to ingest data you intended to keep private, or it might ignore index instructions and skip your most important "Expert Sentiment" because it assumed the page had no directives at all.

How to fix it

Move to the Head: Verify that all <meta name="robots" ...> tags are placed between the opening <head> and closing </head> tags. Place Early: For the best results, place these directives near the top of the <head>, before heavy CSS or JavaScript files that might cause the parser to "timeout" or stop reading. Audit CMS Plugins: If you use a CMS like WordPress, ensure your SEO plugin isn't accidentally injecting tags into the footer or body of the page due to a theme conflict.

What it checks. This test checks the <meta name="robots"> tag for correct syntax and compatibility. In SEO, these directives control how search engines index and follow a page, while for AI systems, they act as permission headers that define what content can be scraped or ignored.

Why it matters

This test audits the <meta name='robots'> tag for both syntax accuracy and protocol compatibility. In SEO, these directives (like noindex, nofollow, noarchive) tell search engines how to treat the page. For AI agents, these tags are the Permission Headers: they define the legal and technical boundaries of what the AI is allowed to scrape using a Strict Vocabulary List.

If the test fails

If a tag is misspelled (Syntax) or uses a made-up directive like "nocach" (Compatibility), the instruction is ignored. This leads to Accidental Indexing, where private pages or duplicate content are exposed in public search results because the bot didn't understand your command to stop. AI agents operate on Consent-Based Scraping. If you use proprietary or outdated tags that the agent doesn't support, it triggers a Vocabulary Mismatch. The agent defaults to its own Scrape All policy because it doesn't recognize your specific restriction. This results in Unintended Access, where your Expert Sentiment is ingested and processed despite your attempts to limit its use.

How to fix it

Standardize your permissions using the industry-standard vocabulary: Validate Syntax: Ensure there are no typos, missing quotes, or conflicting instructions (e.g., having index and noindex on the same page). Use Supported Directives: Stick to the core vocabulary recognized by modern crawlers: index, noindex, follow, nofollow, noarchive, nosnippet, and max-snippet. Purge Legacy Tags: Remove unsupported or invented tags like "nocache" or "noodp", as these create noise that can confuse AI parsers.

What it checks. Checks for the nosnippet directive, which strips the description text from search results.

Why it matters

This test checks for the nosnippet directive in the meta robots tag or X-Robots-Tag header. The directive tells search engines to show no description text under the result title, leaving a bare link.

If the test fails

The result loses the two lines of text that persuade a user to click, so click-through falls even where the ranking holds. For AI agents nosnippet is an explicit instruction not to quote the page, which rules it out as a citable source: the content may be crawled, but it can never be the sentence an assistant attributes to you.

How to fix it

Remove nosnippet from pages you want found. Where a snippet must be limited rather than removed, use max-snippet with a character budget so the result still carries persuasive text.

What it checks. Checks for the notranslate directive, which blocks search engines from translating the page.

Why it matters

This test checks for the notranslate directive in the meta robots tag or X-Robots-Tag header. The directive stops search engines offering a translation of the page, which limits it to readers of the language it was written in.

If the test fails

The page is unreachable in practice for users searching in another language, which costs the most on a bilingual market where a single page was meant to serve both audiences. AI assistants answering in a second language will summarize a translatable competitor instead, since they cannot restate content they are told not to translate.

How to fix it

Remove notranslate unless the wording is legally fixed, as with regulated terms or contractual language. If the page exists in several languages already, connect them with hreflang instead of blocking translation.

What it checks. Verifies whether your website passes Core Web Vitals assessment.

Why it matters

This test follows Google PageSpeed Insights to assess the three Core Web Vitals: LCP, INP, and CLS. When INP is not measured, the assessment uses LCP and CLS; without LCP or CLS, it cannot be assessed.

If the test fails

Failing this assessment is a strong signal of weak page experience. Even with strong content, users and search systems may deprioritize pages that feel slow or unstable.

How to fix it

Track and improve LCP, INP, and CLS continuously, especially after releases. Review the separate TTFB test for server response performance.

What it checks. Checks if any single CSS file exceeds 300 KB.

Why it matters

This test checks if any single CSS file exceeds 300 KB. In SEO, large files are a primary cause of slow page load time. For AI agents, this is a "Processing Tax": machines prefer lean, efficient code so they can quickly understand the visual structure of your site without sifting through thousands of lines of unused styling.

If the test fails

Large CSS files create a "Render Block." The browser refuses to show anything to the user until the entire CSS file is downloaded and parsed. This ruins your First Contentful Paint (FCP) score, a key part of Google's ranking algorithm. If your FCP is slow, your rankings will drop. AI scrapers evaluate the "Efficiency Score" of a site. If your code is cluttered with thousands of lines of unused styling, the AI triggers a "Resource Penalty." It may decide your site is too heavy to crawl frequently, causing a "Discovery Lag" where your newest content takes weeks to appear in AI-generated summaries.

How to fix it

Optimize your CSS to stay under 300 KB limit. 1. Minification: Strip out all spaces, comments, and line breaks to shrink the file size. 2. CSS Purging: Identify and remove 'Dead CSS': styles that belong to old versions of your site or features you no longer use. 3. Modular Loading: Instead of one giant 500 KB file, split your CSS into smaller pieces that only load when a specific page needs them. By keeping your CSS lean, you create a High-Speed Entry for both users and AI agents.

What it checks. Counts how many individual pieces (elements) make up your webpage.

Why it matters

This test counts how many individual pieces (elements) make up your webpage. In SEO, a page with a massive "skeleton" takes a long time to load and can make the screen feel "frozen" while the browser tries to figure out where everything goes. For AI agents, a large skeleton creates "Processing Clutter," it makes it harder for the machine to cut through the code and find your actual words.

If the test fails

A huge DOM can cause the page to stutter or lag when scrolling. This is a bad user experience, and search engines like Google will notice and lower your ranking. Imagine trying to read a letter wrapped in 1,000 different envelopes. That’s what a large DOM feels like to an AI. Every "envelope" is a layer of code the machine must peel back to find your main content.

How to fix it

Simplify your page layout. Avoid using nested boxes (boxes inside boxes inside boxes) where they aren't needed. If you use a page builder (like Elementor or Divi), try to remove extra sections that don't add value. Keeping your "skeleton" under 1,000 pieces ensures your page is fast and easy to read for everyone.

What it checks. Measures how quickly the first visible page content appears.

Why it matters

This test measures First Contentful Paint (FCP). PageSpeed Insights reports FCP as the time until the browser renders the first text, image, SVG, or non-white canvas content.

If the test fails

Slow FCP makes the page feel blank or stalled, increasing abandonment before users can evaluate the content.

How to fix it

Reduce render-blocking resources, improve font loading, inline critical CSS where appropriate, and shorten server and redirect delays.

What it checks. Measures interaction latency of your pages.

Why it matters

This test measures Interaction to Next Paint (INP). A healthy threshold is 200ms or less. In SEO, this is a direct signal for responsiveness and usability.

If the test fails

If interaction latency is high, users experience delayed responses and your site feels unresponsive. This increases abandonment and degrades search performance signals.

How to fix it

Reduce long main-thread tasks, optimize third-party scripts, and split heavy JavaScript execution.

What it checks. Checks the size of individual JavaScript (.js) files to ensure they remain under the 300 KB threshold.

Why it matters

This test audits the size of individual JavaScript (.js) files to ensure they remain under the 300 KB threshold. In SEO, oversized scripts are the primary cause of poor "Total Blocking Time'"(TBT) and "Interaction to Next Paint" (INP) scores. For AI agents, large JS files represent "Execution Bloat": they require significant CPU resources to parse and execute before the actual content can be accessed.

If the test fails

Pages with massive JS files suffer from slow loading speeds, especially on mobile devices. Google penalizes these pages via Core Web Vitals, leading to a drop in rankings and a frustrating user experience. Many AI agents use "Headless Rendering" to see what a human sees. If a script is too large, the agent may trigger a "Resource Budget Timeout." Instead of waiting for the script to load your expert data, the agent moves on, resulting in an "Ingestion Failure." The AI "sees" a blank page or a loading spinner.

How to fix it

Optimize JavaScript delivery through Code Splitting, Minification, and Compression.

What it checks. Measures the Cumulative Layout Shift (CLS) of your pages.

Why it matters

This test measures the Cumulative Layout Shift (CLS) of your pages. To meet Core Web Vitals standards, your CLS score should be 0.1 or less. In SEO, this is a critical metric for "Visual Delight" and user retention. For AI agents, this is a "Coordinate Reliability" factor: it ensures that the elements the bot is trying to scrape don't move during the rendering process.

If the test fails

A high CLS score (above 0.1) results in a Frustration Penalty. Google’s algorithms detect when elements shift unexpectedly, which signals a low-quality user experience. This leads to lower rankings in the "Page Experience" category and, more importantly, a high bounce rate as users abandon a site that feels glitchy or difficult to navigate. AI scrapers often use "Visual Selectors" to identify specific data points (like price, author, or product specs). If a page has high CLS, the AI triggers a "Target Misalignment Error." The machine may attempt to extract data from a coordinate that has shifted, leading to "Corrupted Ingestion."

How to fix it

Set Explicit Dimensions: Always include width and height attributes on images and video elements so the browser can reserve the space before they load. Reserve Space for Dynamic Content: If you have ads or embedded widgets, use a placeholder container with a fixed height so they don't push the rest of your content down when they appear. Avoid Inserting Content Above Existing Content: Never insert new elements (like banners or newsletters) above content that has already loaded, except in response to a user action. By maintaining "Visual Layout Stability," you ensure that both humans and machines can interact with your brand with total confidence.

What it checks. Measures the Largest Contentful Paint (LCP) of your pages.

Why it matters

This test measures the Largest Contentful Paint (LCP) of your pages. To meet Core Web Vitals standards, LCP should occur within 2.5 seconds. In SEO, this is a primary ranking signal for user experience. For AI agents, this is the "Contextual Maturity" point: the moment the most significant data block is ready for extraction and processing.

If the test fails

If your LCP exceeds 2.5 seconds, search engines flag your site as slow. This usually happens due to unoptimized hero images or heavy render-blocking scripts. Because the largest element is what users focus on most, a delay here causes immediate frustration and significantly lowers conversion rates. AI scrapers prioritize the Main Body to determine "Expert Sentiment." If the largest element (often the main article or product image) loads slowly, the AI agent may trigger a "Contextual Timeout." This leads to "Partial Ingestion," where the AI understands your headers but misses the core data found in the main content.

How to fix it

Optimize the LCP Element: If it's an image, ensure it is compressed (WebP/AVIF) and use fetchpriority="high" to tell the browser to grab it first. Remove Render-Blocking CSS: Ensure the styles needed for that "Hero section" are inlined or loaded with the highest priority.

What it checks. Checks whether your server is compressing your HTML, CSS, and JavaScript files.

Why it matters

This test audits whether your server is compressing your HTML, CSS, and JavaScript files. In SEO, compression is a primary driver of Page Load Speed, which is a core ranking signal. For AI agents, this is a "Processing Incentive." Compressed sites are cheaper and faster to scrape, leading to more frequent indexing.

If the test fails

Without compression, your files can be 70% to 90% larger than they need to be. This causes a massive delay in Time to First Byte (TTFB) and Largest Contentful Paint (LCP). AI scrapers are optimized for "Resource Conservation." If your site sends uncompressed data, the AI triggers a "Crawl Latency" penalty. Over time, the AI will prioritize faster, compressed competitors for its real-time "Knowledge Graph" updates, leaving your "Expert Sentiment" outdated in AI-generated answers.

How to fix it

Apply high-performance compression to HTML, CSS, JavaScript, and SVG files.

What it checks. Measures whether the first byte of the main document arrives within 800ms.

Why it matters

This test measures Time to First Byte (TTFB), the server and network response latency before the first byte of the main document is received. A healthy threshold is 800ms or less.

If the test fails

Slow TTFB delays every later loading milestone, including FCP and LCP, and can make pages feel slow even when frontend assets are optimized.

How to fix it

Improve origin response time, caching, CDN routing, database queries, and redirect chains so the first byte arrives quickly.

What it checks. A redirecting URL must point to a live, 200 OK page.

Why it matters

This test flags any URL that redirects to a dead or missing page (returning a 4xx or 5xx status code). In SEO, pointing a bot to a broken page creates a "Black Hole" for authority. For AI agents, it is a "Verification Failure," as the scraper follows your explicit instructions only to find missing data, breaking trust in your site's architecture.

If the test fails

A broken redirect severely harms User Experience and completely wastes crawl budget. You are actively forcing search engines and AI to load an error page, which causes them to instantly drop the original URL from their knowledge graph and heavily penalize your domain's technical health score.

How to fix it

Find the broken redirect rule in your server settings or CMS and update the destination URL to point to a live, indexable page that returns a 200 OK status code. If the content no longer exists and has no replacement, remove the redirect entirely and let the original URL return a clean 404.

What it checks. Checks the total size of your raw HTML document to ensure it stays below the 1 MB limit.

Why it matters

This test audits the total size of your raw HTML document to ensure it stays below the 1 MB limit. In SEO, oversized HTML leads to "Crawl Truncation" where Google simply stops reading the page halfway through. For AI agents, this is a "Token Efficiency" issue: excessive code "noise" that wastes the agent's processing budget before it can reach your actual content.

If the test fails

Googlebot has a limit on how much of a page it will parse. If your HTML is massive (1 MB+), Google may only index the first few hundred kilobytes. If your most important Expert Sentiment or product details are at the bottom of that file, they effectively do not exist to search engines. This leads to missing rankings for key terms located deep in the code. AI tools have a budget for how much they can read at once. Every line of code uses up that budget. If your page is 90% messy code and only 10% real information, the AI might fill up its brain reading your menus and background settings. By the time it gets to your actual advice, it has no room left to learn, leading to the AI giving users shallow or wrong answers about your brand.

How to fix it

External CSS and JS: Don't use inline large blocks of styling or scripts. Move them to separate files so the HTML stays clean and content focused. Remove unnecessary nested <div> tags and comments on DOM that add weight without values.

What it checks. Checks the destination of all redirects to ensure they utilize the HTTPS protocol.

Why it matters

This test audits the destination of all redirects to ensure they utilize the HTTPS protocol. In SEO, HTTPS is a confirmed ranking signal and a prerequisite for modern web features. For AI agents, HTTPS represents the "Secure Access Layer." If a redirect points to an insecure HTTP URL, the agent may flag the link as a "Security Exception" and terminate the connection.

If the test fails

Search engines like Google prioritize the secure version of the web. If your redirects point to HTTP, you are intentionally downgrading your security signal, which can lead to lower rankings. If an AI agent follows a redirect that leads to an insecure HTTP page, it will often trigger an "Insecure Source" warning. The AI may decide to exclude your Expert Sentiment from its synthesized answer because the "Handshake" was not secure.

How to fix it

Perform a global audit of your redirect table. Ensure every 301 and 302 destination URL starts with "https://." Implement HSTS (HTTP Strict Transport Security) to tell browsers and AI agents to only interact with your site over secure connections.

What it checks. Checks that URLs do not pass through multiple consecutive redirects before reaching the final destination.

Why it matters

URLs should reach their final destination in a single redirect hop. This test identifies URLs that bounce through multiple consecutive redirects (e.g., Page A -> 301 -> Page B -> 301 -> Page C). In SEO, every hop dilutes PageRank and slows page speed. For AI agents, redirect chains can trigger a max-hop timeout and the crawler may abandon the path before reading the final page.

If the test fails

When a bot follows multiple redirects, it repeatedly downloads new server instructions before any content is rendered. This latency penalty hurts Core Web Vitals and crawl efficiency. Search engine bots and AI crawlers also enforce redirect-hop limits; long chains can cause crawl drop-off and indexing abandonment.

How to fix it

Audit your server's routing rules (e.g., .htaccess, Nginx config, or CMS SEO plugin). Update the initial redirect (Page A) so that it points directly to the final, active destination (Page C). Ensure no URL requires more than a single 301 or 302 hop to load.

What it checks. A healthy page should return "200 status" code.

Why it matters

A healthy page should return "200 status" code.

If the test fails

A 200 OK status indicates a healthy, accessible URL. This successful "handshake" confirms the page is live and ready for full indexing. If a page fails to return this status, its visibility is compromised: 4xx/5xx errors and "No Response" states create total access barriers that make content invisible to search engines, leading to an immediate collapse in rankings and user trust. Furthermore, a "No Response" signal often suggests a critical server timeout or a bot-blocking firewall. Meanwhile, 3xx redirects introduce latency and deplete "crawl budget."

How to fix it

Status: 200 (Ok): Page is healthy, no actions required. Status: 3xx (Redirected): Ensure this redirect is a permanent 301 and not a temporary 302. Audit your internal links to point directly to the final destination URL to eliminate 'Redirect Chains' and save crawl budget. Status: 4xx (Client Error/Missing): Check for typos in the URL. If the page has been permanently removed, implement a 301 redirect to the most relevant live category or product page to retain "link juice." Status: 5xx (Server Error): Review your server logs immediately. This is often caused by database connection issues, plugin conflicts, or memory exhaustion. Contact your hosting provider if the issue persists across the entire site. Status: No Response (Timeout/Blocked): Verify that your server is online. If it is, check your Firewall or CDN settings (like Cloudflare) to ensure you aren't accidentally blocking legitimate search engine or AI bot IP addresses.

What it checks. Checks the destination of your redirects to ensure they are forced to lowercase.

Why it matters

This test audits the destination of your redirects to ensure they are forced to lowercase. In SEO, inconsistent casing (e.g., mixing /About and /about) causes Duplicate Content issues and splits your ranking power across multiple URLs. For AI agents, lowercase URLs are the industry standard for "Clean Pathing." Maintaining a lowercase-only environment ensures that the machine can map your site architecture without encountering case-sensitivity conflicts.

If the test fails

If your redirects point to URLs with uppercase characters, search engines may index two versions of the same page. This confuses the "Canonical Signal" and forces Google to choose which version to rank. AI models use "Path Hashing" to remember which pages they have already scraped. If your system redirects to "/Expert-Insight" but your sitemap says "/expert-insight," the AI agent might crawl the same content twice, or worse, flag the site for "Inconsistent Data Architecture."

How to fix it

Implement a global server-side rule (usually via .htaccess or NGINX) to force all inbound requests and redirects to lowercase. Ensure all internal links and Canonical tags match this lowercase format. This creates a "Uniform Access Pattern" that allows AI agents to navigate your site with 100% path certainty.

What it checks. Checks URLs for accidental double slashes that can create duplicate content and messy site architecture.

Why it matters

This test checks your URLs for accidental double slashes (e.g., website.com//page). While web browsers usually fix this automatically for human users, search engines and AI agents view website.com/page and website.com//page as two completely different locations. We flag this to prevent duplicate content issues and keep your site architecture perfectly clean.

If the test fails

Having double slashes in your URLs creates accidental duplicate pages. This forces search engines to guess which version to rank, splitting your SEO power and wasting your crawl budget. For AI models, messy URLs act as structural noise. AI agents expect clean, predictable paths to map your brand's data. When they encounter sloppy URL formatting, it lowers their overall confidence in your site's technical quality.

How to fix it

Set Up a Global Redirect: Create a site-wide server rule that automatically redirects (301) any URL containing a double slash to its correct single-slash version. Update Internal Links: Check your website navigation menus, XML sitemaps, and canonical tags to make sure you are not accidentally linking to the broken double-slash version anywhere on your site.

What it checks. Verifies that paginated pages use regular anchor links that users, search engines, and AI bots can follow.

Why it matters

This test verifies that paginated pages are linked with regular HTML anchor tags (<a href="...">) so users, search engines, and AI bots can navigate to the next page in the series.

If the test fails

Search engines and AI bots cannot click JavaScript-only buttons like a human can; they need physical link paths to follow. If pagination relies on interactive buttons instead of standard links, bots can get stuck on Page 1, leaving older articles and deep product catalogs unindexed and undiscovered by AI agents.

How to fix it

Use Standard Links: Always use the <a> tag for pagination. Avoid using 'buttons' that rely solely on JavaScript to load the next page, as bots may not trigger the click. Visible Navigation: Ensure your "Next," "Previous," and "Page X" links are visible in the layout. This confirms to the bot that the content is part of a deliberate, accessible series. Check for 'Infinite Scroll' Conflicts: If you use infinite scroll, ensure there is still a fallback pagination system (like a noscript version or hidden standard links) so bots can still find the deeper URLs.

What it checks. Identifies cases where pagination URLs exist in the hidden code (like rel='next') but have no corresponding clickable links on the actual page.

Why it matters

This test identifies cases where pagination URLs exist in the hidden code (like rel='next') but have no corresponding clickable links on the actual page. In SEO, hidden attributes do not pass PageRank (ranking power). For AI agents, this is a "Contextual Isolation" warning, it suggests that while the pages exist, they aren't considered important enough to show to users.

If the test fails

If you only use pagination tags in the <head> but forget the visible links, PageRank stops at Page 1. Google might know Page 2 exists, but it won't give it any "strength." Consequently, the articles or products on Page 2+ will struggle to rank because they are effectively starved of the authority that should be flowing through your site. AI scrapers use "Authority Weighted Ingestion." They prioritize data that is vouched for by internal links. If an AI sees a pagination URL that is unlinked, it triggers an Importance "Tier Exception." It may classify that deep content as low-priority or archival only, leading to your "Expert Sentiment" being ignored in favor of more "connected" competitors.

How to fix it

Sync Code and Content: Every URL listed in your rel='next' and rel='prev' tags must have a matching clickable link in your website's footer or navigation bar. Audit for Hidden Pagination: Some themes use code to tell Google "there's more" but don't give the user a way to get there. Ensure your pagination is both "Search Engine Ready" and "User Friendly." Check for Redirects: If your pagination tags point to a URL that immediately redirects, the PageRank is leaked and lost. Always point to the final, healthy 200 OK page.

What it checks. Verifies that the URLs used in your rel='next' and rel='prev' attributes are fully functional and return a 200 OK status code.

Why it matters

This test verifies that the URLs used in your rel='next' and rel='prev' attributes are fully functional and return a 200 OK status code. In SEO, these links are instructions for crawlers to discover deeper content. For AI agents, this is a "Data Continuity" signal, if the sequence is broken, the agent assumes the knowledge base has ended, even if there are hundreds of pages left to ingest.

If the test fails

Search engines treat non-200 pagination URLs as errors and immediately ignore the instruction. If Page 2 points to a Page 3 that redirects (301) or is broken (404), Googlebot may stop crawling the series entirely. This leads to "Archive Decay," where your older content is never recrawled or updated because the bot lost the trail in the pagination sequence. AI scrapers use "Sequence Mapping" to ingest large datasets efficiently. A broken link in a rel="next" tag triggers a "Traversal Exception Error." Rather than trying to guess where the next page is, the AI agent will finalize its ingestion at the break point. This results in "Incomplete Brand Training," where the AI's understanding of your "Expert Sentiment" is limited only to your most recent posts, leaving your deep expertise untouched.

How to fix it

Direct Links Only: Ensure every rel="next" and rel="prev" URL leads directly to a 200 OK destination. Never point these attributes to a redirecting URL (301) or a blocked URL. Audit for "Off-by-One" Errors: Common pagination bugs include pointing the next link of the very last page to a non-existent URL. Ensure the sequence logic ends cleanly. Coordinate with Robots.txt: Verify that the URLs in your pagination are not accidentally blocked by a Disallow rule in your robots.txt file.

What it checks. Ensures that your paginated pages (Page 2, 3, etc.) are indexable and correctly canonicalized.

Why it matters

This test ensures that your paginated pages (Page 2, 3, etc.) are indexable and correctly canonicalized. In SEO, these pages are critical pathways for crawling deep content. For AI agents, this is a "Knowledge Depth" signal, if the deeper pages are blocked, the agent cannot access the full breadth of your brand's expertise or product range.

If the test fails

Canonicalizing Page 2+ back to Page 1 is a classic error. Because Page 2 has different content than Page 1, Google will view this as a "Conflicting Signal" and may stop crawling the series entirely. Similarly, using a noindex tag on Page 2+ tells Google to remove those pages from the index. Over time, Google stops following the links on those pages, causing your older content to disappear from search results. AI scrapers use "Hierarchical Traversal." They start at the top and follow the pagination to build a complete map of your data. If you block these pages, you create a "Discovery Dead-End." The AI agent will only ingest the most recent content on Page 1, leaving your historical "Expert Sentiment" and deep-archive value completely invisible to the LLM.

How to fix it

Self-Referencing Canonicals: Every page in a series (e.g., "/blog?page=2") should have a canonical tag that points to itself, not to Page 1. Ensure Indexability: Remove "noindex" tags from paginated pages. They must be indexable so search engines can follow the links to your deeper articles or products. Clean Navigation: Ensure "Next" and "Previous" links are clear and use standard <a> tags so bots can easily navigate the sequence.

What it checks. Checks whether the sitemap link in your robots.txt uses a full, absolute URL including the protocol (HTTPS).

Why it matters

This test audits whether the sitemap link in your robots.txt uses a full, absolute URL including the protocol (HTTPS). In SEO, this is the only valid way to declare a sitemap in this file. For AI agents, this is a "Data Root Verification": it confirms exactly which domain and protocol the following data belongs to.

If the test fails

Many search engines will simply ignore a sitemap link if it is not an absolute URL. This results in a "Discovery Failure," where the search engine is forced to crawl your site blind instead of following your optimized map. This leads to slower indexing of new pages and potentially missing deep-nested content. AI scrapers are highly sensitive to "Protocol Inconsistency." If you provide a relative path, the AI triggers a "Resource Resolution Error." It doesn't want to guess if you mean the HTTP or HTTPS version, the AI might skip the page entirely.

How to fix it

Standardize your roadmap for universal machine readability: Use the Full URL: Ensure your "robots.txt" line looks exactly like this: "Sitemap: https://www.yourdomain.com/sitemap.xml." Include the Protocol: Never omit the "https://."

What it checks. This test reviews your robots.txt for rules targeting AI and LLM scrapers like GPTBot or Google-Extended. In SEO, this affects visibility in AI search features, and for AI systems, it defines whether your content is allowed or restricted for training and citation use.

Why it matters

This test audits your robots.txt for directives targeting AI and LLM scrapers like GPTBot, CCBot, or Google-Extended. In SEO, this determines whether your content appears in AI Search Overviews. For AI agents, this is an "Instructional Baseline": a "stop sign" or "green light" that defines your site's boundaries in the age of generative search. Without these rules, you have no control over how your data is used for training or real-time citations.

If the test fails

Search is no longer just a list of links, it is a synthesis of information. If you block LLM crawlers, you voluntarily remove yourself from the AI Knowledge Graph. Conversely, if you have no strategy, you may experience Data Exploitation, where AI models learn from your Expert Sentiment without driving any traffic back to your domain. LLMs respect robots.txt to avoid technical and legal conflicts. If no instructions are provided, you are allowing your content to be consumed by default. However, agents like Google-Extended determine if your content can be used in Gemini’s generated answers, if your rules are unclear, the AI may trigger a Source Exclusion, choosing to exclude your site entirely to avoid copyright risk. This causes you to lose visibility to competitors who have explicitly defined their access path.

How to fix it

Define Your Policy: Decide if you want to allow full training (GPTBot/CCBot), allow only real-time citations/summaries (Google-Extended), or opt-out entirely. Audit Your Directives: Check your robots.txt for blocks against GPTBot, CCBot, Claude-Bot, and OAI-SearchBot. Implement Specific Rules: Add User-agent: GPTBot with Disallow: / to opt-out of model training, or use Allow: / for Google-Extended to ensure your brand is cited as a source in AI Overviews.

What it checks. This test checks that the Allow directive properly overrides broader Disallow rules to keep specific files or subdirectories accessible. In SEO, it protects private areas while preserving public pages, and for AI systems, it ensures valuable content isn’t accidentally blocked by broad restrictions.

Why it matters

This test verifies that the "Allow" directive is correctly implemented to "rescue" specific files or subdirectories that sit within a larger, restricted "Disallow" rule. In SEO, this is critical for keeping specific public pages accessible while protecting a private parent folder. For AI agents, this is a Precision Access Check, it ensures that your most valuable data nodes aren't accidentally locked behind a broad security rule.

If the test fails

Broad "Disallow" rules often catch high-value pages in the crossfire. If you block /resources/ to protect your backend but forget to explicitly Allow: /resources/public-whitepaper.pdf, search engines will treat that PDF as a restricted zone. This leads to "Hidden Content," where your best assets are barred from appearing in search results despite being technically public. Modern LLMs and high-speed scrapers respect your directory hierarchy strictly. If you use a broad block to save crawl budget but fail to "rescue" your training-ready content with an "Allow" tag, the AI triggers a Resource Restricted error. The agent assumes you have opted out of sharing that specific knowledge, causing the AI to skip your brand's expertise in its final responses.

How to fix it

Audit Parent Blocks: Review your robots.txt for broad Disallow rules (e.g., /assets/ or /content/) that might be covering valuable sub-pages. Implement "Rescue" Rules: Immediately follow a broad block with a specific Allow rule for the high-value files you want crawled (e.g., Allow: /assets/images/primary-infographic.png). Test for Conflicts: Use a robots.txt validator to ensure the "Allow" rule is being prioritized correctly by Googlebot and Bingbot.

What it checks. Checks for the presence of the crawl-delay directive in your robots.txt.

Why it matters

This test checks for the presence of the crawl-delay directive in your robots.txt. In SEO, Googlebot officially ignores this tag, but other search engines and scrapers do not. For AI agents, this is a "Throttling Signal": it tells the machine that your server is fragile or slow, causing it to deprioritize your content in favor of faster sources.

If the test fails

While Google ignores it, Bing and other engines will strictly obey a crawl-delay. This means it could take weeks longer for your new content to be indexed. AI scrapers work at Real-Time Velocity. If you have a 5-second crawl delay, an AI agent trying to map a 1,000-page site will take over an hour to finish resulting in failed scraping and skip your site and use a competitor's data to answer the user's prompt.

How to fix it

Remove :Crawl-delay:" lines from your "robots.txt."

What it checks. Checks if robots.txt files exist on non-canonical variants of your domain.

Why it matters

This test checks if robots.txt files exist on non-canonical variants of your domain. In SEO, only your master version should host this file. For AI agents, having multiple protocol files creates "Directive Ambiguity": the machine may be unsure which set of rules takes precedence.

If the test fails

If a bot hits "www.yourdomain.com/robots.txt" and finds a file, but then is redirected to "yourdomain.com" (your Master Version), it has to process two different sets of instructions. If the files aren't identical, it can lead to crawl errors where the bot gets confused about what is allowed. AI scrapers aim for "Zero-Waste Ingestion." If they encounter multiple robots.txt files across different domain variants, it triggers a "Conflict Resolution Protocol." The AI has to stop and compare the files to ensure they don't contradict each other, this extra step increases the "compute cost" of your site

How to fix it

Delete the Clutter: Remove any "robots.txt" files from your non-canonical domains (e.g., the http or www versions). Redirect Everything: Ensure that any request for "/robots.txt" on a non-canonical variant 301-redirects to the "/robots.txt" on your master version.

What it checks. This test ensures your robots.txt file stays under the 500KB limit. In SEO, oversized files are truncated and directives beyond the limit are ignored, and for AI systems, important rules placed at the end may become completely invisible to scrapers.

Why it matters

This test verifies that your robots.txt file is under the 500KB limit enforced by Google and other major search engines. In SEO, if the file exceeds this threshold, the bot will truncate the file and ignore all directives after the limit. For AI agents, this is an "Instructional Cutoff": rules placed at the bottom of an oversized file (like AI-specific blocks) will be completely invisible to the scraper.

If the test fails

If your file is bloated with thousands of individual lines, search engines will stop reading it once it hits 500KB. If your most important rules, such as Disallow: /admin or your Sitemap link are at the bottom of the file, the bot will proceed as if those rules do not exist, leading to accidental indexing of private directories. Many AI crawlers have even stricter memory limits for configuration files. An oversized file triggers a "Contextual Overflow" error. Rather than trying to process a massive document, the agent may default to a "Scrape All" state or ignore your specific "Allow" rules that were meant to give the AI access to your high-value data.

How to fix it

Audit for Bloat: Check your robots.txt for thousands of Disallow lines targeting specific spam bots. These are often the cause of oversized files. Use Wildcards: Consolidate your rules using patterns (e.g., Disallow: /spambot*/) rather than listing every individual URL. Prioritize the Header: Move your most critical security rules and your Sitemap declaration to the top 10 lines of the file to ensure they are always processed first.

What it checks. Verifies that the sitemap URL listed in your robots.txt is actually live and returning a 200 OK status code.

Why it matters

This test verifies that the sitemap URL listed in your robots.txt is actually live and returning a 200 OK status code. In SEO, an inaccessible sitemap is a "Dead Signal" that halts crawl efficiency. For AI agents, this is a "Data Source Verification" failure. If the map is broken, the machine cannot verify the structure of your knowledge base.

If the test fails

When you reference a broken or 404 URL in your robots.txt, search engines waste time trying to fetch it. Once they fail, they are forced to crawl your site the hard way by following individual links. This often leads to Indexing Lag, where your newest pages don't show up in Google for days or weeks. AI scrapers use the sitemap as a "Ground Truth" for your domain. If the sitemap is inaccessible, the AI triggers a "Structural Integrity Error." Rather than risk ingesting a fragmented or incomplete version of your site, the AI may deprioritize your content in its "Expert Sentiment" analysis.

How to fix it

Ensure your technical instructions lead to a functional destination: Test the Link: Manually copy the sitemap URL from your "robots.txt" and paste it into your browser. If it doesn't load instantly, it's broken. Fix 404s/Redirects: Ensure the sitemap URL does not redirect. It should go directly to the XML file.

What it checks. This test checks your robots.txt for syntax errors and invalid directives to ensure search engines and AI agents correctly interpret your crawl rules instead of ignoring them due to broken or non-standard instructions.

Why it matters

This test audits your robots.txt file for syntax errors (typos, missing colons, incorrect casing) as well as non-standard or broken directives (like using Noindex: or Crawl-delay:). In SEO, search engines are literal; a single typo or invented command renders an entire security rule invisible. For AI agents, this is a "Logic Integrity Check," if the syntax is broken or the vocabulary includes "Instructional Noise," the agent cannot trust the parameters and may default to a "Scrape All" or "Conservative Crawl" behavior, ignoring your privacy preferences.

If the test fails

Common mistakes include typos (e.g., Disalow) or using invented commands (e.g., Noindex: inside the txt file, which Google ignores). This leads to Accidental Indexing and a false sense of security, where a site owner thinks they have hidden a private staging environment, but the bot is actually ignoring the invalid line and indexing sensitive data anyway. AI scrapers use strict parsers for "High-Fidelity Compliance" to respect site owner rights. If an AI encounters a syntax error or an unrecognized line, it triggers a "Parser Exception" or an "Ambiguity Protocol." Rather than guessing what you meant, the AI may flag the file as corrupted and proceed to ingest all data (including the Expert Sentiment you intended to protect) or severely slow down its crawl of your site.

How to fix it

Standardize your gatekeeper logic to guarantee your data is accessed exactly how you intended: Correct the Typos: Disalow is not a valid directive. Change it to exactly Disallow. Verify Punctuation: Every directive (User-agent, Disallow, Allow, Sitemap) must be followed by a colon and a space. Stick to the Basics: Only use recognized commands. Do not use unsupported directives like Crawl-delay for Google. Use Meta Tags for Indexing: If you want to keep a page out of search results, use <meta name='robots' content='noindex'> in the page's HTML <head>, not a directive in robots.txt., Standardize Case Sensitivity: Use standard casing (e.g., User-agent, NOT useragent or USER-AGENT) to ensure universal machine compatibility.

What it checks. Flags robots.txt files that are overly generic.

Why it matters

This test flags robots.txt files that are overly generic (e.g., only containing User-agent: * and Disallow:). In SEO, a detailed file helps manage crawl budget by cordoning off junk folders. For AI agents, this is a "Contextual Guide": it tells the AI which parts of the site are for public.

If the test fails

If your file is too simple, you aren't protecting your Crawl Budget. Bots might waste time indexing your pages. This dilutes your ranking power because the "noise" is being indexed alongside your "signal." High-end AI agents look for specific "Scraper-Agent" directives. If you don't have detailed rules, the AI may default to a generic crawl that misses your high-value "Expert Sentiment."

How to fix it

Block the Junk: Explicitly disallow administrative folders, internal search results, and staging environments (e.g., Disallow: /admin/). Add Your Sitemap: Always include a link to your XML sitemap at the bottom: "Sitemap: https://yourdomain.com/sitemap.xml."

What it checks. This test confirms your robots.txt is encoded in UTF-8 so bots can read it correctly. In SEO, proper encoding prevents parsing errors, and for AI systems, it ensures your directives aren’t misread or ignored due to incompatible character formats.

Why it matters

This test verifies that your robots.txt file is saved in the UTF-8 character set. In SEO, this ensures that search engine bots can read your instructions without error. For AI agents, this is a Decoding Standard. If the file uses an outdated format (like ANSI or UTF-16), the AI may interpret your text as "garbage" data and ignore your privacy rules entirely.

If the test fails

Bots like Googlebot expect UTF-8. If you save your file in a different encoding, special characters or even standard directives might be garbled. This leads to Directive Blindness, where the bot ignores your "Disallow" rules because it can't read the words, potentially indexing your private admin pages. AI scrapers process millions of files per second. If your encoding is non-standard, the AI triggers a Parsing Failure. Instead of trying to decode your unique format, the AI will likely skip your file or assume default permissions (Allow All), leading to the unauthorized scraping of your Expert Sentiment.

How to fix it

Check the Save Settings: Open your robots.txt file in a code editor (like Notepad++ or VS Code) and ensure the encoding is set to UTF-8 without BOM. Avoid Rich Text Editors: Never use Microsoft Word or Google Docs to edit this file, as they add hidden formatting characters that break bot readability. Validate Headers: Use your browser's Developer Tools to confirm the server is sending the header "Content-Type: text/plain; charset=utf-8."

What it checks. Checks your robots.txt file for directives that block bot access to essential site assets (CSS, JS, Images) using the "*" wildcard.

Why it matters

This test audits your robots.txt file for directives that block bot access to essential site assets (CSS, JS, Images) using the "*" wildcard. In SEO, this prevents "Full Page Rendering." For AI agents, this is a "Contextual Blackout": the machine cannot "see" the layout.

If the test fails

Google’s ranking algorithm is now "Visual-First." If your robots.txt blocks the CSS or JavaScript required to render the page, Google sees a broken, unstyled version of your site. This triggers a Mobile-Friendly Failure and a Core Web Vitals Penalty. If you block these assets, the AI triggers a "Semantic Confusion Error": It may misinterpret your Expert Sentiment.

How to fix it

Remove Wildcard Blocks: Ensure your robots.txt does not contain "Disallow:" "/*.css" or "Disallow: /*.js."

What it checks. This test scans your robots.txt for Disallow: / under a general user-agent. In SEO, it blocks search engines from your entire site, and for AI systems, it creates a total data blackout that removes your content from the AI knowledge ecosystem.

Why it matters

This test checks your robots.txt file for the use of "Disallow: /" under a general user-agent. In SEO, this is the most dangerous command you can issue, as it tells search engines to ignore your entire domain. For AI agents, this is a "Total Data Blackout." it prevents LLMs from accessing any part of your site, effectively deleting your brand's presence from the AI knowledge ecosystem.

If the test fails

A single forward slash (/) in the Disallow field is a command to every bot to stay away from your entire website. For AI Agents if you use a full block without a specific user-agent, you are triggering a "Knowledge Exclusion" event. While you may want to block AI from training on your data, a generic "Disallow: /" will also block AI-powered search engines (like Gemini or Perplexity) from citing your Expert Sentiment as a source, causing your competitors to dominate the AI-generated answers.

How to fix it

Check the Path: If you see "Disallow: /" and your site is live, delete that line immediately. This is only for private staging environments. Be Specific: If you only want to block a certain part of the site, use a specific path (e.g., Disallow: /private/). Target the Bot: If you want to block AI but allow Google Search, use specific User-agents (e.g., User-agent: GPTBot with Disallow: /) instead of a blanket ban.

What it checks. Checks the robots.txt file: the server's "Terms of Entry." In the 2026 AI-first landscape, this file is the primary governor of AI-Scrapability.

Why it matters

This test audits the robots.txt file: the server's "Terms of Entry." In the 2026 AI-first landscape, this file is the primary governor of AI-Scrapability. It dictates which folders a bot is allowed to crawl. A Disallow directive here is a hard technical and legal barrier that prevents an AI agent from even parsing your content.

If the test fails

If a folder containing your main content is "Disallowed," search engines will stop crawling those pages. While they might still appear in results if linked from elsewhere, they will lack snippets and authority, leading to a massive drop in organic visibility. Compliance with robots.txt is the gold standard for "Ethical AI Scraping." If you accidentally block your content, AI agents will treat the site as a "No-Fly Zone." They will not access your Expert Sentiment.

How to fix it

Perform a regular audit of your robots.txt file. Ensure that your high-value content directories (blogs, whitepapers, services) are set to "Allow."

What it checks. Verifies the existence of a robots.txt file at your domain's root.

Why it matters

This test verifies the existence of a robots.txt file at your domain's root (e.g., yourdomain.com/robots.txt). In SEO, this is the first file a search engine looks for to understand your crawling rules. For AI agents, this is the "Permission Handshake": without it, the agent may default to overly aggressive or overly cautious crawling behavior.

If the test fails

Without a robots.txt, search engines have no "Speed Limit," they may waste your Crawl Budget on infinite calendar loops, internal search filters, or sensitive PDF directories. This results in Index Bloat, where poor-quality pages compete with your high-value content for rankings. Many AI scrapers operate under a "Consent-First" model. If a robots.txt is missing, the AI agent triggers an "Uncertainty Flag." This means your "Expert Sentiment" never gets indexed by the LLM.

How to fix it

Establish a formal entry point for all automated visitors: Create the File: Even a simple file that allows everything is better than no file at all. Point to the Map: Always include your Sitemap URL at the bottom of the file to give bots a quick start guide.

What it checks. Checks if your robots.txt file contains a direct link to your XML sitemap.

Why it matters

This test checks if your robots.txt file contains a direct link to your XML sitemap. In SEO, this serves as a "Universal Discovery" signal for search engines. For AI agents, this is the "Ingestion Shortcut": it allows the scraper to bypass deep-crawling every internal link and instead jump straight to a verified list of your most important content.

If the test fails

Without a sitemap reference in your robots.txt, search engines have to rely on "Link Crawling" (following one link to the next) to find your pages. If you have deep-nested pages or "orphan pages" (pages with no internal links), Google may never find them. AI scrapers prioritize "Structured Ingestion." If an AI agent enters your site and doesn't find a sitemap link in the robots.txt, it triggers a Manual Discovery Protocol, this is slower and more computationally expensive.

How to fix it

Add the Directive: Insert a single line at the bottom of your "robots.txt" file: "Sitemap: https://yourdomain.com/sitemap.xml." Use Absolute URLs: Always use the full "https://" version of the URL to avoid any protocol confusion. Keep it Updated: Ensure the sitemap linked in your robots.txt is the "Master Version" that stays updated as you add new content. By referencing the sitemap, you provide an instant roadmap that allows machines to access your data with zero wasted effort.

What it checks. It detects pages no internal link path reaches from the start URL.

Why it matters

Flags pages that no chain of internal links reaches from the start URL, including pages only linked from other unreachable pages.

If the test fails

Without an inbound internal link, visitors and crawlers cannot discover this page by following links on the site.

How to fix it

Add a relevant internal link to this page from another page on the site.

What it checks. Checks whether the current URL is listed in any of the site’s submitted XML sitemaps.

Why it matters

This test audits whether the current URL is listed in any of the site’s submitted XML sitemaps. In SEO, the sitemap is the primary tool for communicating site architecture and page priority to crawlers. For AI agents, the sitemap serves as a "Verified Data Manifest": it acts as a checklist for the machine to ensure it has successfully accessed and archived all of your brand’s authoritative content.

If the test fails

Pages missing from the sitemap are crawled less frequently and are viewed by Google as "orphaned" or "lower priority." This leads to slower indexing of updates and a diminished "Crawl Budget" for your most important expert insights. In a AI-first environment, AI agents use sitemaps to perform "Differential Crawling" (only scraping what is new or verified). If a page is missing from the manifest, it may be excluded from the AI’s Active Knowledge Set. The AI might see the page via a link but hesitate to use it as a primary source.

How to fix it

Ensure that all high-value, indexable URLs are included in your dynamic sitemap.xml. Remove any utility pages (like 'Thank You' pages) that don't need to be indexed.

What it checks. Checks the uncompressed file size of your individual XML sitemaps.

Why it matters

This test audits the uncompressed file size of your individual XML sitemaps. In SEO, Google and Bing set a hard limit of 50MB per sitemap file. For AI agents, this is a "Compute Efficiency" signal. If a file is too heavy, the agent may flag the source as unoptimized for high-speed ingestion.

If the test fails

If an individual sitemap exceeds 50MB, search engine bots will simply stop reading it mid-way. This results in "Truncated Indexing," where thousands of your pages are ignored because they were listed too far down in a file that was too large to process. AI scrapers operate on strict "Token and Memory Limits." A sitemap over 50MB triggers an "Ingestion Timeout." To save on compute cost, the AI will discard the heavy file and move to a more efficient competitor.

How to fix it

Sitemap Splitting: If your sitemap is approaching the limit, split it into several smaller files (e.g., sitemap-1.xml, sitemap-2.xml). Clean the URLs: Ensure you aren't including junk parameters or duplicate URLs that are unnecessarily increasing the file size.

What it checks. This test checks the syntax of Image and Video sitemap extensions, ensuring required fields are present so media can appear in search results. Broken visual metadata limits visibility in SEO and prevents AI systems from properly linking images to their textual context.

Why it matters

This test validates the syntax of Image and Video sitemap extensions. In SEO, missing required fields like <video:thumbnail_loc> prevents your media from appearing in Google Images or Video Search. For AI agents, this causes Contextual Blindness, if the visual metadata is broken, the AI cannot associate your images with your text, losing critical context.

If the test fails

Google requires specific tags to index videos. If you miss the "<video:player_loc>" or "<image:license>" tags, your rich media assets are effectively invisible in search features, even if the content is high quality. Multimodal AI models (like Gemini or GPT-4o) rely on structured metadata to "see" the web. Broken image syntax means the AI cannot scrape the relationship between your product photo and its description, weakening the entity understanding of your page.

What it checks. Confirms that the XML sitemap is reachable by external bots and returns a 200 OK status code.

Why it matters

This test confirms that the XML sitemap is reachable by external bots and returns a 200 OK status code. In SEO, this ensures search engines don't hit a wall when trying to map your site. For AI agents, this is the "Data Handshake": it is the prerequisite for the agent to begin structured data ingestion.

If the test fails

If your sitemap returns a 403 (Forbidden) or 404 (Not Found) error, search engines will assume your site structure is private or broken. They will stop attempting to use the map, leading to "Indexing Decay." AI scrapers operate with a "Failure Threshold." If the sitemap isn't accessible on the first attempt, the AI may flag the entire domain as "Unstable Source" and skip it.

How to fix it

Direct Accessibility: Verify that your sitemap is not hidden behind a password or a login screen. No Redirects: The sitemap should be a direct link, not a 301 redirect to another page, to ensure the fastest possible ingestion for high-speed AI agents.

What it checks. This test verifies that every sitemap URL is the self-referencing canonical version and does not redirect or point elsewhere. In SEO, this prevents signal confusion, and for AI systems, it ensures the sitemap is a clean, reliable list of final destinations.

Why it matters

This test ensures that every URL listed in the sitemap is the Self-Referencing Canonical version. You should never include a URL in a sitemap that redirects or has a canonical tag pointing elsewhere. In SEO, this creates Signal Confusion. For AI agents, this is a "Manifest Validation": the AI expects the sitemap to be a clean list of final destinations.

If the test fails

If your sitemap lists Page A, but Page A has a canonical tag pointing to Page B, you are sending conflicting signals. Google has to decide whether to trust the Map or the Page. This wastes crawl budget and delays the indexing of the correct page. AI scrapers treat the sitemap as a Verified Asset List. If they follow a link from the sitemap and land on a page that says "Don't index me, index that other page instead," the AI triggers a Verification Exception. It may flag your entire sitemap as unreliable and stop using it for discovery.

How to fix it

Check for Redirects: Remove any URL that returns a 301 or 302 status code. Check Canonical Tags: Remove any URL where the rel='canonical' tag does not match the URL itself (non-self-referencing). Replace with Master: Replace these "dirty" URLs with the final, self-referencing canonical versions.

What it checks. This test verifies your Sitemap Index structure, ensuring that sites with over 50,000 URLs use a sitemap of sitemaps that acts as the root discovery layer in SEO and a master directory for AI systems to understand how your content is organized and where each sub-sitemap is located.

Why it matters

This test validates the technical structure of your Sitemap Index file. For websites with more than 50,000 URLs, a "Sitemap of Sitemaps" is required. In SEO, this is the root of your discovery tree. For AI agents, this is the "Master Knowledge Manifest": the high-level directory that tells the machine how your entire database of expertise is organized and where to find the sub-directories.

If the test fails

If the parent Index file has a syntax error or is malformed, search engines cannot "unlock" the child sitemaps. Google will stop at the index level, failing to discover the thousands of pages hidden inside the sub-files. This leads to a total stagnation in rankings for any new or updated content. AI scrapers use the Sitemap Index to determine the "Content Breadth" of a brand. A structural failure here causes a "Discovery Timeout": the machine sees a broken root node and assumes the knowledge base is empty or corrupted, causing the AI to prioritize a competitor with a cleaner data manifest.

How to fix it

Check Tag Integrity: Ensure the file uses the "<sitemapindex>" root tag and only contains "<sitemap>" entries. Never include individual "<url>" tags in an index file. Verify Child Accessibility: Every child sitemap URL listed in the index must return a 200 OK status. If one sub-map is a 404, it can flag the entire index as unreliable. Validate XML Syntax: Use an XML validator to ensure there are no missing closing tags or illegal characters that would cause a parser exception.

What it checks. Verifies that your sitemap conforms to the official XML sitemap protocol (sitemaps.org).

Why it matters

This test verifies that your sitemap conforms to the official XML sitemap protocol (sitemaps.org). In SEO, invalid syntax causes search engines to reject the entire file. For AI agents, this is a "Data Integrity" check. If the structure is non-standard, the agent cannot parse the URLs to begin its ingestion of your brand's data.

If the test fails

Even a tiny error, like a missing "</url>" tag or an illegal character in a URL, can break the entire sitemap. When this happens, Googlebot triggers a "Parsing Error" and stops reading. This results in Total Discovery Failure, where none of the pages listed in that specific sitemap fragment are indexed or updated in search results. AI scrapers use high-speed Schema Parsers. If the XML is malformed, the parser throws an "Exception Error." To avoid processing "garbage" data, the AI agent will skip the source.

How to fix it

Validate the Code: Use an XML validator to check for hidden syntax errors or illegal characters (like unescaped ampersands &). Standard Headers: Ensure the file starts with the correct namespace declaration: xmlns="http://www.sitemaps.org/schemas/sitemap/0.9". UTF-8 Encoding: Confirm the file is saved in UTF-8 encoding to ensure special characters don't break the machine's ability to read the text. By maintaining Sitemap Syntax Protocol, you ensure your "Knowledge Map" is readable by every bot on the planet.

What it checks. This test checks your XML sitemap for protocol mismatches, ensuring an HTTPS site is not listing insecure HTTP URLs. In SEO, this creates conflicting signals that harm trust and discovery, while AI systems may treat such sitemaps as unreliable due to security risks.

Why it matters

This test audits your XML sitemap for protocol mismatches, specifically checking if an HTTPS website is listing insecure HTTP URLs. In SEO, this is known as Dirty Data, it creates a conflict between your site’s secure identity and its discovery roadmap. For AI agents, this is a Trust Boundary Breach. Modern LLMs prioritize secure data streams and may flag a sitemap as "unreliable" if it points to unencrypted entry points.

If the test fails

If an HTTPS site includes HTTP links in its sitemap, it creates mixed signals that can confuse Google, waste crawl budget, and cause indexing issues. Secure-first AI systems may skip those insecure URLs entirely, preventing your content from being discovered and used.

How to fix it

Run a Global Scan: Audit your XML sitemap and identify any URLs beginning with http://. Enforce HTTPS: Update your sitemap generator settings to ensure every <loc> entry matches your site’s SSL protocol (https://). Purge Dirty Data: Remove any legacy HTTP entries. A sitemap should only ever point to the live, secure, and final destination of your content.

What it checks. Checks the number of URLs contained within a single XML sitemap file.

Why it matters

This test audits the number of URLs contained within a single XML sitemap file. In SEO, the industry standard (and hard limit for Google/Bing) is 50,000 URLs per file. For AI agents, this is a "Processing Capacity" signal, exceeding this limit can cause memory overflow or partial ingestion during the discovery phase.

If the test fails

If a single sitemap lists more than 50,000 URLs, search engines will simply ignore every link after the 50,000th mark. This leads to "Dark Data," where potentially thousands of your pages exist on your server but are never discovered or indexed by search engines. AI scrapers prioritize "Predictable Data Structures." A file that exceeds standard limits triggers a "Resource Allocation Warning." Rather than risking a crash or an incomplete crawl, the agent may discard the entire file. This leaves your "Expert Sentiment" unmapped.

How to fix it

Enforce the Limit: If your site has more than 50,000 pages, split them into multiple sitemap files (e.g., sitemap-posts-1.xml, sitemap-posts-2.xml). Use an Index: Ensure all these fragments are listed in a Sitemap Index (like the wp-sitemap.xml you verified earlier). Prioritize Quality: Don't bloat your sitemap with utility pages or "junk" URLs.

What it checks. Checks the sitemap.xml to ensure it only contains "clean" URLs (200 OK status and indexable).

Why it matters

This test audits the sitemap.xml to ensure it only contains "clean" URLs (200 OK status and indexable). Pages that are set to noindex, password-protected, or that redirect to other locations should never be in the sitemap. In SEO, this prevents "Crawl Budget" waste. For AI agents, this is a "Data Trust" signal. A clean sitemap tells the machine that every URL in the manifest is a high-quality, authorized source of information.

If the test fails

When search engines encounter non-indexable pages in a sitemap, they lose trust in the file's accuracy. This can lead to the search engine ignoring the sitemap entirely, resulting in slower indexing for your actual content. In an AI-first landscape, agents perform "Pre-Flight Validation." If an AI agent hits a noindex or a 404 error inside your sitemap, it flags the site for "High Inefficiency," this creates a Scrapability Friction.

How to fix it

Audit your sitemap generation logic to ensure it automatically excludes any page that is not a 200 OK indexable URL. If you use a manual sitemap, remove all redirects and noindex pages immediately. This ensures a "Frictionless Access Path" for AI agents, allowing them to focus 100% of their resources on ingesting your authoritative content.

What it checks. This test checks for a valid XML sitemap at the domain root, ensuring proper page discovery for search engines and serving as a structured URL directory for AI agents.

Why it matters

This test verifies that a valid XML sitemap is present at the root of your domain. In SEO, this is the primary mechanism for page discovery. For AI agents, this is the "Knowledge Directory": a curated list of all the URLs that contain the brand's "Expert Sentiment" and data sets.

If the test fails

If the sitemap is physically missing, search engines have to rely on "Crawl Discovery": following one link to the next. If your site has a complex hierarchy or "orphan pages," they may never be indexed, leading to a massive loss in organic traffic. Many high-speed AI scrapers are programmed to skip traditional "link-following" crawls to save on compute resources. They go straight for the XML file. If it’s missing, your site is effectively invisible to the LLM.

How to fix it

Verify Root Access: Ensure the file remains at the standard location (e.g., poliris.io/sitemap.xml or referenced correctly in robots.txt).Cross-Platform Submission: Ensure this map is not only present but also submitted to Google Search Console and Bing Webmaster Tools for maximum visibility. By maintaining a Sitemap Presence, you ensure that no piece of your expertise is left in the dark.

What it checks. Identifies links to Microsoft Word documents (.doc or .docx).

Why it matters

This test identifies links to Microsoft Word documents (.doc or .docx). In SEO, these files are harder for search engines to index and can provide a poor user experience. For AI agents, a Word document is an "Unstructured Risk": they prefer PDFs or raw HTML because the data is more stable and easier to "scrape" accurately.

If the test fails

While Google can index Word docs, they rarely rank well. When a user clicks a .doc link, it often forces a download rather than opening in the browser. This breaks the user's flow, often leading them to close the tab immediately, which signals to Google that your content wasn't helpful. AI scrapers use "Fixed-Layout Ingestion." A PDF preserves the exact structure of your tables, headers, and images. A Word doc can change its layout depending on what software opens it. This creates "Extraction Uncertainty": the AI might misinterpret your main content because the document's structure shifted during the reading process.

How to fix it

Convert all downloadable documents to PDF format:: Universality: Ensure your content can be read on any phone, tablet, or laptop without needing extra apps.: Security: PDFs can be locked to prevent unauthorized editing, which protects your "Expert Sentiment.": Stability: Use PDFs to ensure AI agents see your data exactly as you intended it to be seen. By switching to PDFs, you provide a Standardized Path for both human readers and AI crawlers.

What it checks. Checks all anchor <a> tags to ensure they contain a valid, functional href attribute.

Why it matters

This test audits all anchor <a> tags to ensure they contain a valid, functional href attribute. In SEO, every link should be a clear path to new information. For AI agents, an empty href is a "Logic Gap": the machine sees an invitation to access but no "Address" to follow, which can cause the scraper to stall or flag the page code as low-quality.

If the test fails

Search engines like Google will fail to discover and pass "Link Equity" to your internal pages, leading to poor rankings for your deep content. AI scrapers use links to understand the Relationship between your pages. When they encounter an empty link, it creates Semantic Friction. The AI has to use extra processing power to determine if the link is a mistake or a hidden element. This reduces your "Scrapability Score."

How to fix it

Every link tag must have a valid destination. 1. Provide a URL: Ensure the href='' " is filled with a real web address. 2. Use a Button: If the element is meant to trigger a pop-up or a function (not a new page), use a "<button>" tag instead of a link tag. 3. Remove the Tag: If the link is no longer needed, delete the <a> tags entirely. By cleaning up these "Ghost Links," you provide a frictionless path for AI agents to follow, ensuring they spend their time learning from your data rather than getting stuck on broken code.

What it checks. Verifies the presence of the "lang" attribute within the <html> tag of your code.

Why it matters

This test verifies the presence of the "lang" attribute within the <html> tag of your code. In SEO, this helps search engines categorize your page for regional search results. For AI agents, this is the "Linguistic Anchor": it tells the machine exactly which dictionary to use to interpret your content correctly.

If the test fails

Without a lang tag, Google might struggle to determine if your page is meant for a specific country. This can lead to "Regional Misplacement," where your Spanish-language site for Mexico accidentally shows up in searches for Spain, or doesn't show up at all for your target audience. AI bots process your site almost instantly. If you do not define the language in the code, the AI is forced to guess the language. If the AI guesses incorrectly, it will likely mistranslate your content or apply the wrong tone. This means when an AI summarizes your business for a potential customer, it may use clunky phrasing or incorrect vocabulary, directly damaging your professional credibility.

How to fix it

Ensure your developer adds the correct language code to the very first line of your website's code: Be Specific: Use lang="en" for English, lang="es" for Spanish, or lang="fr" for French. Regional Accuracy: If your content is specifically for a region, use a sub-tag like lang="en-US" (English for the USA) or lang="en-GB" (English for the UK). By labeling your language clearly, you give AI bots a guaranteed path to follow. This ensures they can translate and summarize your professional advice perfectly, without having to guess what you are trying to say.

What it checks. This test checks if the page uses the <meta name='keywords'> tag.

Why it matters

This test checks if the page uses the <meta name='keywords'> tag. In the early days of SEO, this was where you listed the words you wanted to rank for. Today, major search engines like Google ignore them completely. For AI agents, this tag is mostly ignored in favor of reading your actual sentences, though it can occasionally be used as a tiny hint for the page's main topic.

If the test fails

Major search engines abandoned the meta keywords tag over a decade ago. Today, it provides absolutely zero SEO or AI visibility value. Worse, leaving these tags on your pages adds unnecessary code bloat and publicly exposes your exact target keyword strategy to your competitors.

How to fix it

Remove them entirely: Do not waste any time manually writing or generating meta keywords for new or existing pages.

What it checks. Checks for the "<meta http-equiv='refresh'>" tag in your page code.

Why it matters

This test looks for the "<meta http-equiv='refresh'>" tag in your page code. In SEO, these are considered unreliable redirects that search engines often ignore or penalize. For AI agents, this is an "Unpredictable Jump": the machine starts reading your content, but the page suddenly changes, which can break the agent's logic flow and lead to incomplete data indexing.

If the test fails

Google prefers 301 Redirects (permanent server-side moves). When you use a Meta Refresh, the "Ranking Power" of the old page often fails to transfer to the new one. It can also be flagged as a "Sneaky Redirect," which is a violation of Google’s quality guidelines and can lead to your site being de-indexed. AI scrapers are built for speed. If a page has a 5-second refresh timer, the AI might finish its scrape and leave before the refresh even happens, or it might hit the second page and lose the context of the first.

How to fix it

Stop using Meta Refresh tags and switch to Server-Side Redirects: 301 Redirect: Use this for permanent moves. It tells the search engine, "This page has moved forever; give all the credit to the new URL.

What it checks. Checks the HTML source code for the presence of the "style=" attribute within individual elements.

Why it matters

This test audits the HTML source code for the presence of the "style=" attribute within individual elements. While inline styles are technically functional, they create "Code Bloat" that intertwines presentation with information. In a modern technical framework, visual instructions should be abstracted into external CSS files to maintain a clean Text-to-HTML ratio.

If the test fails

Excessive inline styles increase the page's byte size and can lead to slower parsing times. It also makes site-wide design updates a nightmare, which indirectly leads to inconsistent User Experience (UX), a known Google ranking factor. AI agents use "Tag-to-Text Analysis" to understand content hierarchy. When your HTML is littered with inline styles, the "Noise Floor" of the document rises. The agent has to work harder to "Tokenize" your text because it is constantly interrupted by style strings.

How to fix it

Migrate all inline styles to a centralized external CSS stylesheet. Use semantic classes (e.g., .expert-insight instead of style='...') to provide both a visual and a programmatic signal of the content's importance.

What it checks. Checks for analytics tracking snippets.

Why it matters

This test audits the page for the presence of analytics tracking snippets (such as Google Analytics 4, Adobe Analytics, or privacy-first alternatives). In SEO, analytics allow you to measure "Dwell Time" and "Engagement," which are critical indirect ranking signals. For AI agents, analytics, specifically those that track bot behavior, provide the "Access Audit Trail," allowing site owners to see which AI models are scraping their content and how they are navigating the site."

If the test fails

Without tracking, you cannot identify which pages are performing well or where users are "bouncing." This makes it impossible to optimize your content for human access and authority. In 2026, the battle for visibility happens in the "AI Attribution" space. If analytics are missing, you cannot measure "Referral Traffic" from AI agents like SearchGPT or Gemini. This results in a Strategic Access Gap, you cannot verify if your Expert Sentiment is actually being accessed and cited by AI models.

How to fix it

Ensure a global analytics tracking snippet is correctly implemented on every indexable page. Prioritize configurations that can distinguish between human traffic and AI-bot traffic. This secures the "Data Feedback Access" needed to refine your site’s visibility in a machine-driven search economy.

What it checks. Checks for visual behavioral tracking tools like Hotjar, Microsoft Clarity, or Mouseflow.

Why it matters

This test audits the page for the presence of visual behavioral tracking tools like Hotjar, Microsoft Clarity, or Mouseflow. In SEO, these tools provide the "why" behind high bounce rates or low conversion. For AI agents, this data is the foundation of "UX-Signal Optimization." Understanding how humans visually navigate your content allows you to restructure your data to ensure the most critical "Expert Insights" are in the primary Access Path.

If the test fails

You cannot see where users stopped scrolling. This leads to a User Experience (UX) failure, which Google uses as a primary signal for ranking in 2026. If users cannot find (access) what they need, your rankings will drop. AI agents prioritize content that is "high-engagement." If your page layout blocks human users from easily accessing information (e.g., a massive popup or confusing layout), AI models may eventually flag the URL as "Low-Utility/Obstructive."

How to fix it

Implement a visual analytics layer on key landing pages and high-traffic expert content. Analyze session recordings to identify "Content Friction."

What it checks. Ensures your website has a designated "default" page for international visitors who don't match your specific language settings.

Why it matters

Ensures your website has a designated "default" page for international visitors who don't match your specific language settings.

If the test fails

The website lacks a designated "Universal Destination" for international visitors. Without this safety net, search engines and AI agents are forced to guess which language or regional version to show a visitor when a perfect match isn't available. This often results in "Cross-Language Friction," where a user in one country is accidentally served content in a different language, leading to an immediate loss of trust, and high bounce rates.

How to fix it

Define a default page for your international audience. Update your site's header tags or Sitemap to include an x-default attribute that points to your primary language version (e.g., your English homepage). This ensures that any visitor whose language isn't specifically supported is automatically routed to your most authoritative global version instead of landing on a broken or irrelevant page.

What it checks. Checks if your language and region codes are official and recognizable.

Why it matters

This test checks if your language and region codes are official and recognizable. Search engines use specific international standards (ISO codes). If you use an unofficial code or make a typo, the search engine will ignore your language settings entirely.

If the test fails

The page contains "Invalid Language Codes." For example, using "fr-UK" (French in the UK) or "us" instead of "en-us." When a code is invalid, search engines cannot understand which audience the page is for. This leads to your global pages being ignored in local search results and causes "Language Mismatch" for your users.

How to fix it

Audit your language tags and replace any unofficial codes with the correct ISO format. For example, use en for English, es for Spanish, and fr for French. Ensure the combination of language and region follows the standard language-country format.

What it checks. Verifies that all international alternate pages have Return Links.

Why it matters

This test verifies that all international alternate pages have Return Links. Hreflang is a reciprocal protocol, if Page X points to Page Y as an alternate, Page Y must point back to Page X. In SEO, missing return links cause search engines to ignore your localization instructions. For AI agents, this is a "Geospatial Context" signal: it helps the agent serve the correct "regional Expert Sentiment" to the user.

If the test fails

When return links are missing, Google Search Console triggers a "No Return Tag" error. Because the relationship isn't confirmed by both sides, Google may default to showing the wrong language version in search results (e.g., showing a UK English page to a US user). This leads to high bounce rates and poor conversion as users land on pages with the wrong currency, shipping info, or spelling. AI assistants provide "Hyper-Localized Answers." If the hreflang return links are broken, the AI may fail to connect your regional subdomains. It might ingest your global brand data but miss the specific localized nuances (like regional pricing or local compliance) because the map between languages was incomplete.

How to fix it

Map Your Alternates: For every page that has a localized version, ensure the code contains a full list of all alternates, including the page itself (self-referencing). Verify the Return: Use a crawling tool to confirm that if the English page points to the French page, the French page contains a tag pointing back to the English URL. Check for URL Accuracy: Ensure the return link uses the absolute, canonical URL. Even a slight mismatch (like http vs https) will break the reciprocity and cause the tag to be ignored.

What it checks. Checks if the page has at least one language or region attribute (hreflang) defined.

Why it matters

This test checks if the page has at least one language or region attribute (hreflang) defined.

If the test fails

The page is missing its "International Signal." Even if you have versions of this page in other languages, search engines don't know they exist because there is no code connecting them.

How to fix it

adding at least one link rel="alternate" hreflang="..." tag to the page's <head>.

What it checks. Verifies that each language and region is assigned to exactly one unique page.

Why it matters

This test verifies that each language and region is assigned to exactly one unique page. Providing multiple "targets" for the same audience creates a conflict, forcing search engines to choose one and ignore the other. Ensuring a 1:1 relationship between a language and a URL creates a clear, stable path for your global visitors.

If the test fails

The page contains "Competing Destinations." For example, you might have two different links both claiming to be the official "French" version. This causes "Ranking Cannibalization," where your own pages fight each other for the same spot in search results. It leads to indexing instability and can result in the wrong page being shown to your audience.

How to fix it

Review your technical header <head> and remove any duplicate language assignments. Ensure that each unique hreflang code (like en-us or fr-fr) points to only one specific URL. Every audience should have one clear destination.

What it checks. Checks if your international links use the full website address (Absolute URL).

Why it matters

This test checks if your international links use the full website address (Absolute URL). Every link must include "https://" and your domain name to ensure search engines can find the page correctly.

If the test fails

The links use shortcuts (Relative URLs) instead of full addresses. This confuses search engines and can lead to "Page Not Found" errors or the wrong language appearing in search results. It makes the site's global setup unreliable.

How to fix it

Change all links in the language tags to the full URL format. Ensure they start with "https://www.yourdomain.com/."

What it checks. Confirms that the page explicitly identifies its own language and region to search engines.

Why it matters

This test confirms that the page explicitly identifies its own language and region to search engines. In a global setup, every page must "sign" its own identity while also pointing to its foreign-language counterparts.

If the test fails

The page is missing its Identity Signature. Without this, the link between your different language versions is broken. Search engines may get confused and show the wrong version to your visitors: like showing an English page to a French customer. This fragmentation makes your brand look disorganized to AI and lowers your global ranking power.

How to fix it

Update the page's <head> tag to include a self-pointing reference. e.g <head> <title>Poliris Global Audit</title> <link rel="alternate" hreflang="es" href="https://example.com/es/page" /> <link rel="alternate" hreflang="en" href="https://example.com/en/page" /> <link rel="alternate" hreflang="x-default" href="https://example.com/en/page" /> </head>

What it checks. Verifies that all international return links point only to the Canonical (Master) version of the page.

Why it matters

This test verifies that all international return links point only to the Canonical (Master) version of the page. In SEO, hreflang tags must be reciprocal and point to the official URL. For AI agents, this is a "Source of Truth" verification. If the links point to non-canonical URLs, the AI may struggle to determine which version of your brand's expertise is the most current.

If the test fails

When an international return link points to a non-canonical URL (like a URL with ?source=ref at the end), Google sees a Mismatch Error. Because the "Handshake" isn't clean, Google may ignore your hreflang tags entirely. This results in the wrong language version appearing in search results, frustrating users and tanking your international conversion rates. AI scrapers use "Canonical Mapping" to consolidate data. If your international links point to "dirty" or non-canonical URLs, the AI triggers a "Data Redundancy Warning." It might ingest the same content multiple times under different URLs, leading to a diluted and confused representation of your "Expert Sentiment" in different regions.

How to fix it

Use Clean URLs: Audit your hreflang tags to ensure they point to the exact URL set in the page's canonical tag. No tracking parameters, no fragments, and no session IDs. Verify Reciprocity: If the US page points to the Spanish page, the Spanish page must point back to the official US URL. Strict URL Standards: Ensure that protocols (https) and trailing slashes (/) match perfectly between the hreflang tag and the canonical tag. Even a tiny difference will break the handshake.

What it checks. Identifies images that are missing the alt (alternative text) attribute.

Why it matters

This test identifies images that are missing the alt (alternative text) attribute. Alt tags are the primary method used by search engines and AI agents to understand the subject matter of an image. Without this attribute, the visual content of your site is blind to crawlers, and the context provided by those images is lost to the Knowledge Graph.

If the test fails

When an image lacks an alt attribute, it creates a massive gap in your site's data integrity. Search engines cannot "see" the image. Without descriptive text, your graphics will not appear in Google Image Search, and the page loses a critical relevance signal. For an AI agent, this results in "Contextual Loss." If your page uses a chart or process diagram to prove a point, the AI will ignore that data entirely. This creates a Sentiment Gap where the AI perceives your content as thin or unverified because it cannot process the evidence hidden inside the graphic.

How to fix it

Perform an audit of all site imagery to ensure every non-decorative image has a descriptive, keyword-relevant alt tag.

What it checks. Checks that every image on the page loads, including images hosted on other sites.

Why it matters

This test checks that every image the page loads actually responds, whatever site hosts it. An image that returns 404, 410 or a server error (5xx) shows as a broken or empty frame. In SEO, broken images signal a neglected page and lose their place in image search. For AI agents, a missing image removes the visual evidence the text refers to. Images that refuse automated checks (401, 403, 405, 429) are named but not counted.

If the test fails

Visitors see broken or empty image frames, and search engines and AI agents find image references that lead nowhere. Images loaded from a staging or retired host break without any change on your own site.

How to fix it

Replace each broken image URL with one that loads, usually by uploading the file to your own media library, or remove the image. Check that no image still points to a staging or development host.

What it checks. This test audits the site to ensure all visual assets utilize industry-standard web formats (JPEG, PNG, GIF, SVG, ICO, WebP, AVIF).

Why it matters

This test audits the site to ensure all visual assets utilize industry-standard web formats (JPEG, PNG, GIF, SVG, ICO, WebP, AVIF).

If the test fails

A state where the use of non-standard image formats creates a hard barrier for both legacy SEO crawlers and modern AI agents. From an SEO perspective, search engines may simply ignore unsupported file types, leading to a loss in image search visibility and fragmented page context. In the 2026 AI-first landscape, this causes a "Logic Break" during data ingestion. If an AI agent cannot natively parse the file structure, it will fail to "see" the image.

How to fix it

Convert any non-standard image formats (such as BMP, TIFF, or high-resolution RAW files) into universal web standards like WebP or high-quality JPEG.

What it checks. Checks the individual file size of every image asset on the page.

Why it matters

This test audits the individual file size of every image asset on the page. In SEO, keeping images under 100 KB is a critical benchmark for maintaining ultra-fast load times and passing Core Web Vitals. From an AI standpoint, this ensures that your visual data is "lightweight" enough to be indexed in real-time without exceeding the compute budget of the AI agent.

If the test fails

Images exceeding 100 KB act as primary drivers for slow "Time to Interactive" (TTI) and unstable layout shifts, directly triggering search ranking penalties on mobile devices. In the 2026 AI-first environment, this creates "Ingestion Latency" for high-speed agents, which prioritize rapid data ingestion and may timeout on heavy visual assets to focus solely on text.

How to fix it

Compress all images to fall below the 100 KB threshold without sacrificing visual clarity. Use "Lossy" compression and "Responsive Image" (srcset) attributes to ensure that mobile users and AI agents aren't forced to download a desktop-sized 500 KB image when a 50 KB version will suffice.

What it checks. Checks the site’s use of image formats, specifically identifying legacy file types like JPEG and PNG.

Why it matters

This test audits the site’s use of image formats, specifically identifying legacy file types like JPEG and PNG. In the SEO landscape, modern formats like WebP and AVIF are the industry standard for meeting Core Web Vitals (CWV) requirements. From an AI perspective, smaller, highly-compressed files allow AI agents to ingest visual data more efficiently, reducing the risk of timeouts during a crawl.

If the test fails

The site is suffering from "Asset Bloat," a technical friction point that triggers a dual penalty in performance and intelligence. From a SEO standpoint, legacy image formats significantly increase the Largest Contentful Paint (LCP), leading to degraded mobile experiences and direct ranking demotions. However, the AI impact is even more critical. AI agents operate on a strict "Compute Budget," meaning large, unoptimized assets are often deprioritized or bypassed to save processing power. This results in "Visual Data Latency," where your site’s graphics and evidence are skipped during the AI’s knowledge synthesis, allowing faster, more "Scrapable" competitors to claim the primary citation in AI-generated answers.

How to fix it

Implement an automated image conversion protocol to serve all visual assets in WebP or AVIF formats. This ensures high-fidelity visuals at a fraction of the file size.

What it checks. Checks the security protocol of all visual assets to ensure they are served via HTTPS.

Why it matters

This test audits the security protocol of all visual assets to ensure they are served via HTTPS. On a secure website, every single element, including images, must match the site's security certificate. Serving images over an unencrypted HTTP connection on an HTTPS page triggers "Mixed Content" warnings, which undermines the encrypted environment and compromises data integrity.

If the test fails

The page is suffering from "Mixed Content Vulnerability," a state where insecure image requests trigger browser security warnings and negatively impact your Technical SEO trust signals. From a search perspective, Google and other engines prioritize "Secure-at-all-Points" sites. In the 2026 AI-first landscape, this creates an "Access Block" for high-security AI agents and scrapers, which are programmed to ignore or block unencrypted content to prevent data leaks. This means your brand’s visual evidence and diagrams will fail to load for the AI.

How to fix it

Perform a global search-and-replace to update all image source URLs from "http://" to "https://." Ensure that your Content Delivery Network (CDN) or hosting server is configured to force SSL for all media assets.

What it checks. Checks the character count of the <meta name="description"> tag.

Why it matters

This test audits the character count of the <meta name="description"> tag. To maintain professional visibility and technical clarity, the description must fall between 120 and 155 characters. In SEO, this range ensures that your message is fully visible in search results without being cut off. For AI agents, this represents the "Optimal Signal Window," a concise enough string to be tokenized efficiently while providing enough data to map your expert sentiment.

If the test fails

Descriptions under 120 characters are often too thin to persuade a user to click, while those over 155 characters are truncated by search engines, often cutting off your primary call-to-action or unique value proposition. AI agents use this tag as a "Priority Abstract." If the description is too long, the AI may experience "Inference Latency," where it has to guess the priority of the information.

How to fix it

Refine all meta descriptions to stay within the 120-155 character

What it checks. Checks the HTML to ensure that only one <meta name="description"> tag exists on the page.

Why it matters

This test audits the HTML to ensure that only one <meta name="description"> tag exists on the page. In SEO, multiple meta descriptions confuse search engines and often lead to the wrong snippet being displayed in search results. For AI agents, this property is the "Primary Knowledge Abstract," having more than one creates a structural redundancy that compromises the machine-readability of the page.

If the test fails

The presence of multiple descriptions causes search engines to ignore your intended brand message and default to random page text, leading to a loss of first-impression control and a diminished CTR. In the 2026 AI-first environment, this technical conflict triggers a "Reliability Flag" during ingestion as agents like Perplexity or GPT-based crawlers encounter "Conflicting Directives."

How to fix it

Perform a technical audit to identify and remove duplicate meta description tags. Ensure that your CMS or SEO plugins, or manual implementation are configured to output only one unique, high-quality description per URL.

What it checks. Checks the HTML for the presence of the <meta name="description"> tag.

Why it matters

This test audits the HTML for the presence of the <meta name="description"> tag. This tag is the "Elevator Pitch" for your page in Search Engine Results Pages (SERPs), directly influencing Click-Through Rate (CTR). For AI agents, the meta description serves as a "High-Level Semantic Abstract," that provides a pre-verified summary that helps the agent classify your expert sentiment

If the test fails

Without a defined meta description, search engines will scrape random, often disjointed snippets from the page. This leads to a messy and unprofessional appearance in search results, resulting in a significant loss of organic traffic and brand authority. AI Agents utilize the meta description for "Initial Knowledge Filtering." If the tag is missing, the AI is forced to auto-summarize the page using its own logic that may cause "Hallucination Risk."

How to fix it

Craft a unique, keyword-rich meta description for every page that accurately reflects the "Expert Sentiment" of the content.

What it checks. Identifies pages that share identical Meta Descriptions.

Why it matters

This test identifies pages that share identical Meta Descriptions. When descriptions are duplicated, search engine result pages (SERPs) look repetitive and unprofessional. Furthermore, AI-powered search assistants use these descriptions to understand the specific nuance of a page

If the test fails

When a user sees three different pages from your site with the exact same description, they perceive the content as low-quality or automated. This leads to a lower Click-Through Rate (CTR). For 2026 AI discovery, duplicate descriptions cause "Summary Blurring," where LLMs may group distinct pages together as a single entity.

How to fix it

Craft a unique Meta Description for every indexable page. The description should be between 140-160 characters and specifically describe the value found only on that specific URL.

What it checks. Checks for the "og:description" tag in your site's metadata.

Why it matters

Open Graph Descriptions outside the 55-155 character range risk being truncated on mobile messaging UIs or lacking the "signal density" required to drive a click. For AI agents, a description that is too short or cut off prevents accurate content extraction, often resulting in vague or incomplete summaries in AI-generated chat answers.

If the test fails

When your description exceeds the character limit, platforms like mobile LinkedIn or X will cut the text off with an ellipsis (...). If your Call to Action or key value proposition is at the end, users will never see it. This results in a lower Click-Through Rate (CTR) because the "hook" of your content is hidden. I scrapers often use the "og:description" as a "Primary Hook" for voice assistants and chat previews. If the description is a rambling paragraph, the AI triggers a "Summarization Penalty," and may choose to ignore your provided text

How to fix it

Treat your og:description like a high-value advertisement: Front-Load the Value: Put the most exciting or important fact in the first 40 characters.

What it checks. Checks for the "og:description" tag in your site's metadata.

Why it matters

This test checks for the "og:description" tag in your site's metadata. In SEO, this tag defines the snippet of text shown when your link is shared on social platforms. For AI agents, this is the "Contextual Summary": it provides a pre-digested explanation of your page's value, which AI models use to verify if your content matches a user's intent.

If the test fails

Without this tag, platforms like LinkedIn or Facebook will scrape random text from your page. This looks unprofessional and significantly lowers your Click-Through Rate (CTR), meaning fewer people "access" your content. AI scrapers use Open Graph descriptions for "Entity Verification." If the description is missing, the AI has to "guess" the core theme of your page based on the full body text. This leads to "Summarization Lag," where the AI might not be able to quickly provide a snippet of your "Expert Sentiment."

How to fix it

Write a unique, compelling summary for your social media tag: Be Brief: Keep it between 150-160 characters to avoid it being cut off. Add Value: Don't just repeat the title: explain why the user should click. Code Format: <meta property='og:description' content='Discover expert 2026 SEO strategies to boost your AI visibility and search rankings.' /> By providing this summary, you ensure a frictionless entry for users and a clear "cheat sheet" for AI agents.

What it checks. Checks your code for the "og:image" property.

Why it matters

This test audits your code for the "og:image" property. In SEO, this is the most critical factor for social media Click-Through Rate (CTR). For AI agents, this tag provides visual context, it tells the machine which specific image best represents the "Core Expert Sentiment" of your page.

If the test fails

When your link is shared on LinkedIn, X, or Facebook without an og:image, the platform will either show a blank box or scrape a random, irrelevant image (like a tiny logo or a generic icon). This looks unprofessional and makes your content appear untrustworthy or broken. When a user asks an AI assistant for a recommendation, the AI may be unable to provide a visual preview of your brand or product, causing the user to choose a competitor whose "Visual Identity" is clearly defined in their metadata.

How to fix it

Assign a specific, high-resolution image to every page: Dimensions: Use an image that is 1200 x 630 pixels for the best display across all platforms. Relevance: Choose an image that actually reflects the content (e.g., a chart for a data post, or a product photo for a shop page).

What it checks. Measures the character count of your og:title.

Why it matters

This test measures the character count of your og:title. In SEO, a title under 60 characters ensures your full message is visible in social feeds. For AI agents, this is about "Signal Clarity": a concise title allows the machine to immediately categorize your page without processing redundant text.

If the test fails

When a title exceeds 60 characters, platforms like LinkedIn or X will truncate the text. If your most important keywords or your brand name are at the end of the title, they disappear. This significantly lowers your Click-Through Rate (CTR) because the user only sees a partial, confusing thought. In 2026, AI scrapers prioritize "Density of Information." A long, rambling title triggers a "Noise Penalty," the AI may struggle to extract the core entity of your page.

How to fix it

Refine your social titles to be punchy and informative: Front-Load Keywords: Put your most important topic at the very beginning of the title.

What it checks. Checks for the "og:title" tag in your page's hidden code.

Why it matters

This test checks for the "og:title" tag in your page's hidden code. In SEO, this tag controls how your content looks when shared on social media, which directly affects your Click-Through Rate (CTR). For AI agents, this is a "High-Level Summary": AI assistants often use Open Graph tags as a quick way to understand the main idea of a page before reading the full text.

If the test fails

If the "og:title" is missing, social platforms will try to guess a title from your page. Often, they pick something generic like "Home" or untitled, which looks unprofessional. AI scrapers use Open Graph data for "Rapid Classification." If this tag is missing, the AI triggers a "Metadata Gap." It has to work harder to summarize your page, which can lead to an inaccurate preview in AI-generated chat responses.

How to fix it

Ensure your site's code includes a specific Open Graph title tag. Match the Content: The "og:title" should be very similar to your main page title. Be Punchy: Keep it under 60 characters so it doesn't get cut off on mobile screens. Use the Format: <meta property='og:title' content='Your Catchy Headline Here' />

What it checks. Checks the "og:url" property in your metadata.

Why it matters

This test audits the "og:url" property in your metadata. In SEO, this tag acts like a social-specific "Canonical Tag," ensuring all engagement (likes, shares) points to a single, preferred URL. For AI agents, this is a "Source of Truth" anchor: it helps the machine identify the definitive version of a page when multiple versions of a link might exist across the web.

If the test fails

Without this tag, social platforms might treat different versions of the same link (e.g., "yoursite.com/page" vs "yoursite.com/page?source=social") as separate entities. This splits your "Engagement Equity," making it harder for search engines to see how popular your content actually is. AI scrapers deal with massive amounts of "noise" and duplicate URLs. If the "og:url" is missing, the AI triggers a "Data Disambiguation Loop." It has to spend more energy verifying which URL is the official one.

How to fix it

Ensure your metadata includes the absolute, permanent URL for the current page.

What it checks. Checks the character count of the primary <h1> tag.

Why it matters

This test audits the character count of the primary <h1> tag. An effective H1 should be between 20 and 70 characters to balance descriptive depth with punchy clarity. In SEO, this range ensures the headline is fully visible in search snippets and browser tabs. For AI agents, this length provides a "High-Signal Summary" that clearly defines the page's core expertise without unnecessary noise.

If the test fails

Headers under 20 characters lack the specificity to rank for intent, while those over 70 characters risk truncation or being flagged as "keyword stuffing" by modern search algorithms. In a 2026 AI-first environment, this imbalance disrupts the H1's role as the primary "Semantic Anchor," an overly short headline provides insufficient data for AI agents like ChatGPT or Gemini to categorize your "Main Content."

How to fix it

Refine the primary headline to fall within the 20-70 characters. Ensure the H1 is descriptive, incorporates your primary keyword, and captures the specific value proposition of the content.

What it checks. Checks the character count of all <h2> tags on the page.

Why it matters

This test audits the character count of all <h2> tags on the page. Like the H1, H2 headers should fall within the 20-70 character range to remain descriptive yet concise.

If the test fails

H2s that are too short (e.g., "Summary") offer no keyword value and fail to help search engines understand the breadth of your expertise. AI Agents use H2s as "Retrieval Pointers." When an AI is asked a specific question, it looks for an H2 that matches the intent. An optimized H2 allows for High-Speed Ingestion.

How to fix it

Refine your sub-headings to be descriptive, keyword-rich "Signposts" between 20 and 70 characters.

What it checks. Checks the document for the presence of <h2> tags.

Why it matters

This test audits the document for the presence of <h2> tags. H2s are the primary sub-headings that break a page into logical, digestible sections. In SEO, H2s allow you to target secondary keywords and provide a clear topical map. For AI agents, H2s serve as "Semantic Dividers," they allow the agent to "Chunk" your data into specific knowledge blocks for more precise retrieval and summarization.

If the test fails

The lack of H2s creates a "Wall of Text" that drives higher bounce rates and lowers "Dwell Time" while simultaneously diluting your ranking potential by making it difficult for search engines to identify specific sub-topics of expertise. In the 2026 landscape, this absence of structure disrupts an AI agent's ability to perform "Rapid Chunking."

How to fix it

Organize your content into logical chapters using at least one (and preferably several) <h2> tags. Each H2 should represent a distinct sub-topic or "Expert Insight" that supports the primary H1 title.

What it checks. Checks the document structure to ensure that heading levels (H1 through H6) follow a logical, descending order.

Why it matters

This test audits the document structure to ensure that heading levels (H1 through H6) follow a logical, descending order. In SEO, a proper hierarchy helps search engines understand the relationship between primary topics and sub-topics. For AI agents, this structure acts as the "Table of Contents" for your data.

If the test fails

From an SEO perspective, skipping heading levels (like jumping from H1 to H3) confuses crawlers about the importance of your content, which can dilute your ranking power for key sub-topics. In the 2026 AI-first landscape, this results in "Contextual Disconnection." AI agents use heading levels to nest information in their internal knowledge graphs.

How to fix it

Restructure the page HTML so heading levels step down one at a time without skipping. For example, an H3 should follow an H2, not jump straight from an H2 to an H4. You can still repeat the same level (multiple H2s or H3s) as long as deeper levels are introduced in order.

What it checks. Checks the HTML structure to ensure that exactly one <h1> tag exists on the page.

Why it matters

This test looks for the presence of <h1> tag within the <body> of your HTML. This test verifies that your page has a clear, singular topic. In SEO, the H1 is the most heavily weighted on-page text element. For AI agents, the H1 acts as the Primary Entity Signal, it ensures algorithms and LLMs understand the core subject matter of the page.

If the test fails

Without an H1 tag, search engines and AI agents have to guess your page's main topic by reading less important text. For traditional SEO, this means you might rank for the wrong keywords. For AI agents (like ChatGPT), missing an H1 means the bot cannot confidently identify your subject matter. If the AI isn't 100% confident in your topic, it will skip your page and cite a competitor who has a clearly labeled H1 instead.

How to fix it

Ensure every public-facing page has an <h1> tag located near the top of the visual hierarchy. Do not use zero H1s, and do not use multiple H1s. There should be exactly one Primary Entity Definition per URL. Write the H1 using clear, natural language that perfectly summarizes the core topic or keyword of that specific page.

What it checks. Verifies that the H1 tag: the most important structural heading on the page is unique across your entire domain.

Why it matters

This test verifies that the H1 tag: the most important structural heading on the page is unique across your entire domain. The H1 provides the primary context for the page’s content.

If the test fails

When H1s are duplicated across multiple pages, it signals to both users and bots that your content may be repetitive or low-value, weakening the topical authority of your site.

How to fix it

Audit your H1 headings and ensure each one is specifically tailored to the unique value proposition of that page.

What it checks. Checks if your <title> tag is under 30 characters.

Why it matters

This test checks if your <title> tag is under 30 characters. In SEO, a title that is too brief lacks the necessary keywords to rank for specific searches. For AI agents, a short title is a "Vague Signal": the machine sees a lack of detail and may categorize the page as low-effort or "thin content."

If the test fails

Google uses the title tag to understand the main topic of your page. If your title is only 10 characters long, you aren't providing enough information to compete for high-value search terms. This leads to "Ranking Stagnation," where your page gets buried behind competitors who use descriptive, keyword-rich titles. AI scrapers use the title tag as the "Primary Anchor" for their Knowledge Graphs. A title like "SEO Tips" is too broad. The AI triggers a "Low-Confidence Flag." Because the title doesn't specify the "Who, What, or When," the AI is less likely to pull your "Expert Sentiment" into an AI-generated answer because it can't verify the specific relevance of your data.

How to fix it

Expand your title to provide a clear, descriptive summary of the page. Be descriptive, include your brand, and target the recommended length.

What it checks. Checks your HTML to ensure there is exactly one <title> tag.

Why it matters

This test audits your HTML to ensure there is exactly one <title> tag. In SEO, having multiple titles confuses search engine crawlers and can lead to the wrong headline appearing in search results. For AI agents, this is a "Semantic Conflict": the machine sees two competing definitions for the page, which can lead to data instability.

If the test fails

When Google encounters two title tags, it doesn't know which one to trust. It may pick the first one, the second one, or ignore both and invent its own title based on your content. This results in "Display Volatility," where your carefully crafted headline is replaced by random text. AI scrapers rely on "Definitive Metadata" to build their Knowledge Graphs. Multiple titles trigger a "Validation Error," and AI agent might flag the site as poorly coded or "spammy."

How to fix it

Audit your code to ensure only one title tag is generated. Ensure uniqueness, and text-richness.

What it checks. Verifies the existence of the <title> tag within your page's HTML <head>.

Why it matters

This test verifies the existence of the <title> tag within your page's HTML <head>. In SEO, this tag is the primary headline used by search engines in their results pages. For AI agents, this is the "Root Label": it is the first thing a machine reads to determine the topic and relevance of the entire document.

If the test fails

If a title tag is missing, Google has to invent a title for you by pulling random text from your page. This usually results in a messy, unprofessional headline in search results that destroys your Click-Through Rate (CTR). Even worse, search engines may struggle to rank the page at all because they lack a definitive signal of what the page is about. AI scrapers use the title tag as the "Parent Topic" for their database. If the tag is missing, the AI triggers a "Classification Failure." Because the machine cannot instantly verify the page's purpose, it may skip the site entirely to avoid indexing "junk" data.

How to fix it

Every page must have a unique and descriptive title tag: Be Unique: No two pages on your site should have the same title. Be Keyword-Rich: Include your primary topic early in the title.

What it checks. Identifies pages that share identical or highly similar Title Tags.

Why it matters

This test identifies pages that share identical or highly similar Title Tags. When two or more pages have the same title, you are forcing search engines to choose between them, leading to internal competition where your own pages cannibalize each other’s rankings.

If the test fails

Because the Title Tag is the strongest on-page signal for what a page is about, duplicate titles create "Internal Cannibalization." Search engines won't know which page to prioritize, often leading to lower rankings for both versions.

How to fix it

Review your site’s Title Tag architecture. Ensure that every page has a unique, descriptive title that reflects its specific content.

What it checks. Checks the page to verify the presence of any valid Schema.org markup (JSON-LD, Microdata, or RDFa).

Why it matters

This test audits the page to verify the presence of any valid Schema.org markup (JSON-LD, Microdata, or RDFa). In SEO, Schema is the primary method for communicating the page's "Identity" to search engines. For AI agents, Schema represents the "Structured Access Layer," it is the difference between an AI having to "Read" your content like a human and being able to download your content as structured knowledge.

If the test fails

Without a foundational Schema layer, you are invisible to "Rich Result" carousels and specialized search filters, leading to a massive disadvantage in organic visibility. AI agents perform a "Schema-First Scan." If no Schema is detected, the AI's "Confidence Score" in your content's data drops immediately.

How to fix it

Implement foundational Schema.org markup across all indexable pages. At a minimum, every page should include WebPage schema, while core pages should use more specific types like Organization or Product.

What it checks. Checks the <script type="application/ld+json"> elements to ensure they contain a valid, parsable JSON object.

Why it matters

This test audits the <script type="application/ld+json"> elements to ensure they contain a valid, parsable JSON object. In SEO, JSON-LD is the preferred format for search engines because it is decoupled from the user-facing HTML. For AI agents, this is the "Direct Data API" of your website.

If the test fails

If the JSON object is unparsable, Google and Bing cannot extract any metadata, rendering your investment in structured data useless and preventing any Rich Result visibility. AI agents use "Streamed Ingestion." When they encounter a script block that is not a valid JSON object, it creates a "Technical Exception." To maintain speed, most LLM-crawlers will abort the parse of that specific element.

How to fix it

Audit all JSON-LD implementations to ensure they are wrapped in a clean, single JSON object.

What it checks. Checks the page to see if it utilizes the most relevant Schema.org "Entity" types.

Why it matters

This test audits the page to see if it utilizes the most relevant Schema.org "Entity" types (e.g., Article for blogs, Product for e-commerce, LocalBusiness for physical stores). While general schema tells an AI that data exists, Recommended Schema tells the AI what that data is.

If the test fails

The page is suffering from "Entity Ambiguity," causing you to miss out on specialized SERP features like review stars and price drops while making your listing look generic and reducing CTR. In the 2026 landscape, this triggers a failure in AI-Scrapability because agents use "Type-Based Filtering" to isolate specific products or articles.

How to fix it

Identify the primary entity for each page and implement the most specific Schema type available. Use Article for news and blogs, Product for items for sale, and Organization for your brand's identity.

What it checks. Checks the JSON-LD or Microdata blocks for syntax errors, missing required properties, or non-compliance with the Schema.org vocabulary.

Why it matters

This test audits the JSON-LD or Microdata blocks for syntax errors, missing required properties, or non-compliance with the Schema.org vocabulary. In SEO, invalid schema is ignored by search engines, stripping the page of Rich Result eligibility. For AI agents, this is a "Data Access Failure": the machine detects that structured data is present but cannot unlock or interpret it due to code corruption.

If the test fails

Search engines like Google will flag the markup as "Invalid," meaning your stars, prices, and author attributes will never appear in search results, directly hurting CTR. LLMs and AI-search agents use "Strict Parsing Protocols" to save on compute costs. If a Schema block contains a syntax error (like a missing comma or an unclosed bracket), the agent will simply discard the entire block.

How to fix it

Run all Schema markup through the official Schema.org Validator or the Google Rich Results Test. Fix all "Critical" and "Warning" errors to ensure a clean, high-speed "Digital Handshake" with AI agents.

What it checks. Checks the "twitter:description" meta tag, which provides a concise summary of the page content when shared on social platforms.

Why it matters

This test audits the "twitter:description" meta tag, which provides a concise summary of the page content when shared on social platforms. While the title captures attention, the description provides the SEO context needed to drive engagement. For AI agents, this tag serves as a high-priority summary that helps the model quickly categorize the page's topical authority without needing to parse the entire body of content.

If the test fails

The lack of a defined twitter:description forces AI agents and social platforms to scrape random snippets of text from the page. From an SEO perspective, this leads to messy, broken previews that fail to convert users.

How to fix it

Craft a unique, compelling "twitter:description" for every page between 120-160 characters, front-loading the hook in the first 80 characters.

What it checks. Checks the character count of the twitter:description property.

Why it matters

This test audits whether the twitter:description property contains between 120 and 160 characters so the summary provides enough context without being truncated across devices and social platforms.

If the test fails

A description outside the recommended range weakens the social preview: a short description may not provide enough context, while a long one can truncate the page's hook and value proposition. This can reduce engagement and create inconsistent snippets for social platforms and AI aggregators.

How to fix it

Draft a unique twitter:description between 120 and 160 characters, front-loading the hook in the first 80 characters.

What it checks. Checks the presence of the "twitter:image" property.

Why it matters

This test audits the presence of the "twitter:image" property. This tag specifies the exact visual asset that should represent the page when shared.

If the test fails

The lack of a defined image property results in a text-only or broken link preview. From an SEO perspective, this drastically reduces the page's prominence in social feeds, making your expert insights easy to overlook. In the 2026 AI-first landscape, if the image is missing, the AI cannot represent your brand visually, causing your content to feel less authoritative and "generic" compared to competitors who provide clear visual data.

How to fix it

Ensure every page has a unique, high-resolution "twitter:image" that aligns with the page's core topic. Use a standard ratio (typically 1.91:1) and ensure the image file size is optimized for fast loading.

What it checks. Checks the twitter:site meta tag, which links a specific web page to a verified social media profile.

Why it matters

This test audits the twitter:site meta tag, which links a specific web page to a verified social media profile. In SEO, this strengthens the connection between your domain and your brand’s social footprint. For AI agents, this property acts as a "Verified Source" identifier,

If the test fails

From an SEO and engagement perspective, this means that when users share your content, your brand is not automatically tagged or credited, leading to a loss in social reach and community growth. In the 2026 AI-first environment, this creates "Entity Ambiguity." AI agents use these tags to verify the origin of information.

How to fix it

Add the "twitter:site" meta tag to your global site header, ensuring it correctly references your brand's official @username. This simple technical addition ensures that every piece of content you produce is "Signed" by your brand.

What it checks. Checks the presence of the twitter:title meta tag.

Why it matters

This test audits the presence of the twitter:title meta tag. This tag is part of the "Open Graph" and "Twitter Card" protocols, which control how your content appears when shared on social platforms. In SEO, these tags are essential for driving Click-Through Rate (CTR). In the AI landscape, these tags act as "Semantic Signposts," providing a pre-defined summary of the page's identity for scrapers and AI researchers.

If the test fails

The page is suffering from "Metadata Anemia," a state where the absence of a specific twitter:title forces platforms and AI agents to fallback to generic, unoptimized page titles. From an SEO and social perspective, this results in unappealing link previews that lower engagement and brand authority. In the 2026 AI-first environment, this creates a "Contextual Blur," instead of receiving a clear, intentional title

How to fix it

Implement a unique and descriptive twitter:title for every page, ensuring it remains under 55 characters for optimal display. This title should mirror the core "Sentiment" of your expert content while being optimized for human engagement.

What it checks. Checks the character count of the "twitter:title" property.

Why it matters

This test audits the character count of the "twitter:title" property. To ensure full visibility across all device types and social aggregators, the title should be capped at 55 characters.

If the test fails

The page will suffering from "Signal Truncation," where an excessively long title results in an incomplete brand message. From an SEO perspective, if the core keyword or "hook" is pushed beyond the 55-character limit, engagement rates drop because the user cannot see the full context of the link. In the 2026 AI-first landscape, this creates "Contextual Noise."

How to fix it

Refine all twitter:title properties to be punchy, descriptive, and under the 55-character threshold.

What it checks. Checks the "twitter:card" property, which defines the visual layout of a page’s preview (e.g., "summary" vs.

Why it matters

This test audits the "twitter:card" property, which defines the visual layout of a page’s preview (e.g., "summary" vs. "summary_large_image"). In SEO, choosing the correct card type is essential for maximizing "screen real estate" and improving Click-Through Rates (CTR).

If the test fails

From an SEO perspective, this results in small, low-impact thumbnails that fail to capture user attention in competitive feeds. In the 2026 AI-first landscape, this creates "Structural Ambiguity." AI-driven social aggregators and research agents use this property to determine the "Prominence" of the content.

How to fix it

Define a global "twitter:card" type, ideally "summary_large_image" for technical and visual content to ensure your brand occupies the maximum available space in the digital ecosystem. This standardization ensures that both human users and AI agents perceive your content as high-value.

What it checks. Checks the specific value assigned to the "twitter:card" property.

Why it matters

This test audits the specific value assigned to the "twitter:card" property. To be recognized by social platforms and AI aggregators, the value must be one of four valid types: "summary," "summary_large_image," "app," or "player."

If the test fails

From an SEO perspective, this results in small, low-impact thumbnails that fail to capture user attention in competitive feeds. In the 2026 AI-first landscape, this creates "Structural Ambiguity." AI-driven social aggregators and research agents use this property to determine the "Prominence" of the content.

How to fix it

Review the twitter:card values across the site and ensure they strictly adhere to the supported types. For most professional and technical content, summary_large_image is recommended to maximize "Technical Visibility."

What it checks. It detects duplicate-topic pages that compete with each other, weakening SEO and confusing AI about the main source.

Why it matters

Checks if multiple pages are semantically identical. In SEO, this splits your domain authority as pages compete against each other. For AI agents, it creates conflicting data points, making it impossible for the LLM to map a single, definitive "source of truth" for your brand.

If the test fails

Multiple pages targeting the exact same meaning force search engines to guess which one to rank. This splits your domain authority, cannibalizes your own organic traffic, and confuses AI models trying to map a single "source of truth" for your brand.

How to fix it

Merge the competing pages into one highly authoritative, comprehensive master asset. Set up a permanent 301 redirect from the discarded URLs to the new master page to consolidate your SEO power.

What it checks. Compares the body text of the current page against every other page on your domain.

Why it matters

This test compares the body text of the current page against every other page on your domain. It identifies "Thin Content" or "Mirror Pages" where the text is identical or nearly identical.

If the test fails

To search engines, having multiple pages with the same content suggests a lack of depth and value, often resulting in most of those pages being filtered out of search results entirely.

How to fix it

Rewrite the content to ensure it provides a unique perspective or specific data not found elsewhere on the site.

What it checks. It detects pages that are semantically disconnected from your main topic clusters using embeddings.

Why it matters

Flags pages that are semantically isolated from the rest of the crawl set based on embedding similarity. In SEO, these pages are harder for search engines to connect to your core topic clusters. For AI agents, isolated pages weaken knowledge graph cohesion and reduce confidence in your topical authority.

If the test fails

Semantically isolated pages are less likely to be understood as part of your core expertise. This weakens topical authority signals and can reduce visibility for related queries.

How to fix it

Align isolated pages with a clearer cluster by strengthening topic focus, improving contextual relevance, and adding internal links to semantically related pillar or supporting pages.

What it checks. It detects robotic AI writing patterns that hurt trust, rankings, and overall content quality.

Why it matters

Identifies formulaic LLM transitions and robotic phrasing. Synthetic, unedited text degrades brand trust and triggers spam filters in both search engines and AI scrapers, leading to visibility downgrades.

If the test fails

Robotic phrasing and AI footprints signal low-effort content, triggering algorithmic demotions and spam filters. For users, unedited synthetic text degrades brand trust and signals a lack of expertise, directly lowering conversion rates.

How to fix it

Edit the text to remove generic LLM tropes (e.g., "In today's fast-paced world"). Inject your unique brand voice, break up robotic paragraph structures, and ensure the content sounds like a human wrote it.

What it checks. It detects recent dates to ensure content stays fresh, improving SEO performance and preventing outdated information for AI.

Why it matters

Scans for recent dates to verify content freshness. In SEO, current dates improve click-through rates and satisfy "Freshness" algorithms. For AI agents, recency is a key filter to prevent the extraction of obsolete or outdated information.

If the test fails

Outdated content loses rankings to fresher competitors. AI agents built to answer user questions heavily prioritize recent data to avoid hallucinating obsolete facts, meaning your site will be bypassed for modern queries.

How to fix it

Manually review the content for factual accuracy. Update old statistics, refresh case studies, and include references to the current year to signal active maintenance to search algorithms.

What it checks. It checks if content shows real expertise and authority to meet E-E-A-T standards and gain trust from search engines and AI.

Why it matters

Evaluates whether content demonstrates real authority. In SEO, this fulfills Google's strict E-E-A-T guidelines for competitive rankings. For AI models, the credibility of the source dictates whether the LLM will trust your data enough to generate an answer based on it.

If the test fails

Paraphrased "Wikipedia-level" content fails Google's strict E-E-A-T (Experience, Expertise, Authoritativeness, Trustworthiness) guidelines. This prevents the page from ranking for high-value terms and stops AI models from citing your brand as a trusted source.

How to fix it

Have a true Subject Matter Expert (SME) review the page. Add unique industry insights, first-hand experience, and authoritative credentials that prove you are a practitioner, not just a content scraper.

What it checks. It checks if the introduction clearly states the user's problem and value proposition to boost engagement and reduce bounce rates.

Why it matters

Evaluates the first 200 words for a strong Value Proposition. In SEO, this immediately hooks the human reader, driving down bounce rates and signaling to search engines that the page successfully answered the user's query.

If the test fails

The digital attention span is unforgiving. Without a strong hook, readers will bounce back to the search results before scrolling, destroying your engagement metrics and signaling to Google that your page did not answer the user's query.

How to fix it

Rewrite the introduction. Immediately state the specific problem the user is facing and clearly outline the unique benefit they will gain by reading the rest of your page.

What it checks. It checks if content includes unique data or insights to outperform generic pages and be useful for AI extraction.

Why it matters

Evaluates if text contains substantive "Information Gain." In SEO, deep content satisfies user intent and outranks generic fluff. For Generative Engine Optimization (GEO), unique statistics and expert case studies are exactly the "High-Value Nodes" AI Overviews actively look to extract and cite.

If the test fails

Generic content fails to satisfy user intent. It will consistently be outranked by competitor pages that offer real expertise. Furthermore, AI Overviews specifically look for rich data points to extract; without them, your page is effectively invisible to Generative Engine Optimization (GEO).

How to fix it

Inject verified data points, unique case studies, or expert quotes into the text to substantiate your claims and provide actionable value that competitors lack.

What it checks. It measures vocabulary diversity to avoid keyword stuffing and provide richer semantic context for SEO and AI understanding.

Why it matters

Calculates vocabulary diversity. In SEO, avoiding heavy repetition prevents "keyword stuffing" penalties. For AI agents, a richer vocabulary provides a denser web of Latent Semantic Indexing (LSI) keywords, giving the LLM more contextual nodes to associate with your target topic.

If the test fails

A highly repetitive vocabulary triggers algorithmic penalties for "keyword stuffing." To modern Natural Language Processing (NLP) engines, it signals low-effort content that lacks the Latent Semantic Indexing (LSI) keywords needed to rank for complex queries.

How to fix it

Broaden your vocabulary. Incorporate natural synonyms and related sub-topics instead of awkwardly repeating your primary target keyword throughout the copy.

What it checks. It ensures readable text exceeds 15% of HTML to avoid thin content and provide AI with meaningful, content-rich data.

Why it matters

Analyzes the page payload to ensure readable text makes up >15% of the HTML. In SEO, this proves the page isn't just "thin content" or template bloat. For AI agents, a high text ratio guarantees the bot is ingesting pure, valuable data rather than wasting its token limits parsing messy frontend code.

If the test fails

A low ratio signals "thin content" drowning in template bloat. Search engines will index this as a low-value page, and AI scrapers will waste their crawl budget parsing your code rather than extracting your data, severely limiting your visibility.

How to fix it

Expand the page with unique, substantive text. Add relevant FAQs, detailed product descriptions, or expert insights to comfortably surpass the code-to-text threshold.

What it checks. Checks that the main text scores at least 50 for reading ease (Flesch, or Kandel-Moles in French) for better user and AI comprehension.

Why it matters

Measures how easy the page's main text is to read with the Flesch Reading Ease score (Kandel-Moles on French pages), from the average sentence length and the number of syllables per word. The page passes at 50 or above; below 50 the text is difficult to read, below 30 very difficult. Pages with fewer than 100 words of main content are not scored. In SEO, this prevents user fatigue and reduces mobile bounce rates. For AI agents, clear and accessible language lowers processing overhead, allowing large language models to extract key facts without struggling with overly complex or academic phrasing.

If the test fails

Text that is too dense can cause users to leave the page quickly and return to search results. Excessive jargon and complex sentence structures create semantic noise, making it harder for AI systems to identify the core entities and meaning of the content.

How to fix it

Simplify complex vocabulary, shorten long sentences, and break up dense paragraphs while keeping the technical information accurate.

What it checks. It checks that your H1 and title tag share at least 50% of keywords to ensure consistent SEO signaling and clear topic identification for AI.

Why it matters

Verifies that your H1 and Title Tag share at least 50% of the same core keywords. In SEO, this provides a unified topical map from the SERP click to the page load. For AI agents, explicitly aligned headings serve as "Semantic Anchors," allowing the bot to instantly verify the page's core entity without guessing.

If the test fails

Conflicting Title and H1 tags create "Contextual Ambiguity." This confuses traditional search engines and AI RAG (Retrieval-Augmented Generation) agents about your page's primary topic, diluting your topical authority and causing rankings to drop.

How to fix it

Ensure your H1 and Title Tag present a unified topic. Keep the Title Tag optimized for the SERP, and make the H1 a natural, engaging extension of that exact same keyword theme.

What it checks. Checks for the old <bgsound> tag used to play background music.

Why it matters

This test looks for the old <bgsound> tag used to play background music. In SEO, using deprecated tags tells search engines that your site is not being maintained, which can hurt your rankings. For AI agents, this tag is just "Technical Noise": it's a piece of junk code that adds no value to the information you are trying to share.

If the test fails

Most modern browsers (like Chrome or Safari) don't even support this tag anymore. If it does work, sudden unexpected audio is one of the fastest ways to make a user close your tab. This "Bounce" tells Google your page is low quality. AI looks for modern, clean, and professional code. When it sees an old tag, it lowers the "Trust Score" of your main content.

How to fix it

If you have this tag, delete it immediately. If you actually need audio on your page, use the modern "<audio>" tag which gives the user a "Play" and "Pause" button.

What it checks. Checks if too many sentences use passive voice, reducing clarity for users and AI systems.

Why it matters

Flags pages where more than 10% of sentences use passive voice. In SEO, passive constructions weaken the clarity and persuasiveness of content. For AI agents, passive voice obscures the Subject-Action-Object relationship, making it harder for language models and knowledge graphs to accurately interpret who is performing an action.

If the test fails

A high ratio of passive voice makes content sound evasive to users. Technically, it forces LLMs to work harder to understand the entity relationships in your text, blurring your topical authority.

How to fix it

Rewrite sentences in active voice to clearly define who is performing the action (e.g., change "the service is provided by us" to "we provide the service").

What it checks. It measures the balance of short (<12 words) and long (>30 words) sentences to improve pacing, boost time on page, and signal more human-like writing.

Why it matters

Checks the ratio of short sentences (<12 words) to longer sentences (>30 words). In SEO, rhythmic pacing holds user attention and increases "Time on Page" metrics. For overall quality, it differentiates human-crafted narratives from monotonous text blocks.

If the test fails

Monotonous text causes reader fatigue and quick drop-offs. Search engines interpret poor "time-on-page" as a negative quality signal, which indirectly harms your ranking power.

How to fix it

Mix your sentence structures. Use short sentences to make strong points, and longer sentences to provide detail. Create a natural, engaging rhythm that keeps users scrolling.

What it checks. Checks if the content uses lists or tables to improve readability and AI extraction.

Why it matters

Scans the text for HTML <ol>, <ul>, and <table> elements to evaluate the presence of structured content. In SEO, lists and tables improve the chances of earning Featured Snippets. For AI systems, structured formats are easier to parse and extract, reducing computational effort and improving content visibility.

If the test fails

A long article with no bullet points or tables becomes a wall of text that overwhelms readers and forces AI systems to process dense paragraphs to find key information, lowering the chances of being cited in AI-generated summaries.

How to fix it

Break down key ideas into bullet points or tables so both users and AI systems can quickly scan and extract important information.