ତୁଳନା

Proof of Actor ବନାମ bot management: ଭିନ୍ନ ପ୍ରଶ୍ନ, ଏକେ stack

Bot management ଆପଣଙ୍କ infrastructure କୁ ଦୁର୍ବ୍ୟବହାରମୂଳକ automation ରୁ ସୁରକ୍ଷା କରେ। Proof of Actor ଆପଣଙ୍କ application କୁ ଆବଶ୍ୟକ actor context ଦିଏ, ଯାହା ଦ୍ୱାରା ସେ ଲୋକ, AI-assisted user ଏବଂ agent ମାନଙ୍କୁ ଭିନ୍ନ ଭାବରେ ସେବା ଦେଇପାରେ। ଏହିପରି ସେଗୁଡ଼ିକ କିପରି ତୁଳନୀୟ ଏବଂ କିପରି ଏକାସାଙ୍ଗରେ ମେଳ ଖାନ୍ତି, ଏଠାରେ ଦିଆଯାଇଛି।

Early Access ପାଆନ୍ତୁ ଏହା କିପରି କାମ କରେ ଅନୁସନ୍ଧାନ କରନ୍ତୁ

ଦ୍ୱାରା Toshendra SharmaFounder & CEO, AgentCredia · Updated November 13, 2026

ଅଧିକାଂଶ web ଇତିହାସରେ, automated traffic ର security stack ମଧ୍ୟରେ ଏକଟି କାମ ଥିଲା: ଚିହ୍ନଟ ହେବା ଏବଂ ରୋକାଯିବା। Bot management ସେହି କାମକୁ ନେଇ ବିକଶିତ ହୋଇଛି। ଏହା ଆପଣଙ୍କ infrastructure ର edge ରେ ବସେ, request score କରେ, ଏବଂ ଯେଗୁଡ଼ିକ ଦୁର୍ବ୍ୟବହାରମୂଳକ ଲାଗେ ସେଗୁଡ଼ିକୁ block କିମ୍ବା challenge କରେ। ଏଥିରେ ଏହା ବହୁତ ଭଲ, ଏବଂ ଆପଣ ଏହାକୁ ରଖିବା ଉଚିତ।

AI agent ଗୁଡ଼ିକ applications କୁ କ’ଣ ଜଣାଇବାକୁ ପଡ଼େ ତାହା ପରିବର୍ତ୍ତନ କରିଛି। ବଢ଼ୁଥିବା automation request ର ଏକ ଅଂଶ ଏବେ ସତ୍ୟିକି customer ଙ୍କ ପକ୍ଷରୁ କାର୍ଯ୍ୟ କରୁଥିବା agent ମାନଙ୍କୁ ଆସୁଛି: plan ତୁଳନା କରୁଥିବା assistant, support ticket file କରୁଥିବା agent, task ସମାପ୍ତ କରିବା ପାଇଁ ଆପଣଙ୍କ MCP server କୁ call କରୁଥିବା client। ସେହି ସମୟରେ, ଅନେକ ଲୋକ ନିଜ product କୁ AI assistant ସହିତ ବ୍ୟବହାର କରନ୍ତି। ଏଗୁଡ଼ିକ attack ନୁହେଁ। ସେଗୁଡ଼ିକ user, ଏବଂ ସେମାନେ block page ନୁହେଁ, ଠିକ୍ experience ପାଇବା ଯୋଗ୍ୟ।

ସେହି gap କୁ Proof of Actor ପୂରଣ କରେ। ଏହି page ଦୁଇଟି category କୁ ସାଧାରଣ ଭାଷାରେ ତୁଳନା କରେ, ଯାହାଦ୍ୱାରା ପ୍ରତ୍ୟେକଟି କେଉଁଠି ରହିଥାଏ ଆପଣ ଦେଖିପାରିବେ।

ସଂକ୍ଷିପ୍ତ ସାର

	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, route ଅନୁଯାୟୀ ଆପଣ ବାଛିଥିବା fallback ସହିତ
