Geo and Locale Determinism for Browser Agents

Agentic browsing systems are leaving the lab and entering production. They pilot shopping flows, verify ad placements, test localized UX, and gather regulatory evidence. But they often break in frustratingly non-deterministic ways because the web is not a uniform substrate. Sites fork logic on country, ASN, language, timezone, UA and Client Hints, TLS fingerprints, DNS answers, and even IP reputation. If you do not control those variables, your agents will drift and your tests will flake.

This article lays out a practical, opinionated blueprint for geo-locale determinism in auto-agent browsers:

• Deterministic IP and ASN via mTLS forward-proxy egress pools per country or ISP
• Accept-Language and timezone control aligned with navigator languages
• A deliberate UA and Client Hints switcher compatible with UA reduction
• A what-is-my-browser-agent telemetry service to measure what the world sees
• CI/CD drift gates that block releases when reality deviates from your golden profile

It includes concrete configuration examples, CDP code, Envoy forward proxy snippets, telemetry collectors, and test gating logic, plus notes on pitfalls like QUIC, WebRTC leaks, and DNS determinism.

Why geo-locale determinism matters

If you ship agentic browsers at scale, you will encounter these symptoms:

• A test suite passes in Virginia but fails in Frankfurt because cookie banners, price formats, or shipping options differ.
• A checkout flow works from one cloud provider but triggers extra fraud checks from another.
• An LLM browser tool shifts behavior between runs as Accept-Language or timezone floats with the container host.
• A site flips to a mobile experience due to UA reduction and Client Hints policy, breaking element locators.

The root cause is drift between what you intended (for example, simulate a French user on SFR in Paris with fr-FR UI conventions) and what the origin actually sees (for example, a US ASN with en-US, UTC, and a reduced UA). Determinism turns that drift into a measurable, controllable budget.

What must be deterministic

To make browser agents reproducible, treat these attributes as test fixtures and SLOs:

• Network
  • Public egress IP and announcing ASN
  • TCP and TLS connection characteristics visible to the origin
  • DNS answers, resolver behavior, and EDNS client subnet handling
• Locale and time
  • Accept-Language header with stable q-weights
  • navigator.languages and navigator.language
  • Timezone offset and IANA name
  • Localized formatting via Intl resolved options
• Browser identity
  • User-Agent string (subject to UA reduction)
  • Client Hints: low entropy and high entropy values
  • Screen and device metrics used by UX forks
• Side channels
  • WebRTC ICE candidate IPs
  • QUIC versus H2 selection
  • Geolocation API prompts and overrides

You will not control everything. Some fingerprints are costly or impractical to shape without breaking the end-to-end TLS model. You can still achieve strong determinism by explicitly deciding which layers you own and then measuring the rest.

Architecture blueprint (layered)

Think in layers that each own a slice of determinism:

1. Egress layer: forward proxy pools with mTLS client authentication, segmented by country and ASN, that perform SNAT to stable IPs. The proxy relays CONNECT tunnels so the origin still sees the browser’s TLS handshake, not the proxy’s.
2. Browser layer: Chromium or WebKit with CDP hooks that set timezone, Accept-Language, geolocation, UA and Client Hints, and patch navigator properties on document start. Disable QUIC and WebRTC IP leaks, and align OS and browser locale.
3. Header and hint switcher: a policy module that chooses the right Accept-Language, UA, and userAgentMetadata per scenario, consistent with the virtual device profile.
4. Telemetry: a what-is-my-browser-agent endpoint you own that echoes back everything the origin would see and adds enrichment such as ASN, geo, and TLS properties.
5. CI/CD gates: compute diffs between the profile you intend and the telemetry you measured; block merges when drift exceeds thresholds.

The following sections dive into each part.

Egress determinism: IP and ASN via mTLS forward proxies

Goals

