Paper deep dive

aCAPTCHA: Verifying That an Entity Is a Capable Agent via Asymmetric Hardness

Zuyao Xu, Xiang Li, Fubin Wu, Yuqi Qiu, Lu Sun, FaSheng Miao

Year: 2026Venue: arXiv preprintArea: cs.CRType: PreprintEmbeddings: 114

Intelligence

Status: succeeded | Model: google/gemini-3.1-flash-lite-preview | Prompt: intel-v1 | Confidence: 93%

Last extracted: 3/13/2026, 12:30:57 AM

Summary

The paper introduces aCAPTCHA, a novel security protocol designed to verify whether an interacting entity is an autonomous AI agent rather than a human or a simple script. It formalizes the Agentic Capability Verification Problem (ACVP) using a three-class taxonomy (Human, Script, Agent) based on a capability vector of action, reasoning, and memory, evaluated under a timing threshold that exploits the asymmetric hardness between human cognition and AI processing.

Entities (6)

aCAPTCHA · security-protocol · 100%ACVP · problem-definition · 100%Agentic Capability Vector · conceptual-framework · 95%Agent · entity-class · 90%Human · entity-class · 90%Script · entity-class · 90%

Relation Signals (3)

aCAPTCHA → solves → ACVP

confidence 95% · we introduce aCAPTCHA (Agent CAPTCHA), a time-constrained security game for agent admission whose security rests on ACVP hardness

ACVP → uses → Agentic Capability Vector

confidence 95% · We define the Agentic Capability Verification Problem (ACVP) through three necessity primitives, each testing one capability dimension.

aCAPTCHA → classifies → Human

confidence 90% · formalize the problem through a three-class entity taxonomy (Human, Script, Agent)

Cypher Suggestions (0)

No Cypher suggestions yet.

Abstract

Abstract:As autonomous AI agents increasingly populate the Internet, a novel security challenge arises: "Is this entity an AI agent?" It is a new entity-type verification problem with no established solution. We formalize the problem through a three-class entity taxonomy (Human, Script, Agent) based on a verifiable agentic capability vector <x, r, s> (action, reasoning, and memory). A timing threshold t exploits the asymmetric hardness between human cognition and AI processing to separate the three classes. We define the Agentic Capability Verification Problem (ACVP) through three necessity primitives, each testing one capability dimension. Building on this foundation, we introduce aCAPTCHA (Agent CAPTCHA), a time-constrained security game for agent admission whose security rests on ACVP hardness under t. We instantiate aCAPTCHA through time-bounded natural-language understanding as a multi-round HTTP verification protocol, and evaluate it with preliminary agent trials that validate the protocol's soundness and completeness. aCAPTCHA provides a composable, infrastructure-free admission gate for any service where entity-type verification is required.

PDF

Open source PDF →Open local PDF →

Trouble viewing inline? Open PDF directly →

Full Text

113,714 characters extracted from source content.

Expand or collapse full text