response କିଏ ନିର୍ଣ୍ଣୟ କରେ	Edge rule set	ଆପଣଙ୍କ application code
install ପରେ default behavior	Enforcement	Observation; policy ଯୋଡ଼ିବା ପର୍ଯ୍ୟନ୍ତ କିଛି ପରିବର୍ତ୍ତନ ହୁଏନାହିଁ
କେଉଁଥିରେ ସର୍ବୋତ୍ତମ	Credential stuffing, scraping abuse ଏବଂ volumetric attack ରୋକିବା	ପ୍ରତ୍ୟେକ actor ପାଇଁ product, analytics ଏବଂ policy ନିଷ୍ପତ୍ତି

ଏହି page ର ଅବଶିଷ୍ଟ ଅଂଶ ପ୍ରତ୍ୟେକ row କୁ ବ୍ୟାଖ୍ୟା କରେ।

ଦୁଇଟି ଭିନ୍ନ ପ୍ରଶ୍ନ

Bot management ଏକ protection ପ୍ରଶ୍ନର ଉତ୍ତର ଦିଏ। ତାହାର ଲକ୍ଷ୍ୟ ହେଉଛି ଦୁର୍ବ୍ୟବହାରମୂଳକ automation କୁ ଆପଣଙ୍କ infrastructure, account ଏବଂ inventory ଠାରୁ ଦୂରେ ରଖିବା। ଏହା ଯେତେ signal ସଂଗ୍ରହ କରେ, ସେଗୁଡ଼ିକ ସେହି ଲକ୍ଷ୍ୟକୁ ସେବା କରେ, ଏବଂ ତାହାର output ଏକ ନିଷ୍ପତ୍ତି ହୁଏ: request କୁ ଛାଡ଼ିଦିଆଯିବ, block କରାଯିବ, କିମ୍ବା ତାହା ସାମ୍ନାରେ ଏକ challenge ରଖାଯିବ।

Proof of Actor ଏକ understanding ପ୍ରଶ୍ନର ଉତ୍ତର ଦିଏ। ତାହାର ଲକ୍ଷ୍ୟ ହେଉଛି ପ୍ରତ୍ୟେକ interaction କୁ କିଏ କିମ୍ବା କ’ଣ ଚଳାଉଛି ସେଥିରେ ଆପଣଙ୍କ application କୁ ଜଣାଇବା, ଯାହାଦ୍ୱାରା ଆପଣ ଏହାକୁ କିପରି ସେବା ଦେବେ ସେ ନିଷ୍ପତ୍ତି ନେଇପାରିବେ। ଏହାର output request ଉପରେ ଏକ verdict ନୁହେଁ। ଏହା evidence ସହିତ ଏକ classification:

Human: ଦେଖାଯାଉଥିବା signal ଗୁଡ଼ିକ human-directed interaction କୁ ସୂଚିତ କରେ।
Human + AI: ଏକ ଲୋକ AI assistance ସହ interaction କୁ ଚଳାଇଛନ୍ତି, ଯାହା declared କିମ୍ବା observed ହୋଇଛି।
Agent: automated କିମ୍ବା agent-origin interaction, verifiable identity କିମ୍ବା qualified inference ଦ୍ୱାରା ସମର୍ଥିତ।
Unknown: evidence ଭରସାଯୋଗ୍ୟ determination କୁ ସମର୍ଥନ କରେନାହିଁ।

ପ୍ରତ୍ୟେକ result ମଧ୍ୟ ତାହାର evidence basis କୁ କହେ: verified, declared, inferred କିମ୍ବା unknown। ଏହା ହେଉଛି product decision କୁ ଆବଶ୍ୟକ ସୂଚନା, ଏବଂ protection score ଯାହା ବହନ କରିବାକୁ ତିଆରି ହୋଇନଥିଲା ସେହି ସୂଚନା।

ପ୍ରତ୍ୟେକଟି କେଉଁଠି ଚାଲେ