• A stable IP pool per geo and ISP class
• Predictable ASN observed by origins
• No TLS interception; keep the browser’s TLS handshake intact
• AuthNZ through mTLS, not bearer tokens or source IPs

Why a forward proxy with CONNECT

Use a forward proxy that requires client certificates. Your browser opens an HTTP CONNECT tunnel to the origin’s host:port via the proxy. After CONNECT is established, the proxy simply pipes traffic; the TLS handshake happens between the browser and origin. That preserves a browser-native TLS fingerprint and avoids breakage from TLS bumping.

Envoy example: mTLS forward proxy that supports CONNECT

The following Envoy config exposes an mTLS listener for clients and allows CONNECT tunneling to arbitrary origins. It does not terminate TLS to origins; it only authenticates clients.

yaml
static_resources:
  listeners:
  - name: listener_egress
    address:
      socket_address: { address: 0.0.0.0, port_value: 8443 }
    filter_chains:
    - filters:
      - name: envoy.filters.network.http_connection_manager
        typed_config:
          "@type": type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager
          stat_prefix: forward_proxy
          http2_protocol_options: {}
          route_config:
            name: local_route
            virtual_hosts:
            - name: any
              domains: ["*"]
              routes:
              - match: { connect_matcher: {} }
                route: { cluster: dynamic_forward_proxy_cluster }
          http_filters:
          - name: envoy.filters.http.router
    transport_socket:
      name: envoy.transport_sockets.tls
      typed_config:
        "@type": type.googleapis.com/envoy.extensions.transport_sockets.tls.v3.DownstreamTlsContext
        require_client_certificate: true
        common_tls_context:
          tls_params: { tls_minimum_protocol_version: TLSv1_2 }
          tls_certificates:
          - certificate_chain: { filename: /etc/envoy/certs/proxy.pem }
            private_key: { filename: /etc/envoy/certs/proxy.key }
          validation_context:
            trusted_ca: { filename: /etc/envoy/certs/ca.pem }
  clusters:
  - name: dynamic_forward_proxy_cluster
    connect_timeout: 5s
    lb_policy: CLUSTER_PROVIDED
    cluster_type:
      name: envoy.clusters.dynamic_forward_proxy
      typed_config:
        "@type": type.googleapis.com/envoy.extensions.clusters.dynamic_forward_proxy.v3.ClusterConfig
        dns_cache_config:
          name: local_dns_cache
          dns_lookup_family: V4_ONLY
    transport_socket:
      name: envoy.transport_sockets.raw_buffer

Points to note:

• require_client_certificate enforces mTLS. Your agent presents a client cert to use the proxy.
• CONNECT match routing ensures HTTP CONNECT is tunneled; the TLS handshake to the origin is end-to-end between browser and site.
• No upstream TLS config is set because the proxy is not terminating TLS to the origin.

Country and ASN segmentation

• Country: segment by deployment location or IP block. Run separate proxy pools in specific regions and attach elastic IPs allocated to those countries. If you BYOIP with region-specific announcements, you keep control during failover.
• ASN: trickier. Cloud providers announce their own ASNs. If you must appear from a specific ASN class (for example, consumer ISP versus hyperscaler), you need an intermediary network provider that originates routes from the desired ASN. Options include:
  • Work with a network partner that owns the ASN and offers mTLS forward proxies with their announced space.
  • Lease IP space and arrange announcements from your own ASN in the target region (heavier operational burden).
  • For compliance testing only, use ethical ISP or enterprise proxy providers with contracts, audit, and rate controls.

Be intentional. If your use cases do not require a specific ASN, prefer the simplicity and cost of cloud-native egress. If they do, treat the proxy vendor as critical infrastructure and integrate telemetry and rate governance.

Network policy and stability check-list

