ਤੁਲਨਾ

Proof of Actor ਬਨਾਮ bot management: ਵੱਖਰੇ ਸਵਾਲ, ਇੱਕ stack

Bot management ਤੁਹਾਡੀ infrastructure ਨੂੰ abusive automation ਤੋਂ ਬਚਾਉਂਦਾ ਹੈ। Proof of Actor ਤੁਹਾਡੀ application ਨੂੰ ਉਹ actor context ਦਿੰਦਾ ਹੈ ਜਿਸਦੀ ਇਸਨੂੰ ਲੋਕਾਂ, AI-assisted users ਅਤੇ agents ਨਾਲ ਵੱਖਰੇ ਤਰੀਕੇ ਨਾਲ ਸੇਵਾ ਦੇਣ ਲਈ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇੱਥੇ ਵੇਖੋ ਕਿ ਇਹ ਕਿਵੇਂ compare ਕਰਦੇ ਹਨ ਅਤੇ ਇਕੱਠੇ ਕਿਵੇਂ fit ਹੁੰਦੇ ਹਨ।

ਅਗਾਊਂ ਪਹੁੰਚ ਲਵੋ ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ ਵੇਖੋ

ਦੁਆਰਾ Toshendra SharmaFounder & CEO, AgentCredia · Updated November 13, 2026

ਵੈੱਬ ਦੇ ਜ਼ਿਆਦਾਤਰ ਇਤਿਹਾਸ ਵਿੱਚ, automated traffic ਦਾ security stack ਵਿੱਚ ਇੱਕ ਹੀ ਕੰਮ ਸੀ: ਪਛਾਣਿਆ ਜਾਵੇ ਅਤੇ ਰੋਕਿਆ ਜਾਵੇ। Bot management ਇਸੇ ਕੰਮ ਦੇ ਆਸ-ਪਾਸ ਵਿਕਸਤ ਹੋਇਆ। ਇਹ ਤੁਹਾਡੀ infrastructure ਦੇ edge ਤੇ ਬੈਠਦਾ ਹੈ, requests ਨੂੰ score ਕਰਦਾ ਹੈ, ਅਤੇ ਉਹਨਾਂ ਨੂੰ block ਜਾਂ challenge ਕਰਦਾ ਹੈ ਜੋ abusive ਲੱਗਦੀਆਂ ਹਨ। ਇਹ ਇਸ ਵਿੱਚ ਬਹੁਤ ਚੰਗਾ ਹੈ, ਅਤੇ ਤੁਹਾਨੂੰ ਇਸਨੂੰ ਰੱਖਣਾ ਚਾਹੀਦਾ ਹੈ।

AI agents ਨੇ applications ਦੀਆਂ ਲੋੜਾਂ ਬਦਲ ਦਿੱਤੀਆਂ। ਹੁਣ automated requests ਦਾ ਵਧਦਾ ਹਿੱਸਾ agents ਵਲੋਂ ਆਉਂਦਾ ਹੈ ਜੋ ਅਸਲੀ customers ਵਾਸਤੇ ਕੰਮ ਕਰ ਰਹੇ ਹੁੰਦੇ ਹਨ: ਇੱਕ assistant plans ਦੀ ਤੁਲਨਾ ਕਰ ਰਿਹਾ ਹੈ, ਇੱਕ agent support ticket file ਕਰ ਰਿਹਾ ਹੈ, ਇੱਕ client ਆਪਣੇ ਕੰਮ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ ਤੁਹਾਡੇ MCP server ਨੂੰ call ਕਰ ਰਿਹਾ ਹੈ। ਇਸੇ ਵੇਲੇ, ਬਹੁਤ ਸਾਰੇ ਲੋਕ ਤੁਹਾਡੇ product ਨੂੰ ਆਪਣੇ ਨਾਲ ਇੱਕ AI assistant ਰੱਖ ਕੇ ਵਰਤਦੇ ਹਨ। ਇਹ attacks ਨਹੀਂ ਹਨ। ਇਹ users ਹਨ, ਅਤੇ ਇਹਨਾਂ ਨੂੰ block page ਦੀ ਥਾਂ ਸਹੀ experience ਮਿਲਣਾ ਚਾਹੀਦਾ ਹੈ।

ਇਹੀ gap Proof of Actor ਭਰਦਾ ਹੈ। ਇਹ page ਦੋਵਾਂ categories ਦੀ ਸਿੱਧੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ ਤਾਂ ਜੋ ਤੁਸੀਂ ਦੇਖ ਸਕੋ ਕਿ ਹਰ ਇੱਕ ਕਿੱਥੇ fit ਹੁੰਦਾ ਹੈ।