Bot management ସାଧାରଣତଃ network edge କିମ୍ବା reverse proxy ରେ, ସବୁକିଛିର ସମ୍ମୁଖରେ ଚାଲେ। ସୁରକ୍ଷା ପାଇଁ ସେହି position ସଠିକ୍। ଏହା traffic କୁ ଶୀଘ୍ର ଦେଖେ, attack ଗୁଡ଼ିକ ଆପଣଙ୍କୁ କିଛି ଖର୍ଚ୍ଚ କରାଇବା ପୂର୍ବରୁ absorb କରେ, ଏବଂ ଆପଣଙ୍କ origin server ଗୁଡ଼ିକୁ ସଫା ରଖେ।

Proof of Actor ସେଠାରେ ଚାଲେ ଯେଉଁଠି ଆପଣଙ୍କ application logic ବସେ: server middleware, Next.js, ଆପଣ ନିୟନ୍ତ୍ରଣ କରୁଥିବା edge layer, ଏକ approved browser integration, ଏକ generic HTTP API, କିମ୍ବା ଆପଣଙ୍କ MCP server। ସେହି position ଏହାକୁ ଆପଣଙ୍କ application ଯାହା ଜାଣେ ତାହାକୁ ଆକ୍ସେସ୍ ଦିଏ: କେଉଁ route call ହେଉଛି, କେଉଁ workflow ର ଅଂଶ, ଆପଣଙ୍କ own assistant କି action କରିଛି, ଏବଂ କୌଣସି client ନିଜକୁ ଘୋଷଣା କରିଛି କି ନାହିଁ। ସମ୍ପୂର୍ଣ୍ଣ list ପାଇଁ integration paths ଦେଖନ୍ତୁ।

ଯେହେତୁ ଦୁଇଟି ଭିନ୍ନ ସ୍ଥାନରେ ଚାଲେ, ସେମାନେ ଏକେ କାମ ପାଇଁ ପ୍ରତିସ୍ପର୍ଧା କରନ୍ତି ନାହିଁ। ଏକ request ଆପଣଙ୍କ bot management ଦ୍ୱାରା ପାର ହୋଇ, ଆପଣଙ୍କ application ପହଞ୍ଚି, ଏବଂ ପରେ actor context ପାଇପାରେ ଯାହା response କୁ ଆକାର ଦିଏ।

Score ବନାମ evidence

ଅନେକ protection product ନିଜ ମତାମତକୁ score ଆକାରରେ ପ୍ରକାଶ କରନ୍ତି। ଏକ score block decision ପାଇଁ କାର୍ଯ୍ୟକ୍ଷମ: ଏକ threshold ବାଛନ୍ତୁ, ତାହାଉପରେ କାର୍ଯ୍ୟ କରନ୍ତୁ। ପ୍ରଶ୍ନ ଯଦି "ଏହି actor କେମିତି experience ପାଇବ?" ହୋଇଥାଏ, ତେବେ ଏହା ବହୁତ କମ୍ ଉପଯୋଗୀ।

ଏକ score ଆପଣଙ୍କୁ କହେନାହିଁ କି ଏକ low-risk request ଏକ ଲୋକଙ୍କ ଠାରୁ, ଏକ assistant ସହ କାମ କରୁଥିବା ଲୋକଙ୍କ ଠାରୁ, କିମ୍ବା ଭଲ ଆଚରଣ କରୁଥିବା agent ଠାରୁ ଆସିଥିଲା। ଏହା କହେନାହିଁ ଯେ କେଉଁ ଅଂଶ verified ଥିଲା ଏବଂ କେଉଁଗୁଡ଼ିକ inferred ଥିଲା। ଏବଂ ଏହା ସଂଖ୍ୟାରେ ବାଧ୍ୟ କରିବା ବିନା "ଆମେ ଜାଣୁନାହିଁ" ବ୍ୟକ୍ତ କରିପାରେନାହିଁ।