• Disable QUIC in the browser; many forward proxies do not support UDP. Prefer HTTP/2 or HTTP/1.1 over CONNECT.
• Pin a DNS resolver per pool using DoH or DoT to avoid resolver-based drift. Disable EDNS Client Subnet unless you need CDN localization by resolver.
• Keep NAT pools small and sticky to avoid cross-run IP churn; long-lived sockets and keepalives reduce origin session resets.
• Measure from the origin’s perspective by calling your telemetry endpoint from each pool on a schedule and recording ASN and geo.

Locale determinism: Accept-Language and timezone

Accept-Language done right

Accept-Language affects content negotiation, date and number formats, login flows, cookie banners, and even antifraud. The header should match navigator.languages and navigator.language. Ensure both are controlled.

Guidelines:

• Be explicit: set q-weights. Example for French primary with English fallback: fr-FR,fr;q=0.9,en;q=0.8.
• Align the document lang attribute and Accept header when you can.
• Match languages list in the browser to the order of Accept-Language.

Timezone and clock

• Use CDP Emulation to set the timezone by IANA name.
• Also set the system clock and TZ for consistency, especially for native libraries used by headless components.
• Consider locale-aware formatting via Intl resolvedOptions to match expectations.

Playwright example: language and timezone

ts
import { chromium } from 'playwright';

async function launchFrenchParis(profile: {
  acceptLanguage: string;
  timezoneId: string;
  languages: string[];
}) {
  const browser = await chromium.launch({ args: [
    '--lang=fr-FR',
    '--disable-quic',
    '--disable-webrtc-encryption', // if you must, but prefer policy below
  ]});
  const context = await browser.newContext({
    locale: 'fr-FR',
    timezoneId: profile.timezoneId,
    userAgent: undefined, // we will override via CDP for UA-CH
    extraHTTPHeaders: {
      'Accept-Language': profile.acceptLanguage,
    },
  });
  const page = await context.newPage();

  // Ensure navigator.languages matches
  await context.addInitScript((langs) => {
    Object.defineProperty(navigator, 'languages', { get: () => langs });
    Object.defineProperty(navigator, 'language', { get: () => langs[0] });
    document.documentElement.setAttribute('lang', langs[0]);
  }, profile.languages);

  // Emulate timezone explicitly via CDP (overrides OS)
  const client = await context.newCDPSession(page);
  await client.send('Emulation.setTimezoneOverride', { timezoneId: profile.timezoneId });

  return { browser, context, page, client };
}

launchFrenchParis({
  acceptLanguage: 'fr-FR,fr;q=0.9,en;q=0.8',
  timezoneId: 'Europe/Paris',
  languages: ['fr-FR', 'fr', 'en'],
});

Note: Playwright’s locale option sets navigator.language but not Accept-Language; explicitly add the header to match. CDP’s Emulation.setTimezoneOverride ensures JavaScript Date renders with the correct zone.

UA reduction, Client Hints, and a deliberate identity switcher

Chromium’s UA reduction deprecates high-entropy data in the User-Agent string, shifting detail into Client Hints. Origins receive low-entropy hints by default and opt into high-entropy hints via Accept-CH response headers and delegation. For agents, this means you must control both the legacy UA string and the userAgentMetadata used to generate CH values.

Your switcher should:

• Choose a device profile with these attributes: browser brand and version, platform and platformVersion, architecture, model, mobile flag, fullVersionList.
• Override via CDP Network.setUserAgentOverride with userAgentMetadata set.
• Align window dimensions and deviceScaleFactor to the profile.
• Decide policy for sending hints even when the server does not opt in. Some automation stacks inject Sec-CH headers on requests proactively. That may diverge from real browser behavior; measure and pick a consistent policy per test.

Example: Puppeteer CDP override with UA-CH

js
import puppeteer from 'puppeteer';