ਛੋਟਾ ਜਵਾਬ

	Bot management	Proof of Actor
ਮੁੱਖ ਸਵਾਲ	ਕੀ ਇਹ request ਰੋਕੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ?	ਕੌਣ ਜਾਂ ਕੀ ਕਾਰਵਾਈ ਕਰ ਰਿਹਾ ਹੈ, ਅਤੇ evidence ਕੀ ਹੈ?
ਇਹ ਕਿੱਥੇ ਚੱਲਦਾ ਹੈ	edge ਤੇ, ਤੁਹਾਡੀ application ਦੇ ਸਾਹਮਣੇ	ਤੁਹਾਡੀ application, API ਜਾਂ MCP server ਦੇ ਅੰਦਰ
ਆਮ output	Allow, block ਜਾਂ challenge; ਅਕਸਰ ਇੱਕ score	Human, Human + AI, Agent ਜਾਂ Unknown, ਨਾਲ ਹੀ ਇੱਕ basis
AI-assisted ਲੋਕਾਂ ਨਾਲ ਕਿਵੇਂ ਸਲੂਕ ਕਰਦਾ ਹੈ	ਆਮ ਤੌਰ 'ਤੇ ਹੋਰ ਲੋਕਾਂ ਤੋਂ ਅਲੱਗ ਨਹੀਂ ਕਰਦਾ	ਇੱਕ ਵੱਖਰੀ class, Human + AI
ਅਸਪਸ਼ਟ traffic ਨਾਲ ਕਿਵੇਂ ਸਲੂਕ ਕਰਦਾ ਹੈ	ਅਕਸਰ challenge ਜਾਂ block	Unknown, ਨਾਲ ਇੱਕ fallback ਜੋ ਤੁਸੀਂ route ਦੇ ਹਿਸਾਬ ਨਾਲ ਚੁਣਦੇ ਹੋ
ਜਵਾਬ ਕੌਣ decide ਕਰਦਾ ਹੈ	edge rules ਦਾ set	ਤੁਹਾਡਾ application code
install ਕਰਨ ਬਾਅਦ default behavior	Enforcement	Observation; ਜਦ ਤੱਕ ਤੁਸੀਂ policy ਨਹੀਂ ਜੋੜਦੇ, ਕੁਝ ਨਹੀਂ ਬਦਲਦਾ
ਸਭ ਤੋਂ ਵਧੀਆ ਕੀ ਹੈ	Credential stuffing, scraping abuse ਅਤੇ volumetric attacks ਨੂੰ ਰੋਕਣਾ	ਹਰ actor ਲਈ product, analytics ਅਤੇ policy decisions

ਇਸ page ਦਾ ਬਾਕੀ ਹਿੱਸਾ ਹਰ row ਨੂੰ ਸਮਝਾਉਂਦਾ ਹੈ।

ਦੋ ਵੱਖਰੇ ਸਵਾਲ

Bot management ਇੱਕ protection ਸਵਾਲ ਦਾ ਜਵਾਬ ਦਿੰਦਾ ਹੈ। ਇਸਦਾ ਮਕਸਦ abusive automation ਨੂੰ ਤੁਹਾਡੀ infrastructure, ਤੁਹਾਡੇ accounts ਅਤੇ ਤੁਹਾਡੀ inventory ਤੋਂ ਦੂਰ ਰੱਖਣਾ ਹੈ। ਇਹ ਜੋ ਵੀ signals ਇਕੱਠੇ ਕਰਦਾ ਹੈ ਉਹ ਇਸੇ ਮਕਸਦ ਲਈ ਹੁੰਦੇ ਹਨ, ਅਤੇ ਇਸਦਾ output ਇੱਕ decision ਹੁੰਦਾ ਹੈ: request ਨੂੰ ਜਾਣ ਦਿਓ, block ਕਰੋ, ਜਾਂ ਉਸਦੇ ਸਾਹਮਣੇ challenge ਰੱਖੋ।

Proof of Actor ਇੱਕ understanding ਸਵਾਲ ਦਾ ਜਵਾਬ ਦਿੰਦਾ ਹੈ। ਇਸਦਾ ਮਕਸਦ ਤੁਹਾਡੀ application ਨੂੰ ਇਹ ਦੱਸਣਾ ਹੈ ਕਿ ਹਰ interaction ਨੂੰ ਕੌਣ ਜਾਂ ਕੀ ਚਲਾ ਰਿਹਾ ਹੈ, ਤਾਂ ਜੋ ਤੁਸੀਂ ਫ਼ੈਸਲਾ ਕਰ ਸਕੋ ਕਿ ਇਸਨੂੰ ਕਿਵੇਂ serve ਕਰਨਾ ਹੈ। ਇਸਦਾ output request ਬਾਰੇ verdict ਨਹੀਂ ਹੁੰਦਾ। ਇਹ evidence ਨਾਲ ਇੱਕ classification ਹੁੰਦਾ ਹੈ:

Human: observable signals human-directed interaction ਦਰਸਾਉਂਦੇ ਹਨ।
Human + AI: ਇੱਕ ਵਿਅਕਤੀ ਨੇ interaction ਨੂੰ AI assistance ਨਾਲ ਚਲਾਇਆ, ਜੋ declared ਸੀ ਜਾਂ observed ਸੀ।
Agent: automated ਜਾਂ agent-origin interaction, ਜੋ verifiable identity ਜਾਂ qualified inference ਨਾਲ supported ਹੈ।
Unknown: evidence reliable determination ਨੂੰ support ਨਹੀਂ ਕਰਦਾ।

ਹਰ result ਆਪਣਾ evidence basis ਵੀ ਦੱਸਦਾ ਹੈ: verified, declared, inferred ਜਾਂ unknown। ਇਹ ਉਹ ਜਾਣਕਾਰੀ ਹੈ ਜਿਸਦੀ product decision ਨੂੰ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਅਤੇ ਇਹ ਉਹ ਜਾਣਕਾਰੀ ਹੈ ਜੋ protection score ਲਈ ਬਣਾਈ ਨਹੀਂ ਗਈ।

ਹਰ ਇੱਕ ਕਿੱਥੇ ਚੱਲਦਾ ਹੈ

Bot management ਆਮ ਤੌਰ 'ਤੇ network edge ਜਾਂ reverse proxy ਵਿੱਚ, ਹੋਰ ਸਭ ਕੁਝ ਤੋਂ ਪਹਿਲਾਂ ਚੱਲਦਾ ਹੈ। Protection ਲਈ ਇਹੀ ਸਥਿਤੀ ਬਿਲਕੁਲ ਠੀਕ ਹੈ। ਇਹ traffic ਨੂੰ ਜਲਦੀ ਦੇਖਦਾ ਹੈ, attacks ਨੂੰ ਤੁਹਾਡੇ ਲਈ ਮਹਿੰਗਾ ਬਣਨ ਤੋਂ ਪਹਿਲਾਂ absorb ਕਰਦਾ ਹੈ, ਅਤੇ ਤੁਹਾਡੇ origin servers ਨੂੰ ਸਾਫ਼ ਰੱਖਦਾ ਹੈ।

Proof of Actor ਉੱਥੇ ਚੱਲਦਾ ਹੈ ਜਿੱਥੇ ਤੁਹਾਡੀ application logic ਰਹਿੰਦੀ ਹੈ: server middleware, Next.js, ਤੁਹਾਡਾ control ਕੀਤਾ ਹੋਇਆ edge layer, ਇੱਕ approved browser integration, ਇੱਕ generic HTTP API, ਜਾਂ ਤੁਹਾਡਾ MCP server। ਇਹ ਸਥਿਤੀ ਇਸਨੂੰ ਉਹਨਾਂ ਚੀਜ਼ਾਂ ਤੱਕ ਪਹੁੰਚ ਦਿੰਦੀ ਹੈ ਜੋ ਤੁਹਾਡੀ application ਜਾਣਦੀ ਹੈ: ਕਿਹੜਾ route call ਹੋ ਰਿਹਾ ਹੈ, ਕਿਹੜੇ workflow ਨਾਲ ਉਹ ਸੰਬੰਧਿਤ ਹੈ, ਕੀ ਤੁਹਾਡਾ ਆਪਣਾ assistant ਕੋਈ action ਕਰ ਰਿਹਾ ਸੀ, ਅਤੇ ਕੀ client ਨੇ ਆਪਣੇ ਆਪ ਨੂੰ declared ਕੀਤਾ ਸੀ। ਪੂਰੀ ਸੂਚੀ ਲਈ integration paths ਵੇਖੋ।

