Repository navigation
ai agent timing signal
The browser under your agent can be flawless - a real engine, a real fingerprint, a clean driver surface - and the session can still read as automated for a reason that has nothing to do with the browser: the rhythm of the loop driving it.
Every AI agent, invisible_playwright_mcp included, runs a think-act cycle. It looks at the page, sends what it sees to a model, waits for the model to decide, performs the action, and looks again. That cycle has a shape, and the shape is measurable from the other side of the connection. If your agent gets through the first page load fine and gets challenged a few interactions later, this page is probably about your problem: the block that arrives after actions, not before them, is usually a behaviour verdict, not a fingerprint one.
A behavioural check does not read the GPU string or the canvas hash. It reads the stream of events a session produces over time, and an agent loop left to its own timing produces four things a person does not:
- Gaps that cluster. Between one action and the next sits a wait for the model. That wait is not random the way a human pause is: it clusters around the model's inference latency, step after step, run after run. A person's pauses spread wide and ragged - a one-second glance here, an eight-second read there. The individual number is not the tell; the shape of the distribution is.
- Stillness inside the pause. A person reading a page drifts the pointer, scrolls a little, hovers over things. An agent's pointer sits perfectly still for two seconds and then arrives exactly where it needs to be.
- Actions that land dead centre, instantly. Coordinates computed from page structure or from a screenshot land on the centre of the target, with no approach, no overshoot, no correction, and no reading time in front of the click.
- No wasted actions. People scroll past things, open the wrong tab, hover over what they never click, change their minds. An agent performs exactly the actions the task needs and nothing else, which is efficient and visible.
None of that appears in any fingerprint report, which is exactly why it deserves its own page: it is a separate signal, read by a separate part of a detection system, and it survives every fingerprint fix.
A fingerprint is a photograph; behaviour is a motion study. Making the photograph perfect does nothing to the motion study.
invisible_playwright_mcp runs on a Firefox patched at the C++ level (the invisible_playwright engine), and that engine's job is the photograph: the rendering, the driver surface and the network handshake read as a genuine Firefox rather than an automated build. That is real, and it is most of what agents are blocked for. It is also not everything, and the honest boundary matters: the engine controls what the browser is, not the cadence at which the loop above it decides to act. The cadence is produced by the model and the harness calling it, above the browser, out of the engine's reach. The engine wiki's testing method lists behaviour among the things no in-page test suite covers, for the same reason.
Part of the motion problem does live below the loop, and that part is handled there, so you should know which part it is before trying to fix it yourself.
- The pointer path. When the agent clicks, the engine arcs the pointer to the target on a curved, human-shaped path rather than teleporting it. An individual click's motion is covered; the gap before the click is not, because the loop decides when the click happens. The boundary between pointer realism and fingerprint realism is drawn in detail on the engine wiki.
- Real input, not script shortcuts. invisible_playwright_mcp drives the page the way a person would: the pointer moves and keys are pressed, and it refuses to set a form field from JavaScript even when that would be quicker, because a page can tell the difference.
- Read before act. invisible_playwright_mcp's system prompt instructs the model to inspect the page before acting on it and to prefer one clear action at a time over long chains. That produces read-shaped traffic in front of actions instead of blind action bursts.
What none of that covers is the distribution of gaps between steps. That is the model's latency wearing a trench coat, and it is visible no matter how good each individual action looks.
Be clear-eyed about what you control. If you run an off-the-shelf agent - invisible_playwright_mcp's interface, or an assistant driving the browser over MCP - the loop's internal timing is not a knob you turn. What you control is everything around the loop, and that is where the wins are:
- Fewer, larger tasks. One instruction that reads five prices in one visit produces one session with a natural arc. Five separate instructions produce five bursts, each starting cold on the same site.
- No fixed schedule. Running the same task from a timer every ten minutes turns the task itself into a metronome. If something must repeat, vary the interval.
- Space out repeat visits. The rhythm tell compounds with the volume tell, and the volume half is a page of its own.
- Do not re-run a blocked task immediately. A challenge answered by the identical session ten seconds later confirms the verdict.
If you are building your own harness above an agent loop - executing its actions
yourself, or scripting the engine directly through its Python library - you own the timing, and then the rule
is: vary it, and make it depend on the step. A uniform delay is its own tell. A
sleep(1.0) between every action just moves the cluster from "instant" to "exactly
one second", and a tight cluster at one second is as machine-regular as a tight
cluster at zero. Long pauses before decisions, short ones inside a form, no number
twice:
import random, time
def dwell(low=0.6, high=2.4):
"""A varied pause, the kind reading and deciding actually produces."""
time.sleep(random.uniform(low, high))You can read this signal off your own sessions the way a site would. invisible_playwright_mcp's interface narrates every step as it takes it, so the cadence is on screen while the task runs; for anything scripted, log a timestamp at each action and look at the spread of the gaps. If the minimum and maximum are close together, or the mean sits right on top of your model's typical response time, the loop is emitting the clustered distribution described above. A human trace has a wide spread and a long tail. Measure the stream; do not assume the shape.
The fingerprint and the rhythm are two different signals, read by two different parts of a detection system, and the engine under invisible_playwright_mcp addresses the first. It makes the browser real, gives each click a human-shaped path, and puts real key presses behind typed text. The cadence between actions is produced above the browser - by the model and by how you run it - so it is yours: fewer and larger tasks, no fixed schedules, varied pacing where you control the code, and a look at your own gap distribution before a site looks at it for you.
Does a stealth browser hide that I am running an AI agent? It hides that the browser is automated. It does not hide the rhythm of the loop driving it, which is a separate signal produced above the browser.
What is the timing signal, exactly? The gaps between actions cluster around the model's latency instead of spreading like human pauses, the pointer is still during the pause, and actions land dead centre with no reading time in front of them.
Why do I get blocked after a few actions rather than at the first page? A block at first load points at the fingerprint or the address. A block after interactions points at behaviour, and the agent rhythm is the usual behaviour verdict.
Can invisible_playwright_mcp add the pacing for me? The engine humanizes each click's pointer path and presses real keys, and the agent reads before acting. The step-to-step cadence is decided by the model's loop, so what you control is how many tasks you run, against what, on what schedule.
Do I just add a fixed sleep between actions? No. A tight cluster at one second is as regular as a tight cluster at zero. Vary the pauses and make them depend on the step.
Will fixing the timing get me past everything? No. A clean rhythm on a bad exit, over quota, or against a rate limit still fails. Why does my AI agent get blocked? sorts the layers.
- invisible_playwright_mcp's own source: the system prompt in
src/invisible_playwright_mcp/agent.pyinstructs the model to inspect pages before acting and to prefer one clear action at a time, and the README documents the input behaviour (pointer moves, keys pressed, JavaScript form-fill refused). Both read 2026-09-03. - The engine wiki's testing method, which lists behaviour and the model-latency-shaped pause among the things no in-page suite covers, and its detected-on-one-site checklist, which reaches pointer motion and cadence only after the browser itself is clean.
See also: why does my AI agent get blocked? for the full layer-by-layer sort, agent retry loops and rate limits for the volume half of the same problem, and Claude computer use detected as a bot for the rhythm of a screenshot-driven agent specifically.
Written while maintaining invisible_playwright_mcp, an AI agent on a Firefox patched at the C++ level. The engine makes the browser real; the rhythm comes from the loop, and this page is what I check first when a session of my own gets challenged after the third click.
- OpenAI Operator alternatives
- Open-source Operator-style agents
- Is OpenAI Operator still available?
- OpenAI Operator vs Claude computer use
- browser-use alternatives
- Choosing an AI browser agent
- Open-source AI browser agents
- Open-source computer-use agents
- What is an AI web agent?
- AI browser agents vs traditional scraping
- Cloud browser infrastructure for AI agents, explained
- Browserbase alternatives
- Firecrawl vs an AI browser agent
- Skyvern alternatives
- Stagehand vs browser-use
- Project Mariner is gone: what replaced it
- Manus alternatives
- Gemini computer use vs Claude computer use
- A stealth browser MCP, reviewed honestly by its own wiki
- AI browser vs AI browser agent: which one do you want?
- AI browser agent vs RPA: which one fits the job
- AI browser agent vs n8n, Zapier and Make
- Vercel agent-browser alternatives, compared honestly
- What is an agentic browser? Definition and the two kinds
- Open-source agentic browsers: the three layers, compared
- Choosing an MCP server for browser automation: four axes
- Stealth MCP servers compared: Camoufox, nodriver, Patchright
- Playwright MCP alternatives, and the three you don't need
- Autonomous browser agents: the four rungs of autonomy
- What is actually free in the AI browser agent stack
- browser-use on GitHub: what the repo actually gives you
- Playwright MCP vs Chrome DevTools MCP: different jobs
- How to choose among MCP servers: a map by category
- Which MCP servers are worth adding to Claude Code
- MCP on GitHub: finding servers and judging them fast
- MCP vs an API: the decision, and what the wrapper costs
- MCP alternatives: when the protocol is the wrong shape
- Why does my AI agent get blocked?
- The timing signal AI agents give off
- Agent retry loops trip rate limits, not fingerprints
- Claude computer use detected as a bot
- browser-use getting blocked: what you can and cannot change
- Playwright MCP session blocked: four causes, four fixes
- Playwright MCP and captchas: what actually gets you past
- Cloudflare and a browser MCP server: what is being read
- Can an AI agent solve a captcha? The honest answer
- Getting an AI agent to fill out forms
- The best model for an MCP browser agent, and what it really costs
- Browser problem or model problem?
- How to use a Playwright MCP server with Claude Code
- Extracting data to a CSV with an AI agent
- Monitoring a page for changes with an AI agent
- How to let Claude Desktop control a browser
- How to add a browser to Cursor as an MCP server
- Using an AI agent to hunt for apartments
- Getting website data into Google Sheets with an AI agent
- Using an AI agent to download invoices from portals
- AI agents for web research
- Using an AI agent to test your own website
- How to add a browser to Cline as an MCP server
- Posting to social media with an AI agent
- Posting to Facebook with an AI agent
- Posting to Instagram with an AI agent
- Posting to X with an AI agent
- Automating LinkedIn posts: read this first
- Appointment bots: what they are and what an agent can legitimately do
- Track prices across sites with an AI agent
- Build a lead list with an AI browser agent
- Run an AI browser agent on a schedule
- AI browser agent with a local LLM: what changes
- Should you log your AI agent into your accounts?
- How to write a task an AI browser agent can follow
- Move data between two web apps with an AI agent
- The MCP server
- How the tools are shaped, and why
- Playwright MCP vs the Playwright CLI: which fits when
- Playwright MCP: browser is already in use, and the fix
- Playwright MCP best practices: four decisions that matter
- Playwright MCP with a proxy, and the three leaks it leaves
- A browser MCP server in GitHub Copilot: setup and limits
- Using a browser MCP server for web scraping: the pattern
- Which LLM for browser automation: the four properties
- How to build a browser agent, and what to take instead
- Getting an AI agent to log into a website: three routes
- MCP tools, resources and prompts: who controls each
- How many MCP tools is too many? The context arithmetic
- How to build an MCP server: the decisions, not the scaffold
- Local or remote MCP server: what changes, and what does not
- Writing an MCP client in Python: the thirty-line version
- Self-hosted AI agent: what one actually costs to run
- How long an AI browser agent takes per step, measured
- Text, HTML, snapshot or screenshot: what the agent should read
- Giving an AI browser agent a stopping condition
- Keeping an AI browser agent out of destructive actions
- Why did the AI agent click the wrong thing
- When the page changes under the AI agent
- Running one AI agent task across a list of sites
- Seeing a page as it appears in another country
- Getting data out of a dashboard with no export button
- Two browsers in one session: main and support
- Finding the dead links on a site with an AI agent
- Filling a CRM record from a company's website
- One form submission per spreadsheet row, with an AI agent
- Dated screenshots of a page as evidence
- Checking order and delivery status with an AI agent
- Reading a PDF that opens inside the browser
- Summarising a long page or thread with an AI agent
- Collecting every image on a page with its caption
- Collecting event and course listings with an AI agent
- Cancelling a subscription with an AI agent
- What an AI agent can and cannot do inside an iframe
- Shadow DOM and an AI agent: you can click it, you cannot read it
- How to add a browser to Codex as an MCP server
- What a page snapshot costs, per control
- How to let Gemini CLI use a browser
- Native selects and the ones that only look like selects
- Clicking by selector or by coordinates
- How long the agent waits before it gives up
- What a second browser costs
- Uploading a file with an AI agent, and why this one cannot
- Watching the agent work, and when it is worth it
- When not to use an AI browser agent
- Agent or script: deciding once instead of every time
- Using the keyboard instead of the mouse
- Secrets in an agent task: where they end up
- What an agent run should log
- Deduplicating what an AI agent collects
- Normalising values across sites
- Validating an AI agent's output
- Reading a table with an AI agent
- Driving a site's own search and filters
- The task works headed and fails headless
- How to let the AdaL CLI use a browser