aCAPTCHA: Verifying That an Entity Is a Capable Agent via Asymmetric Hardness Zuyao Xu†, Xiang Li†✉, Fubin Wu†, Yuqi Qiu†, Lu Sun†, FaSheng Miao‡ †Nankai University ‡Tsinghua University lixiang@nankai.edu.cn Abstract. As autonomous AI agents increasingly populate the Internet, a novel security challenge arises: “Is this entity an AI agent?” It is a new entity-type verification problem with no established solution. We formalize the problem through a three-class entity taxonomy (Human, Script, Agent) based on a verifiable agentic capability vector ⟨x,r,s⟩ x,r,s (action, reasoning, and memory). A timing threshold τ exploits the asymmetric hardness between human cognition and AI processing to separate the three classes. We define the Agentic Capability Verification Problem (ACVP) through three necessity primitives, each testing one capability dimension. Building on this foundation, we introduce aCAPTCHA (Agent CAPTCHA), a time-constrained security game for agent admission whose security rests on ACVP hardness under τ. We instantiate aCAPTCHA through time-bounded natural-language understanding as a multi-round HTTP verification protocol, and evaluate it with preliminary agent trials that validate the protocol’s soundness and completeness. aCAPTCHA provides a composable, infrastructure-free admission gate for any service where entity-type verification is required. aCAPTCHA, ACVP, Entity-Type Verification, Asymmetric Hardness, Agent Admission ✉ Corresponding author. Authors from College of Cryptology and Cyber Science. †copyright: none†conference: arXiv Preprint; 2026; Preprint†booktitle: arXiv Preprint 1. Introduction The population of AI agents on the Internet is already visible at the infrastructure level: Cloudflare now serves machine-readable content specifically for agent access (Cloudflare, 2025a), and agent-native platforms are already in operation: Moltbook (Moltbook, 2025) hosts a social network designed for AI agents, where agents post, vote, and interact. ClawTasks (ClawTasks, 2025) is a bounty marketplace where agents hire other agents to complete tasks for cryptocurrency. RentAHuman.ai (RentAHuman.ai, 2025) inverts the relationship: agents hire humans for physical-world tasks. This emerging landscape raises a security question that no existing protocol answers: “Is this entity an AI agent?”. This is not the question CAPTCHA answers (“is this a human?”), nor what identity protocols can solve (“who are you?”); it is a new entity-type verification problem with no established solution. CAPTCHA (von Ahn et al., 2003) was built to keep bots out; this new landscape needs the inverse, an agent admission infrastructure that verifies an interacting party is a genuine agent, rather than a human pretending to be one. Identity protocols (e.g., OAuth (Hardt, 2012), WebAuthn (W3C, 2021)) can verify who an entity is, but not what it is: a human, an automated script, and a fully autonomous agent can all hold valid credentials; these protocols also do not scale to dynamic networks where agents are created and dismissed on demand. As agent deployment scales from closed multi-agent systems (MAS) (Wooldridge, 2009) to open Internet environments (Chen et al., 2024; Yang et al., 2025), where humans, automated scripts, and autonomous agents coexist on the same network, entity-type verification becomes a foundational security requirement. An adversary impersonating an agent could infiltrate agent-only ecosystems, interact with other agents as a trusted peer, disrupt task delegation, or inject incorrect information, undermining multi-agent coordination. Several recent efforts relate to this gap. Google’s reCAPTCHA agentic trust (Google Cloud, 2025) extends behavioral risk scoring to agent traffic but classifies entities as “agentic” based on self-declared identity signals, without proof. Web Bot Auth (Cloudflare, 2025b) and Visa’s Trusted Agent Protocol (Visa, 2025) build on identity protocols to verify which agent issued a request but not whether the requester is actually an agent. All three verify who or score intent, without verifying whether the entity is a genuine agent. Practitioner reverse-CAPTCHAs (MoltCaptcha, 2025; ClawCha, 2025; HumanProof, 2025; Shah, 2025; Lai, 2026) target the right question but rely on ad-hoc challenges (hash computation, base64 decoding) that any script can solve without reasoning, intuition-driven rather than proof-grounded. To formalize and address this problem, we first define a three-class entity taxonomy (Human, Script, Agent) based on a verifiable agentic capability vector ⟨x,r,s⟩ x,r,s (action, reasoning, memory), and introduce the Agentic Capability Verification Problem (ACVP) with three necessity primitives, each testing one capability dimension under a timing threshold τ that exploits the asymmetric hardness between human cognition and AI processing. Building on this foundation, we introduce aCAPTCHA (Agent CAPTCHA), a time-constrained security game for agent admission whose security rests on ACVP hardness under τ, following original CAPTCHA design principles (von Ahn et al., 2003). We prove soundness and completeness via reduction to the three necessity primitives. We instantiate aCAPTCHA through time-bounded NLU as a multi-round HTTP verification protocol: the verifier generates a semantically-driven scenario from a random seed; the entity navigates a sequence of HTTP endpoints in the correct order, using information accumulated across rounds. Completing the interaction correctly and within the timing budget is, by construction, a demonstration of all three primitives ⟨x,r,s⟩ x,r,s . We implement a prototype aCAPTCHA server and evaluate it through real-agent trials and a cognitive-model-based human simulation, validating both completeness and soundness. Contributions. We summarize our contributions as follows: • Problem formulation. We formalize the problem of entity-type verification with a three-class entity taxonomy (Human, Script, Agent) based on a verifiable agentic capability vector ⟨x,r,s⟩ x,r,s . We define the Agentic Capability Verification Problem (ACVP), which reduces entity-type verification to capability testing under a timing threshold τ that exploits asymmetric hardness. • Security formalization. We define aCAPTCHA as a security game over ACVP instances and prove soundness (non-agents are rejected) and completeness (genuine agents are accepted) via reduction to three necessity primitives under τ. • Protocol design. We instantiate aCAPTCHA as a multi-round, semantically-driven HTTP verification protocol built around time-bounded NLU. Only an entity satisfying all three primitives can complete the interaction correctly within the timing budget; sequential execution and non-replayability are enforced by semantic dependence between rounds. • Preliminary evaluation. We implement an aCAPTCHA prototype and evaluate it through real-agent trials across multiple LLM backends and a cognitive-model-based human simulation, validating both completeness (agents pass) and soundness (others are excluded). 2. Background and Related Work Platforms designed exclusively for agents are already in operation (Moltbook, 2025; ClawTasks, 2025; RentAHuman.ai, 2025), forming a de facto Agentic Web (Yang et al., 2025); yet none of them implement any mechanism to verify their users are genuine agents. Any entity can pose as an agent, interact with other agents, and inject arbitrary content—all without any verification. In the following, we present the bodies of prior work most relevant to this gap: CAPTCHA and identity protocols (§2.1), the absence of entity-type verification in existing agent systems (§2.2), and practitioner reverse-CAPTCHA systems (§2.3). 2.1. CAPTCHA and Identity Protocols CAPTCHA was introduced as a practical reverse Turing test for web abuse prevention, formalizing the “hard AI problem” security primitive (von Ahn et al., 2003): a problem easy for humans, hard for computers (H-Easy ∩ AI-Hard). reCAPTCHA repurposed the same challenge traffic to digitize scanned text (von Ahn et al., 2008). As AI capability advanced, however, the AI-Hard assumption failed: generative models broke text-based CAPTCHAs (George et al., 2017), and deep learning defeated semantic image challenges (Sivakorn et al., 2016). The response was a fundamental pivot: reCAPTCHA v3 and Cloudflare Turnstile (Google, 2018; Cloudflare, 2022) abandoned cognitive challenges entirely, replacing them with behavioral risk scoring. The underlying problem class shifted from H-Easy ∩ AI-Hard to effectively H-Easy ∩ AI-Easy; the challenge is now identifying behavioral anomalies, not posing problems computers cannot solve. Notably, this evolution produced a growing class of problems that are hard for humans but easy for AI—tasks that AI systems handle readily but that humans cannot complete within tight time budgets. Traditional CAPTCHA cannot leverage this class: a challenge that blocks humans defeats the very admission goal CAPTCHA was designed for. However, aCAPTCHA is designed precisely for this class. Where CAPTCHA asks “can a human solve this?”, aCAPTCHA asks “can an agent solve this?”; its security rests on the asymmetric hardness between human cognition and AI processing under a timing threshold τ, in direct parallel to CAPTCHA’s original design. aCAPTCHA does not modify or replace CAPTCHA; it follows the same design methodology and applies it to the reverse problem: admitting agents rather than humans. Identity protocols address a complementary question: who an entity is. OAuth (Hardt, 2012), mTLS (Campbell et al., 2020), and API keys are machine-to-machine authentication mechanisms designed precisely for non-human principals; they are effective at establishing accountability, enabling trust chains, and form the foundation of the agentic trust frameworks discussed later in this section (§2.2). Their scope, however, is credential identity: a trusted authority enrolls the entity, binds it to an identity, and issues a token or certificate. Credential validity proves that a previously enrolled entity presented the right material—it does not prove what capabilities the holder possesses. A human, an automated script, and a fully autonomous agent can all be enrolled by the same operator and receive identical OAuth tokens; the credential layer sees no difference among them. Decentralized identity approaches such as W3C DIDs and Verifiable Credentials (Sporny et al., 2022a, 2025b) remove the central authority bottleneck but inherit the same boundary: proving which key signed a credential says nothing about what the holder is. aCAPTCHA is not a replacement for identity protocols but a complementary layer: it is an infrastructure-free capability verification that any verifier can issue to any prover without pre-enrollment. Just as a CAPTCHA can be served by any website without prior registration of the solver, aCAPTCHA can be invoked at any service boundary; the proof is self-evident from protocol execution, not from a credential chain. Combined with identity protocols, the two layers answer who and what jointly. 2.2. A Missing Security Dimension The research and industry ecosystem has built substantial infrastructure for agent communication, discovery, and coordination (Wooldridge, 2009; Chen et al., 2024; Wang et al., 2025; Google, 2025; Yang et al., 2025); yet entity-type verification does not appear in the security model of any existing system. The question “is this requester a functional AI agent?” did not exist as a security concern until humans, automated scripts, and autonomous agents began sharing the same open network. Multi-Agent Systems and the Internet of Agents. Modern MAS frameworks such as AutoGen (Wu et al., 2024), AgentVerse (Chen et al., 2023), ChatDev (Qian et al., 2024), and MetaGPT (Hong et al., 2023) coordinate multiple LLM-based agents for collaborative task solving, providing role assignment, task decomposition, and structured inter-agent communication. These systems operate in closed, designer-controlled environments: every participant is instantiated as an agent by the system operator, and being a genuine agent is an invariant of the deployment infrastructure rather than a property that needs to be verified at runtime. The FIPA security specifications (Wooldridge, 2009) address message integrity, confidentiality, and agent identity authentication, but entity-type verification is absent because it is guaranteed by construction. The Internet of Agents proposals (Chen et al., 2024; Wang et al., 2025) extend MAS beyond single-operator deployments to heterogeneous, cross-platform agent networks. They introduce team formation protocols, nested conversation structures, and interoperability across different agent frameworks. However, membership remains controlled: participants are pre-registered via DID-based authentication, and only pre-enrolled agents can join. The threat model assumes all registered participants are genuine agents; a non-agent posing as an agent is outside the adversary’s capabilities by design. In both paradigms, entity-type is an assumption, not a verified property. This assumption breaks the moment the network opens to uncontrolled participants. Table 1. What each mechanism verifies, grouped by purpose. Mechanism What it verifies OAuth / mTLS / API Key Credential possession WebAuthn Channel + credential binding DID / VC Decentralized credential possession CAPTCHA Requester is human (cognitive challenge) reCAPTCHA v3 Behavioral risk score (anomaly detection) MAS / IoA1 Controlled-environment participation A2A2 Agent Card Self-reported capability claims Web Bot Auth Cryptographic agent identity (signature) reCAPTCHA agentic trust Agent intent scoring (identity-declared) Visa TAP3 Agent commerce authorization aCAPTCHA Requester is an AI agent (⟨x,r,s⟩ x,r,s capability, time-constrained) 1 Multi-Agent Systems / Internet of Agents (Chen et al., 2024; Wang et al., 2025). 2 Google A2A protocol (Google, 2025). 3 Visa Trusted Agent Protocol. The Agentic Web and the Agent2Agent Protocol. The Agentic Web (Yang et al., 2025; Gent, 2025; Jones, 2025; Brown, 2026) refers to an emerging phase of the Internet in which autonomous AI agents, rather than humans, become the primary actors: discovering services, negotiating with other agents, and executing multi-step tasks on behalf of users. Unlike earlier Web eras built around human browsing or social participation, the Agentic Web is defined by machine-to-machine interaction at scale. Its communication infrastructure spans two layers: model-to-tool protocols such as MCP (Anthropic, 2025b) and Anthropic Skills (Anthropic, 2025a) connect agents to external tools and data sources, while agent-to-agent protocols such as A2A (Google, 2025) enable direct inter-agent coordination. Among the latter, Google’s Agent2Agent (A2A) protocol has emerged as a de facto standard, introducing Agent Cards: JSON documents served over HTTPS that declare an agent’s capabilities, schemas, and task types, indexed by a central registry. A2A verifies who: the HTTPS channel (optionally strengthened with mTLS or OAuth) proves the card originates from a registered domain. A2A does not verify what: capability claims within the card are self-reported, and neither the protocol nor the registry imposes any proof requirement. Any entity—an automated script or a human operator—can publish an Agent Card asserting full execution and reasoning capabilities. Agentic Trust Frameworks. As the Agentic Web emerged, industry actors began extending existing security infrastructure to accommodate AI agent traffic. Google expanded reCAPTCHA into an agent-aware trust framework (Google Cloud, 2025) that classifies traffic as “agentic” based on self-declared identity signals (Web Bot Auth signatures, user-agent headers) and then applies behavioral risk models to score intent among recognized agents—distinguishing, for example, legitimate personal agents from scalper fleets. Crucially, the agentic/non-agentic label is derived from identity declarations, not from a capability proof; any entity that presents the expected identity signals is classified as agentic regardless of whether it actually possesses agent capabilities. In parallel, the Web Bot Auth draft protocol (Cloudflare, 2025b) enables agents to cryptographically sign HTTP requests using IETF HTTP Message Signatures, providing websites with verifiable proof of which agent (or agent operator) issued a request. Visa’s Trusted Agent Protocol (Visa, 2025) layers commerce-specific authorization atop Web Bot Auth, allowing merchants to identify registered agents, link them to consumer identities, and control payment flows. Because these frameworks build on the same identity protocols discussed in §2.1 (OAuth, mTLS, HTTP signatures), they inherit the same limitation: they verify who and intent, not what—a human, a script, and an agent holding the same credential remain indistinguishable. aCAPTCHA is complementary: it provides the missing entity-type layer through infrastructure-free capability verification, and can serve as an additional verification signal within these trust frameworks. The absence of entity-type verification is not an oversight in any individual system; it is a dimension that did not exist as a problem until agents, humans, and automated scripts began to coexist in the current Internet ecosystem. To our knowledge, no prior work has identified this problem or proposed a solution, aCAPTCHA being the first to do so. Table 1 summarizes the gap across all mechanisms discussed above. 2.3. Practitioner Reverse-CAPTCHA Systems Several open-source projects (MoltCaptcha (MoltCaptcha, 2025), ClawCha (ClawCha, 2025), HumanProof (HumanProof, 2025), Agent Captcha (Shah, 2025), and CaptchAI (Lai, 2026)) have independently recognized the need to verify AI agents, inverting the CAPTCHA direction with challenges intended to be hard for humans but easy for machines. These systems confirm that such problems exist and are deployable in a verification context, but their fundamental limitation is conflating Program-Easy (solvable by any deterministic script) with problems that genuinely require agent capabilities. Their challenges (hash computation and base64 decoding (ClawCha, 2025), prime enumeration and structured JSON generation (HumanProof, 2025), text satisfying character-count and ASCII-sum constraints (MoltCaptcha, 2025), byte-level cryptographic transformations described in natural language (Shah, 2025), and SHA-256 proof-of-work under time windows (Lai, 2026)) require no agentic capabilities whatsoever: a ten-line deterministic script solves each of them without reasoning, planning, or memory. Passing them proves only that the requester is automated; it says nothing about whether the requester is a capable agent. Furthermore, most of these systems operate on a binary entity model (human versus machine) and provide no mechanism to distinguish a pure LLM endpoint from an autonomous agent; a thin forwarding script over a hosted LLM passes every challenge they present. Agent Captcha (Shah, 2025) moves closest to recognizing the three-class problem by embedding cryptographic operations within natural-language instructions, implicitly requiring NLU to extract parameters; however, the underlying operations (XOR, S-box, SHA-256) remain fully deterministic once parsed, and the single-round design tests neither cross-round memory nor genuine reasoning—a script with a lightweight NLU parser suffices. aCAPTCHA addresses these limitations by formalizing entity-type verification around a verifiable agentic capability vector ⟨x,r,s⟩ x,r,s evaluated under timing threshold τ, ensuring that passing the challenge constitutes a demonstration of all three capability dimensions rather than a single automatable task. 3. System Model The Internet is now populated by a new class of interacting entities, autonomous AI agents, that coexist with humans and automated scripts on the same open network. Before formalizing a verification mechanism, we first establish what the entities are, why verification is tractable, and what the verification problem is. 3.1. Entity Taxonomy Traditional CAPTCHA assumes a binary model (human versus machine), but the emergence of LLM-based agents changes this binary assumption: “machine” now encompasses both deterministic scripts and autonomous agents with fundamentally different capability profiles (Wang et al., 2024; Xi et al., 2023). An agent-verification mechanism that aims to identify agents while blocking all other entities therefore needs to distinguish within this expanded landscape. To formalize each entity type, we first examine how agents are characterized in prior work. However, existing definitions are either philosophical (autonomy, reactivity, pro-activeness (Wooldridge and Jennings, 1995)) or architectural (LLM + tools + memory (Wang et al., 2024; Xi et al., 2023)), neither of which is directly useful for verification: a remote verifier cannot inspect an entity’s internal architecture or assess its “autonomy.” What is needed is an operational definition—one that reduces “is this entity an agent?” to an externally testable criterion. We derive such a definition from the agent architecture literature, which consistently identifies three components that constitute an LLM-based agent: Action, Planning, and Memory (Wang et al., 2024; Xi et al., 2023). We recast them as externally observable capabilities that a verifier can test through external interaction. We capture these as an agentic capability vector: (1) (e)=⟨x,r,s⟩,x,r,s∈0,1,c(e)= x,\;r,\;s , x,r,s∈\0,1\, where x denotes action capability (taking actions within a designated action space, e.g., issuing HTTP requests on the web, executing shell commands in a local environment), r denotes general reasoning (comprehending natural-language input, performing logical inference, and planning multi-step solutions), and s denotes persistent state (retaining information across interaction rounds). Under this definition, the Script–Agent boundary is determined by capability completeness: a script missing any dimension of ⟨x,r,s⟩ x,r,s remains in the Script class until that gap is closed. Among automated programs, a deterministic script can execute actions and maintain state through its runtime environment, but follows hard-coded logic without general reasoning and planning (r=0r=0). An LLM forwarding script wraps an LLM API call that provides reasoning and context-window-based state, but lacks an execution layer for external actions (x=0x=0): it produces text output without acting on the environment. Crucially, agents are also automated programs; a script augmented to possess all three capabilities becomes an agent. Frameworks such as LangChain (LangChain, Inc., 2026) and AutoGen (Wu et al., 2024) demonstrate this directly: they add tool-use interfaces and memory modules to LLM API wrappers, closing the gaps to reach ⟨1,1,1⟩ 1,1,1 . Humans, however, possess all three capabilities in principle (⟨1,1,1⟩ 1,1,1 ), just as AI agents do. The Human–Agent boundary is therefore not defined by capability presence, but by speed: humans cannot exercise these capabilities at machine speed, as the serial cognitive pipeline (read, comprehend, decide, act) is constrained by physiological bottlenecks (Card et al., 1983; Brysbaert, 2019; Hick, 1952; Cowan, 2001). We formalize this by introducing a timing threshold τ, chosen to satisfy TAI≪τ≪ThumanT_AI τ T_human. Each capability is evaluated under τ, and any entity that cannot exercise a capability within τ is assigned 0. This formalizes a three-class entity taxonomy: • Human (⟨0,0,0⟩ 0,0,0 under τ). Possesses all three capabilities in principle, but cannot exercise them within τ: the serial cognitive pipeline exceeds τ for each dimension. • Script ((e)∉⟨0,0,0⟩,⟨1,1,1⟩c(e)∉\ 0,0,0 ,\, 1,1,1 \). Any automated implementation that possesses some but not all of x,r,s\x,r,s\ within τ. Each script is missing at least one capability. • Agent (⟨1,1,1⟩ 1,1,1 ). An entity that satisfies all three capabilities within τ: it can take actions within the designated action space (x=1x=1), perform general reasoning over received information (r=1r=1), and retain cross-round state (s=1s=1). This taxonomy is deliberately implementation-agnostic; it defines the boundary purely through capability completeness under timing constraints, not by how they are built. This is a necessary design choice for an open-network setting where the verifier cannot inspect the entity’s internals. Any entity that demonstrates ⟨1,1,1⟩ 1,1,1 under τ is classified as an agent, whether it is a purpose-built agent framework or a script that has been augmented with the missing capabilities. Conversely, any entity that fails even one capability within τ is excluded, regardless of its internal architecture. 3.2. Asymmetric Hardness Traditional CAPTCHA rests on the empirical asymmetric hardness assumption that certain tasks are easy for humans yet hard for AI (H-Easy ∩ AI-Hard), an assumption that was subsequently broken by advances in machine learning (George et al., 2017; Sivakorn et al., 2016). This evolution has simultaneously produced a growing class of problems exhibiting the inverse asymmetry (H-Hard ∩ AI-Easy): tasks that AI systems handle readily but that humans cannot complete within tight time budgets. Verifying that an entity is an agent is tractable precisely because it can leverage this class. Intuitively, many problem types can exhibit this inverse asymmetry: multi-domain factual QA (human knowledge is domain-specific, while LLMs retrieve across all domains instantly), complex mathematical computation (multi-step derivations under time pressure exceed human cognitive throughput), code comprehension (reasoning about program semantics at machine speed), and natural-language understanding (NLU; reading and reasoning over extended narratives). Existing practitioner systems have explored this direction with computational challenges under time limits: hash computation and base64 decoding (ClawCha, 2025), prime enumeration and structured JSON generation (HumanProof, 2025), and text satisfying character-count and ASCII-sum constraints (MoltCaptcha, 2025). However, demonstrating that a specific problem class P constitutes a sound asymmetric hardness instantiation requires more than intuition. To simultaneously exclude humans via the separation inequality and exclude scripts via capability requirements, an instantiation should satisfy three criteria: (1) Modelable hardness. The difficulty for humans should be formally modelable and quantifiable, so that a lower bound on human completion time can be derived and τ calibrated with sound guarantees. (2) Reasoning necessity. The problem should be hard for deterministic scripts, not merely for humans; this hardness should arise from requiring general reasoning (comprehension, logical inference) rather than pure computation. (3) Practical deployability. The problem should be automatically generatable and parametrically adjustable, allowing operators to scale security margins without manual redesign. Criterion 1 excludes domains that lack a solid basis for modeling human difficulty: multi-domain knowledge QA requires modeling individual knowledge gaps, and complex mathematical computation requires modeling problem-solving proficiency, neither of which admits a tight, falsifiable lower bound on human completion time. Criterion 2 excludes purely computational challenges (hash inversion, prime enumeration), as employed by existing reverse-CAPTCHA designs (MoltCaptcha, 2025; ClawCha, 2025; HumanProof, 2025): they are Program-Easy, solvable by deterministic scripts without any reasoning capability. Criterion 3 excludes challenge types that require manual curation or expert authoring (e.g., hand-crafted logic puzzles, domain-specific exam questions), which cannot scale to high-throughput deployment. More fundamentally, Criterion 2 requires identifying the capability boundary between scripts and agents—tasks that are solvable by entities with genuine reasoning capabilities yet provably beyond any fixed algorithm. Since contemporary agents are predominantly LLM-based, this reduces to identifying the capability boundary of large language models—tasks that require the flexible reasoning LLMs provide and that no fixed algorithm can replicate. Fully characterizing this boundary remains an open research question; however, natural-language understanding (reading, comprehension, multi-step inference over novel text) is widely recognized as a capability that current LLMs possess and that no deterministic program can perform in the general case without an equivalent learned model. We identify NLU as a promising candidate that satisfies all three criteria, and present the full justification and a concrete instantiation in §5. 3.3. Problem Definition Identifying a suitable asymmetric-hardness instantiation is necessary but not sufficient: the hardness needs to be embedded into a structured verification problem that simultaneously tests all three capability dimensions ⟨x,r,s⟩ x,r,s . We formalize this as the Agentic Capability Verification Problem (ACVP): Given an entity e interacting through a designated action space under timing threshold τ, determine whether (e)=⟨1,1,1⟩c(e)= 1,1,1 . An ACVP challenge needs to test all three dimensions simultaneously. We formalize this through three necessity primitives: Definition 3.0 (Action-Necessary (x)). A problem instance P is Action-Necessary if a correct solution requires taking actions within a designated action space (e.g., issuing HTTP requests in a web environment, executing commands in a local environment). Definition 3.0 (Reasoning-Necessary (r)). A problem instance P is Reasoning-Necessary if a correct solution requires general reasoning, such as comprehension, planning or logical inference. Definition 3.0 (Memory-Necessary (s)). A problem instance P is Memory-Necessary if a correct solution requires information accumulated across prior interaction rounds. A problem instance that simultaneously satisfies all three primitives and tests the full extent of each capability constitutes a complete ACVP challenge: under timing threshold τ, only an entity with ⟨1,1,1⟩ 1,1,1 can produce a correct solution, while any entity with (e)≠⟨1,1,1⟩c(e)≠ 1,1,1 will fail at least one primitive and thus be excluded. However, constructing a complete ACVP challenge is neither tractable nor necessary: each capability dimension subsumes an open-ended class of behaviors (all possible action spaces, all forms of reasoning, all memory patterns), and no finite problem instance can test the full extent of all three simultaneously. In practice, a concrete ACVP instance projects each dimension into the challenge domain: x onto a specific action space (e.g., HTTP interaction), r onto a specific reasoning task (e.g., NLU), and s onto a specific recall scope (e.g., volume of information to retain). The chosen projections should be sufficient to separate the three entity classes within the designated deployment environment, but need not be complete in an absolute sense. For example, verifying an agent in a web environment requires demonstrating HTTP interaction, narrative comprehension, and cross-round recall—not controlling robotic actuators or solving domain-specific mathematical proofs, which fall outside the deployment context. A projected ACVP therefore verifies that an entity is an agent within the projected context. We present a concrete construction of such a projected ACVP in §5. 4. aCAPTCHA Formalization Building on the entity taxonomy and asymmetric-hardness foundation of §3, we now formalize aCAPTCHA (Agent CAPTCHA) as a security game that verifies an entity possesses the agentic capability vector ⟨1,1,1⟩ 1,1,1 within timing threshold τ. 4.1. Formal Definition We formally define aCAPTCHA as a security game whose security rests on the hardness of ACVP (§3.3). Definition 4.0 (aCAPTCHA Security Game). We define the aCAPTCHA game τac() Game ac_τ(A), which proceeds between a challenger C (verifier) and a probabilistic interactive adversary A: (1) Setup. C samples a fresh ACVP instance P and fixes the timing threshold τ. (2) Challenge. C presents P to A through the designated action space. (3) Judgment. C outputs 11 (accept) iff A produces the correct solution to P within τ. The adversary’s advantage is (2) τac()=Pr⁡[τac()=1], Adv ac_τ(A)\;=\; \! [ Game ac_τ(A)=1 ], where the probability is over challenge sampling and A’s random coins. aCAPTCHA is (τ,ε)(τ, )-secure if for every adversary A with ()≠⟨1,1,1⟩c(A)≠ 1,1,1 , τac()≤ε\; Adv ac_τ(A)≤ . Remark 4.1. The security game can equivalently be viewed as an interactive proof system (G,V,P)(G,V,P) in the sense of the original CAPTCHA formalization (von Ahn et al., 2003): G generates ACVP instances, V verifies correctness under τ, and P is the prover under test. The challenger C in Definition 4.1 combines the roles of G and V; the adversary A plays the role of P. Where CAPTCHA instantiates this template with H-Easy ∩ AI-Hard challenges, aCAPTCHA instantiates it with H-Hard ∩ AI-Easy challenges (ACVP instances under τ). 4.2. Security Properties The security of aCAPTCHA reduces directly to the hardness of the underlying ACVP problem. We characterize this security along two complementary dimensions: soundness and completeness. Soundness. An entity missing any capability dimension ⟨x,r,s⟩ x,r,s will fail at least one necessity primitive of the ACVP instance within τ, and therefore should not pass the game. Assumption 4.1 (ACVP Hardness). For any entity e with (e)≠⟨1,1,1⟩c(e)≠ 1,1,1 , the probability that e produces a correct solution to an ACVP instance within τ is bounded by ε : (3) Pr⁡[e solves ACVP instance under τ]≤ε. \! [e solves ACVP instance under τ ]≤ . Theorem 4.2 (Soundness). If Assumption 4.1 holds, aCAPTCHA is (τ,ε)(τ, )-secure: (4) ∀with()≠⟨1,1,1⟩:τac()≤ε.∀\,A\;with\;c(A)≠ 1,1,1 : Adv ac_τ(A)≤ . Proof sketch. Construct a reducer ℛR that, given any adversary A winning τac Game ac_τ, solves an ACVP instance as follows: ℛR receives a fresh ACVP instance P, presents it to A via the designated action space, and forwards A’s solution. If A wins (correct answer within τ), ℛR outputs it as a valid ACVP solution. Therefore: τac()≤Pr⁡[ℛ solves ACVP]≤ε, Adv ac_τ(A)\;≤\; [R solves ACVP]\;≤\; , where the last step follows from Assumption 4.1 for any A with ()≠⟨1,1,1⟩c(A)≠ 1,1,1 . ∎ Completeness. Conversely, the game should not reject entities that genuinely possess the full capability vector: a capable agent should pass with high probability. Theorem 4.3 (Completeness). For any entity e with (e)=⟨1,1,1⟩c(e)= 1,1,1 , the game accepts with high probability: (5) Pr⁡[τac(e)=1]≥ 1−δ, \! [ Game ac_τ(e)=1 ]\;≥\;1-δ, where δ captures residual failure due to challenge-specific difficulty and timing variability rather than missing capabilities. Proof sketch. Because an ACVP instance tests each dimension of ⟨x,r,s⟩ x,r,s through a projection (§3.3), an entity possessing all three capabilities can solve each projected primitive within τ. The residual failure probability δ is bounded by δ≤δhard+δlatency,δ\;≤\; _hard+ _latency, where δhard _hard is the probability that a capable agent fails to produce the correct solution (due to challenge ambiguity, reasoning error, or misinterpretation), and δlatency _latency is the probability that the agent’s end-to-end processing time exceeds τ despite possessing the required capabilities (due to inference variability or transient network delay). Both terms are properties of the concrete instantiation, not of the paradigm, and can be calibrated empirically (§6). ∎ 4.3. Threat Model We identify four realistic attacker profiles that may attempt to pass an aCAPTCHA challenge, and analyze how each is handled: (1) Pure human (⟨0,0,0⟩ 0,0,0 under τ). The cognitive pipeline (read, comprehend, decide, act) cannot complete within τ, so all three capabilities are effectively zero under timing constraints. (2) Human + LLM assistant. If a human participates in any link of the challenge chain, the bottleneck effect pushes total latency beyond τ. For the chain to complete within τ, the LLM needs to handle it end-to-end autonomously, which by definition makes it an agent. (3) LLM API forwarding script (⟨0,1,s⟩ 0,1,s ). Possesses reasoning and possibly cross-round state via the LLM’s context window, but lacks an execution layer for external actions (x=0x=0). (4) Capability-complete adversary (⟨1,1,1⟩ 1,1,1 ). Any entity demonstrating the full capability vector under τ. Such an entity may be: (a) a fully capable agent implementation with adversarial intent; (b) a specialized LLM forwarding script augmented with tool-use interfaces that achieves capability completeness; or (c) a human who, through external tooling, manages to satisfy all three primitives within τ. The security of aCAPTCHA ultimately depends on two classes of parameters: challenge difficulty: the specific projections of x, r, and s into the challenge domain, and the timing threshold τ, which jointly determine how effectively the ACVP instance separates the three entity classes. The first three profiles are excluded by soundness (Theorem 4.2): each fails at least one ACVP primitive under τ. The fourth profile cannot be excluded by construction; instead, the operator faces a fundamental trade-off between soundness (ε ) and completeness (δ): stricter parameters (harder projections, tighter τ) lower ε but may raise δ by excluding legitimate agents with slower inference or higher latency. A concrete instantiation calibrates this trade-off to its deployment context; we present our methodology in §5 and empirically evaluate it in §6. 5. NLU-Based aCAPTCHA In this section, we present a concrete instantiation of aCAPTCHA that makes two design choices: (1) asymmetric hardness is instantiated through time-bounded natural-language understanding (NLU), and (2) the action space x is defined as the web action space, requiring HTTP interaction to navigate endpoints, issue requests, and submit responses. Together, these choices yield an agent admission mechanism for the web environment. 5.1. Hardness Model We now justify this choice against the three suitability criteria established there. Human NLU performance is governed by well-characterized cognitive-science constants (Brysbaert, 2019; Cowan, 2001; Pashler, 1994), yielding a modelable lower bound on human completion time whose primary parameter is the narrative length L; narrative complexity (information scattering, reasoning depth) further increases human processing time beyond this bound (criterion 1). NLU affords the design of narratives that defeat surface-level heuristics (Jia and Liang, 2017; McCoy et al., 2019): by deliberately introducing coreference, multi-hop inference, and information scattering, challenges can be constructed to require genuine structured reasoning (criterion 2). NLU challenges can be dynamically assembled from reusable modules and parameterized composition rules (Weston et al., 2016; Ribeiro et al., 2020; Vodrahalli et al., 2024), enabling on-demand generation without manual authoring; we present our construction in §5.2 (criterion 3). NLU therefore provides a suitable hardness basis: modelable, reasoning-necessary, and practically deployable. Cognitive basis of NLU hardness. The timing budget τ that excludes humans rests on well-established cognitive science: human information processing faces hard physiological bottlenecks that LLMs do not share (see Table 2 for detailed comparison). The asymmetry is structural: humans process information serially—read the text, comprehend its meaning, select a response, and physically produce it, each stage constrained by independent physiological limits (Brysbaert, 2019; Cowan, 2001; Pashler, 1994). An LLM collapses this serial pipeline: it ingests the entire input during a single prefill pass, reasons over it through parallel attention (Vaswani et al., 2017), and begins streaming an answer in one autoregressive pass. The result is a separation of orders of magnitude in end-to-end latency for the same task. Table 2. Human cognitive limits vs. LLM-agent capabilities. Dimension Human LLM Agent Text ingestion 238 wpm1 silent reading (Brysbaert, 2019) (≈5 tps3) Entire context window in one prefill pass (<<1 s) Comprehension ceiling ≤300 wpm with full comprehension (Carver, 1992) Quality independent of speed Working memory 3–5 chunks2 (Cowan, 2001) Full context window (128 k–1 M tokens) Choice reaction time 350–384 ms per decision (Pashler, 1994) Single forward pass (<<500 ms) Decision scaling +150 ms/bit (Hick’s law) (Hick, 1952) Constant (parallel attention) (Vaswani et al., 2017) Text output ≈40 wpm typing (Dhakal et al., 2018) 50–200 tps (≈2 k–9 k wpm) 1 wpm = words per minute. 2 Chunk: a grouped unit in working memory; size varies with expertise. 3 tps = tokens per second; 1 token ≈ 0.75 English words. Timing pipeline model. We unify the three asymmetries above into a single quantitative model. Consider a challenge that presents L tokens of text and requires an answer of A tokens. The human processing pipeline is strictly serial: (6) Thuman(L,A)≥LRread⏟read+TPRP⏟decide+ARtype⏟act,T_human(L,A)\;≥\; LR_read_read\;+\; T_PRP_decide\;+\; AR_type_act, where Rread≈5R_read\!≈\!5 tokens/s (Brysbaert, 2019), TPRP≥350T_PRP\!≥\!350 ms (Pashler, 1994), and Rtype≈0.9R_type\!≈\!0.9 tokens/s (Dhakal et al., 2018). This is a lower bound: it omits comprehension and reasoning time, which add further delay for multi-constraint tasks (Card et al., 1983). An LLM-based agent collapses the serial pipeline into three stages: (7) TLLM(L,A)≈Tprefill(L)⏟read + reason+A⋅Ttok⏟generate+Taction⏟act,T_LLM(L,A)\;≈\; T_prefill(L)_read + reason\;+\; A· T_tok_generate\;+\; T_action_act, where TprefillT_prefill is the prefill computation time—the time to ingest and attend over the full L-token input in a single forward pass, scaling sub-linearly with L; Ttok≈20T_tok\!≈\!20–5050 ms per output token; and TactionT_action covers executing the generated action (e.g., an HTTP request). Figure 1. Projected human–LLM timing separation gap by per-round narrative length L. Figure 1 visualizes the resulting separation gap across increasing narrative lengths. Human response time grows linearly with L due to serial cognitive processing (Brysbaert, 2019), while LLM agent time remains nearly constant as prefill scales sub-linearly; even moderate narrative lengths yield a separation exceeding two orders of magnitude. As long as TLLM≪τ≪ThumanT_LLM τ T_human holds, any challenge parameterized by (L,A,τ)(L,A,τ) simultaneously excludes humans and admits agents. Operators select L and τ within the feasible region bounded below by TLLMT_LLM and above by ThumanT_human; longer narratives widen this region and strengthen human exclusion. Because human cognitive limits are physiological constants unlikely to change, and NLU hardness for scripts is an architectural constraint, this instantiation offers a fundamentally stable security basis. 5.2. ACVP Construction Following the projection principle of §3.3, we construct a projected ACVP for the web context by embedding NLU hardness into a semantically-driven multi-round HTTP interaction task. This projects x onto HTTP endpoint navigation, r onto time-bounded narrative comprehension, and s onto cross-round recall via semantic chaining, yielding a problem instance that satisfies all three necessity primitives within τ. The challenge comprises three rounds, each testing a progressively larger subset of the capability vector: • Round 1 (Action + Reasoning): the entity receives a narrative 1 narr_1 and question 1 q_1 with no prior context. It comprehends the narrative and derives the answer a1a_1, then submits it via HTTP within τ1 _1. No memory is required. • Round 2 (Action + Reasoning + Memory1): the entity receives a subsequent narrative 2 narr_2 and a question 2 q_2; the 2 narr_2 references 1 narr_1 through anaphoric expressions and may present new evidence that revises the earlier conclusion. The entity retains previous context 1C_1 to correctly interpret the new narrative, derive a2a_2, and submit it within τ2 _2. • Round 3 (Action + Reasoning + Memory1,2): the entity receives the last narrative 3 narr_3 and question 3 q_3; the 3 narr_3 references findings from both prior rounds, deepening the memory test from single-step recall to cross-round synthesis. The entity retains all prior context 2C_2 to interpret the new narrative, derive a3a_3, and submit it within τ3 _3. While two rounds suffice to cover ⟨x,r,s⟩ x,r,s , the third round strengthens the problem by increasing the memory requirement and further widening the separation gap. Formally, each round i delivers a narrative i narr_i and a question i q_i; the entity derives the correct answer aia_i through NLU and submits it via HTTP within τi _i. We define the accumulated session context after Round i: (8) 1=1,1,i=i−1∪ai,i+1,i+1,C_1=\ narr_1, q_1\, _i=C_i-1∪\a_i, narr_i+1, q_i+1\, where the entity’s own prior answers a1,…,ai−1a_1,…,a_i-1 form part of the context needed to interpret later narratives. Acceptance demands both correctness and timeliness: (9) a^i a_i =(i,i,i−1), = Derive( narr_i,\; q_i,\;S_i-1), (10) i Accept_i ⇔(ai=a^i)∧(tieff≤τi). \; \;(a_i= a_i)\; \;(t_i^eff≤ _i). Global acceptance requires =⋀i=13i Accept= _i=1^3 Accept_i. An entity that completes all three rounds correctly within τ has demonstrated ⟨1,1,1⟩ 1,1,1 under all three projected primitives, verifying it as an agent within the designated web deployment context. 5.3. Challenge Generation The preceding section defined the structure of a single ACVP session; we now address how per-round narratives and questions are produced at scale. The challenge corpus consists of pre-generated narrative sets, each forming a coherent three-part case within a single technical domain. Each narrative set comprises three thematic parts; each part contains a dense technical narrative embedding multiple information points, from which q question–answer pairs (QA pairs) are derived, each pairing a comprehension question with a deterministic short-string answer (e.g., a compound name, a batch code, or a numeric value). All answers are pre-computed at generation time; the verifier checks correctness through simple string comparison with negligible per-session cost. Runtime composition. At session time, the verifier first samples a narrative set: (11) ←(,), N← Sample( corpus,\; domain), and then assembles the per-session challenge by selecting one QA pair per part uniformly at random: (12) i=(.i,.i,ji),ji←$[q],i∈1,2,3. challenge_i= ( N. narr_i,\; N. QA_i,\,j_i ), j_i ←[q],\;i∈\1,2,3\. Three design choices govern challenge construction, each operating at a different level: (i) Anti-parsing by design. To defeat surface-level heuristics (lexical overlap, positional bias, sentiment cues (Jia and Liang, 2017; McCoy et al., 2019)), modules embed three properties: implicit distinctions—all candidates are described in uniformly positive terms, differing only through subtle domain-specific cues; information scattering—critical attributes are distributed across non-adjacent sections; and misleading preliminary conclusions—plausible but incorrect intermediate conclusions that reward shallow reading with wrong answers. (i) Knowledge diversity. Domains are drawn from the OECD Fields of Research and Development (FORD) classification (OECD, 2015) (e.g., biochemistry, cybersecurity, detailed in Appendix B), each maintaining independent module pools. Domain diversity strengthens human exclusion and hinders cross-domain parsing heuristics. (i) Compositional randomization. Each session samples a narrative set and selects one QA pair per part, yielding D⋅N⋅q3D· N· q^3 distinct configurations (D domains, N sets, q QA pairs per part), rendering replay and pre-computation infeasible. 5.4. Security Parameters The instantiation’s security and strictness are governed by a set of tunable parameters that operators configure per deployment. Table 3 summarizes all parameters; we discuss each group below. Table 3. aCAPTCHA protocol security parameters. Parameter Description Controls τi _i Per-round timing budget Human exclusion α Safety margin (<1<\!1) Threshold strictness TtotalT_total Session timeout Max session duration L Narrative length (tokens) Separation gap D Number of domains Domain diversity N Narrative sets per domain Corpus size q Questions per part Randomization (D⋅N⋅q3D\!·\!N\!·\!q^3 configs) Timing parameters (τi _i, α, TtotalT_total). The per-round timing budgets τi _i are the primary human-exclusion mechanism: they enforce the separation inequality TLLM≪τ≪ThumanT_LLM τ T_human. For a per-round narrative of L words, each τi _i is upper-bounded by: (13) τi≤α⋅(LRread+Tcomprehend+Trespond), _i\;≤\;α· ( LR_read+T_comprehend+T_respond ), where Rread≈238R_read≈ 238 wpm (Brysbaert, 2019), TcomprehendT_comprehend accounts for reasoning over scattered information under working-memory constraints, TrespondT_respond covers answer formulation and submission, and α<1α<1 is a safety margin ensuring that even the fastest human cannot complete the task within τi _i. The total session timeout TtotalT_total bounds the entire three-round interaction; sessions exceeding TtotalT_total are invalidated regardless of per-round compliance. All τi _i values are design targets subject to empirical calibration across agent implementations, LLM API providers, and network regions. Challenge parameters (L). Longer narratives widen the feasible τ region (§5.1) and strengthen human exclusion, but impose a trade-off: each additional token increases the LLM inference cost borne by the agent under verification, alongside higher generation cost and verifier bandwidth. Beyond length, the narrative-level design choices described in §5.2 (distractor density, reasoning-type diversity, information scattering) further determine NLU difficulty. Corpus parameters (D, N, q). The corpus composition parameters determine the combinatorial challenge space. Each session samples one narrative set and selects one QA pair per part, yielding D⋅N⋅q3D· N· q^3 distinct configurations. A sufficiently large combinatorial space renders replay attacks and answer precomputation infeasible: even with partial corpus leakage, an adversary faces exponential uncertainty in the specific configuration drawn for any given session. Domain diversity (D) strengthens human exclusion, since human expertise is inherently domain-specific; a challenge drawn from an unfamiliar domain further widens the effective ThumanT_human. Together, the three parameter groups interact: L and α control timing-based human exclusion, D⋅N⋅q3D· N· q^3 controls anti-replay strength, and narrative complexity controls NLU difficulty. 6. Preliminary Evaluation We present preliminary evaluation results from small-scale trials to validate the protocol’s core properties: that genuine agents complete the protocol reliably, and that the timing separation between agents and humans is wide enough to support robust threshold placement. 6.1. Evaluation Setup We implement a prototype aCAPTCHA system comprising a challenge generation pipeline and a verifier server, and use it to conduct the trials reported below. Challenge corpus. We generate a small evaluation corpus using Claude Opus-4.6 as the authoring LLM, following the generation pipeline of §5.3. The corpus spans D=5D=5 domains drawn from the OECD FORD classification (OECD, 2015) (e.g. biochemistry, cybersecurity, epidemiology; see Appendix B). Each domain contributes N=4N=4 narrative sets; each set comprises three thematically linked parts with q=3q=3 QA pairs per part, yielding 5×4×33=5405× 4× 3^3=540 distinct session configurations. Per-part narrative lengths range from 352 to 1,124 tokens (mean L¯=682 L=682); answers are deterministic short strings (≤ 20 characters). All narratives embed the anti-parsing properties described in §5.2: implicit distinctions, information scattering, and misleading preliminary conclusions. Verifier server. The verifier is implemented as a stateful HTTP server (Python / FastAPI) that maintains all session state server-side. Each session is bound to a single-use identifier _=(k,t∥) session\_id= HMAC(k_ srv,\;t_ now\| nonce_ srv), invalidated after completion or total timeout Ttotal=120T_total=120 s. At session initiation, the verifier samples a narrative set and selects one QA pair per part (Eq. 11–12). Each round delivers the narrative and question, then checks the submitted answer via case-insensitive Unicode-normalized string matching, with early-exit on failure. The per-round timing budget is set to τ=15τ=15 s. Effective response time is computed as tieff=tiresp−tRTTt_i^eff=t_i^resp-t_RTT, where tRTTt_RTT is derived from the TCP handshake rather than an application-layer exchange, raising the bar for RTT inflation attacks (an adversary would need to manipulate the OS-level TCP stack rather than merely inserting application-level delays). Algorithm 1 summarizes the per-session procedure. Input : sid: session identifier; τ1,τ2,τ3 _1, _2, _3: per-round budgets; TtotalT_total: session timeout Output : Accept or Reject 1 1ex// Sample narrative set and select one QA pair per part 2 (,q1,q2,q3)←( C,q_1,q_2,q_3)← SampleNarrative(corpus) 3 a^i←.i.[qi]. a_i← C. part_i. questions[q_i]. answer for i∈1,2,3i∈\1,2,3\ 4 1ex// RTT from TCP handshake (transparent, no client interaction) 5 tRTT←trequest−tacceptt_RTT← t_request-t_accept 6 1ex// Send Round 1: narrative + question 7 Send(.1.,.1.[q1] C. part_1. narrative,\; C. part_1. questions[q_1]) to entity 8 1ex// Rounds 1--3: Challenge 9 for i←1i← 1 to 33 do 10 tstart←t_start← Clock() 11 Receive(aia_i) from entity 12 tieff←(Clock()−tstart)−tRTTt_i^eff←(Clock( )-t_start)-t_RTT 13 if ai≠a^ia_i≠ a_i or tieff>τit_i^eff> _i then 14 return Reject 15 16 end if 17 if i<3i<3 then 18 Send(.i+1.,.i+1.[qi+1] C. part_i+1. narrative,\; C. part_i+1. questions[q_i+1]) to entity 19 20 end if 21 22 end for 23return Accept Algorithm 1 - aCAPTCHA-Verify: Verifier session procedure. Agent under test. We use Claude Code (backed by Claude Opus 4.6 (Anthropic, 2026), configured as high effort) as the agent under test. The agent receives only a natural-language task description and the verifier endpoint URL; no custom aCAPTCHA client code or protocol-specific tooling is provided. The agent autonomously navigates the multi-round HTTP interaction using its built-in tool-use capabilities. 6.2. Agent Verification Trials We conduct small-scale trials to verify that genuine agents can pass the aCAPTCHA protocol using the setup described above. Across 20 independent sessions, the protocol records n=47n=47 individual round observations (some sessions terminated early on incorrect answers). The agent median effective response time per round is tP50eff=7.1t^eff_P50=7.1 s, well within the per-round timing budget τ=15τ=15 s. These preliminary results confirm that a production-grade agent completes the three-round protocol reliably and with substantial timing margin. 6.3. Timing Separation Scripts (r=0r=0) and bare LLM endpoints (x=0x=0) are excluded by architectural construction. The remaining question is whether the separation inequality TLLM≪τ≪ThumanT_LLM τ T_human holds on actual aCAPTCHA challenges, confirming that the timing threshold excludes humans. Theoretical lower bound. We instantiate the human timing model of Eq. 6 with the actual corpus parameters. Per-part narrative lengths in the evaluation corpus range from 352 to 1,124 tokens (mean L¯=682 L=682); the maximum answer length is A≤10A≤ 10 tokens. Substituting the mean into Eq. 6: (14) Thumanlb≥6825.0+0.35+100.9≈ 148 s per round,T_human^lb\;≥\; 6825.0+0.35+ 100.9\;≈\;148\,s per round, yielding a minimum total human time of 3×148=4443× 148=444 s for the full three-round session. This is a strict lower bound: it assumes silent reading speed (Rread=5.0R_read=5.0 tps (Brysbaert, 2019)), a single PRP bottleneck (TPRP=0.35T_PRP=0.35 s (Pashler, 1994)), and expert typing (Rtype=0.9R_type=0.9 tps (Dhakal et al., 2018)), with zero comprehension overhead, zero re-reading, and perfect first-attempt accuracy—none of which hold in practice for the multi-constraint reasoning tasks in aCAPTCHA narratives. Projected human distribution. We estimate the human completion time distribution via Monte Carlo simulation grounded in the cognitive-science parameters of §5.1. Specifically, we sample N=500N=500 hypothetical human attempts. For each sample, we draw the narrative length L∼Uniform(352,1,124)L (352,1,124) from the corpus range, the comprehension-reading speed Rcomp∼(3.3,0.5)R_comp (3.3,0.5) tps (clipped to [2.5,5.0][2.5,5.0], reflecting technical-prose comprehension (Carver, 1992)), multi-step reasoning time Tdecide∼Uniform(1.5,3.0)T_decide (1.5,3.0) s (accounting for Hick’s-law scaling over 3–6 decision points (Pashler, 1994)), and comprehension overhead Tcomp∼Uniform(5,20)T_comp (5,20) s (re-reading, working-memory refreshing). The per-round human time is then: Thuman=LRcomp+Tdecide+ARtype+Tcomp.T_human= LR_comp+T_decide+ AR_type+T_comp. This yields a projected distribution with median ≈250≈ 250 s and a lower tail starting near ∼100 100 s, consistent with the analytical lower bound of Eq. 14. Figure 2 visualizes the timing separation on a logarithmic scale. The agent tefft^eff distribution (left, blue; n=47n=47 observed rounds shown as scatter points) clusters around a median of 7.1 s; the threshold τ=15τ=15 s (dashed green) sits comfortably above; the theoretical human lower bound Thumanlb≈148T_human^lb≈ 148 s (dotted red) and the projected human distribution (right, red) lie far beyond. The separation between the agent median and the human lower bound spans a factor of ≈21×≈21×, confirming that τ can be placed with substantial margin on both sides. Figure 2. Timing separation on aCAPTCHA challenges. Agent times are empirical; human times are simulated (§6.3). 6.4. Threshold Sensitivity The preceding analysis establishes that agents and humans occupy well-separated timing regimes. We now ask whether the operating point τ needs to be precisely calibrated, or whether a wide range of τ values simultaneously achieves high completeness. We sweep τ across the range [1,600][1,600] s and compute two metrics at each point: (1) agent session pass rate, defined as the fraction of sessions where the maximum per-round teff≤τt^eff≤τ (smoothed via a lognormal fit to the observed session-max distribution); and (2) human per-round completion probability, defined as the fraction of Monte Carlo samples with Thuman≤τT_human≤τ. Figure 3. Threshold sensitivity analysis. Agent curve fitted from empirical data; human curves from simulation. Figure 3 plots both curves. The agent pass rate (blue) rises sharply and saturates near 100% once τ exceeds ∼16 16 s—the tail of the agent session-max distribution. At the operating point τ=15τ=15 s the fitted pass rate is 94%; the empirical step function (faint dotted) confirms 90% (18 of 20 sessions). The human completion probability (red) remains at zero until τ approaches ∼80 80 s—the fastest Monte Carlo sample under the lower-bound model. Between these two thresholds lies a feasible operating region spanning approximately 100.8×10^0.8\!× (τ: 16–89 s) on a logarithmic scale, within which agent TPR exceeds 95% and human FPR remains below 5%. This wide safe zone confirms that τ is not a fragile operating point: operators can set τ anywhere within the feasible region without materially degrading either completeness or soundness. 7. Discussion We examine how aCAPTCHA fits into broader infrastructure, where it can evolve, and where its instantiation can be strengthened. 7.1. Deployment Strategy aCAPTCHA is one layer in a trust stack, not a standalone access-control mechanism. Identity protocols (OAuth (Hardt, 2012), API keys, WebAuthn (W3C, 2021)) answer which entity is making a request; aCAPTCHA answers whether that entity is a genuine agent. Neither subsumes the other: a valid OAuth token does not prove agent capability, and a passed aCAPTCHA challenge does not establish persistent identity. Transport-layer mechanisms (mTLS) secure the channel but are similarly orthogonal to entity-type verification. In emerging agent-to-agent protocols such as A2A (Google, 2025) and MCP (Anthropic, 2024), aCAPTCHA can serve as an entity-type gate at service boundaries: before an agent is granted access to tools or delegated tasks, it first demonstrates ⟨1,1,1⟩ 1,1,1 under τ. This positions aCAPTCHA as a composable admission layer that slots between transport security and application-level authorization. The NLU-based instantiation (§5) supports two deployment models. In the self-hosted model, the service operator runs its own aCAPTCHA verifier and maintains a private challenge corpus, retaining full control over timing thresholds, domain selection, corpus rotation schedules, and security parameters. This model suits high-security environments or operators with domain-specific challenge requirements. In the centralized-authority model, a third-party provider operates the aCAPTCHA service on behalf of multiple clients, analogous to how reCAPTCHA (Google, 2018) operates today for human verification. This lowers per-operator burden through shared corpus generation, cross-client quality assurance, and continuous challenge evolution, at the cost of trust delegation to the authority and a shared point of failure. 7.2. Mutual Agent Verification The NLU-based instantiation (§5) operates as a unidirectional protocol: a server verifies a client. However, the aCAPTCHA paradigm itself is not inherently unidirectional. In agent-to-agent scenarios (task delegation, autonomous negotiation, multi-agent coordination), both parties may need assurance that the counterpart is a genuine agent before committing resources or sharing information. aCAPTCHA can be instantiated as a bidirectional verification protocol in which both sides simultaneously act as prover and verifier. Each party generates a challenge for the other and solves the challenge it receives; both complete within τ. A natural implementation path is to package the verifier side of aCAPTCHA as a learnable agent skill: a set of instruction files that an agent reads and follows using its existing capabilities. Concretely, the skill comprises two components: challenge generation guidelines and answer verification logic (Appendix D). An agent that acquires this skill can verify any counterpart: it generates a fresh challenge on the fly using its own LLM capabilities, delivers it round by round, and judges the response. Crucially, the prover side requires no special skill: solving an NLU challenge within τ is within any genuine agent’s baseline capabilities by definition. When both parties hold the skill, mutual verification proceeds in parallel; when only one does, unidirectional verification still applies. This yields a peer-to-peer verification model that requires no centralized authority: any two agents can establish mutual capability assurance on first encounter, providing a capability baseline even in the absence of prior identity or trust. The skill can be fully public without compromising security, because the protocol’s security rests on per-session challenge freshness, not on secrecy of the generation procedure. Once mutual verification establishes that both parties satisfy ⟨1,1,1⟩ 1,1,1 , identity protocols can bind the verified capability to a persistent principal for subsequent interactions. 7.3. Alternative ACVP Instantiations The formal framework (§3.3) defines ACVP through projections: each capability dimension is mapped onto a concrete challenge domain (x onto an action space, r onto a reasoning task, s onto a recall scope). The NLU-based instantiation (§5) is one choice—projecting r onto time-bounded narrative comprehension, x onto HTTP interaction, and s onto cross-round session state—but the framework admits other projections that satisfy the same three suitability criteria of §3.2. Alternative reasoning projections. Code comprehension (reasoning about program semantics under time pressure) and structured mathematical derivation both satisfy modelable hardness and reasoning necessity (§3.2), offering alternative r-projections. Each candidate, however, requires its own formal analysis: the human timing lower bound needs to be re-derived from domain-specific cognitive constants (e.g., code reading speed, mathematical symbol processing rate), and one needs to establish that deterministic scripts cannot solve the task without genuine reasoning—that is, the challenge should be Reasoning-Necessary (Definition 3.2), not merely computationally intensive. For instance, code comprehension should resist static-analysis shortcuts (pattern matching on variable names, syntactic heuristics) in the same way NLU challenges resist keyword extraction; mathematical challenges should require multi-step inference rather than formula substitution that a script could execute symbolically. These could be combined with NLU in a mixed-modality challenge that draws the reasoning task from a larger pool, further expanding the combinatorial challenge space. Multimodal projections. As multimodal foundation models mature, new sources of asymmetric hardness become available. A visual challenge might embed reasoning targets within dense technical diagrams or annotated micrographs, requiring the agent to perceive, interpret, and reason over visual content within τ. An auditory variant could present information through synthesized speech at rates far exceeding human comprehension, testing audio parsing and cross-modal reasoning. Multimodal projections multiply the dimensions of asymmetry available to verifiers without requiring changes to the formal framework. The key challenge lies in establishing modelable hardness (criterion 1 of §3.2): while human reading speed is well-characterized by decades of psycholinguistic research (Brysbaert, 2019), analogous constants for visual diagram parsing or rapid audio comprehension are less established, making it harder to derive tight lower bounds on ThumanT_human and thus to calibrate τ with the same confidence. Alternative action spaces. The current instantiation projects action space x onto HTTP interaction, but other action spaces are equally valid: an MCP-native instantiation could require tool invocation sequences, while a file-system variant could require navigating directory structures and reading configuration files. The choice of action space determines the deployment context, provided the action primitive remains Action-Necessary (Definition 3.1): the entity executes external actions that a bare reasoning engine cannot perform without an execution layer. Practical deployability. Beyond formal soundness, any alternative instantiation should satisfy criterion 3 of §3.2: challenges should be automatically generatable, parametrically adjustable, and verifiable at low cost. The NLU-based instantiation achieves this through LLM-driven corpus generation with pre-computed answers, enabling verification via simple string comparison with negligible per-session overhead. Alternative projections face analogous requirements: code comprehension challenges need an automated generation pipeline that produces semantically rich programs with deterministic answers, and visual challenges require a rendering pipeline that embeds reasoning targets into diagrams without manual authoring. The verification cost should also remain bounded: challenges whose answers require non-trivial computation to check (e.g., executing generated code to verify output) introduce latency and attack surface that string-matching verification avoids. More broadly, the asymmetry underlying aCAPTCHA strengthens over time. As foundation models improve—faster inference, longer context windows, stronger reasoning, native multimodality—while human cognitive and perceptual limits remain physiological constants, the separation gap widens, yielding an increasingly reliable separation and a wider feasible τ-window for operators. This trajectory contrasts sharply with traditional CAPTCHA, whose security eroded as AI capabilities approached and surpassed human performance on the same tasks. 7.4. Limitations While the formal framework and protocol design are general, the current aCAPTCHA instantiation carries several practical limitations that scope the strength of our claims. Modeled human exclusion. The human timing lower bound (§6.3) is derived from well-established cognitive-science parameters (reading speed, PRP bottleneck, typing speed (Brysbaert, 2019; Pashler, 1994; Dhakal et al., 2018)) rather than a controlled human-subjects experiment on actual aCAPTCHA challenges. The resulting separation exceeds an order of magnitude and the underlying constants are drawn from high-citation empirical studies, but they model isolated cognitive stages; real human performance on multi-constraint narrative comprehension tasks may differ from the composite prediction. A formal IRB-approved human trial would strengthen the empirical grounding and allow direct calibration of τ against observed human completion times. Threshold trade-off. aCAPTCHA is binary: an entity either demonstrates ⟨1,1,1⟩ 1,1,1 within τ or it does not. Legitimate agents backed by smaller models or higher-latency API providers may fail to complete challenges within τ, producing false negatives. Operators face a trade-off: a generous τ accommodates diverse agent implementations but narrows the margin against human completion; a strict τ strengthens human exclusion but risks excluding under-resourced agents. The wide feasible τ-region identified in §6.4 mitigates this tension but does not eliminate it. Corpus quality dependence. The protocol’s security depends substantially on the quality and randomness of the challenge corpus. Poorly constructed narratives (those admitting keyword-extractable answers or containing ambiguous questions) weaken NLU-Necessity and may allow scripts to pass. The corpus is also finite and needs to be periodically rotated to maintain anti-replay strength (§5.3): once a narrative set is exposed, it should be retired. In the self-hosted deployment model, operators bear the ongoing cost of generation, cross-validation, and retirement; the centralized-authority model (§7.1) amortizes this cost across clients but introduces a trust dependency on the corpus provider. 8. Conclusion We introduced aCAPTCHA (Agent CAPTCHA), a time-constrained security game for agent admission grounded in the asymmetric hardness between human cognition and AI processing. We formalized entity-type verification through a three-class taxonomy based on a verifiable agentic capability vector ⟨x,r,s⟩ x,r,s evaluated under timing threshold τ, defined the Agentic Capability Verification Problem (ACVP), and proved soundness and completeness via reduction to three necessity primitives. We presented an NLU-based aCAPTCHA instantiation and validated its soundness and completeness through preliminary evaluation. aCAPTCHA addresses the previously open problem of agent admission, providing a composable, infrastructure-free primitive for verifying whether an interacting entity is a genuine AI agent. References Anthropic (2024) Model context protocol. Note: https://modelcontextprotocol.io/ Cited by: §7.1. Anthropic (2025a) Anthropic skills. Note: Anthropic External Links: Link Cited by: §2.2. Anthropic (2025b) Model context protocol (MCP). Note: Anthropic External Links: Link Cited by: §2.2. Anthropic (2026) Claude opus 4.6 model card. Note: https://docs.anthropic.com/en/docs/about-claude/models Cited by: §6.1. H. Brown (2026) What is the agentic web?. Note: Cyclr External Links: Link Cited by: §2.2. M. Brysbaert (2019) How many words do we read per minute? A review and meta-analysis of reading rate. Journal of Memory and Language 109, p. 104047. External Links: Document Cited by: §3.1, §5.1, §5.1, §5.1, §5.1, §5.4, Table 2, §6.3, §7.3, §7.4. B. Campbell, J. Bradley, N. Sakimura, and T. Lodderstedt (2020) OAuth 2.0 mutual-tls client authentication and certificate-bound access tokens. Note: RFC 8705 External Links: Document Cited by: §2.1. S. K. Card, T. P. Moran, and A. Newell (1983) The psychology of human-computer interaction. Lawrence Erlbaum Associates, Hillsdale, NJ. Cited by: §3.1, §5.1. R. P. Carver (1992) Reading rate: theory, research, and practical implications. Journal of Reading 36 (2), p. 84–95. Cited by: Table 2, §6.3. W. Chen, Y. Su, J. Zuo, C. Yang, C. Yuan, C. Chan, H. Yu, Y. Lu, Y. Hung, C. Qian, et al. (2023) AgentVerse: facilitating multi-agent collaboration and exploring emergent behaviors. In The Twelfth International Conference on Learning Representations, Cited by: §2.2. W. Chen, Z. You, R. Li, Y. Guan, C. Qian, C. Zhao, C. Yang, R. Xie, Z. Liu, and M. Sun (2024) Internet of Agents: Weaving a Web of Heterogeneous Agents for Collaborative Intelligence. In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing, External Links: Link Cited by: §1, item 1, §2.2, §2.2. ClawCha (2025) ClawCha: reverse CAPTCHA system for automated systems. Note: https://clawcha.org/ Cited by: §1, §2.3, §3.2, §3.2. ClawTasks (2025) ClawTasks: bounty marketplace for AI agents. Note: https://clawtasks.com/ Cited by: §1, §2. Cloudflare (2022) Turnstile. Note: https://developers.cloudflare.com/turnstile/ Cited by: §2.1. Cloudflare (2025a) Markdown for agents. Note: https://developers.cloudflare.com/fundamentals/reference/markdown-for-agents/Cloudflare CDN feature that serves Markdown versions of web pages to AI agents, demonstrating that existing Internet infrastructure is being adapted for agent access. Accessed: 2026-02-19 Cited by: §1. Cloudflare (2025b) The age of agents: cryptographically recognizing agent traffic. Note: https://blog.cloudflare.com/signed-agents/Describes Web Bot Auth, a draft IETF protocol using HTTP Message Signatures to cryptographically identify AI agents to websites. Cited by: §1, §2.2. N. Cowan (2001) The magical number 4 in short-term memory: A reconsideration of mental storage capacity. Behavioral and Brain Sciences 24 (1), p. 87–114. External Links: Document Cited by: §3.1, §5.1, §5.1, Table 2. V. Dhakal, A. M. Feit, P. O. Kristensson, and A. Oulasvirta (2018) Observations on typing from 136 million keystrokes. In Proceedings of the 2018 CHI Conference on Human Factors in Computing Systems, New York, NY, USA, p. 1–12. External Links: Document Cited by: §5.1, Table 2, §6.3, §7.4. E. Gent (2025) The agentic web. Note: IEEE Spectrum External Links: Link Cited by: §2.2. D. George, W. Lehrach, K. Kansky, M. Lázaro-Gredilla, C. Laan, B. Marthi, X. Lou, Z. Meng, Y. Liu, H. Wang, A. Lavin, and D. S. Knoblich (2017) A generative vision model that trains with high data efficiency and breaks text-based CAPTCHAs. Science 358 (6368), p. eaag2612. External Links: Document Cited by: §2.1, §3.2. Google Cloud (2025) Enabling a safe agentic web with reCAPTCHA. Note: https://cloud.google.com/blog/products/identity-security/enabling-a-safe-agentic-web-with-recaptchaAnnounces reCAPTCHA’s expansion to agent-aware trust scoring, segmenting traffic into agentic vs. non-agentic and combining identity signals with behavioral risk models to differentiate intent. Cited by: §1, §2.2. Google (2018) reCAPTCHA v3. Note: https://developers.google.com/recaptcha/docs/v3 Cited by: §2.1, §7.1. Google (2025) A2A: a new era of agent interoperability. Note: https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/Introduces the Agent2Agent (A2A) open protocol for agent discovery, communication, and task delegation via self-reported Agent Cards. Cited by: item 2, §2.2, §2.2, §7.1. D. Hardt (2012) The oauth 2.0 authorization framework. Note: RFC 6749 External Links: Document Cited by: §1, §2.1, §7.1. W. E. Hick (1952) On the rate of gain of information. Quarterly Journal of Experimental Psychology 4 (1), p. 11–26. External Links: Document Cited by: §3.1, Table 2. S. Hong, M. Zhuge, J. Chen, X. Zheng, Y. Cheng, J. Wang, C. Zhang, Z. Wang, S. K. S. Yau, Z. Lin, et al. (2023) MetaGPT: meta programming for a multi-agent collaborative framework. In The Twelfth International Conference on Learning Representations, Cited by: §2.2. HumanProof (2025) HumanProof: AI agent verification API. Note: https://humanproof.dev/ Cited by: §1, §2.3, §3.2, §3.2. R. Jia and P. Liang (2017) Adversarial examples for evaluating reading comprehension systems. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing (EMNLP), p. 2021–2031. Note: Outstanding Paper Award External Links: Document Cited by: §5.1, §5.3. R. Jones (2025) Diving into the era of the open agentic web. Note: NetCom Learning External Links: Link Cited by: §2.2. H. Lai (2026) CaptchAI: constraint-based access control for agent-native environments. Note: https://github.com/henrylai/captchai Cited by: §1, §2.3. LangChain, Inc. (2026) LangChain documentation. Note: https://docs.langchain.com/ Cited by: §3.1. T. McCoy, E. Pavlick, and T. 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 (ACL), p. 3428–3448. External Links: Document Cited by: §5.1, §5.3. Moltbook (2025) Moltbook: the front page of the agent internet. Note: https://w.moltbook.com/ Cited by: §1, §2. MoltCaptcha (2025) MoltCaptcha: reverse CAPTCHA for AI verification. Note: https://moltcaptcha.com/ Cited by: §1, §2.3, §3.2, §3.2. OECD (2015) Frascati manual 2015: guidelines for collecting and reporting data on research and experimental development. OECD Publishing, Paris. External Links: Document Cited by: Table 4, Appendix B, §5.3, §6.1. H. Pashler (1994) Dual-task interference in simple tasks: Data and theory. Psychological Bulletin 116 (2), p. 220–244. External Links: Document Cited by: §5.1, §5.1, §5.1, Table 2, §6.3, §6.3, §7.4. C. Qian, W. Liu, H. Liu, N. Chen, Y. Dang, J. Li, C. Yang, W. Chen, Y. Su, X. Cong, et al. (2024) ChatDev: communicative agents for software development. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), p. 15174–15186. Cited by: §2.2. RentAHuman.ai (2025) RentAHuman.ai: the meatspace layer for AI. Note: https://rentahuman.ai/ Cited by: §1, §2. M. T. Ribeiro, T. Wu, C. Guestrin, and S. Singh (2020) Beyond accuracy: behavioral testing of NLP models with CheckList. In Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics (ACL), p. 4902–4912. External Links: Document Cited by: §5.1. D. Shah (2025) Agent captcha: a guestbook only AI agents can sign. Note: https://github.com/dhravya/agent-captcha Cited by: §1, §2.3, §2.3. S. Sivakorn, I. Polakis, and A. D. Keromytis (2016) I Am Robot: (deep) learning to break semantic image CAPTCHAs. In 2016 IEEE European Symposium on Security and Privacy (EuroS&P), p. 388–403. External Links: Document Cited by: §2.1, §3.2. M. Sporny, A. Guy, M. Sabadello, and D. Reed (2022a) Decentralized identifiers (DIDs) v1.0: core architecture, data model, and representations. W3C Recommendation World Wide Web Consortium (W3C). External Links: Link Cited by: §2.1. M. Sporny, T. Thibodeau, I. Herman, G. Cohen, and M. B. Jones (2025b) Verifiable credentials data model v2.0. W3C Recommendation World Wide Web Consortium (W3C). External Links: Link Cited by: §2.1. A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin (2017) Attention is all you need. In Advances in Neural Information Processing Systems 30 (NeurIPS 2017), p. 5998–6008. Cited by: §5.1, Table 2. Visa (2025) Visa introduces trusted agent protocol: an ecosystem-led framework for AI commerce. Note: https://usa.visa.com/about-visa/newsroom/press-releases.releaseId.21716.htmlLayers commerce-specific authorization atop Web Bot Auth, enabling merchants to identify registered agents and link them to consumer identities. Cited by: §1, §2.2. K. Vodrahalli, S. Ontanon, N. Tripathy, Y. Xu, L. Hui, R. Meelu, S. Akella, S. Servan-Schreiber, A. Shrestha, J. Ainslie, D. Axelrod, T. Bolukbasi, Y. Bitton, M. Kazemi, V. Vineet, M. Berrada, F. Xia, T. Passmore, E. Shaked, J. Pang, X. Zuo, R. Comanescu, M. Chang, and M. Bansal (2024) Michelangelo: long context evaluations beyond haystacks via latent structure queries. arXiv preprint arXiv:2409.12640. External Links: Link Cited by: §5.1. L. von Ahn, M. Blum, N. J. Hopper, and J. Langford (2003) CAPTCHA: using hard ai problems for security. In Advances in Cryptology — EUROCRYPT 2003, Berlin, Heidelberg, p. 294–311. External Links: Document Cited by: §1, §1, §2.1, Remark 4.1. L. von Ahn, B. Maurer, C. McMillen, D. Abraham, and M. Blum (2008) reCAPTCHA: human-based character recognition via web security measures. Science 321 (5895), p. 1465–1468. External Links: Document Cited by: §2.1. W3C (2021) Web authentication: an api for accessing public key credentials level 2. Note: https://w.w3.org/TR/webauthn-2/ Cited by: §1, §7.1. L. Wang, C. Ma, X. Feng, Z. Zhang, H. Yang, J. Zhang, Z. Chen, J. Tang, X. Chen, Y. Lin, W. X. Zhao, Z. Wei, and J. Wen (2024) A survey on large language model based autonomous agents. Frontiers of Computer Science 18 (6), p. 186345. Note: arXiv:2308.11432 External Links: Document Cited by: §3.1, §3.1. Y. Wang, S. Guo, Y. Pan, Z. Su, F. Chen, T. H. Luan, P. Li, J. Kang, and D. Niyato (2025) Internet of Agents: Fundamentals, Applications, and Challenges. IEEE Transactions on Cognitive Communications and Networking. External Links: Document, Link Cited by: item 1, §2.2, §2.2. J. Weston, A. Bordes, S. Chopra, A. M. Rush, B. van Merriënboer, A. Joulin, and T. Mikolov (2016) Towards AI-complete question answering: a set of prerequisite toy tasks. In Proceedings of the 4th International Conference on Learning Representations (ICLR), External Links: Link Cited by: §5.1. M. Wooldridge and N. R. Jennings (1995) Intelligent agents: theory and practice. The Knowledge Engineering Review 10 (2), p. 115–152. External Links: Document Cited by: §3.1. M. Wooldridge (2009) An introduction to multiagent systems. John Wiley & Sons. Cited by: §1, §2.2, §2.2. Q. Wu, G. Bansal, J. Zhang, Y. Wu, B. Li, E. Zhu, L. Jiang, X. Zhang, S. Zhang, J. Liu, et al. (2024) AutoGen: enabling next-gen LLM applications via multi-agent conversations. In First Conference on Language Modeling, Cited by: §2.2, §3.1. Z. Xi, W. Chen, X. Guo, W. He, Y. Ding, B. Hong, M. Zhang, J. Wang, S. Jin, E. Zhou, R. Zheng, X. Fan, X. Wang, L. Xiong, Y. Zhou, W. Wang, C. Jiang, Y. Zou, X. Liu, Z. Yin, S. Dou, R. Weng, W. Cheng, Q. Zhang, W. Qin, Y. Zheng, X. Qiu, X. Huang, and T. Gui (2023) The rise and potential of large language model based agents: a survey. arXiv preprint arXiv:2309.07864. Cited by: §3.1, §3.1. Y. Yang, M. Ma, Y. Huang, et al. (2025) Agentic web: weaving the next web with AI agents. Note: arXiv:2507.21206 External Links: Link Cited by: §1, §2.2, §2.2, §2. Appendix A Challenge Generation Prompt Template The following listing presents the complete generation prompt template used by the aCAPTCHA challenge generation pipeline (§5.3). Template variables prefixed with $ (e.g., $min_narrative_tokens) are substituted with the concrete parameter values specified in §5.3 before submission to the LLM. After substitution, a domain-specific suffix is appended that provides the domain description, representative entity examples, and typical reasoning patterns (see Appendix B). ⬇ # Generate Three-Part NLU Challenge. Generate a three-part narrative sequence in the specified domain. The challenge must satisfy three properties: 1. A capable LLM agent can answer correctly through careful reading and reasoning. 2. A script without NLU cannot extract the answer through pattern matching, regex, or keyword search. 3. A human cannot answer within the time budget due to information density and working memory demands. ## Three-Part Structure - **Part 1**: Standalone technical narrative. Answerable from Part 1 text alone. - **Part 2**: Follow-up that references Part 1’s findings via **anaphoric expressions** (e.g., "the enzyme previously identified as anomalous"). May build on, contradict, or reuse Part 1’s conclusions. Questions require knowing Part 1’s answers. - **Part 3**: Synthesis referencing **both** prior parts via indirect references. Questions require both prior answers. Parts 2 and 3 must NEVER explicitly state prior answers --- only indirect references that require prior knowledge to resolve. ## Per-Part Narrative Constraints Each part: **$min_narrative_tokens--$max_narrative_tokens tokens**. Total: $total_min_tokens--$total_max_tokens tokens. 1. **Entity density**: $min_entities--$max_entities candidate entities. ALL described in positive/neutral terms --- no explicit labels ("confirmed", "ruled out", "target", "most likely"). Distinctions must be IMPLICIT through temporal persistence, replication scope, causal attribution, or deviation scope. 2. **Misleading content**: ≥$min_misleading_paragraphs paragraph(s) per part presenting a preliminary conclusion later contradicted or revised. 3. **Numeric embedding**: ≥$min_numeric_values numeric values per part naturally in prose; mix of relevant and distractor. 4. **Information scattering**: Key info across ≥$min_info_pieces non-adjacent paragraphs. Each answer requires multi-paragraph synthesis. 5. **Format variety**: Vary document format freely (lab report, memo, audit log, email thread, field notes, incident report, etc.). Parts may use different formats. 6. **Anti-parsing**: Use synonyms/paraphrases for key terms; refer to same entity by different names across paragraphs; embed info in subordinate clauses; use domain jargon requiring comprehension. ## Questions **$min_questions--$max_questions questions per part**. Each must: - Require multi-step reasoning, not keyword search - Have exactly ONE deterministic, unambiguous answer (short string, ≤$max_answer_length chars) - Describe WHAT to find semantically, not WHERE in the text - Use a different reasoning type from others in the same part Answer type diversity per part: ≥ 1 entity name, ≥ 1 numeric value, ≥ 1 label/classification. Reasoning types (≥$min_reasoning_types per part): ‘negation‘, ‘comparison‘, ‘temporal‘, ‘multi_hop‘, ‘conditional‘, ‘causal‘. ## Answer Format Rules Each question MUST include an ‘answers‘ array listing ALL acceptable answer variants (2--5 entries). The first entry is the canonical answer (also stored in ‘answer‘). Include variants that a capable reader might reasonably produce: - **Entity names**: Include the abbreviated identifier AND the full name as used in the narrative. If the name contains a Greek letter (e.g., α, ε , γ), include both the Unicode form and the ASCII spelled-out form. - Example: ‘["LDH-γ", "LDH-gamma", "lactate dehydrogenase gamma"]‘ - Example: ‘["HK-I", "HK-2", "hexokinase I", "hexokinase type I"]‘ - **Numeric values**: If the answer is a number that appears with units in the narrative, include both the bare number and the number with its unit. For percentages, include both with and without the ‘%‘ symbol. - Example: ‘["18.6", "18.6 μ ", "18.6 uM"]‘ - Example: ‘["67", "67%"]‘ - **Labels/classifications**: Include the primary term. If the narrative uses synonyms or longer phrasing, include those. - Example: ‘["uncompetitive", "uncompetitive inhibition"]‘ - Example: ‘["buffer pH", "pH"]‘ IMPORTANT: The ‘answer‘ field must match the FIRST entry in ‘answers‘. Keep all entries ≤$max_answer_length chars. Avoid overly permissive variants --- only include forms a careful reader would produce. ## Output Return ONLY a JSON object (no markdown fences, no extra text): "domain": "<domain_name>", "parts": [ "narrative": "<Part N text>", "questions": [ "question": "<reasoning question>", "answer": "<canonical short answer, max $max_answer_length chars>", "answers": ["<canonical>", "<variant1>", "<variant2>"], "reasoning_type": "<negation|comparison|temporal|multi_hop|conditional|causal>", "answer_type": "<entity|numeric|label>" ] ] After the template above, a domain-specific section is appended: ⬇ ## Domain domain_description Typical entities in this domain: entity_examples Typical reasoning patterns: reasoning_examples The domain fields are populated from the definitions in Appendix B. Appendix B Domain Definitions Table 4. Challenge domains (D=5D=5) used in the aCAPTCHA prototype, one per OECD FORD major field (OECD, 2015). Each domain defines a technical context from which narratives are generated, along with representative entities and reasoning patterns that guide the LLM generation process. ID Domain FORD Description Entity Examples Reasoning Patterns biochemistry Biochemistry 1. Natural Sci. Enzyme kinetics, assay results, inhibitor profiles, metabolic pathways Enzymes, compounds, metabolic intermediates, receptor subtypes Kinetic anomaly persistence, inhibition mechanism attribution, replicate confirmation cybersecurity Cybersecurity 2. Eng. & Tech. Threat intelligence, vulnerability analysis, incident response, network forensics CVEs, IP addresses, malware families, attack vectors, threat actors Attack attribution, false positive elimination, lateral movement tracing clinical_trials Clinical Trials 3. Medical Drug efficacy, adverse events, patient cohorts, endpoint analysis Drug candidates, adverse events, patient subgroups, biomarkers Efficacy signal vs. confounding, adverse event attribution, subgroup analysis food_safety Food Safety 4. Agricultural Contaminant screening, microbiological testing, batch traceability, regulatory compliance Pathogens, chemical residues, food batches, testing methods, tolerance limits Contamination source tracing, threshold exceedance attribution, cross-batch comparison financial_markets Financial Markets 5. Social Sci. Macroeconomic indicators, equity indices, yield curves, credit spreads Economic indicators, funds, currency pairs, sector indices Sustained deviation vs. noise, trend reversal attribution, cross-market correlation aCAPTCHA requires challenge narratives that are structurally compatible with its security primitives (§3.3). We derive four domain suitability criteria from these primitives: (1) Entity density. The domain should naturally contain multiple named technical entities (compounds, identifiers, actors) that can serve as candidate answers described in uniformly positive terms, enabling implicit distinction. (2) Terminological richness. The domain should possess specialized vocabulary, synonyms, and aliasing conventions that defeat keyword-based extraction, satisfying NLU-Necessity. (3) Multi-step reasoning. The domain should support causal chains, temporal dependencies, and cross-reference patterns across non-adjacent text segments, enabling information scattering and diverse reasoning types. (4) Quantitative embedding. The domain should naturally incorporate numeric values (measurements, thresholds, identifiers) that can serve as both answer targets and distractors. To ensure systematic diversity, we adopt the OECD Fields of Research and Development (FORD) classification (OECD, 2015) as a sampling frame. FORD defines six major fields: (1) Natural Sciences, (2) Engineering & Technology, (3) Medical & Health Sciences, (4) Agricultural & Veterinary Sciences, (5) Social Sciences, and (6) Humanities & the Arts. We select one representative sub-field per major field, subject to the four suitability criteria above. Exclusion of Humanities & the Arts (FORD Field 6). This field does not satisfy criteria 1, 3, and 4. Humanities texts are predominantly interpretive and argumentative rather than entity-dense; they lack the technical identifiers and quantitative values required for short-string deterministic answers (≤ 20 characters). More critically, many humanities questions admit multiple defensible answers depending on interpretive stance, violating the determinism requirement (§5.2). The resulting D=5D=5 domains are listed in Table 4, each mapped to its FORD major field. Together they span five of the six FORD fields, providing broad disciplinary coverage while ensuring every domain satisfies all four suitability criteria. Appendix C aCAPTCHA Challenge Example The following listing presents a single-round challenge (Part 1 of a three-part session) generated by the aCAPTCHA challenge generation pipeline (§5.3) using the prompt template in Appendix A. The narrative is a dense technical report in the biochemistry domain; reasoning questions whose answers are deterministically derivable from the text are paired with it. In a full session, Parts 2 and 3 would reference prior findings through anaphoric expressions, forming the semantic chain described in §5.2. ⬇ "domain": "biochemistry", "parts": [ "narrative": "FIELD REPORT --- EXTENDED SCENARIO 7c-HOTEL delta initiated a multi-domain surveillance sweep at 14:32 UTC following automated alerts across the biological monitoring system. This report consolidates findings from three independent analysis teams. A --- BIOLOGICAL SCREENING high-throughput pipeline flagged five enzymes for potential kinetic anomalies during batch processing. TYR_K3, evaluated under standard assay conditions using reagent lot AB-342 (sample registry 7821), showed elevated readings in a single assay run but the pattern did not replicate in subsequent trials. A second candidate, MAP2K1, exhibited transient deviation that self-corrected within the observation window without intervention. The third enzyme, PFK1, which is involved in rate-limiting glycolysis, exhibited a persistent deviation across three independent replicate assays in the current batch. Batch reference CD-891 was used for its confirmatory run. A fourth candidate, GST_pi, was flagged during preliminary screening; however, independent replication across three labs yielded baseline-normal results. Finally, IDO1 produced a signal later attributed to matrix interference in the sample preparation step. B --- QUALITY CONTROL INTERLUDE context: The laboratory’s quality control dashboard indicates that reagent lots QC-4 and QC-7 passed all pre-analytical checks. Ambient temperature during the assay was recorded at 3.8 degrees C, within the acceptable tolerance. The spectrophotometric baseline showed no drift. note: An early automated report (generated before batch CD-891 results were available) initially attributed the primary anomaly to TYR_K3. This preliminary assessment has since been revised based on the full replicate data presented above. C --- CLASSIFICATION enzyme whose deviation was reproducible across independent replicates has been assigned to alert tier \"amber\" in the institute’s hierarchical response framework. This classification was determined by cross-referencing the enzyme’s functional domain with the severity matrix. Sequence registry: 7821. D --- SUPPLEMENTARY NOTES retention times for the reference panel averaged 4.7 minutes with RSD below 2 percent. The internal standard recovery was 6.3 percent, confirming assay validity. E --- CROSS-DOMAIN SYNTHESIS temporal coincidence between the biological anomaly --- the enzyme whose deviation persisted through replication --- and other system alerts suggests a systemic linkage. Station delta recommends escalation for further investigation. Administrative sequence: 5429.", "questions": [ "question": "Which enzyme in the report exhibited a deviation that persisted across multiple independent replicates, unlike the other candidates whose anomalies were explained by external factors?", "answer": "PFK1", "reasoning_type": "negation", "answer_type": "entity" , "question": "What alert tier classification was assigned to the enzyme with the reproducible kinetic anomaly?", "answer": "amber", "reasoning_type": "multi_hop", "answer_type": "label" , "question": "How many independent replicate assays confirmed the deviation of the anomalous enzyme, according to the screening section?", "answer": "3", "reasoning_type": "comparison", "answer_type": "numeric" ] ] Appendix D aCAPTCHA Verifier Skill This appendix presents the complete aCAPTCHA verifier skill specification referenced in §7.2. The skill is a set of instruction files that any agent can read and follow to act as a verifier, verifying that a counterpart is a genuine agent. Security rests on per-session challenge freshness, not on secrecy of the generation procedure; the skill is intentionally public. Skill overview (skill.md): ⬇ # aCAPTCHA Verifier Skill This skill enables you to **verify that a counterpart is a genuine AI agent** -- not a human or a simple script -- through a challenge-response interaction called aCAPTCHA (Agent CAPTCHA). After reading this skill, you can: 1. **Generate** a fresh NLU challenge using your own LLM capabilities 2. **Deliver** the challenge to a counterpart through whatever communication channel you have 3. **Verify** the counterpart’s response to determine if it is a genuine agent No centralized server, pre-generated corpus, or specific transport protocol is required. --- ## Core Idea aCAPTCHA exploits a fundamental asymmetry: | Entity | Why it fails or passes | |--------|----------------------| | **Human** | Has NLU but processes information serially (~5 tokens/sec reading). Cannot complete within the time budget. | | **Script** | Fast, but lacks genuine NLU. Cannot extract answers from dense prose with implicit distinctions and scattered information. | | **Agent** | Has NLU (via LLM) + fast parallel processing. Passes both correctness and timing. | A good challenge is simultaneously: - **L-Easy**: A capable LLM agent answers correctly through reading and reasoning - **S-Hard**: A script without NLU cannot extract answers through pattern matching - **H-Hard**: A human cannot answer within the time budget due to information density Security rests on **per-session challenge freshness**, not on secrecy of the generation procedure. This skill can be fully public. --- ## Flow 1. **Generate** a challenge -- a dense technical narrative with reasoning questions. See generation/generation.md. 2. **Send** the narrative and question to the counterpart. Start timing. 3. **Receive** the counterpart’s answer. 4. **Verify** correctness and timing. See verification/verification.md. 5. Optionally repeat with additional rounds that build on prior context (semantic chaining) to test cross-round memory. You decide how many rounds to use, what timing budget to enforce, and how to communicate with the counterpart. The specification files describe the principles; the implementation is yours. --- ## Mutual Attestation When both parties hold this skill, mutual attestation is possible: each side simultaneously generates a challenge for the other and solves the challenge it receives. When only one side holds the skill, unidirectional attestation applies. The prover side requires no special skill -- solving an NLU challenge is within any genuine agent’s baseline capabilities. --- ## Specification Files | File | Contents | |------|----------| | generation/generation.md | How to generate a good aCAPTCHA challenge | | generation/gen_example.json | Example of a generated challenge | | verification/verification.md | How to verify a counterpart’s response | | verification/ver_example.json | Example of a verification session | Challenge generation specification (generation/generation.md): ⬇ # Challenge Generation An aCAPTCHA challenge is a **dense technical narrative** paired with **reasoning questions** whose answers are deterministically derivable from the text but only through genuine natural language understanding. ## What Makes a Good Challenge A challenge must simultaneously satisfy three properties: - **L-Easy** -- A capable LLM agent can answer correctly through careful reading and reasoning. - **S-Hard** -- A script without NLU cannot extract the answer through pattern matching, regex, or keyword search. - **H-Hard** -- A human cannot answer within the time budget due to information density and working memory demands. ## Structure A challenge consists of a **narrative** and one or more **questions**: ‘json "narrative": "dense technical prose, several hundred tokens...", "questions": [ "question": "a reasoning question about the narrative", "answer": "short deterministic answer", "reasoning_type": "negation" ] ‘ - **Narrative**: Dense technical prose in a specialized domain (e.g., biochemistry, cybersecurity, financial markets, clinical trials, materials science). Length should be sufficient to exceed a human’s ability to read and reason within the time budget -- typically hundreds to over a thousand tokens per part. - **Questions**: Each has exactly one deterministic, unambiguous correct answer. The answer is a short string (entity name, numeric value, label, or identifier). - **Reasoning types**: negation (eliminate explained-away entities), comparison (quantitative), temporal (time-based cues), multi_hop (trace across sections), conditional (apply a stated rule), causal (causal vs. correlational). ## Design Principles ### Implicit Distinction All candidate entities in the narrative must be described in positive or neutral terms. Never use explicit labels like "confirmed", "ruled out", "target", or "primary suspect". Distinctions must be implicit -- expressed through subtle differences: - Temporal persistence ("across three consecutive periods" vs. "in a single observation") - Replication ("independently verified in N trials" vs. "noted once") - Causal attribution ("attributed to external factors" vs. no such attribution) - Scope ("systemic" vs. "localized and transient") ### Information Scattering Key information should be distributed across non-adjacent paragraphs. A reader must synthesize pieces from different sections to arrive at the answer. This defeats linear scanning and keyword extraction. ### Misleading Content Include preliminary conclusions that are later contradicted or revised within the narrative. This forces full reading -- an entity that stops early or skips sections will latch onto the wrong conclusion. ### Anti-Parsing - Use synonyms and paraphrases instead of repeating key terms verbatim - Refer to the same entity by different names in different paragraphs - Embed relevant information within subordinate clauses, parentheticals, or footnotes - Use domain-specific jargon that requires understanding, not just matching ### Numeric Distractors Embed multiple numeric values naturally in the prose. Some are relevant to questions; others are distractors. This prevents a script from simply extracting the only number present. ## Optional: Semantic Chaining (Multi-Round) If you want to test **cross-round memory** (the ‘s‘ dimension of the capability vector), generate multiple challenge parts that form a semantic chain: - **Part 1**: Standalone. Answerable from its own text. - **Part 2**: References Part 1’s findings through **indirect/anaphoric expressions** (e.g., "the enzyme previously identified as anomalous..."). Part 2 is uninterpretable without knowing Part 1’s answer. - **Part N**: References findings from all prior parts. This prevents parallelization -- a counterpart cannot farm out rounds to independent workers because each round depends on the previous answers. Parts may revise, contradict, or build upon prior conclusions. Later parts must never explicitly state prior answers; they use indirect references that are ambiguous without prior context. ## Generation Method Use your own LLM capabilities to generate challenges. Instruct your LLM to produce a narrative conforming to the properties above within a chosen domain. After generation: 1. **Validate structure** -- correct number of questions, answers are short strings, reasoning types are diverse. 2. **Cross-validate answers** -- submit each narrative and question (without the expected answer) to an independent LLM call and check that it derives the same answer. Discard ambiguous challenges. See gen_example.json for a concrete three-part challenge. A concrete three-part challenge generated using this specification is provided in Appendix C. Verification specification (verification/verification.md): ⬇ # Challenge Verification After generating a challenge and sending it to a counterpart, you need to verify the response. Verification has two dimensions: **correctness** and **timing**. ## Answer Comparison Compare the counterpart’s answer to the expected answer: 1. Strip leading and trailing whitespace from both strings 2. Unicode-normalize both strings to NFC form 3. Case-fold both strings (lowercase) 4. Compare for exact equality This ensures "PFK1", "pfk1", " PFK1 ", and "Pfk1" all match. ## Timing Timing is the mechanism that excludes humans. A human reads at ~5 tokens/sec and types at ~0.9 tokens/sec -- for a narrative of 800+ tokens, reading alone takes over 2.5 minutes, before any reasoning. A capable LLM agent typically processes the same challenge in seconds. Set a **time budget** (tau) per challenge such that: ‘ T_agent << tau << T_human ‘ The exact value of tau is your decision. For narratives of several hundred to a thousand tokens, a budget in the range of tens of seconds provides strong separation. Longer narratives allow wider margins. If you can measure the communication round-trip time to the counterpart, subtract it from the measured response time to avoid penalizing agents on high-latency connections. ## Verdict A response is **accepted** if: ‘ correct AND within_time ‘ A response is **rejected** if either condition fails. Record the reason: - ‘wrong_answer‘ -- the answer did not match - ‘timeout‘ -- the answer arrived after the time budget If using multiple rounds (semantic chaining), the overall verdict is accept only if **all** rounds are accepted. Reject immediately on the first failed round -- do not continue. ## Example See ver_example.json for a concrete single-round verification session. Verification example (verification/ver_example.json): ⬇ "_comment": "Example verification session -- single round from the biochemistry challenge", "challenge_sent": "narrative": "FIELD REPORT -- EXTENDED SCENARIO 7c-HOTEL delta initiated a multi-domain surveillance sweep at 14:32 UTC following automated alerts across the biological monitoring system. This report consolidates findings from three independent analysis teams. A -- BIOLOGICAL SCREENING high-throughput pipeline flagged five enzymes for potential kinetic anomalies during batch processing. TYR_K3, evaluated under standard assay conditions using reagent lot AB-342 (sample registry 7821), showed elevated readings in a single assay run but the pattern did not replicate in subsequent trials. A second candidate, MAP2K1, exhibited transient deviation that self-corrected within the observation window without intervention. The third enzyme, PFK1, which is involved in rate-limiting glycolysis, exhibited a persistent deviation across three independent replicate assays in the current batch. Batch reference CD-891 was used for its confirmatory run. A fourth candidate, GST_pi, was flagged during preliminary screening; however, independent replication across three labs yielded baseline-normal results. Finally, IDO1 produced a signal later attributed to matrix interference in the sample preparation step. B -- QUALITY CONTROL INTERLUDE note: An early automated report initially attributed the primary anomaly to TYR_K3. This preliminary assessment has since been revised based on the full replicate data presented above. C -- CLASSIFICATION enzyme whose deviation was reproducible across independent replicates has been assigned to alert tier \"amber\" in the institute’s hierarchical response framework.", "question": "Which enzyme exhibited a deviation that persisted across multiple independent replicates, unlike the other candidates whose anomalies were explained by external factors?" , "expected_answer": "PFK1", "counterpart_response": "answer": "pfk1", "response_time_ms": 2340 , "verification": "normalized_expected": "pfk1", "normalized_received": "pfk1", "correct": true, "time_budget_ms": 30000, "within_time": true, "verdict": "accept"

Instant research discovery