Technology ·
CAPTCHA is dead. What do we do about it?
A solved CAPTCHA tells a platform very little about who is behind an action or what they approved. Here's how platforms can make room for useful agents and keep authority explicit.
Jack Schaffer

I want my agent to help me buy concert tickets. I also want 'two per person' to mean two per person, even if someone sends a hundred agents.
That's the tension I keep coming back to as Head of Engineering at VerifyYou. Useful assistance and abuse can both look like automation. Knowing that an agent is present doesn't tell us whether its next action should be allowed.
We need more specific answers: Who does it represent? What did that person authorize? And can the platform enforce its rules across every agent acting for them?
When I say CAPTCHA is dead, I don't mean every challenge has stopped working. I mean that solving one cannot establish permission to make a purchase, share information, or act on someone's behalf.
Solving the challenge isn’t permission
In Robot Visions, researchers report a 92.6% success rate across 500 tested reCAPTCHA sessions using an automated system with locally run vision models and no paid model API calls.
That is session-level success, not accuracy on every individual challenge. It doesn’t establish that every agent can defeat every CAPTCHA.
But it does challenge an assumption underlying these interactions: that a task difficult for software will remain a useful way to distinguish people from automation.
We’re also seeing CAPTCHA solving become something a person can authorize an assistant to attempt. This example shared by swyx shows a setting for allowing future attempts without asking each time.
That may be convenient for the person using the agent. It still tells the business very little about what that person approved.
Did they authorize browsing, or buying? Two tickets, or twenty? A one-time payment, or a subscription?
A CAPTCHA was never a complete answer to those questions. We need to be careful not to treat it like one.
Detection still matters. So do its limitations.
Behavioral signals can still help us understand an interaction.
FP-Agent studied seven browsing agents and human users on an instrumented site. The researchers found differences in typing, scrolling, and mouse activity that helped distinguish the tested agents from humans and from one another.
AgentShield explores related techniques, including dynamically revealed forms and interaction timing.
These are interesting results, not evidence that a particular signal will work reliably across every customer and future agent. The studies use limited agents, tasks, and participants. AgentShield’s human baseline was especially small.
As an engineer, I care about both sides of that result: whether we can identify abuse, and what happens to a legitimate customer when we get it wrong.
One of the more useful papers I’ve read is What Does It Take to Detect an AI Agent?. It tests an “evasion ladder,” progressing from ordinary automation through increasingly human-like movement, timing, generated mouse trajectories, and adapted replay of real human trajectories.

The five evasion levels tested in What Does It Take to Detect an AI Agent? All five ran through Playwright, and the human comparison came from CAPTCHA sessions.
The detector identified all the evaluated agent sessions in the experiments.
The important detail is that the interactions still ran through Playwright-mediated automation. More convincing cursor movement didn’t remove the underlying event-stream artifacts.
There’s also a task mismatch: the human baseline came from mouse-only CAPTCHA tasks, while agents performed broader web tasks. Removing task-related features preserved the result, but that isn’t equivalent to testing people and agents on identical workflows.
My takeaway isn’t “agent detection is solved.” It’s that the mechanism used to interact with a site can matter as much as the model deciding what to do.
Change that mechanism, and a detector’s strongest signal may disappear.
A legitimate agent can still make an unauthorized purchase
Consider a limited shoe release or tickets to a Taylor Swift or Noah Kahan concert.
An assistant buying two tickets for its user could be useful. A fleet of assistants helping one person evade a two-ticket limit is a different problem.
Knowing that an agent is present doesn’t settle it. Neither does knowing that a human exists somewhere behind the activity.
For platforms, I’d separate four questions:
- What is interacting with us? A person, a declared agent, suspected automation, or something we can’t confidently classify?
- Who does it represent? A customer, an employee, a business, or an unknown party?
- What is it allowed to do? Read information, prepare a transaction, submit it, or spend up to a limit?
- What evidence supports that permission? An authenticated session, scoped delegation, specific approval, or simply the agent saying someone said yes?

Signals, delegation, approval and platform rules answer different questions. Evidence for one does not establish the others.
Uniqueness matters too. A hundred agents don’t necessarily represent a hundred customers. Where a business enforces per-person limits, it needs a way to address that distinction without collecting more personal information than necessary.
None of these checks, individually, proves good intent. They answer different questions.
Approval should cover the actual commitment
The ICML position paper AI Agents Need Authenticated Delegation argues for explicit, scoped, auditable ways for agents to act on someone’s behalf.
That’s an architectural argument, not experimental proof that a particular implementation reduces fraud. But I agree with the direction.
For a consequential action, approval should mean something concrete:
- This item, at this price.
- This recipient, receiving this information.
- This spending limit, until this time.
- This one-time payment, not an unexpected recurring commitment.
If the terms materially change, the old approval shouldn’t silently expand to cover them.
That doesn’t mean asking someone to approve every click. It means distinguishing preparation from commitment.
Finishing the task doesn’t mean staying within bounds
The Devil is in the Context examines prompt-injection coverage, including attacks that add unauthorized actions while the legitimate task still gets completed, and cases involving persistent memory.
It’s a preprint with a small controlled experiment, not a production safety ranking. Its discussion of memory attacks also draws on prior cases, rather than newly demonstrating every attack it describes.
The useful question it raises is broader than “Did the agent finish?”
What else did it do? What did it remember? What might that affect later?
This is one reason I’ve been following the Personal Agent Protocol, or Poppy. Its Operations extension takes a useful step by tying approval to specific terms.
It also makes an important limitation explicit: an agent’s assertion that its user approved something is not independent proof of that approval.
A business can require confirmation in its own signed-in experience, and signed user approvals are on the roadmap. The prompt-injection research doesn’t demonstrate an attack against Poppy. It illustrates why that distinction matters.
For higher-risk actions, I want confirmation that the agent cannot manufacture on its user’s behalf.
Isolation and authorization are different jobs
A sandbox can limit access to a device. It doesn’t automatically limit what an agent can do inside a logged-in account.
An isolated browser might be unable to touch my laptop while still being able to send the wrong email or make the wrong purchase.
That means enforcement needs to exist outside the model’s own judgment. If an action is denied, switching interfaces shouldn’t turn it into an allowed action.
“Keep trying” is useful when a page loads slowly. It’s a terrible authorization policy.
Make useful automation easier. Make authority explicit.
These are questions I’m thinking about at VerifyYou as we work on Passive Signals and AgentCheck.
I don’t want businesses to respond by making every automated interaction harder. I want legitimate assistance to work, with stronger evidence where the consequences warrant it.
Behavioral signals help assess an interaction. Delegation establishes scope. Action-specific approval establishes a commitment. Isolation and enforcement limit what can happen when something goes wrong.
The goal should be an agent that can say, “Here’s who I represent, and here’s what I’m allowed to do.”
Not one that has become exceptionally good at clicking traffic lights.
If you’re building a platform, which actions would you let an agent take freely, and which would require independently verifiable approval?