const profile = {
  userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
  userAgentMetadata: {
    brands: [
      { brand: 'Chromium', version: '120' },
      { brand: 'Google Chrome', version: '120' },
    ],
    fullVersionList: [
      { brand: 'Chromium', version: '120.0.6099.129' },
      { brand: 'Google Chrome', version: '120.0.6099.129' },
    ],
    platform: 'Windows',
    platformVersion: '15.0.0',
    architecture: 'x86',
    model: '',
    mobile: false,
  },
  acceptLanguage: 'en-US,en;q=0.9',
  timezoneId: 'America/Los_Angeles',
};

(async () => {
  const browser = await puppeteer.launch({
    headless: 'new',
    args: [
      '--disable-quic',
      '--lang=en-US',
    ],
  });
  const page = await browser.newPage();
  await page.setExtraHTTPHeaders({ 'Accept-Language': profile.acceptLanguage });

  const client = await page.target().createCDPSession();
  await client.send('Emulation.setTimezoneOverride', { timezoneId: profile.timezoneId });
  await client.send('Network.setUserAgentOverride', {
    userAgent: profile.userAgent,
    userAgentMetadata: profile.userAgentMetadata,
    acceptLanguage: profile.acceptLanguage,
    platform: profile.userAgentMetadata.platform,
  });

  // Optional: proactively add Sec-CH headers for test determinism
  await page.setRequestInterception(true);
  page.on('request', (req) => {
    const headers = {
      ...req.headers(),
      'sec-ch-ua': '"Google Chrome";v="120", "Chromium";v="120"',
      'sec-ch-ua-mobile': '?0',
      'sec-ch-ua-platform': '"Windows"',
      // High entropy hints are normally gated; inject only if your tests rely on them
      'sec-ch-ua-full-version-list': '"Google Chrome";v="120.0.6099.129", "Chromium";v="120.0.6099.129"',
    };
    req.continue({ headers });
  });
})();

Caveat: proactively injecting CH headers can diverge from stock browser behavior. Prefer CDP’s userAgentMetadata and let sites request hints. If you must inject for determinism in a closed test environment, mark those runs separately.

Aligning page metrics with the identity

• Set viewport, deviceScaleFactor, and color scheme to match the device profile.
• Override navigator.hardwareConcurrency and deviceMemory via addInitScript when needed.
• Ensure Touch events, pointer capabilities, and media queries (prefers-color-scheme) are consistent.

ts
await context.addInitScript(() => {
  Object.defineProperty(navigator, 'hardwareConcurrency', { get: () => 8 });
  Object.defineProperty(navigator, 'deviceMemory', { get: () => 8 });
});
await page.emulateMedia({ colorScheme: 'light' });
await page.setViewportSize({ width: 1366, height: 768 });

Shut down side-channel leaks

• WebRTC IP leaks: disable non-proxied UDP. In Chromium, use the DisableNonProxiedUDP policy or launch arg. With Playwright, route over a proxy to ensure ICE candidates are constrained.
• Geolocation API: either deny globally or override via CDP Emulation.setGeolocationOverride when tests require location.
• QUIC: disable unless your proxy egress supports UDP and you want HTTP/3. CONNECT over QUIC is improving, but assumptions differ by proxy.

bash
chrome --disable-features=WebRtcHideLocalIpsWithMdns --force-webrtc-ip-handles-policy=disable_non_proxied_udp

DNS determinism

• Use a fixed resolver per pool, preferably DoH. Examples: Cloudflare 1.1.1.1, Quad9, or your own Unbound. Avoid the host’s default if it changes per region.
• Disable EDNS Client Subnet unless you want CDN geo by resolver. ECS can introduce variation by client subnet.
• Prewarm and pin critical hostnames with low TTL logic in your proxy or agent to reduce jitter.

Envoy’s dynamic forward proxy cache and a centralized DoH resolver can give you deterministic cache behavior and observability.

What-is-my-browser-agent telemetry

You need your own endpoint to see exactly what origins see. It should be easy to call from any agent and return structured JSON with:

• Connection data: source IP, reverse DNS; TLS version and cipher; request protocol; HTTP version
• Geo and ASN: enrichment via MaxMind or a similar DB
• Headers: full request headers and, if possible, the order for subtle anti-bot checks
• Client hints: default and any high-entropy hints received
• JS-observable data: navigator UA, languages, userAgentData, Intl settings, timezone offset, screen metrics

Additionally, run a daily job to compare your measurements to external verifiers like:

• ipinfo.io or ipapi.co for IP, ASN, and country
• ifconfig.co/json for IP echo
• Cloudflare trace to see colo and HTTP/2 vs HTTP/3

Simple echo service using Cloudflare Workers

Workers automatically add cf populated fields with approximate geo and ASN.

js
export default {
  async fetch(request, env, ctx) {
    const cf = request.cf || {};
    const headers = Object.fromEntries(request.headers);
    const res = {
      ip: headers['cf-connecting-ip'] || headers['x-forwarded-for'] || null,
      tls: {
        version: cf.tlsVersion || null,
        cipher: cf.tlsCipher || null,
      },
      http: {
        protocol: request.headers.get('x-forwarded-proto') || 'https',
        h2: request.headers.get(':method') ? true : headers['x-http2-stream'] ? true : null,
      },
      geo: {
        asn: cf.asn || null,
        asOrganization: cf.asOrganization || null,
        country: cf.country || null,
        city: cf.city || null,
        colo: cf.colo || null,
        timezone: cf.timezone || null,
      },
      headers,
      ts: new Date().toISOString(),
    };
    return new Response(JSON.stringify(res, null, 2), {
      headers: { 'content-type': 'application/json; charset=utf-8' }
    });
  }
}

For JS-observable data, host a second route that serves a small HTML page with a script returning navigator and Intl data to your backend.

Node express telemetry endpoint capturing client script

js
import express from 'express';
const app = express();
app.use(express.json());

app.get('/agent', (req, res) => {
  res.type('html').send(`
<!doctype html>
<meta charset="utf-8"/>
<title>Agent Probe</title>
<script>
(async function(){
  const high = navigator.userAgentData ? await navigator.userAgentData.getHighEntropyValues(
    ['architecture','model','platformVersion','uaFullVersion']
  ) : {};
  const payload = {
    ua: navigator.userAgent,
    languages: navigator.languages,
    language: navigator.language,
    userAgentData: navigator.userAgentData ? {
      brands: navigator.userAgentData.brands,
      mobile: navigator.userAgentData.mobile,
      platform: navigator.userAgentData.platform,
      high,
    } : null,
    intl: {
      tz: Intl.DateTimeFormat().resolvedOptions().timeZone,
      locale: Intl.DateTimeFormat().resolvedOptions().locale,
      numberingSystem: Intl.DateTimeFormat().resolvedOptions().numberingSystem,
    },
    screen: { w: screen.width, h: screen.height, dpr: devicePixelRatio },
    perf: { nav: performance.navigation, timing: performance.timing },
  };
  const r = await fetch('/collect', { method: 'POST', headers: {'content-type': 'application/json'}, body: JSON.stringify(payload)});
  document.body.innerText = 'ok';
})();
</script>`);
});

app.post('/collect', (req, res) => {
  const headers = req.headers;
  const sourceIp = headers['x-forwarded-for'] || req.socket.remoteAddress;
  const record = {
    when: new Date().toISOString(),
    ip: Array.isArray(sourceIp) ? sourceIp[0] : sourceIp,
    headers,
    js: req.body,
  };
  // TODO: enrich with ASN and geo; store in your observability platform
  console.log(JSON.stringify(record));
  res.json({ status: 'ok' });
});

app.listen(8080, () => console.log('agent probe on :8080'));

With this you have an end-to-end view: what the request looked like to the server and what the page sees via JS. That’s the baseline for drift gates.

CI/CD drift gates: turn measurements into budgets

Build a small library that:

• Defines a golden profile per scenario: geo and ASN class, Accept-Language, timezone, UA and CH values, navigator properties.
• Hits your telemetry endpoint at the start of a test suite and stores the measured values.
• Compares measurement to golden with tolerances. If drift exceeds thresholds, fail fast and halt the suite.

Example drift comparator

python
from dataclasses import dataclass
from typing import List, Dict
import json
import sys

@dataclass
class GoldenProfile:
    country: str
    asn_class: str  # e.g., 'cloud', 'isp', 'enterprise'
    accept_language: str
    timezone: str
    ua_contains: List[str]
    ch_platform: str
    languages: List[str]

@dataclass
class Measurement:
    country: str
    asn: int
    as_org: str
    accept_language: str
    timezone: str
    ua: str
    ch: Dict[str, str]
    languages: List[str]

ASN_CLASSES = {
    'cloud': ['AS16509','AS15169','AS14618','AS8075'],
    'isp': [],
    'enterprise': [],
}

def classify_asn(asn: int, org: str) -> str:
    asn_str = f'AS{asn}'
    for cls, lst in ASN_CLASSES.items():
        if asn_str in lst or (cls == 'cloud' and any(k in org for k in ['Amazon', 'Google', 'Microsoft'])):
            return cls
    return 'unknown'

TOL = {
    'accept_language': 0,  # exact match
    'timezone': 0,
}

def compare(g: GoldenProfile, m: Measurement) -> List[str]:
    errs = []
    if g.country and g.country != m.country:
        errs.append(f'country mismatch: {m.country} != {g.country}')
    if g.asn_class:
        cls = classify_asn(m.asn, m.as_org)
        if cls != g.asn_class:
            errs.append(f'asn class mismatch: {cls} != {g.asn_class}')
    if g.accept_language != m.accept_language:
        errs.append('Accept-Language drift')
    if g.timezone != m.timezone:
        errs.append('timezone drift')
    for s in g.ua_contains:
        if s not in m.ua:
            errs.append(f'UA missing token: {s}')
    if g.ch_platform and m.ch.get('sec-ch-ua-platform') != g.ch_platform:
        errs.append('CH platform drift')
    if g.languages and g.languages != m.languages:
        errs.append('navigator.languages drift')
    return errs

if __name__ == '__main__':
    g = GoldenProfile(
        country='FR', asn_class='cloud', accept_language='fr-FR,fr;q=0.9,en;q=0.8',
        timezone='Europe/Paris', ua_contains=['Chrome/120'], ch_platform='"Windows"',
        languages=['fr-FR','fr','en']
    )
    # In practice, fetch measurement JSON from your telemetry endpoint
    m = Measurement(
        country='FR', asn=16509, as_org='Amazon.com, Inc.',
        accept_language='fr-FR,fr;q=0.9,en;q=0.8', timezone='Europe/Paris',
        ua='Mozilla/5.0 ... Chrome/120.0.0.0 Safari/537.36',
        ch={'sec-ch-ua-platform': '"Windows"'},
        languages=['fr-FR','fr','en']
    )
    errs = compare(g, m)
    if errs:
        print('DRIFT FAIL:', errs)
        sys.exit(1)
    print('DRIFT OK')

Wire this into your CI pipeline so that a failed drift check blocks deploy. That prevents test flakiness later when site logic forks on geo or locale.

Pitfalls and practical notes

