CAPTCHA అనేది ఒక సరళమైన ఆలోచన: సందర్శకుడి ముందు ఒక task ఉంచండి, దాన్ని మనుషులు పరిష్కరించగలరు, machines cannot, మరియు pass అయిన వారిని లోనికి అనుమతించండి. సంవత్సరాల పాటు ఇది ఒక సరైన trade-offగా ఉండేది. People కొద్ది సెకన్లు కోల్పోయారు, మరియు అత్యంత చెడు automation నెమ్మదించింది.
మూడు విషయాలు మారాయి. Machines tasksను పరిష్కరించడంలో మెరుగయ్యాయి. People వాటిని పరిష్కరించడంలో విసిగిపోయారు. మరియు ఒక కొత్త రకం visitor వచ్చింది: నిజమైన customers కోసం acting చేస్తున్న AI agents, మరియు AI assistantsతో పని చేస్తున్న people. "మీరు మనిషా?" అని అడిగే testకి వీరిలో ఎవరికీ సరైన answer లేదు.
Proof of Actor వేరే approach తీసుకుంటుంది. ప్రతి visitorను test చేయడం బదులు, ఇది మీ applicationకి ఎవరు లేదా ఏమి acting చేస్తున్నారో, conclusion వెనుక ఉన్న evidenceతో చెబుతుంది, మరియు challenge అవసరమా కాదా అని మీ code నిర్ణయించనిస్తుంది.
చిన్న సారాంశం
| CAPTCHA | Proof of Actor | |
|---|---|---|
| ప్రధాన ప్రశ్న | ఈ visitor human testను pass చేయగలడా? | ఎవరు లేదా ఏమి acting చేస్తున్నాయి, evidence ఏమిటి? |
| ఖర్చును ఎవరు భరిస్తారు | challenge చూసే ప్రతి visitor | ఎవరూ కాదు; classification backgroundలో జరుగుతుంది |
| సాధ్యమైన సమాధానాలు | Pass లేదా fail | Human, Human + AI, Agent లేదా Unknown, plus a basis |
| legitimate AI agents | ఆపబడతారు, లేదా testని చుట్టి పని చేయాల్సి వస్తుంది | గుర్తించబడతారు, మరియు సరైన experienceకి route చేయబడతారు |
| AI assistantsతో పని చేసే people | ఇతర visitorలాగే పరిగణించబడతారు | ప్రత్యేక class, Human + AI |
| స్పష్టత లేని traffic | అదే testను pass చేయాలి | Unknown, మీరు ప్రతి routeకు ఎంచుకునే fallbackతో |
| ఇది ఎక్కడ వర్తిస్తుంది | మీరు దాన్ని ఉంచిన pages | మీ integration కవర్ చేసే ప్రతి route |
| install చేసినప్పుడు default behavior | visible challenge | observation; మీరు policy జోడించే వరకు ఏదీ మారదు |
test versus evidence
CAPTCHA ఒక bit of informationను ఉత్పత్తి చేస్తుంది: visitor pass అయ్యాడా లేదా fail అయ్యాడా. ఇది visitor ఎవరో, వారు assistantతో పని చేశారా, లేదా resultపై మీరు ఎంత confidence పెట్టాలి అనే విషయాలను చెప్పదు. అలాగే visitorను పని చేయమని అడిగి ఆ bitను ఉత్పత్తి చేస్తుంది.
Proof of Actor ఒక classificationను మరియు దాని evidence basisను ఉత్పత్తి చేస్తుంది. verified result అంటే తనిఖీ చేయగల assertion validated అయ్యింది, ఉదాహరణకు published key against request signature checked చేయబడింది. declared result అంటే client లేదా మీ own application అది stated చేసింది. inferred result అంటే అది inferenceగా labeled చేయబడింది. Unknown అంటే evidence ఒక determinationకు మద్దతు ఇవ్వదు. మీ team ప్రతి resultను చదివి అది ఏదిపై ఆధారపడి ఉందో చూడగలదు, మరియు visitor ఏమీ చేయనవసరం లేదు.
అందరినీ challenge చేయడం యొక్క ఖర్చు
ప్రతి challenge అనేది మీ ఉత్తమ usersపై friction పెట్టి, మీ worst onesను నెమ్మదింపజేయడం. sign-up pageపై, అది conversionsను ఖర్చు చేస్తుంది. checkoutపై, అది revenueను ఖర్చు చేస్తుంది. accessibility స్థాయిలో, అది peopleను పూర్తిగా దూరం చేయవచ్చు. teams ఆ ఖర్చును అంగీకరిస్తారు, ఎందుకంటే అవతల ఎవరు ఉన్నారో తెలియజేసే మెరుగైన signal వారికి లేదు.
actor contextతో, trade మారుతుంది. human-directed sessionsకు మీరు normal experienceను కొనసాగించవచ్చు, evidence బలంగా ఉన్న చోట challengeను దాటవేయవచ్చు, మరియు ఇంకా value జోడించే సన్నని cases కోసం మాత్రమే దాన్ని reserve చేయవచ్చు: ఉదాహరణకు, password change లేదా high-value actionపై Unknown result. ఎక్కువ మంది visitors మళ్లీ challengeను చూడరు.
legitimate agentsకు puzzle కాదు, path కావాలి
CAPTCHA softwareను ఆపేందుకు నిర్మించబడింది. మీ pagesను సందర్శించే software దాదాపు అంతా unwantedగా ఉన్నప్పుడు అది అర్థవంతం. ఇప్పుడు అలా లేదు.
ఈ రోజుల్లో ఒక assistant కస్టమర్ కోసం మీ plansను compare చేయవచ్చు, ఒక agent మీ app ద్వారా సమావేశాన్ని book చేయవచ్చు, మరియు ఒక AI client taskను పూర్తి చేయడానికి మీ MCP serverను call చేయవచ్చు. వారిని ఆపడం అంటే మీ customersను ఆపడం. people కోసం రూపొందించిన pages మరియు puzzles ద్వారా వారిని నడిపించడం వల్ల brittle automation ఏర్పడుతుంది, redesign జరిగిన ప్రతిసారి అది విరిగిపోతుంది.
Proof of Actor agentsను గుర్తిస్తుంది, మరియు signed requestsతో ఏ key మరియు operator వెనుక ఉన్నారో verify చేయగలదు. అప్పుడు మీ application challenge కంటే మెరుగైనది ఏదైనా చేయగలదు: structured APIను serve చేయడం, agent-friendly flowను ఇవ్వడం, లేదా automation కోసం సరిపోయే rate limitను apply చేయడం. serving AI agents structured content guide ఇది ఎలా అనేది చూపిస్తుంది.
Verified identity అంటే permissionతో సమానం కాదు. valid signature అంటే requestను ఏ key sign చేసిందో చెబుతుంది; ఆ agent actionను perform చేయవచ్చా లేదా అనేది మీ authorization decision. Proof of Actor ఈ రెండు ప్రశ్నలను separateగా ఉంచుతుంది.
AIతో పని చేసే people ఇంకా మీ usersే
Assistantతో support message draft చేసే person, లేదా AI సహాయంతో form నింపే వ్యక్తి, ఒక customer. human test వారికి ఉపయోగపడే ఏమీ చెప్పదు: వారు pass అవుతారు, లేదా వారి behavior unusualగా కనిపించిందని block చేయబడతారు.
Proof of Actor వారికి వారి own classను ఇస్తుంది, Human + AI, assistance declared చేసినప్పుడు లేదా supported integration ద్వారా observable అయినప్పుడు reported అవుతుంది. అది AI-drafted submissionsను సరైన teamకి label చేయడానికి, assisted users మీ productలో ఎలా move అవుతున్నారో study చేయడానికి, మరియు వారి experience smoothగా ఉంచడానికి సహాయపడుతుంది. మరింత తెలుసుకోవడానికి AI-assisted interaction glossary entry చూడండి.
అనిశ్చిత casesను ఉద్దేశపూర్వకంగా నిర్వహించడం
కొంత traffic ఎల్లప్పుడూ unclearగానే ఉంటుంది. CAPTCHA దాన్ని ప్రతిచోటా ఒకే విధంగా handles చేస్తుంది: ప్రతి ఒక్కరూ test తీసుకుంటారు.
Proof of Actor Unknownను first-class resultగా ఇస్తుంది, defaultగా humanగా ఎప్పుడూ treat చేయదు, maliciousగా కూడా ఎప్పుడూ treat చేయదు. riskకు అనుగుణంగా ప్రతి routeకు fallbackను మీరు ఎంచుకుంటారు:
- Public pages and documentation: allow, మరియు standard experienceను కొనసాగించండి.
- Sign-up and contact forms: allow, మీ usual abuse controlsతో.
- Account changes: మీ existing re-authentication flowను కొనసాగించండి.
- High-impact actions: reviewకు route చేయండి, లేదా ఇంకా ఒకటి కావాలంటే ఇక్కడ challenge apply చేయండి.
Challenge ఇంకా తన స్థానం సంపాదించగల చోటు ఇదే: sensitive routeపై ఒక deliberate policy outcomeగా, ప్రతి visitorపై tollగా కాదు.
నిర్ణయం ఎక్కడ ఉంటుంది
CAPTCHA widget అది చూపించిన క్షణంలో, మీరు ఉంచిన pageలో, మరియు ఒక్కసారే నిర్ణయిస్తుంది.
Proof of Actorతో, మీ application నిర్ణయిస్తుంది, మీ integration కవర్ చేసే ప్రతి routeపై: server middleware, Next.js, edge, approved browser integration, generic HTTP API లేదా మీ MCP server. Policies actor classను మరియు basisను కలిపి use చేస్తాయి: allow, adapt, challenge, review లేదా rate-limit. అవి మీ codeలో, మిగతా business logic పక్కన ఉంటాయి, మరియు pageను redesign చేయకుండా మీరు వాటిని మార్చవచ్చు.
దాన్ని విడుదల చేయడం
Proof of Actor observation modeలో ప్రారంభమవుతుంది. దాన్ని install చేయడం వల్ల మీ usersకు కనిపించేది ఏదీ మారదు. blanket challenges నుంచి దూరంగా వెళ్లడానికి ఒక sensible path ఇలా ఉంటుంది:
- Observe. మీ existing challengesను అలాగే ఉంచి Proof of Actorను add చేయండి. ప్రతి routeలో actor mix మరియు Unknown rateను చూడండి.
- Compare. ప్రతి challenged route కోసం, ఎన్ని challenges human sessions, AI-assisted users మరియు verified agentsపై వచ్చాయో చూడండి.
- Preview. evidence బలంగా ఉన్న చోట challengeను skip చేసే, మరియు sensitive actionsపై Unknownకు ఉంచే policy రాయండి. real trafficపై దాని effectను preview చేయండి.
- Enforce. documented fallback మరియు rollback switchతో, ఒక route చొప్పున policyను turn on చేయండి.
rolling out actor-aware policies safely guide ప్రతి దశను వివరంగా కవర్ చేస్తుంది.
CAPTCHA ఇంకా అర్థవంతంగా ఉండే సందర్భం
కొన్ని చోట్ల challenges ఇంకా ఉపయోగకరమైన సాధనమే: sensitive actionపై unclear trafficలో అకస్మాత్తు పెరుగుదల, active abuseలో ఉన్న form, లేదా మీకు ఇంకా మరే ఇతర signal లేని route. Proof of Actor ఆ సాధనాన్ని వదిలేయమని అడగదు. ఇది దాన్ని ఉపయోగపడే చోట మాత్రమే వాడటానికి contextను ఇస్తుంది.
ప్రారంభించండి
Proof of Actor private betaలో ఉంది. ఎంపికైన founding developer teams agreed usage limitsలో 12 months వరకు free accessను, దీనిని నిర్మించే team నుంచి direct supportతో, పొందవచ్చు. early access కోసం apply చేయండి మరియు మీరు ఈ రోజు ఏ routesను challenge చేస్తున్నారో మాకు చెప్పండి.