Using the AI agent

What makes this different from a regular audit tool

Most audit tools give you a list of issues and leave you to figure out the rest. The Evalta AI agent is an active collaborator. It knows your specific page, your tech stack, and what your PSI data actually means — and it stays with you through the fix, not just the diagnosis.

The key difference: the agent reasons beyond what PSI explicitly flagged. It looks at your raw page HTML for signals PSI missed — animation libraries running during load, Google Fonts loaded without preconnect, third-party chat widgets adding 500ms — and surfaces these as contributing factors even when they don't appear directly in your PSI results.

Opening a chat

Click any issue in your report to open the AI chat for that specific issue. The agent already has full context:

• Your PSI data — exact scores, failing audits, and measured impact
• Your page HTML — what's actually on the page causing the problem
• Your tech stack — framework, CMS, third-party scripts detected
• Previous fix attempts — what's been tried and whether it worked

You don't need to explain anything. Just open the chat and read the first message — it starts with the most important thing to fix.

What the agent investigates

For performance issues, the agent looks beyond PSI's explicit findings at your actual page HTML. Common things it catches that PSI often misses:

• Lazy-loaded hero images — loading="lazy" on your LCP image is the single most common cause of slow LCP. PSI flags it, but the agent identifies the specific element and gives you the exact fix.
• Animation libraries — GSAP, AOS, ScrollReveal, and Framer Motion all run on the main thread during page load. If you have a slow LCP alongside one of these libraries, the agent flags the connection even when PSI doesn't explicitly surface it.
• Font loading problems — Google Fonts loaded without font-display: swap or without a preconnect hint causes invisible text (FOIT) during load. The agent detects this from your HTML and explains exactly what to add.
• Heavy third-party scripts — chat widgets (Intercom, Drift, Crisp), analytics stacks (GTM + GA4 + Facebook Pixel + Hotjar), and A/B testing tools loaded synchronously. The agent identifies each one, rates its impact, and recommends whether to defer, lazy-load, or remove it.
• Missing resource hints — every third-party domain your page loads from needs a preconnect hint. Missing preconnects add DNS lookup time to every external resource. A quick win the agent always surfaces.

Understanding the agent's responses

First message

The opening message leads with the single most impactful fix, explains the mechanism in plain English (why does this cause the problem), and ends with an invitation to re-scan after making the change. It doesn't list everything at once.

Severity language

The agent uses specific language to signal confidence:

• “PSI measured...” or “your HTML shows...” — high confidence, based on actual data
• “detected in your page HTML” — the agent found a signal PSI didn't flag, likely contributing
• “worth investigating” — medium confidence, may be a contributing factor

Plain English explanations

Every response explains the human impact alongside the technical detail. Not just “your LCP is 3.6s” but “your page takes 3.6 seconds before the main content appears — users on mobile often leave before that.”

After making a fix

Make your change, then click Re-scan inside the chat. Don't close the thread — the agent tracks the conversation history and knows what was recommended.

After the re-scan, the agent:

• If improved — quantifies the improvement specifically (“LCP dropped from 3.8s to 1.9s — you're now in the Good range”), acknowledges the work, and tells you what's left
• If fully resolved — confirms clearly that the issue is fixed and suggests the next highest-impact issue to tackle
• If unchanged — says so honestly and suggests diagnostic steps (was the deployment live? cached?) before trying a different fix
• If regressed — flags it immediately and identifies the likely cause from the diff data

When a fix doesn't work

If a fix doesn't improve the metric, the agent won't repeat the same recommendation. After two confirmed failed attempts (confirmed by a re-scan showing no meaningful change), the agent:

• Acknowledges that the standard approach isn't working
• Searches the web for framework-specific issues or known bugs that might explain the persistence
• Takes a different diagnostic angle — considers less obvious causes
• May ask clarifying questions about your deployment setup or caching layer

A “confirmed failed attempt” requires a re-scan with no meaningful improvement. If you haven't re-scanned yet, the agent treats the recommendation as still pending — not failed.

Sitewide issues

Some issues affect multiple pages — missing meta descriptions across 8 pages, or thin content on all your blog posts. These appear as a single issue in your report with the affected pages listed.

The agent tracks progress per page. Fix the issue on one page, re-scan, and the thread updates:

• Fixed pages are marked and shown with strikethrough
• Remaining pages are listed clearly
• A progress counter shows “2 of 8 fixed”
• Each page fix is credited to your project stats

You get credit for partial progress — you don't need to fix the issue on every page before seeing it acknowledged.

When the agent searches the web

The agent has access to web search and uses it proactively when standard approaches aren't working. You'll see a “Searching...” indicator when this happens. The agent tells you what it's searching for and why — it doesn't search silently.

Searches are triggered for things like:

• Framework-specific bugs that might explain a persistent issue
• Library-specific performance gotchas (GSAP v3 vs v2 behaviour differences, for example)
• Current best practices for a specific fix (Next.js 14 image optimisation, for example)
• Known issues with specific third-party scripts

Issue goals and tracking

When you open a chat for a metric-based issue (like slow LCP), the agent sets a clear goal — for example “Reduce LCP to under 2.5s (currently 3.8s).” Every response is oriented toward that goal.

The goal and current measured value are shown in the chat. As you make improvements and re-scan, the agent updates the current value and tells you how far you are from the target.

Getting the most out of the agent

• Start with Critical issues — the agent is most impactful on high-severity problems where the fix has measurable impact.
• Always re-scan after fixes — the feedback loop is the most valuable part. Don't move to the next issue without confirming the last one worked.
• Tell the agent what you tried — if you made a change that isn't showing up in the re-scan, say so. “I added fetchpriority but the score didn't change” gives the agent context to investigate why.
• Ask follow-up questions — the agent is in a conversation, not giving a report. Ask “why does this matter?” or “what would happen if I ignore this?” and get a direct answer.
• Don't fix everything at once — fix one issue, re-scan, confirm. Multiple simultaneous changes make it impossible to know which fix made the difference.