• UA reduction and GREASE: Chromium may insert randomized CH brand values. When overriding userAgentMetadata, ensure your brands include realistic values and note that explicit overrides suppress GREASE. Track Chrome’s UA reduction milestones to keep expectations in sync.
• Header casing and order: Some defenses look at header order. Most automation stacks cannot deterministically control order across layers. Measure and document what your stack produces, and avoid flipping libraries that reorder headers without notice.
• TLS fingerprinting: With CONNECT, the origin will see the browser’s TLS stack. If you terminate TLS at the proxy, the origin sees the proxy’s TLS. Avoid TLS bumping unless you control both sides of the test. Do not try to spoof JA3 at the proxy for production traffic; it often causes subtle breakage.
• IP warm-up and reputation: New IPs, even in the right ASN, may trigger extra challenges. Warm them with benign traffic and steady usage patterns. Maintain allowlisted traffic classes separate from test traffic.
• Time sync: Ensure NTP is healthy. Clock skew beyond a minute causes auth failures and anti-bot suspicion.
• WebRTC: Disabling UDP can affect real-time features on sites under test. For those tests, use an egress with UDP support and align policies accordingly.

End-to-end example: shipping a French desktop agent from Paris via cloud ASN

1. Provision an Envoy mTLS forward proxy in eu-west-3 with two elastic IPs. Restrict ingress by mTLS client CA.
2. Configure your agent to connect via HTTPS CONNECT to the proxy with client certs.
3. Launch Chromium with args: disable QUIC, lang fr-FR, use a fixed DoH resolver. Set proxy via HTTPS proxy URL.
4. Override Accept-Language to fr-FR,fr;q=0.9,en;q=0.8.
5. Set timezone to Europe/Paris via CDP Emulation.
6. Set UA to a stable Chrome 120 desktop on Windows, with matching userAgentMetadata and viewport 1366x768.
7. Visit your telemetry endpoint; confirm country FR, ASN class cloud, Accept-Language matches, timezone matches, CH platform Windows.
8. Run the suite; block on drift.

Security, privacy, and ethics

• Respect site terms and robots policies. Determinism is not a license to bypass defenses or scrape at scale without consent.
• Keep audit logs of egress usage linked to mTLS client identities.
• Rate limit per pool and per destination; enforce budgets in the proxy.
• Separate test, monitoring, and production automation pools to prevent cross-contamination of reputation.
• Never collect or persist more telemetry than you need; handle IP and UA data as personal data under GDPR and similar laws.

Observability and SLOs for agentic browsers

Track these SLOs per pool and scenario:

• Drift rate: percentage of runs where geo or locale deviated from golden
• Challenge rate: percentage of requests encountering additional verification (for example, captcha)
• Median and p95 connect and TTFB times by destination and protocol (H2 versus H3)
• DNS answer stability by host
• IP churn rate per 24 hours

Trend these metrics and tie regressions to deployments at the egress or browser layer.

Reference checklist

• Egress
  • mTLS forward proxy with CONNECT; segment pools per country and ASN
  • Sticky SNAT IPs; measure with your telemetry endpoint hourly
  • Fixed DoH resolver; ECS disabled unless needed
  • QUIC disabled unless supported end-to-end
• Browser
  • Accept-Language header and navigator languages aligned
  • Timezone via CDP Emulation; system TZ and NTP configured
  • UA and userAgentMetadata set; viewport and deviceScaleFactor matched
  • WebRTC non-proxied UDP disabled or constrained
  • Geolocation overridden or denied per test policy
• Telemetry
  • Echo headers, CH, connection parameters; enrich ASN and geo
  • JS probe returns navigator and Intl data
  • Store samples and compare against golden
• CI/CD
  • Drift comparator as a preflight; block on mismatch
  • Weekly canary tests across all pools; alert on drift trends

Closing opinion

Reproducible agentic browsers are more about systems engineering than about the newest headless API. You earn determinism by owning your egress path, shaping browser identity coherently across legacy UA and Client Hints, and continuously measuring what the world actually sees. The what-is-my-browser-agent telemetry is the source of truth and the CI drift gates are your safety rails. Without both, you will misdiagnose flakiness for months.

Start small: one mTLS proxy per target region; a single device profile; a minimal telemetry endpoint. Wire in the gate on day one. As requirements grow, add ASN-specific pools and richer profiles. Keep your stack boring, measurable, and explicit. Determinism is a product choice, not an accident.