Performance Budgets and Agent Timeout Thresholds

Agents are impatient. Not because they are poorly designed, but because they have budgets: time budgets, compute budgets, and request budgets. A page that takes 8 seconds to become usable is tolerable for a human who has already decided to wait. An agent with 50 pages to check will skip it and move to the next one.

Typical agent timeout thresholds

Most browser-based agents set timeouts in the range of 5 to 30 seconds for full page load, but they start extracting content much earlier. The practical thresholds look something like this:

• Time to First Byte (TTFB): If the server does not respond within 2 to 3 seconds, the agent may abandon the request. This is especially true for agents making many requests in sequence.
• First Contentful Paint (FCP): Agents using headless browsers often wait for FCP before reading the DOM. If FCP takes more than 3 seconds, the agent may time out on content extraction.
• Largest Contentful Paint (LCP): The point at which the main content is visible. Agents that need the primary page content (a product name, a price, an article body) care about this metric. Over 4 seconds and you risk the agent reading a partially loaded page.

These are not standardised numbers. Different agents use different thresholds. But the pattern is consistent: agents expect content faster than most web performance guidelines suggest. The broader question of how latency budgets affect agent behaviour applies here directly.

Why performance budgets matter for agents

A performance budget sets maximum limits for page weight, load time, or resource count. Teams typically set these to improve user experience, but they serve agents equally well.

Consider a page with these characteristics:

• 4MB of JavaScript
• 2MB of images above the fold
• 15 render-blocking CSS files
• 3 third-party analytics scripts that load synchronously

A human on a decent connection waits 5 to 7 seconds. The page loads, they scroll, they find what they need. An agent hits the page, waits for the DOM to stabilise, and gives up at 5 seconds because the JavaScript is still executing.

Metrics that matter for agents

Not all performance metrics affect agents equally:

TTFB is critical. Agents often make many sequential requests. A 500ms TTFB across 50 pages adds 25 seconds of waiting just for server responses. Get TTFB under 200ms for static pages and under 500ms for dynamic ones.

FCP determines when agents can start reading. Once the first content renders, agents can begin extracting text and structure. If FCP is delayed by render-blocking resources, the agent sits idle.

LCP affects content completeness. The largest content element is often the most important one: a hero image, a product photo, a main heading. If the agent reads the DOM before LCP, it may miss the primary content.

Total Blocking Time (TBT) affects interaction. Agents that need to click buttons, fill forms, or trigger navigation cannot do so while the main thread is blocked by JavaScript execution. High TBT means the agent's actions queue up and may time out.

Setting performance budgets for agent compatibility

Here are concrete targets that keep pages within most agent timeout thresholds:

| Metric | Target | Why it matters for agents | |--------|--------|--------------------------| | TTFB | < 500ms | Prevents request-level timeouts | | FCP | < 1.5s | Allows content extraction to begin | | LCP | < 2.5s | Ensures primary content is available | | Total JS | < 300KB (compressed) | Reduces main thread blocking | | TBT | < 200ms | Allows agent interaction |

These targets are tighter than Google's Core Web Vitals thresholds, and deliberately so. Agents have less patience than search engine crawlers.

Practical improvements

Server-side render critical content. If your product name and price come from a client-side API call, an agent may read the page before that call completes. Render critical content in the initial HTML response.

Defer non-essential JavaScript. Analytics, chat widgets, and A/B testing scripts do not need to block page rendering. Use defer or async attributes, or load them after the main content is interactive.

Compress and optimise images. Use modern formats (WebP, AVIF) and appropriate sizes. A 3MB hero image that an agent does not even look at is wasted bandwidth and added load time.

Reduce third-party script impact. Each third-party script adds DNS lookups, TCP connections, and JavaScript parsing time. Audit your third-party scripts regularly and remove any that are not essential.

Your performance budget is not just about user experience. It is about whether agents can access your content at all. A page that misses agent timeout thresholds is functionally invisible to AI-powered tools.