ਕਿਉਂਕਿ ਦੋਵੇਂ ਵੱਖ-ਵੱਖ ਥਾਵਾਂ ਤੇ ਚੱਲਦੇ ਹਨ, ਇਹ ਇੱਕੋ ਕੰਮ ਲਈ ਮੁਕਾਬਲਾ ਨਹੀਂ ਕਰਦੇ। ਇੱਕ request ਤੁਹਾਡੇ bot management ਤੋਂ pass ਹੋ ਸਕਦੀ ਹੈ, ਤੁਹਾਡੀ application ਤੱਕ ਪਹੁੰਚ ਸਕਦੀ ਹੈ, ਅਤੇ ਫਿਰ actor context ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੀ ਹੈ ਜੋ response ਨੂੰ shape ਕਰਦੀ ਹੈ।

Scores ਬਨਾਮ evidence

ਬਹੁਤ ਸਾਰੇ protection products ਆਪਣਾ judgment ਇੱਕ score ਵਜੋਂ ਦੱਸਦੇ ਹਨ। Block decision ਲਈ score efficient ਹੁੰਦਾ ਹੈ: ਇੱਕ threshold ਚੁਣੋ, ਉਸ ਤੋਂ ਉੱਪਰ action ਲਵੋ। ਪਰ ਜਦ ਸਵਾਲ ਹੋਵੇ "ਇਸ actor ਨੂੰ ਕਿਹੜਾ experience ਮਿਲਣਾ ਚਾਹੀਦਾ ਹੈ?" ਤਾਂ ਇਹ ਘੱਟ useful ਹੁੰਦਾ ਹੈ।

ਇੱਕ score ਤੁਹਾਨੂੰ ਇਹ ਨਹੀਂ ਦੱਸਦਾ ਕਿ ਘੱਟ-risk request ਕਿਸੇ ਵਿਅਕਤੀ ਤੋਂ ਆਈ ਸੀ, ਕਿਸੇ assistant ਨਾਲ ਕੰਮ ਕਰ ਰਹੇ ਵਿਅਕਤੀ ਤੋਂ, ਜਾਂ ਇੱਕ well-behaved agent ਤੋਂ। ਇਹ ਇਹ ਨਹੀਂ ਦੱਸਦਾ ਕਿ conclusion ਦੇ ਕਿਹੜੇ ਹਿੱਸੇ verified ਸਨ ਅਤੇ ਕਿਹੜੇ inferred। ਅਤੇ ਇਹ "ਸਾਨੂੰ ਨਹੀਂ ਪਤਾ" ਨੂੰ ਇੱਕ number ਵਿੱਚ force ਕੀਤੇ ਬਿਨਾਂ ਨਹੀਂ ਦੱਸ ਸਕਦਾ।

Proof of Actor ਇਹ distinctions ਬਣਾਈ ਰੱਖਦਾ ਹੈ। ਇੱਕ verified agent result ਦਾ ਮਤਲਬ ਹੈ ਕਿ request signature ਇੱਕ published key ਦੇ ਖ਼ਿਲਾਫ਼ check ਕੀਤੀ ਗਈ ਸੀ, ਉਦਾਹਰਨ ਵਜੋਂ HTTP Message Signatures ਰਾਹੀਂ। ਇੱਕ declared result ਦਾ ਮਤਲਬ ਹੈ ਕਿ client ਜਾਂ ਤੁਹਾਡੀ ਆਪਣੀ application ਨੇ ਇਹ ਦੱਸਿਆ। ਇੱਕ inferred result ਨੂੰ inference ਵਜੋਂ label ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਅਤੇ Unknown hidden default ਦੀ ਥਾਂ ਇੱਕ first-class answer ਹੈ। ਤੁਹਾਡੀ team ਹਰ result ਪੜ੍ਹ ਸਕਦੀ ਹੈ ਅਤੇ ਦੇਖ ਸਕਦੀ ਹੈ ਕਿ ਇਹ ਬਿਲਕੁਲ ਕਿਸ ਤੇ ਆਧਾਰਿਤ ਹੈ।

AI-assisted ਲੋਕ bots ਨਹੀਂ ਹਨ

ਜ਼ਿਆਦਾਤਰ applications ਵਿੱਚ ਸਭ ਤੋਂ ਤੇਜ਼ੀ ਨਾਲ ਵਧਦਾ ਸਮੂਹ ਉਹ ਲੋਕ ਹਨ ਜੋ AI ਨਾਲ ਕੰਮ ਕਰ ਰਹੇ ਹਨ। ਉਹ assistant ਨਾਲ messages draft ਕਰਦੇ ਹਨ, ਮਦਦ ਨਾਲ forms ਭਰਦੇ ਹਨ, ਅਤੇ ਆਪਣੇ product ਵਿਚ AI tool ਨੂੰ ਨਾਲ ਲੈ ਕੇ ਅੱਗੇ ਵਧਦੇ ਹਨ। Protection tooling ਇਹਨਾਂ ਨੂੰ ਹੋਰ ਲੋਕਾਂ ਤੋਂ ਵੱਖਰਾ ਕਰਨ ਲਈ ਨਹੀਂ ਬਣੀ, ਅਤੇ ਇਸਦੀ ਕੋਈ ਲੋੜ ਵੀ ਨਹੀਂ।