Proof of Actor ସେହି ପାର୍ଥକ୍ୟଗୁଡ଼ିକୁ ରକ୍ଷା କରେ। ଏକ verified agent result ମାନେ request signature କୁ published key ସହିତ ଯାଞ୍ଚ କରାଯାଇଛି, ଉଦାହରଣ ସ୍ୱରୂପ HTTP Message Signatures ଦ୍ୱାରା। ଏକ declared result ମାନେ client କିମ୍ବା ଆପଣଙ୍କ own application ଏହା କହିଥିଲା। ଏକ inferred result inference ଭାବରେ ଚିହ୍ନଟ ହୋଇଥାଏ। ଏବଂ Unknown ହେଉଛି ଲୁଚାଇଥିବା default ନୁହେଁ, ଏକ first-class answer। ଆପଣଙ୍କ team ପ୍ରତ୍ୟେକ result ପଢ଼ିପାରିବେ ଏବଂ ଏହା କ’ଣ ଉପରେ ଭିତ୍ତି କରିଛି ସ୍ପଷ୍ଟ ଭାବରେ ଦେଖିପାରିବେ।

AI-assisted ଲୋକମାନେ bot ନୁହେଁ

ଅଧିକାଂଶ application ରେ ସବୁଠାରୁ ଶୀଘ୍ର ବଢ଼ୁଥିବା ଦଳ ହେଉଛନ୍ତି AI ସହ କାମ କରୁଥିବା ଲୋକମାନେ। ସେମାନେ assistant ସହ message ଖସଡ଼ା କରନ୍ତି, ସହଯୋଗରେ form ପୂରଣ କରନ୍ତି, ଏବଂ ନିଜ product ଭିତରେ AI tool କୁ ପାଖରେ ରଖି ଗତି କରନ୍ତି। Protection tooling ସେମାନଙ୍କୁ ଅନ୍ୟ ଲୋକମାନଙ୍କ ଠାରୁ ପୃଥକ କରିବା ପାଇଁ ତିଆରି ହୋଇନଥିଲା, ଏବଂ ତାହାର ଏହା କରିବାକୁ କୌଣସି କାରଣ ମଧ୍ୟ ନାହିଁ।

ଆପଣଙ୍କ product ପ୍ରାୟତଃ କରେ। ଆପଣ AI ଦ୍ୱାରା ଖସଡ଼ା support ticket କୁ label କରି right team ଦ୍ୱାରା ସମ୍ଭାଳିବାକୁ ଚାହିଁପାରନ୍ତି, AI-assisted user onboarding ମାଧ୍ୟମରେ କିପରି ଚାଲୁଛନ୍ତି ମାପିବାକୁ ଚାହିଁପାରନ୍ତି, କିମ୍ବା ସେମାନଙ୍କୁ ଅଧିକ ସହଜ path ଦେବାକୁ ଚାହିଁପାରନ୍ତି। Proof of Actor ସେହି group କୁ ନିଜ class, Human + AI, ଦେଇଥାଏ, ଏବଂ ସହଯୋଗ declared କିମ୍ବା supported integration ମାଧ୍ୟମରେ observable ହେଲେ ମାତ୍ର ଏହା ରିପୋର୍ଟ କରେ। AI-assisted interaction glossary entry ରେ ଅଧିକ ପଢ଼ନ୍ତୁ।

Unknown ଏକ answer, threat ନୁହେଁ

ପ୍ରତ୍ୟେକ classifier ଏମିତି traffic ସାମ୍ନା କରେ ଯାହାକୁ ସେ ବ୍ୟାଖ୍ୟା କରିପାରେନାହିଁ। Protection system ଗୁଡ଼ିକ caution ଉପରେ ଭରସା କରିବାକୁ ତିଆରି, ସେଥିପାଇଁ ଅସ୍ପଷ୍ଟ traffic ପ୍ରାୟତଃ challenge ସାମ୍ନା କରେ। Edge ରେ ଏହା ଏକ ବୈଧ ପସନ୍ଦ।

