Which AI agents run in a person's browser?
To detect AI browser agents that run in a person's own browser, such as Claude in Chrome and Perplexity Comet, you mostly can't: their requests carry the person's cookies, IP address, and browser fingerprint, and no signature, IP check, or User-Agent rule separates them from that person. What you can do is detect automation in the page where it shows, rate limit actions that people don't repeat at machine speed, and treat the request as the person's own. This article explains why, and how to write a policy for agents that you can't name.
Two products show the pattern, as of November 2026:
- Claude in Chrome. Anthropic describes it as "a browser extension that allows Claude to read, click, and navigate websites alongside you." Claude "sees what's on the page and can act on it, reading, clicking, typing, navigating, and filling forms." It runs in Google Chrome, and its debugger permission is "what allows Claude to actually control your browser."
- Perplexity Comet. Perplexity describes Comet as "a Chromium-based browser from Perplexity." Its assistant acts on websites inside that browser, and Perplexity's post on Comet Assistant says that you "see exactly where it's clicking, scrolling, or interacting with a site."
In both cases, the agent works inside the browser that the person already uses. The person's sign-ins, cookies, and network come with it. Neither vendor's documentation describes a User-Agent token, a signature, or an IP range that a website could use to recognize the agent, as of November 2026.
For more information about the agents that you can identify, see How to identify AI agents and bots.
Why can't servers identify browser agents?
Servers can't identify browser agents because every signal that a server sees belongs to the person. The request comes from the person's IP address, carries the person's session cookie, and sends the headers and fingerprint of the person's browser. The agent adds behavior, not identity.
Each server-side identification method fails for a specific reason:
| Method | What it checks | Why it misses a browser agent |
|---|---|---|
| A token that names the bot | The browser sends its own |
| IP ranges and reverse DNS | That the request left the operator's network | The request leaves the person's network. The AI company's servers send none of the page requests. |
| Web Bot Auth | A signature from a key on the operator's domain | No signature is documented for either product. |
| Personal Agent Protocol | A session token signed by the agent's published keys | Neither Anthropic nor Perplexity is a listed personal-agent design
partner, and neither publishes a |
| Session cookie | Who is signed in | It identifies the person, which is correct but says nothing about the agent. |
The Personal Agent Protocol row is as of November 2026. The protocol's path to 1.0 page lists Instinct, Manus, Meta, and OpenAI as personal-agent design partners.
This isn't a gap that a better bot list closes. The agent runs on the person's machine, under the person's account, and its requests are, at the network level, the person's requests.
How are cloud browser agents different?
Cloud browser agents are different because they run on the operator's infrastructure, so the operator can sign every request with a key it controls. A local browser agent runs on the person's machine, where the operator has no key that it can keep secret from that person. That difference decides whether you can name the agent.
The following agents run a browser in the cloud and sign with Web Bot Auth:
- ChatGPT agent. OpenAI's cloud browser signs with a key on
chatgpt.com. Arcjet reports it asCHATGPT_AGENT. For more information, see How to detect ChatGPT agent. - Meta's Muse. Muse signs with a key on
muse.aiand presents Personal Agent Protocol sessions on sites that publishpoppy.json. Arcjet reports it asMETA_MUSE. For more information, see How to detect Meta's Muse AI agent. - Manus. Arcjet reports the Manus cloud browser as
MANUS_BOT. - Hosted browser platforms. Browserbase, Kernel, and Cloudflare Browser Run sign for the sessions that they host. A signature from them identifies the platform, not the customer whose agent runs there. For more information, see Hosted browser platforms: what a Browserbase or Kernel signature tells you.
A verified signature gives the identity SIGNATURE evidence, the strongest that Arcjet reports, and the signing hostname as its operator. For more information about how signing works, see Web Bot Auth.
Could a local browser agent sign its requests?
A local browser agent could sign only with a key on the person's machine, and the person, or malware on their machine, could extract that key. A signature from an extracted key proves nothing about the operator. Neither Anthropic nor Perplexity documents a signing scheme for its browser product, as of November 2026.
What can you detect about AI browser agents?
You can detect the automation, sometimes, but not the agent. Arcjet Advanced Signals runs checks in the browser and reports a failed check as a bot identity with kind AUTOMATION and FINGERPRINT evidence. That tells you a program drove the page, not which program.
Whether a check fails depends on how the agent drives the browser. Some agents leave traces in the page, such as automation flags or a browser environment that no person's machine has. Others act through an extension with the person's real browser, real GPU, and real fonts, and leave little in the page that differs from the person. If an agent sends no signature and passes the browser checks, Arcjet treats the request as a browser.
Signals that you can still act on include the following:
- Speed and repetition. An agent fills a form or walks a checkout faster and more evenly than a person does. Rate limits catch this without knowing what the client is.
- Automation in the page. Advanced Signals catches agents and scripts that leave automation traces, and reports them as
AUTOMATION. - Account behavior. Your application sees the account, the cart, and the history. A run of identical actions on one account is a pattern you can check in your own code.
How do you write a policy for agents you can't identify?
Write the policy for the action, not the client. The person is signed in and accountable for an agent that runs in their own browser, so treat the request as theirs, limit how fast any client can repeat a sensitive action, and confirm irreversible actions in your own flow. Name the agents that you can verify, and give them their own rules.
The following defaults work for most applications:
- Treat the request as the person's. The session cookie is the person's, and the person chose to run the agent. Your existing authorization applies.
- Rate limit sensitive actions. Sign-ups, password resets, checkouts, and review posts have a pace that people keep. Limit by IP address or by account.
- Confirm irreversible actions. A second step that the person completes, such as a confirmation email, protects purchases and account changes from an agent that acts on the wrong instruction.
- Protect human-only forms with Advanced Signals. Forms that are meant for people can deny
AUTOMATIONidentities and point agents at your API. - Offer an API. An agent that has an API to call has less reason to drive your forms.
The following examples protect a form with a detectBot rule that denies every detected bot, including Advanced Signals failures, and a sliding window rate limit of five submissions in 10 minutes per IP address. Add the Advanced Signals script to the pages that lead to the form.
Protect a form in JavaScript
The following Express route returns 429 for a rate limit and 403 for a bot:
import arcjet, { detectBot, slidingWindow } from "@arcjet/node";import express from "express";
const aj = arcjet({ key: process.env.ARCJET_KEY!, rules: [ // Deny every detected bot, including Advanced Signals failures detectBot({ mode: "LIVE", allow: [] }), // Five submissions in 10 minutes for each IP address slidingWindow({ mode: "LIVE", interval: "10m", max: 5 }), ],});
const app = express();
app.post("/reviews", express.json(), async (req, res) => { const decision = await aj.protect(req);
if (decision.isDenied()) { if (decision.reason.isRateLimit()) { res.status(429).json({ error: "Too many submissions" }); return; } res.status(403).json({ error: "This form is for people. Agents can use the API.", api: "https://api.example.com/docs", }); return; }
// Save the review for the signed-in account. res.json({ status: "accepted" });});
app.listen(3000);Protect a form in Python
The following FastAPI route does the same with reason_v2:
import os
from arcjet import Mode, arcjet, detect_bot, sliding_windowfrom fastapi import FastAPI, Requestfrom fastapi.responses import JSONResponse
aj = arcjet( key=os.environ["ARCJET_KEY"], rules=[ # Deny every detected bot, including Advanced Signals failures detect_bot(mode=Mode.LIVE, allow=[]), # Five submissions in 10 minutes for each IP address sliding_window(mode=Mode.LIVE, interval=600, max=5), ],)
app = FastAPI()
@app.post("/reviews")async def reviews(request: Request): decision = await aj.protect(request)
if decision.is_denied(): if decision.reason_v2.type == "RATE_LIMIT": return JSONResponse( {"error": "Too many submissions"}, status_code=429 ) return JSONResponse( { "error": "This form is for people. Agents can use the API.", "api": "https://api.example.com/docs", }, status_code=403, )
# Save the review for the signed-in account. return {"status": "accepted"}Protect a form in Go
The following net/http handler uses Reason.IsRateLimit:
package main
import ( "log" "net/http" "os" "time"
"github.com/arcjet/arcjet-go")
func main() { aj, err := arcjet.NewClient(arcjet.Config{ Key: os.Getenv("ARCJET_KEY"), Rules: []arcjet.Rule{ // Deny every detected bot, including Advanced Signals failures arcjet.DetectBot(arcjet.BotOptions{ Mode: arcjet.ModeLive, Allow: []string{}, }), // Five submissions in 10 minutes for each IP address arcjet.SlidingWindow(arcjet.SlidingWindowOptions{ Mode: arcjet.ModeLive, Interval: 10 * time.Minute, MaxRequests: 5, }), }, }) if err != nil { log.Fatal(err) }
http.HandleFunc("POST /reviews", func(w http.ResponseWriter, r *http.Request) { decision, err := aj.Protect(r.Context(), r) if err != nil { http.Error(w, "Internal Server Error", http.StatusInternalServerError) return }
if decision.IsDenied() { if decision.Reason.IsRateLimit() { http.Error(w, "Too many submissions", http.StatusTooManyRequests) return } http.Error(w, "This form is for people. Agents can use the API.", http.StatusForbidden) return }
// Save the review for the signed-in account. w.Write([]byte("accepted")) })
log.Fatal(http.ListenAndServe(":3000", nil))}Start each rule in DRY_RUN to measure how often it would act, then switch to LIVE. A rate limit that's too tight blocks people who share an IP address, such as an office or a mobile carrier, so set the limit from what you measure.
For more information about challenge-free ways to protect forms, see CAPTCHA alternatives. For more information about the detection layers that this policy combines, see Bot detection techniques.
Frequently asked questions
Can I detect Perplexity Comet?
Not by name. Comet is a Chromium-based browser that the person uses, and as of November 2026 Perplexity documents no User-Agent token, signature, or IP range for its assistant. Advanced Signals can detect automation in the page when the assistant leaves traces, and rate limits catch machine-speed actions. Perplexity's separate Perplexity-User fetcher is verifiable by IP.
Is Claude in Chrome a bot?
It's an agent that acts in the person's own Chrome browser through an extension, with the person's sign-ins and network. Its requests are the person's requests at the network level, so treat them as the person's, and rely on rate limits and your own confirmation steps for sensitive actions.
Should I block browser extensions?
No. A website can't see which extensions a person runs, and blocking browsers that run extensions would block many people. Protect the actions instead: rate limit them, confirm irreversible ones, and offer an API for agents.
Will browser agents adopt Web Bot Auth?
Not documented as of November 2026. A local agent could sign only with a key on the person's machine, which the person or malware could extract, so a signature from it would prove little. Cloud browser agents such as ChatGPT agent and Meta's Muse already sign.
What does Arcjet report for a browser agent?
If Advanced Signals detects automation, Arcjet reports a bot identity with kind AUTOMATION and FINGERPRINT evidence, which says a program drove the page but not which one. If the agent sends no signature and passes the browser checks, Arcjet treats the request as a browser.
How are cloud browser agents easier to handle?
A cloud browser agent runs on the operator's infrastructure, so the operator can sign every request with a key it controls. Arcjet verifies those signatures and names the agent, such as CHATGPT_AGENT or META_MUSE, with SIGNATURE evidence, so you can write a rule for it.
Application security in your code
Protect your application with Arcjet
Protect the forms and actions that matter with Advanced Signals and rate limits, so agents in a person's browser are held to the pace that people keep.