ਤੁਹਾਡਾ product ਅਕਸਰ ਕਰਦਾ ਹੈ। ਤੁਸੀਂ ਚਾਹ ਸਕਦੇ ਹੋ ਕਿ AI-drafted support tickets ਨੂੰ label ਕੀਤਾ ਜਾਵੇ ਤਾਂ ਜੋ ਸਹੀ team ਉਹਨਾਂ ਨੂੰ handle ਕਰੇ, ਇਹ ਮਾਪੋ ਕਿ AI-assisted users onboarding ਵਿਚ ਕਿਵੇਂ ਅੱਗੇ ਵਧਦੇ ਹਨ, ਜਾਂ ਉਹਨਾਂ ਲਈ ਇੱਕ ਹਲਕਾ ਰਸਤਾ ਦਿਓ। Proof of Actor ਇਸ group ਨੂੰ ਆਪਣੀ class, Human + AI, ਦਿੰਦਾ ਹੈ, ਅਤੇ ਇਸਨੂੰ ਤਦ ਹੀ report ਕਰਦਾ ਹੈ ਜਦ assistance declared ਹੋਵੇ ਜਾਂ supported integration ਰਾਹੀਂ observable ਹੋਵੇ। AI-assisted interaction glossary entry ਵਿੱਚ ਹੋਰ ਪੜ੍ਹੋ।

Unknown ਕੋਈ threat ਨਹੀਂ, ਇੱਕ answer ਹੈ

ਹਰ classifier ਨੂੰ ਅਜਿਹਾ traffic ਮਿਲਦਾ ਹੈ ਜਿਸਦੀ ਉਹ ਵਿਆਖਿਆ ਨਹੀਂ ਕਰ ਸਕਦਾ। Protection systems ਆਮ ਤੌਰ 'ਤੇ ਸਾਵਧਾਨ ਹੋਣ ਲਈ ਬਣੇ ਹੁੰਦੇ ਹਨ, ਇਸ ਲਈ ਅਸਪਸ਼ਟ traffic ਨੂੰ ਅਕਸਰ challenge ਮਿਲਦਾ ਹੈ। Edge ਤੇ ਇਹ ਇੱਕ ਸਮਝਦਾਰ ਚੋਣ ਹੈ।

ਤੁਹਾਡੀ application ਦੇ ਅੰਦਰ, ਇੱਕੋ cautious default ਅਕਸਰ ਸਹੀ ਚੋਣ ਨਹੀਂ ਹੁੰਦੀ। ਇੱਕ public documentation page ਲਈ unknown request ਅਤੇ account password ਬਦਲਣ ਲਈ unknown request ਨੂੰ ਬਿਲਕੁਲ ਵੱਖਰਾ handle ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। Proof of Actor Unknown ਨੂੰ ਆਪਣੇ ਖੁਦ ਦੇ result ਵਜੋਂ ਵਾਪਸ ਕਰਦਾ ਹੈ ਅਤੇ ਤੁਹਾਨੂੰ route ਅਨੁਸਾਰ fallback set ਕਰਨ ਦਿੰਦਾ ਹੈ: public pages 'ਤੇ allow ਕਰੋ, account changes 'ਤੇ ਆਪਣੀਆਂ ਮੌਜੂਦਾ checks ਰੱਖੋ, high-impact actions 'ਤੇ review ਲਈ route ਕਰੋ। handling Unknown traffic ਵਾਲਾ guide patterns ਨੂੰ ਸਮਝਾਉਂਦਾ ਹੈ।

ਜਵਾਬ ਕੌਣ decide ਕਰਦਾ ਹੈ

Bot management ਨਾਲ, edge ਵਾਲਾ rules set decide ਕਰਦਾ ਹੈ। ਇਹ efficient ਹੈ ਅਤੇ ਤੁਹਾਡੀਆਂ properties ਵਿੱਚ decisions ਨੂੰ consistent ਰੱਖਦਾ ਹੈ।

