WorksComputer Science
Proof-of-Agentness: Towards Verifying Agents on the Web
Abstract
CAPTCHAs and bot detection have helped protect Web services from automated abuse for decades by distinguishing humans from bots. However, the emergence of LLM-powered agents introduces a new setting: Web services increasingly accommodate agents as legitimate users. Without a way to distinguish agents from other automated clients such as simple bots and scripts, these services risk large-scale automated junk submissions that waste service resources and consume users' attention or tokens. In this paper, we investigate a novel question for today's Web: "How can a Web service obtain evidence that a client is an agent?" We introduce the concept of "Proof-of-Agentness" (PoA), a mechanism for distinguishing agents from other automated clients, motivated by the parallel between human attention and an agent's inference resources. We outline two approaches: active verification through challenge-response and passive analysis of service-visible signals. Eight language models achieve an overall accuracy of 96.5% on our challenges, with an average overhead of 1,647 tokens. For passive analysis, we conduct an IRB-approved user study comparing the Web interactions of twelve human participants and representative Bot and Agent implementations, achieving an average classification accuracy of 95.8% across four classifiers, motivating further study.
CCS Concepts
• Security and privacy → Access control; Authentication.
Keywords
Proof-of-Agentness, Web agents, admission control, resource abuse, behavioral verification
Introduction
CAPTCHAs and other bot detection mechanisms have helped protect human-facing Web services from automated abuse at scale by requiring evidence of human participation before granting access [50, 58]. Each operation performed by a human consumes time and attention, while scripts can cheaply repeat requests and submissions, overwhelming services. These mechanisms aim to make access depend on evidence of human participation that bots cannot cheaply reproduce.
Meanwhile, Web services are increasingly being designed for agents as well as humans. Cloudflare and Vercel serve agent-friendly Markdown pages [19, 41]. Many online services provide agent access through the Model Context Protocol (MCP), covering search (Brave, Exa, and Tavily) [7, 25, 57]; data and knowledge queries (Hugging Face, Kaggle, Wikidata) [32, 36, 64]; payments (Stripe and PayPal) [51, 56]; shopping (Shopify) [55]; and development and workplace collaboration (GitHub, Notion, and Atlassian) [6, 29, 48].
However, these interfaces can also be used by ordinary programs. When agents rely on large language models (LLMs) to interpret tasks and choose actions, they consume inference compute and tokens [53]. A traditional automated program can avoid such resource costs and repeatedly submit requests directly, occupying server-side queues and consuming storage and computing resources. Junk submissions produced in this way can also require users or agents to spend attention or tokens processing their contents.
The resource analogy between human attention and model inference motivates our central research question: Can a Web service obtain evidence that a client is an agent and protect service capacity for useful agent work, just as CAPTCHAs and bot detection protect human-facing services for genuine human interaction?
Agent verification is already entering Web infrastructure. Cloudflare’s Signed agents and Verified bots programs recognize agent traffic, and Web Bot Auth checks signed HTTP requests against registered public keys [15, 16, 38]. However, these approaches authenticate identities asserted by agent operators or infrastructure providers without establishing actual agent participation. Recent studies also explore browser and behavioral fingerprints to distinguish Web agents from human users and other automated clients [26, 61]. These efforts advance agent recognition, but the positioning of agent verification on the Web remains unclear, and the concept itself is not yet fully developed.
Our Study In this paper, we introduce Proof-of-Agentness (PoA), which asks for evidence of language model participation in an interaction. We outline two design approaches: active verification that issues challenges to clients and checks their responses, and passive analysis using Web traffic and interaction characteristics. We then introduce a unified AGENTSCORE that combines evidence for admission decisions. Such mechanisms could empower Web services to restrict access to agents acting on users’ behalf and regulate automated traffic more selectively, limiting large-scale scripted abuse of service resources.
We evaluate active verification with eight language models and two rule-based scripts on 100 challenges, achieving an overall accuracy of 96.5% with an average overhead of 1,647 tokens. For passive analysis, we conduct an IRB-approved study of 720 Web visits across three shopping tasks, involving twelve human participants alongside six Bot and three Agent configurations. Using 40 service-visible features, we achieve an average classification accuracy of 95.8% across four classifiers on held-out tasks. Figure 1 connects the CAPTCHA analogy to agent verification and scripted abuse at a shared Web service.
Figure 1. Human users, AI agents, and scripted abuse on the Web. (a) CAPTCHA seeks human-participation evidence to protect human-facing services from automated abuse. (b) Agents and LLM workflows spend tokens interpreting tasks and feedback; scripts can replay junk without such costs while consuming shared service resources. Motivated by preserving capacity for useful agent work, Proof-of-Agentness asks for evidence of language model participation.
Contributions. We make three contributions:
Concept positioning. We introduce Proof-of-Agentness (PoA) as a Web verification objective centered on language model participation, analyzing its potential benefits and trade-offs for Web services.
Verification design. We outline two approaches to verifying agent participation: active verification through a challenge–response mechanism and passive analysis of Web traffic and interaction characteristics.
Empirical study. We evaluate active verification with eight language models, examining challenge performance and overhead. To explore passive recognition, we collect a Web traffic and interaction dataset from twelve human participants and representative Bot and Agent implementations.
Background and Related Work
Bot Detection and Admission Control
Bot detection is a mechanism used by Web services to protect against large-scale automated abuse and attacks. Such systems examine request headers, browser characteristics, and behavior within sessions for signs of automation [12, 50]. Cloudflare, for example, combines known fingerprints, JavaScript checks, and machine-learning models to assign a bot score indicating how likely a request is to be automated [13]. A service may also use an explicit challenge to block automated traffic. CAPTCHAs follow this approach with tasks designed to be easy for humans and difficult for contemporary programs [58]. The service checks the submitted response for admission control, admitting clients judged to be human.
Admission control can also make access conditional on computational effort. Proof-of-work (PoW) raises the cost of large-scale abuse, such as spam, by requiring clients to solve computational problems that are costly to solve but inexpensive to verify [23]. Client puzzles apply this asymmetry to defend against connection-depletion attacks: the server issues a puzzle and allocates connection resources only after verifying a valid solution [35]. Requiring a solution before allocating resources raises the cost of repeated requests, helping protect service capacity from large-scale abuse.
LLM-Powered Web Agents
LLM-powered Web agents are becoming increasingly common on the Internet [17]. In an LLM-powered Web agent, a language model interprets user instructions and selects actions based on observations from the environment [30, 31]. Chain-of-thought (CoT) prompting guides models to reason step by step [62], while ReAct combines reasoning, actions, and observations [67]. WebAgent brings reasoning to browser interaction by combining planning, HTML understanding, and program generation [30]. Moreover, multimodal agents such as WebVoyager and SeeAct incorporate visual observations to interpret webpages and select actions [31, 68].
A Web agent can access Web services through tools such as web_search and web_fetch [4, 5], MCP interfaces [44], browser extensions [3], or browser-control and computer-use frameworks [2, 8]. For visual interaction, multimodal agents can observe screenshots of the browser or desktop environment and select actions based on visual cues [2, 31]. To evaluate agents’ performance on Web tasks, researchers have developed a variety of Web-agent benchmarks. These include Mind2Web, WebArena, and WorkArena for Web tasks [21, 22, 69], VisualWebArena for visually grounded Web tasks [37], and OSWorld for broader computer-use tasks involving Web applications [65], showcasing the capabilities of LLM-powered agents across various domains and tasks.
Agent Identification and Authentication
Web platforms are introducing mechanisms to identify agents and authenticate their claimed identities. Cloudflare, for example, recognizes registered bots and agents through its Verified bots program, while Signed agents supports cryptographically authenticated agent traffic [15, 38]. Web Bot Auth checks HTTP request signatures against registered public keys, allowing services to authenticate the sender associated with a claimed agent identity [16].
Academic research also explores identity and authentication mechanisms for AI agents. For example, Garzon et al. propose a framework for agents to authenticate one another across organizational boundaries [28]. AgentDID uses decentralized identifiers and verifiable credentials to authenticate agent identities [66]. Beyond identity authentication, several studies explore the use of fingerprints to identify AI browsing agents [26, 40, 61], reflecting research interest in this emerging area. However, identifying an agent or authenticating its identity does not by itself establish whether a language model participates in the current interaction. On the human-facing Web, account authentication verifies control of an account, but valid credentials can also be used by automated programs. CAPTCHAs and other bot detection mechanisms therefore seek evidence of human participation to limit automated abuse [13, 58]. Similarly, an authenticated agent identity can also be used by a scripted program. This motivates a complementary mechanism for verifying model participation in agent-facing Web services.
Proof-of-Agentness: Definition and Design
Problem Formulation
Drawing inspiration from CAPTCHAs and bot detection, we propose Proof-of-Agentness (PoA) based on the resource analogy between human attention and language model inference. Human participation consumes time and attention, while language model participation consumes inference compute and tokens. Simple scripts can repeatedly submit requests at low marginal cost while occupying server-side queues and consuming storage and computing resources. PoA is designed to extend the principle of admitting humans while keeping bots out to agent-facing Web services. The goal is to admit agents while keeping automated bots out, empowering Web services to regulate automated traffic more selectively.
Definition: Proof-of-Agentness
Proof-of-Agentness (PoA) is a mechanism for verifying language model participation in an interaction. Participation means that model output is used to interpret information, select an action, or produce a response in that interaction.
Requiring evidence of model participation could help agent-facing services prevent automated bots from gaining access by posing as agents, limiting opportunities for large-scale automated abuse at no cost. Such a mechanism can be deployed across Web interfaces, APIs, and MCP tools, particularly for operations that change service state, allocate limited resources, or directly affect other users. Services can specify which interactions or operations require evidence of model participation, making participation an explicit part of their access policies.
Design Objectives
Beyond verifying agent participation, PoA should also remain practical for services and agents. This requires considering both service overhead and agent effort during ordinary interactions. We identify three practical design goals for deployment.
Efficiency. Verification should impose limited computation, storage, and communication costs on the service, allowing it to scale with incoming traffic.
Validity. Verification results should be bound to the client and permitted operations, with explicit expiry and reuse limits. The service should enforce these limits so that results cannot authorize access outside their intended scope.
Usability. Verification requirements and formats should be compatible with supported agents and their access interfaces. The additional latency, inference cost, and interaction effort should remain acceptable for useful agent work.
In pursuing these objectives, PoA faces a familiar constraint: a service generally observes a client’s interactions without direct access to the computation behind them. A similar challenge is faced by CAPTCHAs and bot detection mechanisms, whose design principles and deployment experience offer a foundation for extending participation verification to language models.
Verification Framework
Building on these principles and prior work, we organize PoA around two approaches to obtaining participation evidence: active verification and passive analysis. Figure 2 presents our framework, linking evidence to access decisions.
Active verification. The service issues a public challenge and retains private verification state . After receiving the client’s answer , it computes , where indicates failure or success. The challenge is designed under the assumption that it is easy for language models to solve but difficult for simple rule-based programs. Under this assumption, a correct response provides evidence of agent participation, and the strength of this evidence depends on the soundness of the challenge design.
Passive analysis. During ordinary use, the service collects a record of observable interactions. A feature extractor maps the available observations to , capturing patterns in requests and browser interactions. This approach relies on the assumption that agents can produce observable behavioral differences from other automated clients. A model trained on labeled interactions uses these features to estimate , the probability that the client is an Agent. The strength of this evidence depends on the quality of observed signals and the reliability of behavioral analysis.
Hybrid policy. In practice, a service could use a hybrid policy to combine multiple sources of evidence, such as active challenge results, passive interaction signals, and verified agent declarations [16]. The policy could also incorporate existing access controls to govern access to protected operations. To support such hybrid policies, we introduce AGENTSCORE, a unified score expressing the service’s confidence in recognizing a client as an Agent under its policy. If the score is too low to support the requested access, the service may defer its decision and request additional verification through an active challenge or an interaction probe. The resulting evidence updates AGENTSCORE, allowing the service to reassess the request. Moreover, the permission granted should be bound to the authorized client and permitted operations, with expiry and usage limits. We detail the proposed scoring and access policy in Section 4.3.
Implementation
In this section, we present our implementation of the active and passive approaches and detail the proposed AGENTSCORE policy.
Figure 2. Agent verification framework. The proposed framework combines active and passive evidence with verified agent declarations through a unified AgentScore to guide access to protected operations.
Active Verification
We implement active verification through challenge–response based on natural language understanding (NLU), a basic capability of language models. NLU tasks assess the interpretation of text and its implications [47, 60], and carefully designed questions can expose the limitations of shallow rules and pattern matching [39, 42]. Structured simulations and templates also support the systematic generation of natural-language questions and test cases [52, 63].
Building on these studies, we consider NLU a plausible basis for challenges intended to be easy for agents yet difficult for bots. We also believe that other forms of challenge such as mathematical reasoning and visual understanding have potential for agent verification. Nonetheless, we use NLU as a starting point and develop a methodology for dynamically constructing such challenges.
This methodology begins with crafting narrative templates and their accompanying questions. Each template is a long passage with slots for entity names, attribute names, and values, and the questions contain corresponding slots. Each question has a natural-language form for presentation and a corresponding executable function for computing its answer once the slots are instantiated. For each challenge, a verifier uses a random seed to sample entities and attribute values from predefined sets, forming a world state that records the sampled entities and values. It uses this state to fill a selected narrative template and its question, producing a natural-language report and question . The verifier applies the function associated with to to compute the answer directly. The responding agent receives only the natural-language report and question. It is expected to reconstruct the relevant facts from the report and infer the question’s intended operation to derive its answer. Figure 3 illustrates this construction. We describe the protocol between verifier and prover as a tuple of four procedures, :
. First, prepare a resource library containing narrative templates, paired questions, typed entities, and permitted attribute values. The verifier should keep this library private because knowledge of its contents could allow bots to solve the challenges using fixed rules.
. Then, using a fresh private seed , the verifier selects a template and samples entities and attribute values to form a world state . It fills the template and its associated question with these facts, producing report and question . The function associated with question computes the answer , which the verifier uses to construct an accepted-answer set for verification. The procedure outputs the public challenge and retains private verification state .
. The prover receives and returns its answer in the required format. It is expected to recover the relevant facts and intended operation by interpreting the report and question.
. The verifier extracts and normalizes the submitted answer and compares it against the retained set , returning 1 on a match and 0 otherwise.
Security assumptions. The construction relies on the assumption that language models can solve the generated challenges reliably, while simple rule-based programs cannot achieve comparable success. If this assumption holds, a correct response provides evidence of agent participation. Security also depends on keeping each random seed and the resource library private. Knowledge of both could allow an adversary to reproduce the world state and compute the answer directly. Repeated observations of public challenges may also reveal the library’s templates and question functions. The verifier should therefore periodically update or replace to make reconstruction from accumulated observations more difficult.
We present the evaluation results of this approach in Section 5.1 and provide further implementation details and a worked challenge example in Appendix A.
Passive Analysis
Existing bot detection studies characterize human and bot traffic through request characteristics, browser fingerprints, and interaction behavior [33, 34, 50]. A prominent industrial deployment is Cloudflare Bot Management, which combines several detection engines to assign bot scores [13]. Its precursor system further analyzes interaction signals throughout a session [24].
However, as LLM-powered agents become participants in Web traffic, it is still unclear whether they exhibit observable patterns distinct from those of humans and traditional bots. We started by reviewing Web access approaches available to agents in terms of their supported operations and service-visible signals, as summarized
Figure 3. Structured generation and semantic challenge solving. Prepared templates and question pairs let the verifier render a report from sampled state and compute directly. The prover uses the public challenge to reconstruct relevant world-state facts and infer the answer function’s semantics, then returns an answer for verification.
in Table 1. Agents can use nearly all the access approaches listed, sharing interfaces with both humans and traditional bots. Their observable patterns can vary across interfaces and execution tools, overlapping with those of other client types. Automated scripts may also use agent-oriented interfaces and frameworks, such as MCP and Browser Use [9, 44], to pose as agents. Agent verification on the Web fundamentally involves making a finer distinction between agents and bots within automated traffic. Reliable passive analysis generally relies on large, diverse, and representative datasets, which may give providers with broad visibility into Web traffic an advantage in developing and maintaining such models. We illustrate the passive analysis pipeline in Figure 4.
| Interface / examples | Usersᵃ | Ops.ᵇ | Signalsᶜ |
| GUI interfaces: Browser GUI; WebView [1, 59] | ♙ ♧ | R/W | H/B/E |
| HTTP / API clients: curl; SDKs [20] | 🔒 ♧ | R/W | H |
| Browser automation: Playwright; Selenium [43, 54] | 🔒 ♧ | R/W | H/B/E |
| Browser extensions: Content scripts; Claude in Chrome [3, 11] | 🔒 ♧ | R/W | H/B/E |
| Search / fetch: web_search; web_fetch [4, 5] | ♧ | R | Var.ᵈ |
| Agent browser frameworks: Browser Use [9] | ♧ | R/W | H/B/E |
| Agent desktop tools: Computer Use [2] | ♧ | R/W | H/B/E |
| MCP tools: Brave; Stripe; GitHub [7, 29, 56] | ♧ | R/W | Var.ᵈ |
Table 1. Web access across humans, bots, and agents. The table summarizes representative interfaces and tools typically used by humans, bots, and LLM-powered agents, their possible operations, and the signals observable by Web services.
Figure 4. Passive analysis pipeline. Offline training and proposed calibration prepare a fixed predictor for online Agent-probability estimation; insufficient observations defer estimation.
Here, we created a minimal dataset containing Web interactions from human participants, traditional bots, and LLM-powered agents, together with associated client fingerprints. Then, we conduct a preliminary evaluation using supervised classification methods to explore the feasibility of this approach. We present the experimental details and results in § 6.
Hybrid Scoring Policy
We detail how a service could integrate the available evidence into an AgentScore. Similar to Cloudflare’s Bot Score [13], AgentScore denotes the service’s confidence in recognizing a client as an agent and can be used alongside existing access controls to govern protected operations.
Unified score. We express the available evidence as an AgentScore on a common scale in . Let indicate whether a client passes an active challenge or presents a verified agent declaration [16], and let indicate whether sufficient observations for passive analysis are available. The proposed score is
The rule-assigned score of 100 expresses the service’s decision to accept the verified evidence under its policy. For the passive branch, from § 5.1 is scaled to . Here, means that neither verified rule evidence nor a usable passive estimate is available, leaving further handling to the service’s policy.
Access decision. AgentScore could be used alongside identification and authorization to inform access decisions. For each protected operation , let be the required score and indicate whether client satisfies these controls under policy . For score , the final access decision can be expressed as
Otherwise, the policy determines whether to deny or defer the request. If or , the service may request an active challenge or an interaction probe, such as a Turnstile-like embedded web-page component [14], to update AgentScore and reassess access.
Granted permissions should also be bound to the authorized client and permitted operations, with expiry and usage limits. Together, these mechanisms could give Web services finer control over automated access: allowing AI agents to act on behalf of users while limiting large-scale scripted abuse of service resources.
Evaluation
Challenge–Response Evaluation
Experimental setup. We evaluated the proposed NLU challenge design using eight language models and two rule-based scripts for text processing on the same 100 questions. Each challenge contains a textual report of 591–1,090 words, with a median of 819.5 words. Appendix A provides the implementation settings.
We implement two rule-based scripts, Nearest Text and Shallow Relation. Nearest Text selects answer spans using key-word overlap and text proximity. Shallow Relation uses predefined patterns to extract entity–attribute–value relations, then retrieves attribute values or compares numbers to answer the question. For comparison, the models receive the same report, question, and structured-answer instruction. After extracting the first explicit answer, the verifier normalizes type prefixes and checks the result against the accepted-answer set.
Challenge performance. Table 2 shows that the eight models achieve 85–100% accuracy, compared with 21% for Nearest Text and 4% for Shallow Relation. Overall, the models answered 772 of the 800 assigned questions correctly; the remaining 28 responses (3.5%) include incorrect answers and malformed output. The scripts’ successes show that the generation process can yield instances vulnerable to simple solvers. A verifier could introduce a screening procedure to filter out weak instances before use, similar to candidate screening during key generation [46].
| Model | Acc. (%) | Time (s)ᵃ | Inputᵇ | Outputᵇ |
| DeepSeek-V4.1-Flash | 100 | 2.918 | 1380.9 | 200.4 |
| Qwen3.8-Flash | 100 | 6.115 | 1413.2 | 238.9 |
| GPT-5.6-Luna | 99 | 2.062 | 1332.5 | 42.5 |
| Grok-4.3 | 99 | 3.784 | 1509.4 | 307.9 |
| GLM-5.3-Flash | 98 | 2.309 | 1335.0 | 201.6 |
| Claude-Haiku-5.5 | 96 | 2.317 | 2287.4 | 65.7 |
| Gemini-3.5-Flash-Lite | 95 | 1.625 | 1390.8 | 13.4 |
| MiniMax-M3.1-Flash | 85 | 1.400 | 1463.7 | 8.9 |
| Nearest Text | 21 | 0.00297 | — | — |
| Shallow Relation | 4 | 0.00189 | — | — |
Table 2. NLU challenge performance and resource use. Each client is assigned the same 100 questions.
Verification overhead. Next we examined the overhead introduced by this verification process. On the client side, Figure 5 shows the time and tokens spent answering challenges, with median response times of 1.4–6.1 seconds across the eight models. Verification will surely incur additional token costs and processing time for agents, just as CAPTCHAs cost humans time and attention.
Figure 5. Model verification overhead. Response time uses a logarithmic axis and tokens use a linear axis.
ᵃ Time: Median observed solving time (model response or script execution time). ᵇ Tokens: Mean input and output tokens per challenge response.
Challenge / private state: 6.21 / 10.06 kBᵃ
ᵃ Sizes: Compact UTF-8 JSON; private state includes its template.
On the server side, Table 3 reports a combined median of 327.6 microseconds for challenge assembly and response verification. With templates prepared offline, the service only needs to assemble each challenge and check the response at runtime, keeping the overhead low for concurrent verification at scale.
| Phase | Wall (μs) Median | Wall (μs) P95 | CPU (μs) Median | CPU (μs) P95 | Instr. () Median | Instr. () P95 |
| Assembly | 324.3 | 373.2 | 323.2 | 371.1 | 6.546 | 7.946 |
| Verification | 3.48 | 3.91 | 3.45 | 3.89 | 0.0788 | 0.0875 |
| Total | 327.6 | 376.6 | 326.5 | 374.6 | 6.626 | 8.024 |
Table 3. Server verification overhead. Median and P95 per-call costs, with median serialized sizes of challenges and private verification states.
Passive Analysis
Experimental setup. To collect behavioral data, we used the WebArena shopping website [69], with three custom tasks: Wi-Fi adapters, USB drive, and wireless mice. The Wi-Fi task uses fixed instructions, while the USB and mouse tasks allow open-ended product selection within attribute and budget constraints. We recruited twelve participants from our institute with institutional review board (IRB) approval and selected three Bot and three Agent implementations for the main comparison, as summarized in Table 4. Human participants completed the tasks manually using browsers on their own devices. Bots followed predefined rules, while Agents used language models to interpret observations and select actions. The adversarial settings include bots posing as humans using native mouse and keyboard input, and bots posing as agents using Browser Use or Playwright MCP.
| User | Implementation | Input |
| Human | Participant browser | Rendered pages |
| Python Requests | HTML / forms | |
| Bot | Playwright Python | DOM |
| Selenium WebDriver | DOM | |
| Browser Use | DOM | |
| Agent | Playwright MCP | AX tree |
| Codex Computer Use | Screenshots | |
| Adversarial settings | ||
| Bot poses as Human | Native input | DOM |
| Browser Use | DOM | |
| Bot poses as Agent | Playwright MCP | DOM + AX tree |
Table 4. Client configurations. Implementations and observation inputs for the main comparison and adversarial settings.
During browsing, we collected HTTP metadata, browser characteristics, and page events, with pointer movement and scrolling recorded. Finally, we retained a dataset of 720 visits: 72 Human visits (12 participants 3 tasks 2 rounds) and 648 automatic visits (432 Bot and 216 Agent, with 24 visits per task for each configuration). Appendix B provides detailed experimental settings.
HTTP behavior and client fingerprints. Table 5 summarizes service-visible HTTP behavior and client fingerprints. To characterize the networking software, we also examine JA4 and JA4H from the JA4+ suite, which provide TLS and HTTP fingerprints, respectively [27]. From the HTTP perspective, Bot visits have a shorter median request span (4.37 s) than Human and Agent visits (39.42 and 43.55 s), while Agent visits have a longer median request gap (3220.34 ms) than Human and Bot visits (586.47 and 395.15 ms). However, we believe these timing patterns are unreliable indicators because they are easy to alter. From the fingerprinting perspective, Bot and Agent configurations using the same tools share identical JA4 and JA4H values, while ordinary Chrome also matches several automatic configurations, motivating us to further examine client interaction behavior for distinction.
| Attribute | Human (72) | Bot (432) | Agent (216) |
| HTTP requests | 14 | 9 | 10.5 |
| Peak concurrency | 1 | 2 | 1 |
| Request span (s) | 39.42 | 4.37 | 43.55 |
| Request gap (ms) | 586.47 | 395.15 | 3220.34 |
| JA4 | T2, T3 | T1, T2 | T2 |
| JA4H | H2, H4 | H1, H2, H3 | H2, H3 |
Table 5. HTTP behavior and client fingerprints. Median HTTP measurements and fingerprint groups across clients.
Observed interaction patterns. Figure 6 compares page interactions across Humans and interaction-capable Bot and Agent implementations. From the results, we see that Human visits generally contain more pointer movements and scrolls. On the same tasks, even though clients may share the same interfaces, they exhibit different patterns of interaction. Across repeated visits, Humans show the most diverse event-count combinations, while Bots are generally more repetitive, and Agents often fall between them.
Figure 6. Interaction patterns on three shopping tasks. Bars and ticks mark interquartile ranges and medians. Axes use scaling; points may overlap.
Features and model comparison. We extract 40 service-visible features from each visit :
where B/A/I/S/T denote Browser, Activity, Input, Sequence, and Timing, containing 12, 5, 9, 7, and 7 features, respectively. We specify their components in Table 8 (Appendix B).
| Feature group | Count | Measurements | Available visits^a | Human (72) | Bot (360) | Agent (216) |
| Browser () | 12 | Inner/outer window dimensions; total/available screen dimensions; pixel ratio, color depth, maximum touch points, and webdriver flag. | ||||
| Activity () | 5 | Application-request count and peak concurrency; click (including auxiliary click), input, and scroll counts. | ||||
| Input () | 9 | Pointermove count, moves per click, and fraction of clicks preceded by movement; focus, paste, and composition counts; paste, composition, and deletion fractions among inputs with reported types. | ||||
| Sequence () | 7 | Runs and adjacent-repeat fraction of click/input/scroll events; click→input, input→click, click→scroll, and scroll→click fractions; normalized transition entropy. | ||||
| Timing () | 7 | Application-request span and median request gap; click/input/scroll span; within-document gap median, P95, and coefficient of variation; fraction of gaps above one second. |
Table 8. Service-visible feature groups. We use 40 features from 5 groups for passive client classification.
We compare logistic regression (LR), random forest (RF), RBF-SVM [18], and XGBoost [10] using nested cross-validation. Each outer fold trains on two tasks and tests on the remaining task. Human data are split by participant, with P01–P08 used for training and P09–P12 for testing; both rounds of each participant follow this assignment. Within each outer training set, two inner folds select parameters separately for each model and feature setting. Each task contributes 200 test visits, giving 600 test visits across the three tasks: 24 Human, 360 Bot, and 216 Agent visits.
Table 6 shows that RF achieves the highest macro-F1 (1.0000), followed by XGBoost (0.9913), correctly labeling 600 and 593 of the 600 test visits, respectively. All four models correctly identify the 24 Human visits, with errors confined to Bot–Agent confusions. LR and RBF-SVM label 47 and 46 Bot visits as Agents, respectively, whereas XGBoost labels 7 Agent visits as Bots. Figure 7 shows the effects of cumulatively adding feature groups. Activity and
| LR | Macro-F1: 0.9440 | RF | Macro-F1: 1.0000 | ||||
| True\Pred. | H | B | A | True\Pred. | H | B | A |
| H (24) | 24 | 0 | 0 | H (24) | 24 | 0 | 0 |
| B (360) | 0 | 313 | 47 | B (360) | 0 | 360 | 0 |
| A (216) | 0 | 0 | 216 | A (216) | 0 | 0 | 216 |
| Macro-F1: | W 1.000 | U 1.000 | M 0.837 | Macro-F1: | W 1.000 | U 1.000 | M 1.000 |
| RBF-SVM | Macro-F1: 0.9452 | XGBoost | Macro-F1: 0.9913 | ||||
| True\Pred. | H | B | A | True\Pred. | H | B | A |
| H (24) | 24 | 0 | 0 | H (24) | 24 | 0 | 0 |
| B (360) | 0 | 314 | 46 | B (360) | 0 | 360 | 0 |
| A (216) | 0 | 0 | 216 | A (216) | 0 | 7 | 209 |
| Macro-F1: | W 1.000 | U 1.000 | M 0.840 | Macro-F1: | W 1.000 | U 0.974 | M 1.000 |
Table 6. Passive client classification. Rows indicate true classes2; columns indicate predictions, and red cells mark errors. Task-level macro-F1 scores3 appear below each matrix.
Figure 7. Cumulative feature ablation. B/A/I/S/T denote Browser, Activity, Input, Sequence, and Timing. Floating-bar labels show macro-F1 changes (pp).
provide the largest gains across all four models (15.7–23.5 and 6.2–8.1 pp, respectively), while Input has mixed effects and Sequence adds smaller improvements. These results suggest the feasibility of distinguishing Humans, Bots, and Agents using passive analysis of service-visible interaction patterns. However, given the limited scale of our dataset, we believe a larger and more comprehensive study would be a valuable direction for future work.
Discussion
Abuse Cost. An attacker may use a malicious agent or language model to solve a challenge while pursuing abusive goals. This is analogous to malicious humans passing CAPTCHAs themselves or outsourcing them to CAPTCHA-solving services [45]. Such model use meets the participation requirement and incurs inference costs. Under the challenge assumptions, active verification could therefore raise the cost of access for clients that would otherwise rely entirely on scripts. Its practical value depends on whether this added cost changes the economics of large-scale abuse without imposing excessive overhead on agents performing normal tasks.
Verification Scope
From this economic perspective, verification scope affects the cost of sustained access. A client may use a model to pass a challenge and then perform subsequent operations through scripts. The inference cost is then spread across those operations, reducing the average cost per operation. Verification frequency and permission scope therefore need to be considered together. Frequent challenges add overhead to normal agent activity, whereas broad permissions allow more scripted operations after a single check.
Practical Deployment. Passive analysis uses evidence from ordinary interactions and can reduce verification overhead during normal agent activity. However, a script that is able to reproduce agent-like signals could also receive a high score without using a model. A practical policy should consider when passive evidence is sufficient and when an active challenge is warranted. Stricter and more frequent verification could help maintain agent participation during continued access, but would also increase the burden on ordinary agents. The acceptability of this overhead could be explored in future deployments. Like CAPTCHAs and bot detection mechanisms, Proof-of-Agentness faces a usability challenge: the added verification requirements may not be welcomed by all users.
Conclusion
We introduced Proof-of-Agentness (PoA) as a mechanism for verifying language model participation in an interaction and outlined two approaches to obtaining evidence: active verification and passive analysis. These mechanisms could help Web services regulate automated traffic more selectively, admitting agents acting on users’ behalf while limiting large-scale scripted abuse.
References
Active Verification Details
Implementation and Experimental Settings
Offline library construction. We prepare the library offline using LLM-generated materials from 5 domains: biochemistry, clinical trials, cybersecurity, financial markets, and food safety. Domain-specific prompts guide the LLM to generate entity names grouped by type and narrative templates with placeholders for entities, attributes, and values. For each template, the LLM also supplies possible attribute values and questions paired with functions that compute their answers from the world state. We implement rule-based checks to ensure consistent entity types and placeholders and verify that each question refers to facts included in its report. The resulting library contains 208 entities, 40 narrative templates, and 291 questions. At runtime, the verifier constructs each challenge at minimal cost by sampling from this library and instantiating the selected template.
Challenge evaluation. We evaluate the models on 100 questions generated from 35 of the library’s 40 templates, with 20 questions from each domain. Of these questions, 60 ask for an attribute value, 20 compare two entities, and 20 ask for the entity with the highest or lowest value. All model queries go through OpenRouter [49] with the same structured-answer requirement and no model-specific sampling or reasoning settings. The verifier extracts the first submitted answer and normalizes Unicode, case, and whitespace without converting numbers or units. We report accuracy and latency over all 100 assigned questions, counting incorrect, empty, and filtered responses as failures. Each question contributes one selected response to the latency and token statistics. During evaluation, Claude did not answer 2 food-safety questions because of safety filtering. We count both as incorrect and retain their latency, while calculating Claude’s mean token usage from the 98 responses with reported usage.
Server overhead. We measure challenge assembly and answer checking on the same 100 questions using Python 3.9.6 on an Apple M5 running macOS arm64. The saved correct answers serve as inputs to the verifier. Each of the 3 independent Python processes loads resources and completes a warmup before timing. Batching calls reduces the overhead of clock and hardware-counter readings. For each question, we use the median per-call cost from the 3 runs; Table 3 summarizes these 100 estimates. To obtain combined overhead, we add each question’s assembly and verification costs within the same run before taking medians. The measurements exclude offline library preparation, resource loading, serialization, and HTTP serving. Instruction counts include the Python interpreter and operating-system work. Challenge and private-state sizes are measured using compact UTF-8 JSON serialization.
Worked Challenge Example
We illustrate the construction with a biochemistry challenge from the evaluation set. It asks which of two receptors has a higher value in a 624-word report. The box below reproduces the complete report, question, and answer instruction received by the client. Table 7 shows the relevant values and how the verifier obtains and checks the answer.
| Component | Content |
| Relevant values | GABA-A: 0.14 uM; CXCR4: 8.35 uM |
| Answer rule | Select the receptor with the higher IC50 value. |
| Correct answer | CXCR4 |
| Example response | {"answer":"CXCR4"} |
Table 7. Example verification. The verifier compares two IC50 values to obtain the correct answer and check the client’s response.
Public challenge
Report.
ASSAY SCREENING PANEL SUMMARY
Panel reference: BIO-SCR-6; plate map revision 4.2; acquisition window 18 min per plate. The following narrative integrates inhibition curves, receptor displacement traces, and enzyme turnover checks for 6 entries. Buffer was 50 mM HEPES with 150 mM NaCl, pH 7.4, and the initial robotic dispense log also recorded fixed controls of 0.5% DMSO, 2.0 mM MgCl2, and 37 C incubation. Compound Erlotinib was logged with replicate CV 16.3% in the first potency table, while compound Metformin was entered nearby with replicate CV 12.8%. No preference language is used here; these are simply panel entries.
The preliminary readout appeared to place the receptor curves in a narrow band. Receptor GABA-A showed Hill slope 1.58, and receptor CXCR4 showed Hill slope 0.74, with a fixed reference tracer displacement of 68% at 100 nM. On that basis, the run captain initially wrote that receptor behavior looked essentially interchangeable. That early sentence was later softened after the kinetic annotations and replicate summaries were reconciled across the document, because slope, dispersion, and assigned mode did not remain parallel.
For the enzyme block, enzyme LDH- had IC50 0.72 uM after blank subtraction, and enzyme PFK-1 had IC50 64.5 uM. Their turnover checks used 12 substrate points, with a fixed calibration standard at 40.0 nmol/min/mg and a carryover flag below 0.3%. Enzyme LDH- was separately assigned binding mode noncompetitive; enzyme PFK-1 was assigned binding mode uncompetitive. These annotations refer to the fitted inhibition pattern, not to suitability or priority.
Compound records were revisited after the enzyme plates were thawed a second time. Compound Erlotinib then had Hill slope 1.03 and IC50 0.31 uM; compound Metformin had Hill slope 1.76 and IC50 4.90 uM. A fixed distractor value of 91% activity recovery appeared in the washout column for a pooled control and should not be confused with any sampled attribute. The mode calls were kept in a separate column: Erlotinib carried binding mode covalent reversible, while Metformin carried binding mode partial agonist.
Receptor annotations were then cross-checked against the same reporting vocabulary used for the enzyme section. Receptor GABA-A carried replicate CV 9.4% and IC50 0.14 uM. Receptor CXCR4 carried replicate CV 25.5% and IC50 8.35 uM. The fixed scintillation background was 145 cpm, and the ligand concentration was held at 7.5 nM. Receptor GABA-A was annotated as competitive for binding mode; receptor CXCR4 was annotated as inverse agonist for the same label.
The earlier impression of receptor interchangeability was not retained in the final notes. The difference was not attributed to a single number, because the final read used the full set of replicate CV, slope, dispersion, and categorical mode calls. In the same reconciliation pass, enzyme LDH- was also listed with replicate CV 5.6% and Hill slope 0.96; enzyme PFK-1 was listed with replicate CV 1.4% and Hill slope 0.62. A fixed note of 24 h storage at 4 C applied to all plates and is not an entity-specific measurement.
A final pass scattered the compound and receptor entries back into the same spreadsheet view so that no row looked privileged. Compound Erlotinib was mentioned again beside a pooled Z-prime of 0.72, and compound Metformin beside a pooled Z-prime of 0.69; neither number is the sampled IC50. Receptor GABA-A and receptor CXCR4 were also repeated in the reviewer margin to remind readers that categorical calls and quantitative values both contributed to the readout.
The closing assessment states only that all 6 entries were reviewed after curve fitting, replicate inspection, and nomenclature harmonization. Enzyme LDH-, enzyme PFK-1, compound Erlotinib, compound Metformin, receptor GABA-A, and receptor CXCR4 remain neutral records in the panel. The preliminary receptor sentence should be treated as provisional, while the scattered final values above are the values to use for lookup, ranking, and comparison.
Question.
Between GABA-A and CXCR4, which had a higher IC50?
Answer instruction.
For extrema, compare only entities of the requested type for which this report explicitly gives the requested attribute; missing values are not zero. Return one JSON object with exactly one key, answer, whose value is a string. Put only the exact entity name for a which-question, or the reported value for a what-question, inside that string. A numeric answer may omit its unit, but must keep the number exactly as reported. Do not convert units, expand unit names, or rewrite the numeric notation. Do not add a type prefix, explanation, Markdown, or any other field.
The correct answer is CXCR4, whose IC50 value is 8.35 uM, compared with 0.14 uM for GABA-A. The verifier reads these values directly from its private world state, whereas the client receives them only as part of the natural-language report.
Passive Analysis Details
Experimental Settings
We use the 3 shopping tasks summarized in Table 9. The Wi-Fi adapter task specifies the exact products to add to the cart, while the other 2 allow clients to select products satisfying the stated constraints.
| Task | Cart requirements |
| Wi-Fi adapters | One specified Foktech AC1200 adapter and one specified EDUP dual-band adapter with an extender antenna. |
| USB drive | One USB flash drive with at least 32 GB capacity and a price at most $22. |
| Wireless mice | Two different wireless mice, one of each, costing at most 30 combined; at least one must support Bluetooth. |
Table 9. Shopping tasks. All tasks start from the shopping homepage and end with cart review without checkout.
Browser Use and MCP Agents call openai/gpt-6.1-sol via OpenRouter [49], with the MCP Agent controlled through OpenAI Agents SDK. The Computer Use Agent accesses the same model family through Codex with a ChatGPT subscription and operates through screenshots and GUI actions. For each Computer Use visit, we use a separate conversation and Chrome profile. The native-input Bot reads public DOM information for positioning and executes macOS mouse and keyboard events.
Each visit uses an independent guest shopping session. Automatic clients use new browser profiles or Cookie jars, while Human participants use their own browsers and may retain resource caches. For HTTP summaries, we retain application-page and API requests, including repetitions and failures, and exclude static resources, telemetry, and grading. The grader checks the final cart after observation closes. The analyzed dataset retains visits when clients do not complete the shopping tasks or their carts do not satisfy the task requirements. For 5 of the 72 Human visits, event recording was unexpectedly incomplete; we use the available observations and treat unavailable fields as missing. We exclude the HTTP-only Requests Bot from page-based classification.
To construct features, we apply to HTTP measurements, event counts, spans, and gap quantiles, keeping other features on their original scale. Timing and sequence measurements use click, input, and scroll events, with adjacency reset at document boundaries. The collector records pointer-move and scroll events at most once every 100 ms each. Within each training split, we estimate preprocessing parameters and class weights, filling missing fields with the observed means without adding missingness indicators. LR and RBF-SVM also use standardization fitted on that split. The predictors exclude identifiers and proxy-side connection counts, along with model-side logs and task grades.
Within each outer training set, we alternate the 2 tasks between inner training and validation, using P01–P04 for Human training visits and P05–P08 for validation visits. We select among 6 prespecified candidates per classifier and feature setting by mean inner-validation macro-F1, breaking ties by candidate order, and then refit the selected classifier on all outer training data. To supplement the interaction records, we measure TLS/HTTP fingerprints before proxy rewriting using 33 separate HTTPS probes: 3 per automatic configuration and 3 each for ordinary Chrome and Safari. In Table 5, these reference browsers supply the Human fingerprints, while the 72 participant visits provide the Human HTTP statistics.
Ethical Considerations
We obtained institutional review board (IRB) approval for the user study and informed all participants about the study and its data collection. We collected only task-related HTTP metadata, browser characteristics, and page events within the experimental shopping website and did not collect browsing activity outside the site or any personally identifiable information.
References
- [1]Android Developers. n.d.. Build Web Apps in WebView. https://developer.android.com/develop/ui/views/layout/webapps/webview Official documentation accessed 2026-10-23.
- [2]Anthropic. n.d.. Computer Use Tool. https://platform.claude.com/docs/en/agents-and-tools/tool-use/computer-use-tool Official documentation accessed 2026-10-21.
- [3]Anthropic. n.d.. Get Started with Claude in Chrome. https://support.claude.com/en/articles/12012173-get-started-with-claude-in-chrome Official documentation accessed 2026-10-21.
- [4]Anthropic. n.d.. Web Fetch Tool. https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-fetch-tool Official documentation accessed 2026-10-21.
- [5]Anthropic. n.d.. Web Search Tool. https://platform.claude.com/docs/en/agents-and-tools/tool-use/web-search-tool Official documentation accessed 2026-10-21.
- [6]Atlassian. n.d.. Atlassian MCP Server. https://atlassian.github.io/atlassian-mcp-server/ Documentation accessed 2026-10-21.
- [7]Brave. n.d.. Brave Search MCP Server. https://github.com/brave/brave-search-mcp-server Official repository accessed 2026-10-21.
- [8]Browser Use. n.d.. Browser Use Actor. https://github.com/browser-use/browser-use/blob/main/browser_use/actor/README.md Official documentation accessed 2026-10-21.
- [9]Browser Use. n.d.. Browser Use: Open-Source Browser Agents. https://github.com/browser-use/browser-use Official repository accessed 2026-10-23.
- [10]Tianqi Chen and Carlos Guestrin. 2016. XGBoost: A Scalable Tree Boosting System. In Proceedings of the 22nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining. 785–794. doi:10.1145/2939672.2939785DOI
- [11]Chrome for Developers. n.d.. Content Scripts. https://developer.chrome.com/docs/extensions/develop/concepts/content-scripts Official documentation accessed 2026-10-23.
- [12]Cloudflare. 2026. Bot detection engines. https://developers.cloudflare.com/bots/concepts/bot-detection-engines/ Documentation accessed 2026-10-14.
- [13]Cloudflare. 2026. Bot scores. https://developers.cloudflare.com/bots/concepts/bot-score/ Documentation accessed 2026-10-14.
- [14]Cloudflare. 2026. Turnstile. https://developers.cloudflare.com/turnstile/ Documentation accessed 2026-10-24.
- [15]Cloudflare. 2026. Verified bots. https://developers.cloudflare.com/bots/concepts/bot/verified-bots/ Updated October 8, 2026; accessed 2026-10-14.
- [16]Cloudflare. 2026. Web Bot Auth. https://developers.cloudflare.com/bots/reference/bot-verification/web-bot-auth/ Updated October 8, 2026; accessed 2026-10-14.
- [17]Matthew Conroy. 2026. The Internet has a second audience. Cloudflare Blog. https://blog.cloudflare.com/agentic-web/ Published September 30, 2026; accessed 2026-10-21.
- [18]Corinna Cortes and Vladimir Vapnik. 1995. Support-Vector Networks. Machine Learning 20, 3 (1995), 273–297. doi:10.1007/BF00994018DOI
- [19]Jack Cowan and Mitul Shah. 2026. Making agent-friendly pages with content negotiation. Vercel Blog. https://vercel.com/blog/making-agent-friendly-pages-with-content-negotiation Published February 3, 2026; accessed 2026-10-15.
- [20]curl. n.d.. curl—How To Use. https://curl.se/docs/manpage.html Official documentation accessed 2026-10-23.
- [21]Xiang Deng, Yu Gu, Boyuan Zheng, Shijie Chen, Sam Stevens, Boshi Wang, Huan Sun, and Yu Su. 2023. Mind2Web: Towards a Generalist Agent for the Web. In Advances in Neural Information Processing Systems, Vol. 36. Curran Associates, Inc., 28091–28114. doi:10.52202/078528-1220arxiv.org/abs/2306.06070
- [22]Alexandre Dourin, Maxime Gasse, Massimo Caccia, Issam H. Laradji, Manuel Del Verme, Tom Marty, David Vazquez, Nicolas Chapados, and Alexandre Lacoste. 2024. WorkArena: How Capable are Web Agents at Solving Common Knowledge Work Tasks?. In Proceedings of the 41st International Conference on Machine Learning (Proceedings of Machine Learning Research, Vol. 235). PMLR, 11642–11662. https://proceedings.mlr.press/v235/drouin24a.html
- [23]Cynthia Dwork and Moni Naor. 1993. Pricing via Processing or Combatting Junk Mail. In Advances in Cryptology—CRYPTO ’92 (Lecture Notes in Computer Science, Vol. 740). Springer, Berlin, Heidelberg, 139–147. doi:10.1007/3-540-48071-4_10
- [24]Marina Elmore and Benedikt Wolters. 2026. Introducing Precursor: Detecting Agentic Behavior with Continuous Client-Side Signals. Cloudflare Blog. https://blog.cloudflare.com/introducing-precursor/ Published July 13, 2026; accessed 2026-10-23.
- [25]Exa. n.d.. Exa MCP. https://exa.ai/docs/get-started/exa-mcp Documentation accessed 2026-10-21.
- [26]Iliana Fayolle, Sihem Bouhenniche, Samuel Pélissier, Pierre Lapeyrieux, Clémentine Maurice, and Walter Rudametkin. 2026. On the Internet, Nobody Knows You’re an LLM Bot: Unmasking Web Agents with Multi-Layer Fingerprinting. arXiv:2606.30119v1. doi:10.48550/arXiv.2606.30119DOI
- [27]FoxIO. n.d.. JA4+ Network Fingerprinting. https://github.com/FoxIO-LLC/ja4/tree/c6469a7b0dbf8fe963810162429fbdd9dac4d5 Reference implementation accessed 2026-10-25.
- [28]Sandro Rodriguez Garzon, Awid Vaziry, Enis Mert Kuzu, Dennis Enrique Gehrmann, Buse Varkan, Alexander Gaballa, and Axel Küpper. 2026. AI Agents with Decentralized Identifiers and Verifiable Credentials. In Proceedings of the 18th International Conference on Agents and Artificial Intelligence - Volume 1: ICAART. SciTePress, 252–259. doi:10.5220/001423440004052
- [29]GitHub. n.d.. GitHub MCP Server. https://github.com/github/github-mcp-server Official repository accessed 2026-10-21.
- [30]Izzeddin Gur, Hiroki Furuta, Austin Huang, Mustafa Safdari, Yutaka Matsuo, Douglas Eck, and Aleksandra Faust. 2024. A Real-World WebAgent with Planning, Long Context Understanding, and Program Synthesis. In The Twelfth International Conference on Learning Representations. 52690–52717. https://proceedings.iclr.cc/paper_files/paper/2024/hash/e91bf7dfba0477554994c6d64833e9d8-Abstract-Conference.htmlarxiv.org/abs/2307.12856
- [31]Hongliang He, Wenlin Yao, KaiXin Ma, Wenhao Yu, Yong Dai, Hongming Zhang, Zhenzhong Lan, and Dong Yu. 2024. WebVoyager: Building an End-to-End Web Agent with Large Multimodal Models. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). Association for Computational Linguistics, 6864–6890. doi:10.18653/v1/2024.acl-long.371DOI
- [32]Hugging Face. n.d.. Hugging Face MCP Server. https://huggingface.co/docs/hub/en/agents-mcp Documentation accessed 2026-10-21.
- [33]Christos Iliou, Theodoros Kostoulas, Theodora Tsikriki, Vasilis Katos, Stefanos Vrochidis, and Ioannis Kompatsiaris. 2021. Detection of Advanced Web Bots by Combining Web Logs with Mouse Behavioural Biometrics. Digital Threats: Research and Practice 2, 3 (2021), 1–26. doi:10.1145/3447815DOI
- [34]Hugo Jonker, Benjamin Krumnow, and Gabry Vlot. 2019. Fingerprint Surface-Based Detection of Web Bot Detectors. In Computer Security—ESORICS 2019 (Lecture Notes in Computer Science, Vol. 11736). Springer International Publishing, Cham, 586–605. doi:10.1007/978-3-030-29962-0_28DOI
- [35]Ari Juels and John Brainard. 1999. Client Puzzles: A Cryptographic Countermeasure Against Connection Depletion Attacks. In NDSS. Internet Society, 15 pages. https://www.ndss-symposium.org/ndss1999/cryptographic-defense-against-connection-depletion-attacks/
- [36]Kaggle. n.d.. MCP Server Documentation. https://www.kaggle.com/docs/mcp Documentation accessed 2026-10-21.
- [37]Jing Yu Koh, Robert Lo, Lawrence Jang, Vikram Duvvur, Ming Lim, Po-Yu Huang, Graham Neubig, Shuyan Zhou, Russ Salakhutdinov, and Daniel Fried. 2024. VisualWebArena: Evaluating Multimodal Agents on Realistic Visual Web Tasks. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers). Association for Computational Linguistics, 881–905. doi:10.18653/v1/2024.acl-long.50DOI
- [38]Jun-Hee Lee. 2025. The age of agents: cryptographically recognizing agent traffic. Cloudflare Blog. https://blog.cloudflare.com/signed-agents/ Published August 28, 2025; accessed 2026-10-14.
- [39]Hector J. Levesque, Ernest Davis, and Leora Morgenstern. 2012. The Winograd Schema Challenge. In Proceedings of the Thirteenth International Conference on Principles of Knowledge Representation and Reasoning. AAAI Press, Menlo Park, CA, USA, 552–561. https://cdn.aaai.org/ojs/4492/4492-21-1-PB.pdf
- [40]William Lugoolobi, Samuelle Marro, Jabez Magomere, Joss Wright, and Chris Russell. 2026. Known By Their Actions: Fingerprinting LLM Browser Agents via UI Traces. arXiv:2605.14786v1. doi:10.48550/arXiv.2605.14786 Accepted at NeurIPS 2026. Author implementation: https://github.com/KabakaWilliam/known_actions.
- [41]Celso Martinho and Will Allen. 2026. Introducing Markdown for Agents. Cloudflare Blog. https://blog.cloudflare.com/markdown-for-agents/ Published February 12, 2026; accessed 2026-10-15.
- [42]R. Thomas McCoy, Ellie Pavlick, and Tal Linzen. 2019. Right for the Wrong Reasons: Diagnosing Syntactic Heuristics in Natural Language Inference. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, Florence, Italy, 3428–3448. doi:10.18653/v1/P19-1334DOI
- [43]Microsoft. n.d.. BrowserType: Connecting to an Existing Browser. https://playwright.dev/python/docs/api/class-browsertype Official documentation accessed 2026-10-23.
- [44]Model Context Protocol. 2026. MCP Specification: Tools. https://modelcontextprotocol.io/specification/2026-07-28/server/tools Protocol revision 2026-07-28; accessed 2026-10-14.
- [45]Marti Motoyama, Kirill Levchenko, Chris Kanich, Damon McCoy, Geoffrey M. Voelker, and Stefan Savage. 2010. Re: CAPTCHA-Solving Services in an Economic Context. In 19th USENIX Security Symposium (USENIX Security 10). USENIX Association, Washington, DC. https://www.usenix.org/conference/usenixsecurity10/re-captchas%E2%80%94understanding-captcha-solving-services-economic-context
- [46]National Institute of Standards and Technology. 2023. Digital Signature Standard (DSS). Federal Information Processing Standards Publication 186-5. National Institute of Standards and Technology, Gaithersburg, MD, USA. doi:10.6028/NIST.FIPS.186-5DOI
- [47]Yixin Nie, Adina Williams, Emily Dinan, Mohit Bansal, Jason Weston, and Douwe Kiela. 2020. Adversarial NLI: A New Benchmark for Natural Language Understanding. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics. Association for Computational Linguistics, Online, 4885–4901. doi:10.18653/v1/2020.acl-main.441DOI
- [48]Notion. n.d. Notion MCP. https://www.notion.com/help/notion-mcp Documentation accessed 2026-10-21.
- [49]OpenRouter. n.d. OpenRouter Quickstart Guide. https://openrouter.ai/docs/quickstart Official documentation accessed 2026-10-26.
- [50]KyoungSoo Park, Vivek S. Pai, Kang-Won Lee, and Seraphin Calo. 2006. Securing Web Service by Automatic Robot Detection. In 2006 USENIX Annual Technical Conference (USENIX ATC 06). USENIX Association, 255–260. https://www.usenix.org/conference/2006-usenix-annual-technical-conference/securing-web-service-automatic-robot-detection
- [51]PayPal. 2026. MCP server quickstart guide. https://developer.paypal.com/ai-tools/mcp-server Updated June 30, 2026; accessed 2026-10-21.
- [52]Marco Tulio Ribeiro, Tongshuang Wu, Carlos Guestrin, and Sameer Singh. 2020. Beyond Accuracy: Behavioral Testing of NLP Models with Checklist. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics. Association for Computational Linguistics, Online, 4902–4912. doi:10.18653/v1/2020.acl-main.442DOI
- [53]Nikhil Sardana, Jacob Portes, Sasha Doubov, and Jonathan Frankle. 2024. Beyond Child-Centric-Optimal: Accounting for Inference in Language Model Scaling Laws. In Proceedings of the 41st International Conference on Machine Learning (Proceedings of Machine Learning Research, Vol. 235). PMLR, 43445–43460. https://proceedings.mlr.press/v235/sardana24a.htmlDOI
- [54]Selenium. n.d. Selenium Overview. https://www.selenium.dev/documentation/overview/ Official documentation accessed 2026-10-23.
- [55]Shopify. n.d. Build commerce agents with UCP. https://shopify.dev/docs/agents Documentation accessed 2026-10-21.
- [56]Stripe. 2026. Model Context Protocol (MCP). https://docs.stripe.com/mcp Documentation accessed 2026-10-21.
- [57]Tavily. n.d. Tavily MCP Server. https://docs.tavily.com/documentation/mcp Documentation accessed 2026-10-21.
- [58]Luis von Ahn, Manuel Blum, Nicholas J. Hopper, and John Langford. 2003. CAPTCHA: Using Hard AI Problems for Security. In Advances in Cryptology—EUROCRYPT 2003 (Lecture Notes in Computer Science, Vol. 2656). Springer, Berlin, Heidelberg, 294–311. doi:10.1007/3-540-39200-9_18
- [59]W3C Web Accessibility Initiative. n.d. Tools and Techniques. https://www.w3.org/WAI/people-use-web/tools-techniques/ Official documentation accessed 2026-10-23.
- [60]Alex Wang, Amanpreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R. Bowman. 2019. GLUE: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding. In The Seventh International Conference on Learning Representations. https://openreview.net/forum?id=rJ4km2R5t7
- [61]Ethan Wang, Zubair Shafiq, and Yash Vekaria. 2026. Poster: FP-Agent: Towards Fingerprinting AI Browsing Agents. In Proceedings of the 2026 ACM Internet Measurement Conference (IMC ’26). ACM, 1227–1228. doi:10.1145/3777912.3847600DOI
- [62]Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Brian Ichter, Fei Xia, Ed Chi, Quoc V. Le, and Denny Zhou. 2022. Chain-of-Thought Prompting Elicits Reasoning in Large Language Models. In Advances in Neural Information Processing Systems, Vol. 35. Curran Associates, Inc., 24824–24837. doi:10.52202/064831-1800arxiv.org/abs/2201.11903
- [63]Jason Weston, Antoine Bordes, Sumit Chopra, Alexander M. Rush, Bart van Merriënboer, Armand Joulin, and Tomas Mikolov. 2016. Towards AI-Complete Question Answering: A Set of Prerequisite Toy Tasks. In The Fourth International Conference on Learning Representations. https://arxiv.org/abs/1502.05698
- [64]Wikidata contributors. n.d. Wikidata:MCP. https://www.wikidata.org/wiki/Wikidata:MCP Project documentation accessed 2026-10-21.
- [65]Tianbao Xie, Yangyang Deng, Jixuan Chen, Xiaochuan Li, Shengyu Zhao, Ruisheng Cao, Toj Hjing Hua, Zhoujun Cheng, Dongchan Shin, Fangyu Lei, Yitao Liu, Yiheng Xu, Shuyan Zhou, Silvio Savarese, Caiming Xiong, Victor Zhong, and Tao Yu. 2024. OSWorld: Benchmarking Multimodal Agents for Open-Ended Tasks in Real Computer Environments. In Advances in Neural Information Processing Systems, Vol. 37. Curran Associates, Inc., 52040–52094. doi:10.52202/079017-1650
- [66]Minghui Xu, Xiaoyu Liu, Yihao Guo, Chunchi Liu, Yue Zhang, and Xiuzhen Cheng. 2026. AgentDID: Trustless Identity Authentication for AI Agents. In 2026 IEEE 46th International Conference on Distributed Computing Systems (ICDCS). IEEE, 1180–1190. doi:10.1109/ICDCS-8411.2026.00116
- [67]Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. 2023. ReAct: Synthesizing Reasoning and Acting in Language Models. In The Eleventh International Conference on Learning Representations. https://openreview.net/forum?id=WE_vluYUL-Xarxiv.org/abs/2210.03629
- [68]Boyuan Zheng, Boyu Gou, Jihyung Kil, Huan Sun, and Yu Su. 2024. GPT-4V(ision) is a Generalist Web Agent, if Grounded. In Proceedings of the 41st International Conference on Machine Learning (Proceedings of Machine Learning Research, Vol. 235). PMLR, 61349–61385. https://proceedings.mlr.press/v235/zheng24e.htmlarxiv.org/abs/2401.01614
- [69]Shuyuan Zhou, Frank F. Xu, Hao Zhu, Yuhui Zhou, Robert Lo, Abishek Sridhar, Xianyi Cheng, Tianyue Ou, Yonatan Bisk, Daniel Fried, Uri Alon, and Graham Neubig. 2024. WebArena: A Realistic Web Environment for Building Autonomous Agents. In The Twelfth International Conference on Learning Representations. 15585–15606. https://proceedings.iclr.cc/paper_files/paper/2024/hash/4410c0711e9154a7a2d26f9b3816d1ef-Abstract-Conference.htmlarxiv.org/abs/2307.13854