ଆପଣଙ୍କ application ଭିତରେ, ଏକ single cautious default ପ୍ରାୟତଃ ସଠିକ୍ ପସନ୍ଦ ନୁହେଁ। ଏକ public documentation page କୁ ଆସୁଥିବା unknown request ଏବଂ account password ପରିବର୍ତ୍ତନ ପାଇଁ ଆସୁଥିବା unknown request ବହୁତ ଭିନ୍ନ handling ଯୋଗ୍ୟ। Proof of Actor Unknown କୁ ନିଜର ଫଳାଫଳ ଭାବରେ ଫେରାଇଦିଏ ଏବଂ route ଅନୁସାରେ fallback ସେଟ୍ କରିବାକୁ ଦିଏ: public page ରେ ଏହାକୁ allow କରନ୍ତୁ, account ପରିବର୍ତ୍ତନରେ ଆପଣଙ୍କ existing check ରଖନ୍ତୁ, high-impact action ଗୁଡ଼ିକରେ review କୁ route କରନ୍ତୁ। handling Unknown traffic ଉପରେ guide pattern ଗୁଡ଼ିକୁ ଦେଖାଏ।

response କିଏ ନିର୍ଣ୍ଣୟ କରେ

Bot management ସହ, edge ରେ ଥିବା rule set ନିଷ୍ପତ୍ତି କରେ। ଏହା କାର୍ଯ୍ୟକ୍ଷମ ଏବଂ ଆପଣଙ୍କ property ଗୁଡ଼ିକରେ ନିଷ୍ପତ୍ତିଗୁଡ଼ିକୁ ସମନ୍ୱିତ ରଖେ।

Proof of Actor ସହ, ଆପଣଙ୍କ application ନିଷ୍ପତ୍ତି କରେ। Product actor context ଦିଏ; ଆପଣଙ୍କ code policy ପ୍ରୟୋଗ କରେ। ଆପଣ verified agent ମାନଙ୍କୁ people ପାଇଁ ତିଆରି page ପରିବର୍ତ୍ତେ structured API ଦେଇପାରନ୍ତି, human session ପାଇଁ ସାଧାରଣ experience ରଖିପାରନ୍ତି, AI-assisted submission କୁ label କରିପାରନ୍ତି, ଏବଂ ଆପଣଙ୍କ own condition ଆବଶ୍ୟକ କଲେ sensitive action ଉପରେ stronger credential ମାଗିପାରନ୍ତି। Policy ପ୍ରତ୍ୟେକ route, ପ୍ରତ୍ୟେକ actor class ଏବଂ ପ୍ରତ୍ୟେକ basis ଅନୁଯାୟୀ ଲେଖାଯାଏ, ଏବଂ ସେଗୁଡ଼ିକ ଅନ୍ୟ business logic ସହିତ ପାଖରେ ରହେ।

ପ୍ରଥମେ observation

Bot management ସାଧାରଣତଃ enforce କରିବା ପାଇଁ install କରାଯାଏ, କାରଣ ଏହାର ସମ୍ପୂର୍ଣ୍ଣ value ହେଉଛି abuse ରୋକିବା।

Proof of Actor observation mode ରୁ ଆରମ୍ଭ କରେ। ଏହା install କରିଲେ ଆପଣଙ୍କ application କିପରି ବ୍ୟବହାର କରେ, ସେଥିରେ କିଛି ପରିବର୍ତ୍ତନ ହୁଏନାହିଁ। ଆପଣ route ଅନୁଯାୟୀ ଆପଣଙ୍କ real actor mix ଦେଖନ୍ତି, evidence ସମୀକ୍ଷା କରନ୍ତି, real traffic ବିରୁଦ୍ଧରେ policy ର ପ୍ରଭାବ preview କରନ୍ତି, ଏବଂ ପ୍ରସ୍ତୁତ ହେଲେ ମାତ୍ର, ଏକ ସମୟରେ ଏକ route ରେ enforce କରନ୍ତି। rolling out actor-aware policies safely ଉପରେ guide ପ୍ରକ୍ରିୟାକୁ ଆବରଣ କରେ।

ଦୁଇଟି କିପରି ଏକାସାଙ୍ଗରେ କାମ କରେ

ସବୁଠାରୁ ଶକ୍ତିଶାଳୀ setup ଦୁଇଟିକୁ ବ୍ୟବହାର କରେ, ପ୍ରତ୍ୟେକ ନିଜ layer ରେ:

Edge ରେ, bot management credential stuffing, scraping abuse ଏବଂ volumetric attack କୁ ରୋକେ।
ଆପଣଙ୍କ application ଭିତରେ, Proof of Actor ପାର୍ ହୋଇଆସିଥିବା traffic କୁ Human, Human + AI, Agent କିମ୍ବା Unknown ଭାବରେ, basis ସହିତ, classify କରେ।
ଆପଣଙ୍କ code ଭିତରେ, policy ସେହି context ବ୍ୟବହାର କରି experience ବାଛେ: verified agent ପାଇଁ structured API, ଲୋକ ପାଇଁ ସାଧାରଣ flow, AI-assisted submission ପାଇଁ label, Unknown ପାଇଁ explicit fallback।
ଆପଣଙ୍କ analytics ଭିତରେ, ଆପଣଙ୍କ team ଦେଖେ କେଉଁ route ଏବଂ workflow ପ୍ରତ୍ୟେକ actor class ବ୍ୟବହାର କରୁଛି, ଯାହାଦ୍ୱାରା product ଏବଂ security ଏକେ ଚିତ୍ରରୁ କାମ କରନ୍ତି।

Edge decision କୁ actor result ସହିତ record କରିଲେ ଚିତ୍ର ସମ୍ପୂର୍ଣ୍ଣ ହୁଏ: protection କ’ଣ କଲା, ଏବଂ ସତ୍ୟରେ କିଏ କାର୍ଯ୍ୟ କରୁଥିଲା।

କେବେ କ’ଣ ବାଛିବେ

ଆପଣଙ୍କ ପ୍ରଧାନ ସମସ୍ୟା abuse ହେଲେ bot management ବାଛନ୍ତୁ: account takeover ଚେଷ୍ଟା, inventory hoarding, aggressive scraping କିମ୍ବା traffic flood।

ଆପଣଙ୍କ ପ୍ରଧାନ ପ୍ରଶ୍ନ ଯଦି ନିଜ user ବିଷୟରେ ହୋଇଥାଏ ତେବେ Proof of Actor ବାଛନ୍ତୁ: କେତେଟା product agent ପୂର୍ବରୁ ବ୍ୟବହାର କରୁଛନ୍ତି, କେଉଁ agent ଆପଣଙ୍କ API କିମ୍ବା MCP server କୁ call କରୁଛି, AI-assisted ଲୋକ କେଉଁଠି ଅସୁବିଧା ଭୋଗୁଛନ୍ତି, ଏବଂ କେଉଁ route actor-aware policy ଆବଶ୍ୟକ କରେ।

ଏକ production application, API କିମ୍ବା MCP server ଚଳାଉଥିବା ଅଧିକାଂଶ team କୁ ଦୁହିଁ ପ୍ରଶ୍ନର ଉତ୍ତର ଦରକାର, ଯେଉଁଥିପାଇଁ ଦୁଇଟି ସମାନ stack ରେ ରହିବା ଉଚିତ।

ଆରମ୍ଭ କରନ୍ତୁ

Proof of Actor private beta ରେ ଅଛି। ବାଛାଯାଇଥିବା founding developer team ମାନେ agreed usage limits ଭିତରେ up to 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 ପଛରେ ଥିବା signal, ଯାହାଦ୍ୱାରା ଆପଣଙ୍କ team କାହିଁକି ତାହା ଦେଖିପାରିବ।

observation mode ରେ ଆରମ୍ଭ କରନ୍ତୁ: ଆପଣଙ୍କ log ପାଖରେ result record କରନ୍ତୁ ଏବଂ ଆପଣ policy ବାଛିବା ପର୍ଯ୍ୟନ୍ତ କିଛି ମଧ୍ୟ ପରିବର୍ତ୍ତନ କରନ୍ତୁ ନାହିଁ। Node.js integration guide ପଢନ୍ତୁ

ସାଧାରଣ ପ୍ରଶ୍ନଗୁଡ଼ିକ