Proof of Actor ਨਾਲ, ਤੁਹਾਡੀ application decide ਕਰਦੀ ਹੈ। Product actor context ਦਿੰਦਾ ਹੈ; ਤੁਹਾਡਾ code policy ਲਗਾਉਂਦਾ ਹੈ। ਤੁਸੀਂ verified agents ਨੂੰ ਲੋਕਾਂ ਲਈ ਬਣੇ pages ਦੀ ਥਾਂ ਇੱਕ structured API ਦੇ ਸਕਦੇ ਹੋ, human sessions ਲਈ standard experience ਰੱਖ ਸਕਦੇ ਹੋ, AI-assisted submissions ਨੂੰ label ਕਰ ਸਕਦੇ ਹੋ, ਅਤੇ ਜਦ ਤੁਹਾਡੀਆਂ ਆਪਣੀਆਂ conditions ਮੰਗਣ sensitive actions 'ਤੇ stronger credentials ਮੰਗ ਸਕਦੇ ਹੋ। Policies route, actor class ਅਤੇ basis ਦੇ ਹਿਸਾਬ ਨਾਲ ਲਿਖੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਅਤੇ ਇਹ ਤੁਹਾਡੀ ਬਾਕੀ business logic ਦੇ ਨਾਲ ਹੀ ਰਹਿੰਦੀਆਂ ਹਨ।

ਪਹਿਲਾਂ observation

Bot management ਆਮ ਤੌਰ 'ਤੇ enforce ਕਰਨ ਲਈ install ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਕਿਉਂਕਿ ਇਸਦੀ ਪੂਰੀ value abuse ਨੂੰ ਰੋਕਣਾ ਹੈ।

Proof of Actor observation mode ਵਿੱਚ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ। ਇਸਨੂੰ install ਕਰਨ ਨਾਲ ਤੁਹਾਡੀ application ਦੇ behavior ਵਿੱਚ ਕੁਝ ਵੀ ਨਹੀਂ ਬਦਲਦਾ। ਤੁਸੀਂ route ਦੇ ਹਿਸਾਬ ਨਾਲ ਆਪਣਾ ਅਸਲੀ actor mix ਦੇਖਦੇ ਹੋ, evidence review ਕਰਦੇ ਹੋ, real traffic ਦੇ ਮੁਕਾਬਲੇ policy ਦੇ effect ਦਾ preview ਕਰਦੇ ਹੋ, ਅਤੇ ਸਿਰਫ਼ ਤਦ enforce ਕਰਦੇ ਹੋ ਜਦ ਤੁਸੀਂ ਤਿਆਰ ਹੋਵੋ, ਇੱਕ route ਇਕ ਵਾਰ। rolling out actor-aware policies safely ਵਾਲਾ guide ਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸਮਝਾਉਂਦਾ ਹੈ।

ਦੋਵੇਂ ਇਕੱਠੇ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ

ਸਭ ਤੋਂ ਮਜ਼ਬੂਤ setup ਦੋਵੇਂ ਨੂੰ ਵਰਤਦਾ ਹੈ, ਹਰ ਇੱਕ ਆਪਣੀ layer ਵਿੱਚ:

Edge ਤੇ, bot management credential stuffing, scraping abuse ਅਤੇ volumetric attacks ਨੂੰ ਰੋਕਦਾ ਹੈ।
ਤੁਹਾਡੀ application ਵਿੱਚ, Proof of Actor ਉਹ traffic classifies ਕਰਦਾ ਹੈ ਜੋ pass ਹੋ ਜਾਂਦਾ ਹੈ: Human, Human + AI, Agent ਜਾਂ Unknown, ਆਪਣੇ basis ਨਾਲ।
ਤੁਹਾਡੇ code ਵਿੱਚ, policies ਇਸ context ਨੂੰ ਵਰਤ ਕੇ experience ਚੁਣਦੀਆਂ ਹਨ: verified agent ਲਈ structured API, ਇੱਕ ਵਿਅਕਤੀ ਲਈ normal flow, AI-assisted submission ਲਈ ਇੱਕ label, Unknown ਲਈ ਇੱਕ explicit fallback।
ਤੁਹਾਡੇ analytics ਵਿੱਚ, ਤੁਹਾਡੀ team ਵੇਖਦੀ ਹੈ ਕਿ ਹਰ actor class ਕਿਹੜੇ routes ਅਤੇ workflows ਵਰਤਦੀ ਹੈ, ਤਾਂ ਜੋ product ਅਤੇ security ਇੱਕੋ ਹੀ picture ਤੋਂ ਕੰਮ ਕਰਨ।

Edge decision ਨੂੰ actor result ਦੇ ਨਾਲ record ਕਰਨ ਨਾਲ picture ਪੂਰੀ ਬਣਦੀ ਹੈ: protection ਨੇ ਕੀ ਕੀਤਾ, ਅਤੇ ਅਸਲ ਵਿੱਚ ਕੌਣ ਕਾਰਵਾਈ ਕਰ ਰਿਹਾ ਸੀ।

