How the page check works.

1. Normalises the address (https:// is added when missing; only http and https on the standard ports) and refuses IP addresses, local names, genclass.dev itself and hostnames that resolve to private, loopback, link-local, carrier-grade NAT or cloud metadata addresses. It reads the site's robots.txt for a GenClassScan group. From our server it also asks for the page's http:// address (to see whether it redirects to https://; only the first 16 KB are read) and /favicon.ico, and asks hstspreload.org whether the hostname is on the browsers' HSTS preload list.
2. Starts a fresh browser (Cloudflare Browser Rendering) with no cookies or storage, and loads the page three times in parallel: desktop, 1366 × 768, light; phone, 390 × 844, light; phone, 390 × 844, dark. Each load has 16 seconds, then up to 4 more for the network to go quiet (half a second when the page had not finished loading). When a page is still loading after that, the scanner pauses its playing video and audio so the checks can run, and the report says so.
3. Runs the visual checks in each view for about 6 seconds: the measured checks the GenClass runtime ships from version 0.3.0-beta.0, the runtime's visual chunk from commit 6ae209f, in an isolated part of the browser the page's scripts cannot reach. It presses Tab a few times on the desktop and scrolls with the mouse wheel, which some checks need (focus under a sticky header, a scroll lock, a control under a fixed bar). With GenClass on, the checks run in guard mode with their fixes turned on, and a second, report-only set of the same checks then measures the page again; the fixes are undone before the screenshot. The page's fetch and XHR requests in flight are counted and handed to the checks, which do not judge a blank page or a page that ignores clicks while a request runs.
4. Takes a screenshot of the top of the page in each view and records the box of every finding.
5. Asks a model, Clef on Cloudflare Workers AI, about up to 40 single elements across the three views, from a crop of a viewport screenshot: the visual checks' findings, for a second look (with the element's measured facts), and elements the measured checks cannot judge (text over images, covered controls, buttons and links in the dark view). What it finds is labelled as judged by a model, never as measured (the model judge, below).
6. Runs axe-core 4.13.0 in each view, unmodified, in the same isolated part of the browser: its WCAG 2.2 A and AA rules (tags wcag2a, wcag2aa, wcag21a, wcag21aa, wcag22aa) and its best practices (best-practice). Only violations become findings; rules axe-core cannot decide by itself ("needs review") are counted and shown as a number, never scored. Three of its rules are turned off because the scanner measures the same thing itself and would otherwise count it twice: target-size, meta-viewport, meta-viewport-large. It does not look inside iframes and fetches nothing.
7. Audits the light phone view: tap targets, the viewport meta tag, text sizes, the page's head (description, robots, link preview tags, icon) and the main document's security headers and cookies; then narrows the same page to 360 and 320 px wide and widens it to 768 px, without a reload, and measures whether it scrolls sideways. On the desktop and the light phone it compares each image's file with the size it is shown at, and reads its format and the web fonts' font-display. On the desktop, last, it focuses the first keyboard stops and presses Tab to those whose styles did not change, comparing screenshots with and without focus.
8. Reads what the browser itself reports (a DevTools protocol session of the scanner's own) while each view loads and its checks run: uncaught errors, console.error, the status and size of every response, and mixed content. On the desktop it reads Largest Contentful Paint and layout shifts once the network is quiet, before the scanner presses a key or scrolls.
9. On the desktop page, with GenClass 0.2.2 loaded in observe mode (telemetry off, model from genclass.dev/model/), types a, ab, abc into the first search box, 80 ms apart, and double-clicks the most prominent submit button of a same-origin form that would POST. Forms with a password or card field are skipped, and so are forms and buttons that would submit into another window. GET responses during the probe get 0 to 1,500 ms of extra latency, so they can arrive out of order.
10. Opens the page once more with GenClass in guard mode and repeats the probe, to measure what guard changes.
11. Scores the findings and keeps the report for 6 hours. The whole scan has a hard budget of 50 seconds; a step that does not fit is skipped and the report says so. When the page sent requests other than GET while loading, findings that may come from the scanner's stand-in replies (template text, broken images, JavaScript errors, and GenClass diagnoses other than a duplicate) are listed but not scored.

• It never sends a POST, PUT, PATCH, DELETE or a beacon to the site. Every request other than GET, while the page loads and during the probe, is answered inside the browser with a stand-in 200 JSON reply (or a 204 for a form navigation, so the page stays put) and never leaves it. Form data that the page's own script sends with GET does reach the site's own origin.
• It never follows a link off the page: after the first load, any navigation of the page is cancelled. It opens no new windows or tabs: window.open does nothing, and forms and links that would open one stay in the page.
• While it clicks, requests for data to other origins are cancelled and WebSocket messages are held.
• It never signs in, never types into anything but a search box, and registers no service workers. The double-click probe submits the form empty, with the browser's own form validation turned off.
• It does not load private addresses. IP addresses in private, loopback, link-local, carrier-grade NAT and metadata ranges, and local names, are blocked for every request. Every hostname the page asks for is looked up in DNS first, and a name that points to a private address is not loaded; a redirect also has to pass the opt-out list and robots.txt. WebSocket connections to IP addresses or local names are refused, and a WebSocket host that resolves to a private address throws the scan away. The browser then looks each name up again itself, so a DNS server that gives a different answer the second time is the one case these checks cannot rule out.

Every request carries the token GenClassScan/1.0 (+https://genclass.dev/scan) at the end of a normal Chrome user agent:

Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36 GenClassScan/1.0 (+https://genclass.dev/scan)
Mozilla/5.0 (Linux; Android 14; Pixel 8) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Mobile Safari/537.36 GenClassScan/1.0 (+https://genclass.dev/scan)

Requests come from Cloudflare's Browser Rendering network, which identifies them as automated.

• Five new scans per minute per visitor, and one running at a time (cached results do not count). Visitors on IPv6 count by their /64 network.
• A few new scans per minute per site, whoever asks, and a small number of scans at once across everyone.
• Crawlers and link previews can open a report but cannot start a scan.
• One scan per address at a time; a second request for the same address waits for the first result.

Every other finding comes from a measured check: a number against a threshold the finding names. The page check also asks a model, Clef (@cf/cloudflare/clef, Cloudflare's open decision model, which reads images), running on Cloudflare Workers AI, about single elements. It is always given a crop of a viewport screenshot (the element's box and 24 px around it), where the element is in it, and the view. It answers whether a visitor can see and use the element as intended, and if not, what kind of problem it is; its score is 1 minus its probability that nothing is wrong.

• A second look at measured findings. For a visual check's finding the model is also given the element's measured facts in words (its box, colours and contrast, what is behind it, what the hit test found on top of it, how much of it is clipped; text lengths, never the text), with the instruction to judge by what the screenshot shows and to treat the facts as hints: the evaluation's clef-img-p3 prompt. Sideways scrolling, images that failed to load and template text stay as measured, as the evaluation recommends (at its threshold the model dropped 13 of 34 real sideways-scrolling findings, which a crop cannot show, and 4 of 15 real broken images; template text was already real 5 times in 6), and so do findings with no element to crop (a failed stylesheet or font, a missing viewport tag, a lock on the whole page) and layout shift (already listed, not scored). A finding the model scores below 0.9777 in every view it appeared in moves to "Listed, not scored (a model judged it as probably fine)", with the crop; it is never dropped. On the evaluation, the rules followed by the model at that threshold had precision 0.56 where the rules alone had 0.225, and found 0.54 of the real problems where the rules alone found 0.81.
• Findings of its own, where the measured checks abstain: controls another element covers or that are partly clipped, every visible button and link in the dark view, and text over images, gradients or backgrounds the checks cannot know, in that order and the first screen of the page first, leaving out the site's own name (a logotype). Here the model gets the crop, the view and the tag only (the evaluation's clef-imgonly-p2 prompt): the facts of such an element are the measurements the checks could not make, and in calibration they talked the model out of the fixture's deliberate bugs. An element it scores at 0.9757 or more becomes a Visual bugs finding, moderate, labelled "Judged from the screenshot by a model (Clef)", with the crop and what it answered. That threshold was the lowest with precision at least 0.8 on the part of the evaluation used to choose it (4 of 4); on the rest, 32 of the 36 crops it scored that high were real problems (precision 0.89), 5 of 5 among the crops no rule had flagged. Few public pages give it anything to find: the calibration counts what it found and whether it was right.
• How it was measured (wave2/clef-eval, vision/results/clef/RESULTS.md): 1,856 crops of elements on public pages, 139 of them real problems, labelled by six AI labeller agents working in parallel, not people (208 crops labelled by two agents agreed with Cohen's kappa 0.705). Split by site: 412 crops (25 real) to choose the prompt and thresholds, 1,444 (114 real) to measure them once. The labels come from models too, so these numbers say how often Clef agreed with the labelling agents, on crops cut the way the page check cuts them.
• Bounds. At most 40 elements per scan (at least 14, 13, 13 for the desktop, light phone and dark phone views, and a view may use what the views before it left), each asked as soon as its crop is taken and answered while the rest of the scan runs; an answer counts only if it comes within 4 seconds. When Cloudflare Workers AI does not answer, or answers late, the findings stay as measured. About 1,300 input tokens per element or fewer at $0.24 per million (Workers AI pricing, 2026-10-14): at most about $0.0125 for 40 elements.
• What is sent. The crop and the words above go to Cloudflare Workers AI, inside Cloudflare's network, with no account or visitor data. Cloudflare's Workers AI data-usage page says it does not use what is sent to train models, and stores it only when the account adds a storage service; this scanner does not. The crops a report shows are kept with its screenshots and deleted with them after 24 hours.

Signed out, a report shows the score, the category scores, the screenshots and half of the findings. The rest are removed on our server before the report reaches your browser, so a shared link shows everyone the same half. Signed in to genclass.dev, with any account (a free one is enough, no card), it shows every finding, the race probe and an AI review.

The AI review is written by an OpenAI model when you open it: a summary, the fixes to make first, and real sites in the same field to learn from. What is sent: the report's score, categories, findings (what was measured and the suggested fix, cut short) and a few speed numbers, plus the page's title, description, headings and navigation labels, read once from the page. Nothing about you. The model can be wrong; it never changes the score or adds a finding. A suggested site is shown only when its address loads. The review is kept with the report and deleted with it after 24 hours.

The vibecoded factor (0 to 100: how much the page looks like it came straight out of an AI app builder or a starter template) is judged by an OpenAI vision model the first time a report is opened. Everyone sees the number; signed in, you also see the breakdown (fonts, images, layout and copy). What is sent: the desktop screenshot of the page and facts read from its HTML and stylesheets (the fonts it loads, AI-builder fingerprints such as Lovable's or v0's, UI kits such as shadcn/ui). It is an opinion, not a measurement, never part of the score, and is deleted with the report after 24 hours.

A small GenClass model (4.8 MB, 1.19 M parameters) looks at the same crop of each measured visual finding, inside the scan's own Cloudflare browser, and gives a score from 0 to 1. Each finding it saw shows it ("Vision 0.91"); the findings it flags at 0.752 or more that are not scored are listed on their own. It never changes a finding or the score.

• How it was measured (wave2/vision-v2-student, vision/results/vision-v2/RESULTS.md): on 1,052 held-out crops it ranks problems about as well as Clef (average precision 0.611 against 0.615). Behind the measured rules, at this threshold, it kept 69 of their 500 flags, and 33 of those were real (48%; the rules alone: 15%). The labels come from AI labeller agents (Claude subagents), not people.
• Beta. It was taught by OpenAI's Decisions API (gpt-6-luna, public beta), its family answer averaged with Clef's. None of its problem families passed the 60% precision bar on the test set, so nothing it says is scored.

Site owners can stop the page check from loading their pages in two ways:

• Add a group to robots.txt. The scanner reads only groups that name it, since a person asked for one page:

User-agent: GenClassScan
Disallow: /

• Or email mehar@daybot.ca with the hostname. It goes on a block list the scanner checks before every scan, every redirect, every report view and every screenshot, subdomains included, so cached results and screenshots for it stop showing at once.

• The report (findings, timings and the address) is cached for 6 hours, so a shared link shows the same result without a new scan.
• Screenshots and reports are deleted 24 hours after the scan by an hourly sweep.
• For the model judge, crops of the screenshots (an element and 24 px around it) and the element's measured facts are sent to Cloudflare Workers AI, inside Cloudflare's network, with no account or visitor data. Cloudflare's Workers AI data-usage page says it does not use what is sent to train models, and stores it only when the account adds a storage service to it; this scanner does not. The crops a report shows are kept with its screenshots and deleted with them.
• GenClass Vision looks at the same crops inside the same Cloudflare browser. Nothing more is sent anywhere.
• The visitor's IP address is used only for the per-minute rate limit, as a hash, and is not stored.
• The browser starts empty for every scan and is closed afterwards. No cookies or storage carry over between scans.