Proof of Actor bot management କୁ ପ୍ରତିସ୍ଥାପନ କରେ କି?

ନା। Bot management credential stuffing, scraping abuse ଏବଂ volumetric attack ଭଳି ଦୁର୍ବ୍ୟବହାରମୂଳକ automation କୁ ଆପଣଙ୍କ application ପହଞ୍ଚିବା ପୂର୍ବରୁ ରୋକେ। Proof of Actor ଆପଣଙ୍କ application ଭିତରେ କାମ କରେ ଏବଂ product ଓ policy ନିଷ୍ପତ୍ତି ପାଇଁ actor context ଦିଏ। ଉଭୟକୁ ରଖନ୍ତୁ।

Product ନିଷ୍ପତ୍ତି ପାଇଁ bot score ବ୍ୟବହାର କରିବା ଉଚିତ କାହିଁକି ନୁହେଁ?

Bot score ର ଲକ୍ଷ୍ୟ ହେଉଛି କୌଣସି request କୁ ରୋକିବା କି ନାହିଁ, ସେଥିରେ ଉତ୍ତର ଦେବା। ସାଧାରଣତଃ ଏହା କହେ ନାହିଁ କି ଏକ ଲୋକ AI ସହ କାମ କରୁଥିଲେ, କେଉଁ agent ଡାକୁଛି, କିମ୍ବା score କେଉଁ evidence ଉପରେ ଭିତ୍ତି କରିଛି। Proof of Actor ଏକ class ଏବଂ ସ୍ପଷ୍ଟ basis ଫେରାଇଦିଏ, ଯାହା product ନିଷ୍ପତ୍ତି ପାଇଁ ଆବଶ୍ୟକ।

ଦୁଇଟି କି signal ଭାଗ କରିପାରିବେ?

ହଁ। ଆପଣଙ୍କ application edge control ର outcome କୁ Proof of Actor result ସହ ଏକାସାଙ୍ଗରେ record କରିପାରେ, ଯାହାଦ୍ୱାରା ଆପଣଙ୍କ team ଏକେ request ପାଇଁ protection decision ଏବଂ actor context ଦୁହେଁ ଦେଖିପାରିବେ।

Proof of Actor traffic କୁ block କରେ କି?

ନା। ଏହା observation mode ରୁ ଆରମ୍ଭ କରେ ଏବଂ ଆପଣ policy ଲେଖିବା ପର୍ଯ୍ୟନ୍ତ କିଛି ପରିବର୍ତ୍ତନ କରେନାହିଁ। Enforcement ସବୁବେଳେ ଆପଣଙ୍କ own application code ମଧ୍ୟରେ ରହେ।

ମୁଁ କୁହାଁଟି ପ୍ରଥମେ ଯୋଡ଼ିବି?

ଯଦି ଆପଣଙ୍କ ପାଖରେ active abuse ଅଛି, bot management ରୁ ଆରମ୍ଭ କରନ୍ତୁ। ଯଦି ଆପଣ ନିଜ product ବ୍ୟବହାର କରୁଥିବା ଲୋକ, AI-assisted user ଏବଂ agent ମାନଙ୍କୁ ବୁଝିବା ଏବଂ ସେବା ଦେବାକୁ ଚାହୁଁଛନ୍ତି, Proof of Actor ଯୋଡ଼ନ୍ତୁ। ଅଧିକାଂଶ production team ଦୁଇଟିକୁ ଶେଷରେ ରଖନ୍ତି।

ଆପଣଙ୍କ app କୁ କିଏ ବ୍ୟବହାର କରୁଛି, ତାହା ଜାଣନ୍ତୁ।

Founding developer ଙ୍କ ଛୋଟ ଦଳ ପାଇଁ private beta।

Early Access ପାଆନ୍ତୁ ମୂଲ୍ୟ ଦେଖନ୍ତୁ

ପ୍ରଥମେ କଥାହେବାକୁ ପସନ୍ଦ କରନ୍ତି? founderମାନଙ୍କ ସହ କଥାବାର୍ତ୍ତା କରନ୍ତୁ