ਕਦੋਂ ਕਿਹੜਾ ਚੁਣਨਾ ਹੈ

bot management ਚੁਣੋ ਜਦ ਤੁਹਾਡੀ ਮੁੱਖ ਸਮੱਸਿਆ abuse ਹੋਵੇ: account takeover attempts, inventory hoarding, aggressive scraping ਜਾਂ traffic floods।

Proof of Actor ਚੁਣੋ ਜਦ ਤੁਹਾਡਾ ਮੁੱਖ ਸਵਾਲ ਤੁਹਾਡੇ users ਬਾਰੇ ਹੋਵੇ: ਤੁਹਾਡੇ product ਦਾ ਕਿੰਨਾ ਹਿੱਸਾ agents ਪਹਿਲਾਂ ਹੀ ਵਰਤ ਰਹੇ ਹਨ, ਕਿਹੜੇ agents ਤੁਹਾਡੀ API ਜਾਂ MCP server ਨੂੰ call ਕਰਦੇ ਹਨ, ਕਿੱਥੇ AI-assisted ਲੋਕ struggling ਹਨ, ਅਤੇ ਕਿਹੜੇ routes ਨੂੰ actor-aware policy ਦੀ ਲੋੜ ਹੈ।

ਜ਼ਿਆਦਾਤਰ teams ਜੋ ਇੱਕ production application, API ਜਾਂ MCP server ਚਲਾਉਂਦੀਆਂ ਹਨ, ਦੋਵਾਂ ਦੇ ਜਵਾਬਾਂ ਦੀ ਲੋੜ ਮਹਿਸੂਸ ਕਰਦੀਆਂ ਹਨ, ਇਸੇ ਲਈ ਇਹ ਦੋਵੇਂ ਇੱਕੋ stack ਵਿੱਚ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ।

ਸ਼ੁਰੂ ਕਰੋ

Proof of Actor private beta ਵਿੱਚ ਹੈ। ਚੁਣੀਆਂ ਹੋਈਆਂ founding developer teams agreed usage limits ਦੇ ਅੰਦਰ 12 months ਤੱਕ free access ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੀਆਂ ਹਨ, ਉਸ team ਵਲੋਂ direct support ਨਾਲ ਜੋ ਇਸਨੂੰ ਬਣਾਉਂਦੀ ਹੈ। early access ਲਈ apply ਕਰੋ ਅਤੇ ਸਾਨੂੰ application ਅਤੇ ਉਸ interaction ਬਾਰੇ ਦੱਸੋ ਜਿਸਨੂੰ ਤੁਸੀਂ ਸਮਝਣਾ ਚਾਹੁੰਦੇ ਹੋ।

ਡਿਵੈਲਪਰਾਂ ਲਈ

What your code receives

Every interaction resolves to one result record. Your application reads the class and the basis and applies its own policy.

Result record

{
  "route": "GET /api/v1/catalog",
  "class": "agent",
  "basis": "verified",
  "evidence": [
    { "signal": "http_message_signature", "result": "valid", "keyid": "assistant.example" },
    { "signal": "client_declaration", "value": "assistant.example" }
  ],
  "observed_at": "2026-11-13T10:42:07Z"
}

class: Human, Human + AI, Agent ਜਾਂ Unknown।
basis: ਸਬੂਤ ਕਿੰਨਾ ਮਜ਼ਬੂਤ ਹੈ: verified, declared, inferred ਜਾਂ unknown।
evidence: result ਦੇ ਪਿੱਛੇ ਦੇ signals, ਤਾਂ ਜੋ ਤੁਹਾਡੀ team ਵੇਖ ਸਕੇ ਕਿ ਕਿਉਂ।

observation mode ਵਿੱਚ ਸ਼ੁਰੂ ਕਰੋ: results ਨੂੰ ਆਪਣੇ logs ਦੇ ਨਾਲ record ਕਰੋ ਅਤੇ ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ ਕੋਈ policy ਨਾ ਚੁਣੋ, ਕੁਝ ਵੀ ਨਾ ਬਦਲੋ। Node.js integration guide ਪੜ੍ਹੋ

ਅਕਸਰ ਪੁੱਛੇ ਜਾਂਦੇ ਸਵਾਲ

ਕੀ Proof of Actor bot management ਦੀ ਥਾਂ ਲੈਂਦਾ ਹੈ?

ਨਹੀਂ। Bot management credential stuffing, scraping abuse ਅਤੇ volumetric attacks ਵਰਗੀ abusive automation ਨੂੰ ਤੁਹਾਡੀ application ਤੱਕ ਪਹੁੰਚਣ ਤੋਂ ਪਹਿਲਾਂ ਹੀ ਰੋਕਦਾ ਹੈ। Proof of Actor ਤੁਹਾਡੀ application ਦੇ ਅੰਦਰ ਕੰਮ ਕਰਦਾ ਹੈ ਅਤੇ product ਅਤੇ policy decisions ਲਈ actor context ਦਿੰਦਾ ਹੈ। ਦੋਵਾਂ ਨੂੰ ਰੱਖੋ।

Product decisions ਕਰਨ ਲਈ bot score ਕਿਉਂ ਨਾ ਵਰਤੀਏ?

Bot score ਇਸ ਲਈ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ ਕਿ ਕੀ ਕਿਸੇ request ਨੂੰ ਰੋਕਣਾ ਹੈ। ਇਹ ਆਮ ਤੌਰ 'ਤੇ ਇਹ ਨਹੀਂ ਦੱਸਦਾ ਕਿ ਕੋਈ ਵਿਅਕਤੀ AI ਨਾਲ ਕੰਮ ਕਰ ਰਿਹਾ ਸੀ, ਕਿਹੜਾ agent ਕਾਲ ਕਰ ਰਿਹਾ ਹੈ, ਜਾਂ score ਕਿਸ evidence 'ਤੇ ਆਧਾਰਿਤ ਹੈ। Proof of Actor ਇੱਕ class ਅਤੇ ਇਕ explicit basis ਵਾਪਸ ਦਿੰਦਾ ਹੈ, ਅਤੇ product decisions ਲਈ ਇਹੀ ਚਾਹੀਦਾ ਹੈ।

ਕੀ ਦੋਵੇਂ signals ਸਾਂਝੇ ਕਰ ਸਕਦੇ ਹਨ?

ਹਾਂ। ਤੁਹਾਡੀ application edge controls ਦੇ outcome ਨੂੰ Proof of Actor result ਦੇ ਨਾਲ record ਕਰ ਸਕਦੀ ਹੈ, ਤਾਂ ਜੋ ਤੁਹਾਡੀ team ਨੂੰ ਉਸੇ request ਲਈ protection decision ਅਤੇ actor context ਦੋਵਾਂ ਦਿੱਸਣ।

ਕੀ Proof of Actor traffic block ਕਰਦਾ ਹੈ?

ਨਹੀਂ। ਇਹ observation mode ਵਿੱਚ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ ਅਤੇ ਤਦ ਤੱਕ ਕੁਝ ਨਹੀਂ ਬਦਲਦਾ ਜਦ ਤੱਕ ਤੁਸੀਂ policy ਨਹੀਂ ਲਿਖਦੇ। Enforcement ਹਮੇਸ਼ਾ ਤੁਹਾਡੇ ਆਪਣੇ application code ਵਿੱਚ ਹੁੰਦੀ ਹੈ।

ਮੈਨੂੰ ਪਹਿਲਾਂ ਕਿਹੜਾ add ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ?

ਜੇ ਤੁਹਾਨੂੰ active abuse ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪੈ ਰਿਹਾ ਹੈ, ਤਾਂ bot management ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ। ਜੇ ਤੁਸੀਂ ਆਪਣੇ product ਨੂੰ ਪਹਿਲਾਂ ਹੀ ਵਰਤ ਰਹੇ ਲੋਕਾਂ, AI-assisted users ਅਤੇ agents ਨੂੰ ਸਮਝਣਾ ਅਤੇ serve ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ Proof of Actor add ਕਰੋ। ਜ਼ਿਆਦਾਤਰ production teams ਆਖ਼ਰਕਾਰ ਦੋਵਾਂ ਨਾਲ ਕੰਮ ਕਰਦੀਆਂ ਹਨ।

ਜਾਣੋ ਤੁਹਾਡਾ app ਕੌਣ ਵਰਤ ਰਿਹਾ ਹੈ।

Founding developers ਦੇ ਇੱਕ ਛੋਟੇ group ਲਈ private beta।

ਅਗਾਊਂ ਪਹੁੰਚ ਲਵੋ ਕੀਮਤ ਵੇਖੋ

ਪਹਿਲਾਂ ਗੱਲ ਕਰਨੀ ਪਸੰਦ ਕਰੋਗੇ? founders ਨਾਲ ਗੱਲ ਕਰੋ