ମୁଖ୍ୟ ବିଷୟବସ୍ତୁକୁ ଛାଡ଼ନ୍ତୁ
AI ଏଜେଣ୍ଟ ଚିହ୍ନଟ

ପ୍ରତ୍ୟେକ ଫଳାଫଳର ପଛରେ ଥିବା ପ୍ରମାଣ ସହିତ, ୱେବସାଇଟ୍‌ଗୁଡ଼ିକ ପାଇଁ AI ଏଜେଣ୍ଟ ଚିହ୍ନଟ

ଆପଣଙ୍କ ୱେବସାଇଟ୍‌ରେ କେଉଁ ଇଣ୍ଟରାକ୍ସନ୍‌ଗୁଡ଼ିକ ଲୋକମାନଙ୍କ ଠାରୁ, AI ସହ କାମ କରୁଥିବା ଲୋକମାନଙ୍କ ଠାରୁ, ସ୍ୱୟଂଚାଳିତ ଏଜେଣ୍ଟମାନଙ୍କ ଠାରୁ, କିମ୍ବା ଏମିତି ସ୍ରୋତରୁ ଆସୁଛି ଯାହାକୁ ପ୍ରମାଣ ଏପର୍ଯ୍ୟନ୍ତ ଚିହ୍ନଟ କରିପାରୁନାହିଁ, ତାହା ଦେଖନ୍ତୁ। ପ୍ରତ୍ୟେକ ଫଳାଫଳରେ ତାହା କ’ଣ ଆଧାରରେ ଅଛି ତାହା ଦେଖାଯାଏ।

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

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

ଆପଣଙ୍କ ୱେବସାଇଟ୍‌ରେ ଏବେ ଗୋଟିଏ ନୁହେଁ, ଅନେକ ପ୍ରକାରର visitor ଅଛନ୍ତି

ୱେବର ଇତିହାସର ଅଧିକାଂଶ ସମୟରେ, ଗୋଟିଏ website ସରଳ ମଡେଲ୍ ଧାରଣ କରିପାରୁଥିଲା: ଜଣେ person browser ଖୋଲନ୍ତି, କିଛି କ୍ଲିକ୍ କରନ୍ତି, ଏବଂ ସମ୍ଭବତଃ sign in କରନ୍ତି। analytics, rate limit, onboarding flow ଏବଂ security check ସବୁ ସେଇ personକୁ ଧ୍ୟାନରେ ରଖି ଡିଜାଇନ୍ ହୋଇଥିଲା।

ଏହି ମଡେଲ୍ ଆଉ ପ୍ରକୃତ trafficକୁ ବର୍ଣ୍ଣନା କରେନାହିଁ। ଆଜି ଗୋଟିଏ website ସ୍ୱୟଂ ନିଜେ browsing କରୁଥିବା ଲୋକମାନେ, AI assistantକୁ ସାରାଂଶ କରିବାକୁ କିମ୍ବା ସେମାନଙ୍କ ପାଇଁ କିଛି ପୂରଣ କରିବାକୁ କୁହୁଥିବା ଲୋକମାନେ, ଜଣେ ଅନ୍ୟ କାହାରି ପକ୍ଷରୁ pages ପଢ଼ିବା ଏବଂ endpoint call କରୁଥିବା autonomous agent, ଏବଂ crawler ଓ scriptର ଏକ ଦୀର୍ଘ ପୁଛକୁ ସେବା ଦେଉଛି। AI providerମାନେ ଏହି visitorମାନଙ୍କ ମଧ୍ୟରୁ କିଛିକୁ ନିଜେ ଡକ୍ୟୁମେଣ୍ଟ କରନ୍ତି: ଉଦାହରଣ ସ୍ୱରୂପ, OpenAI ତାଙ୍କ search crawler, training crawler ଏବଂ ChatGPT user ଗୋଟିଏ ପ୍ରଶ୍ନ କରିବାବେଳେ pages visit କରୁଥିବା fetcher ପାଇଁ ଅଲଗା user agent ପ୍ରକାଶ କରେ (OpenAI crawler documentation), ଏବଂ Anthropic ClaudeBot, Claude-User ଏବଂ Claude-SearchBot ପାଇଁ ଏହିପରି କରେ (Anthropic crawler documentation). ଏହି visitorମାନଙ୍କ ମଧ୍ୟରୁ କିଛି ସ୍ୱାଗତଯୋଗ୍ୟ। କିଛିକୁ ଭିନ୍ନ experience ଦରକାର। କିଛିଙ୍କୁ କୌଣସି ସମ୍ବେଦନଶୀଳ କାର୍ଯ୍ୟ ପୂର୍ବରୁ ନିକଟରୁ ଯାଞ୍ଚ କରିବା ଦରକାର।

ସମସ୍ୟା ହେଉଛି ଯେ ଏହି interactionମାନଙ୍କର ଅଧିକାଂଶ ପ୍ରଥମ ଦୃଷ୍ଟିରେ ଏକରକମ ଲାଗେ। ଗୋଟିଏ login ଆପଣଙ୍କୁ କେଉଁ account ବ୍ୟବହାରରେ ଅଛି ତାହା କହେ। କିନ୍ତୁ ଏହା କହେନାହିଁ ଯେ ଜଣେ person କ୍ଲିକ୍ କରୁଛନ୍ତି କି, ଜଣେ assistant ସେଇ session ମାଧ୍ୟମରେ କାର୍ଯ୍ୟ କରୁଛି କି, କିମ୍ବା ଜଣେ automated client ଦୂରରେ ଥିବା ଜଣେ user ପାଇଁ ଆପଣଙ୍କ pricing page ପଢ଼ୁଛି କି। ୱେବସାଇଟ୍‌ଗୁଡ଼ିକ ପାଇଁ AI agent detection ହେଉଛି ପ୍ରମାଣ ସହିତ ସେଇ ତଫାତକୁ ପୁରଣ କରିବା, ଯାହାଦ୍ୱାରା ଆପଣଙ୍କ ଟିମ୍ ସମସ୍ତ trafficକୁ ଏକେଭଳି ହାତଲ କରିବା ପରିବର୍ତ୍ତେ ପ୍ରତ୍ୟେକ actor ପ୍ରକାରକୁ ଯଥାଯଥ ଭାବରେ ପ୍ରତିକ୍ରିୟା କରିପାରିବ। ସିଗ୍ନାଲ୍‌ଗୁଡ଼ିକ ବିଷୟରେ ଏକ ବ୍ୟବହାରିକ walkthrough ପାଇଁ, ୱେବସାଇଟ୍ traffic AI agentମାନଙ୍କ ଠାରୁ ଆସୁଛି କିପରି ଜାଣିବେ ପଢ଼ନ୍ତୁ, ଏବଂ production siteରେ ଏହା କିପରି ଦେଖାଯାଏ ତାହା ପାଇଁ websites use case ଦେଖନ୍ତୁ।

କାହିଁକି ଗୋଟିଏ bot score ପର୍ଯ୍ୟାପ୍ତ ନୁହେଁ

ଅନେକ tool ଏହି ପ୍ରଶ୍ନର ଉତ୍ତର ଗୋଟିଏ number ସହିତ ଦିଏ: bot score, risk score, ଏକ percentage ଯାହା visitor କେତେ human ତାହା ବର୍ଣ୍ଣନା କରେ ବୋଲି ଦାବି କରେ। ଏହାର ଆକର୍ଷଣ ସ୍ପଷ୍ଟ। ଗୋଟିଏ numberକୁ ruleରେ ରଖିବା ସହଜ।

ସମସ୍ୟା ହେଉଛି ଯେ ଗୋଟିଏ number ଯୁକ୍ତିକୁ ଲୁଚାଇଦିଏ। ଯେତେବେଳେ score କହେ ଯେ sessionଟି ସମ୍ଭବତଃ automated, ଆପଣଙ୍କ ଟିମ୍ ଦେଖିପାରେନାହିଁ ଯେ ସେଇ ନିଷ୍କର୍ଷ verified signature, ସେଇ user-agent string ଯାହା କେହି ମଧ୍ୟ copy କରିପାରେ, କିମ୍ବା ଗୋଟିଏ pattern ଉପରେ ଆଧାରିତ ଯାହା ତୀବ୍ର speedରେ type କରୁଥିବା human ସହିତ ମଧ୍ୟ ମେଳ ଖାଏ। ଯେତେବେଳେ ସେଇ score block କିମ୍ବା challenge drive କରେ, ଆପଣ କୌଣସି customer, colleague କିମ୍ବା auditorକୁ ବ୍ୟାଖ୍ୟା କରିବାର ଉପାୟ ବିନା ତାହାର ପ୍ରତ୍ୟେକ ଭୁଲକୁ ଉତ୍ତରାଧିକାର କରନ୍ତି।

Proof of Actor ଏକ ଭିନ୍ନ ପ୍ରବନ୍ଧନ ନେଇଥାଏ। ପ୍ରତ୍ୟେକ ଫଳାଫଳ Human, AI-assisted or agent: a taxonomy for app trafficରେ ବ୍ୟାଖ୍ୟା କରାଯାଇଥିବା ଚାରିଟି ସ୍ପଷ୍ଟ class ମଧ୍ୟରୁ ଗୋଟିଏ, ଏବଂ ପ୍ରତ୍ୟେକ ଫଳାଫଳ କହେ ଯେ ଏହା କ’ଣ ଆଧାରରେ ଅଛି। ଆପଣ ନିଷ୍କର୍ଷ ଏବଂ ପ୍ରମାଣକୁ ଏକାସଙ୍ଗରେ ଦେଖନ୍ତି, ଯାହାର ଅର୍ଥ ହେଲା ଆପଣ ଶକ୍ତିଶାଳୀ ଫଳାଫଳକୁ ଭରସା କରିପାରିବେ, ଦୁର୍ବଳଗୁଡ଼ିକୁ ପ୍ରଶ୍ନ କରିପାରିବେ, ଏବଂ ପ୍ରମାଣର ଗୁଣବତ୍ତା ସହିତ ମେଳ ଖାଇଥିବା policy ଗଢ଼ିପାରିବେ।

ଆପଣଙ୍କ ୱେବସାଇଟ୍‌ରେ AI agentମାନଙ୍କୁ ଚାରିଟି ପଦକ୍ଷେପରେ କିପରି ଚିହ୍ନଟ କରିବେ

ଆପଣ ପୂର୍ବରୁ ଥିବା toolଗୁଡ଼ିକ ସହିତ ଆପଣଙ୍କ websiteରେ AI agent ଚିହ୍ନଟ କରିବା ଆରମ୍ଭ କରିପାରିବେ। ଏହି ଚାରିଟି ପଦକ୍ଷେପ vendor-neutral ଏବଂ ଆପଣ Proof of Actor ବ୍ୟବହାର କରନ୍ତୁ କି ନାହିଁ କାମ କରେ; ୱେବସାଇଟ୍ traffic AI agentମାନଙ୍କ ଠାରୁ ଆସୁଛି କିପରି ଜାଣିବେ ବିଷୟରେ blog post ପ୍ରତ୍ୟେକଟିକୁ ଅଧିକ ଗଭୀରତାରେ କଭର୍ କରେ।

  1. ସେମାନେ ନିଜେ ପରିଚୟ ଦେଉଥିବା agentମାନଙ୍କୁ ତାଲିକାଭୁକ୍ତ କରନ୍ତୁ। AI providerମାନେ ପ୍ରକାଶ କରିଥିବା user agentମାନଙ୍କ ପାଇଁ ଆପଣଙ୍କ server କିମ୍ବା CDN log search କରନ୍ତୁ। OpenAI OAI-SearchBot, GPTBot ଏବଂ ChatGPT-User ଡକ୍ୟୁମେଣ୍ଟ କରେ, ଏବଂ କହେ ଯେ ChatGPT-User ତେବେ pages visit କରେ ଯେତେବେଳେ user ChatGPTକୁ ପ୍ରଶ୍ନ କରେ, automatic crawling କରିବା ପରିବର୍ତ୍ତେ। Anthropic ClaudeBot, Claude-User ଏବଂ Claude-SearchBot ଡକ୍ୟୁମେଣ୍ଟ କରେ। ଏହା ଆପଣଙ୍କୁ route ଅନୁସାରେ agent trafficର ଗୋଟିଏ ପ୍ରଥମ, declared ଚିତ୍ର ଦିଏ।
  2. stringକୁ ଭରସା କରିବା ପରିବର୍ତ୍ତେ ଦାବିଗୁଡ଼ିକୁ verify କରନ୍ତୁ। user agent self-reported ଏବଂ copy କରିବା ସହଜ। ଏହାକୁ operatorଙ୍କ ନିଜ verification method ସହିତ ଯାଞ୍ଚ କରନ୍ତୁ: Google reverse DNS lookup ପରେ forward DNS lookup, ସହିତ published IP range file, Googlebot ପାଇଁ ବର୍ଣ୍ଣନା କରେ (Google: verifying Googlebot); Bing Bingbot ପାଇଁ reverse ଏବଂ forward DNS check ସେଇଭଳି ବର୍ଣ୍ଣନା କରେ (Bing: verifying Bingbot); OpenAI ତାଙ୍କ ପ୍ରତ୍ୟେକ user agent ପାଇଁ IP range file ପ୍ରକାଶ କରେ। ଯେଉଁଠାରେ client ତାଙ୍କ requestକୁ HTTP Message Signatures ସହିତ, RFC 9421ରେ ପରିଭାଷିତ, sign କରେ, operatorଙ୍କ ପ୍ରକାଶିତ key ବିରୁଦ୍ଧରେ signature ଯାଞ୍ଚ କରନ୍ତୁ।
  3. ପ୍ରତ୍ୟେକ ଫଳାଫଳକୁ ତାହାର ପ୍ରମାଣ ସହିତ ଚିହ୍ନିତ କରନ୍ତୁ, ଏବଂ Unknownକୁ ରଖନ୍ତୁ। ପ୍ରତ୍ୟେକ ନିଷ୍କର୍ଷ verified, declared କିମ୍ବା inferred କି ନୁହେଁ ରେକର୍ଡ କରନ୍ତୁ। କୌଣସି verified କିମ୍ବା declared agent ସହିତ ମେଳ ନ ଖାଉଥିବା ଏବଂ କୌଣସି ସ୍ପଷ୍ଟ human pattern ନ ଦେଖାଉଥିବା trafficକୁ human କିମ୍ବା botରେ ବଳଜୋରେ ଭର୍ତ୍ତି କରିବା ପରିବର୍ତ୍ତେ Unknown ଭାବେ label କରାଯିବା ଉଚିତ। ଏହାହିଁ ଉପଯୋଗୀ reportକୁ ଅନୁମାନରୁ ଅଲଗା କରୁଥିବା ପଦକ୍ଷେପ।
  4. କାର୍ଯ୍ୟ କରିବା ପୂର୍ବରୁ route ଅନୁସାରେ observe କରନ୍ତୁ। କିଛି ସପ୍ତାହ ପର୍ଯ୍ୟନ୍ତ public content, signup, account settings, API ମାନଙ୍କ ପାଇଁ route ଏବଂ workflow ଅନୁସାରେ ଫଳାଫଳଗୁଡ଼ିକ ଭାଗ କରନ୍ତୁ। ତାପରେ ମାତ୍ର actor context ସବୁଠାରୁ ଅଧିକ ମହତ୍ତ୍ୱପୂର୍ଣ୍ଣ ଥିବା route ପାଇଁ ଗୋଟିଏ ସଙ୍କୀର୍ଣ୍ଣ policy ଲେଖନ୍ତୁ, Unknown ପାଇଁ ସ୍ପଷ୍ଟ fallback ସହିତ।

Proof of Actor ଆପଣଙ୍କ application ଭିତରେ ଏହି ପଦକ୍ଷେପଗୁଡ଼ିକୁ ସ୍ୱୟଂଚାଳିତ କରେ: ଏହା ଆପଣଙ୍କ integration ଦେଖିପାରୁଥିବା signalଗୁଡ଼ିକ ସଂଗ୍ରହ କରେ, ତାହାର basis ସହିତ class ଫେରାଇଦିଏ, route ଅନୁସାରେ Unknownକୁ ଟ୍ରାକ୍ କରେ, ଏବଂ policyକୁ ଆପଣଙ୍କ code ପାଇଁ ଛାଡ଼ି ଦିଏ।

Proof of Actor କିପରି websiteରେ AI agent ଚିହ୍ନଟ କରେ

Proof of Actor ଗୋଟିଏ ସରଳ path ଉପରେ ନିର୍ମିତ: ଆପଣଙ୍କ integration observe କରିପାରୁଥିବା signal, ଏକ explicit basis ସହିତ classification, ଏବଂ ଏକ decision ଯାହା ଆପଣଙ୍କ ହାତରେ ରହେ। ଆପଣ ସମ୍ପୂର୍ଣ୍ଣ flow How It Works ପୃଷ୍ଠାରେ ପଢ଼ିପାରିବେ। ଏଠାରେ ସଂକ୍ଷିପ୍ତ ସଂସ୍କରଣ ରହିଛି।

ଆପଣଙ୍କ integrationରୁ signalଗୁଡ଼ିକ

ପ୍ରତ୍ୟେକ integration ତାହାର context ଯେତେଦୂର ଅନୁମତି ଦେଉଛି, ସେତେଦୂର ଦେଖେ। ଗୋଟିଏ server-side integration request context, protocol detail ଏବଂ, ଯେତେବେଳେ client ଏହାକୁ support କରେ, ଗୋଟିଏ request signature ଦେଖେ। ଗୋଟିଏ browser integration ଯେ pagesରେ ଏହା run କରେ, ସେଠାରେ interaction signal ଦେଖେ। ଗୋଟିଏ application ନିଜର declarationମାନେ ମଧ୍ୟ record କରିପାରେ, ଯେପରିକି user AI assistance ସହିତ drafted ଭାବରେ content ଚିହ୍ନିତ କରୁଛନ୍ତି, କିମ୍ବା agent client ନିଜକୁ ନାମ ଦେଉଛି।

Proof of Actor ପ୍ରକୃତରେ ଉପସ୍ଥିତ ପ୍ରମାଣ ସହିତ କାମ କରେ। ଆପଣଙ୍କ website ଦେଖିପାରେନଥିବା ଜିନିଷକୁ ଦେଖୁଛି ବୋଲି ଏହା ଅଭିନୟ କରେନାହିଁ।

ଚାରିଟି class ଯାହାର ନିର୍ଦ୍ଦିଷ୍ଟ ଅର୍ଥ ଅଛି

ପ୍ରତ୍ୟେକ interaction ଚାରିଟି class ମଧ୍ୟରୁ ଗୋଟିଏରେ ପଡ଼େ:

  • Human: ଦେଖାଯାଉଥିବା signalଗୁଡ଼ିକ human-ନିର୍ଦ୍ଦେଶିତ interactionକୁ ସୂଚିତ କରେ।
  • Human + AI: AI assistance declared ହୋଇଛି, କିମ୍ବା ଏକ supported integration ମାଧ୍ୟମରେ observe ହୋଇଛି ଯାହା ଏହାକୁ ଦେଖିପାରେ।
  • Agent: automated କିମ୍ବା agent-origin interaction, verifiable identity କିମ୍ବା ସାବଧାନତାର ସହିତ qualified inference ଦ୍ୱାରା ସମର୍ଥିତ।
  • Unknown: ଉପଲବ୍ଧ ପ୍ରମାଣ ଏକ reliable determinationକୁ support କରେନାହିଁ।

ପ୍ରତ୍ୟେକ class ସହିତ ସ୍ପଷ୍ଟ ପରିଭାଷା ଏବଂ ସ୍ପଷ୍ଟ ସୀମା ଆସେ। Human result verified identity ନୁହେଁ। Agent result agent authorized ଅଛି ବୋଲି ବକ୍ତବ୍ୟ ନୁହେଁ। Unknown result ଏକ ଅଭିଯୋଗ ନୁହେଁ। ଆପଣ ସମ୍ପୂର୍ଣ୍ଣ taxonomy Detection & Limitations ପୃଷ୍ଠାରେ ପଢ଼ିପାରିବେ।

ପ୍ରତ୍ୟେକ ଫଳାଫଳରେ ଗୋଟିଏ basis

class ସହିତ, ପ୍ରତ୍ୟେକ ଫଳାଫଳ ତାହାର basis ବୋକେ: verified, declared, inferred କିମ୍ବା unknown। ପ୍ରକାଶିତ keyରୁ valid signature ଧାରଣ କରୁଥିବା request ସେଇ check ପାଇଁ verified। ନିଜକୁ agent ଭାବେ ନାମକରଣ କରୁଥିବା client ତାହାକୁ declared କରିଛି। ସ୍ୱୟଂଚାଳନ ସହିତ ସମନ୍ୱୟ ରଖୁଥିବା behavior pattern ଗୋଟିଏ inference। ଏହି ପାର୍ଥକ୍ୟ ହିଁ ଆପଣଙ୍କ policyଗୁଡ଼ିକୁ ସଠିକ୍ କରିବାକୁ ସହାୟ କରେ। read-only routeରେ verified signed agent ଏବଂ account settings pageରେ self-declared clientକୁ ସେଇଭଳି ହାତଲ କରାଯିବା ଉଚିତ ନୁହେଁ, ଏବଂ Proof of Actor ସହିତ ସେମାନେ ତାହା କରିବାକୁ ପଡ଼େନାହିଁ। evidence basis glossary entry ପ୍ରତ୍ୟେକକୁ ଅଧିକ ବିସ୍ତାରରେ ବ୍ୟାଖ୍ୟା କରେ।

ଆପଣଙ୍କ ଟିମ୍ କ’ଣ ପାଏ: Detect, Understand, Route

Proof of Actor ହେଉଛି ଗୋଟିଏ product ଯାହାର ତିନିଟି capability ଏକାସଙ୍ଗରେ କାମ କରେ।

Detect

ଆପଣଙ୍କ integration ପାଇଁ ଉପଲବ୍ଧ actor signalଗୁଡ଼ିକ ସଂଗ୍ରହ କରନ୍ତୁ ଏବଂ verified assertionଗୁଡ଼ିକୁ behavioral inference ଠାରୁ ଅଲଗା କରନ୍ତୁ। Unknown traffic ଏକ guessରେ ମିଶିଯିବା ପରିବର୍ତ୍ତେ ତାହାର ନିଜ category ଭାବରେ ଦେଖାଯାଇ ରହେ। ଆପଣ ସବୁବେଳେ କେଉଁ interaction ବିଷୟରେ ଆପଣ confidence ସହିତ କହିପାରିବେ ଏବଂ କେଉଁଗୁଡ଼ିକୁ ଅଧିକ ପ୍ରମାଣ ଆବଶ୍ୟକ, ତାହା ଜାଣିଥାନ୍ତି।

Understand

ଆପଣଙ୍କ AI agent trafficକୁ contextରେ ଦେଖନ୍ତୁ। route ଏବଂ ସମୟ ଅନୁସାରେ interaction type ଅନ୍ବେଷଣ କରନ୍ତୁ, human, AI-assisted, agent ଏବଂ unknown activityର trend ଅନୁସରଣ କରନ୍ତୁ, ଏବଂ ଯେକୌଣସି classification ଖୋଲି ଦେଖନ୍ତୁ କ’ଣ ଜଣାଯାଇଛି, କ’ଣ ଜଣାଯାଇନାହିଁ, ଏବଂ ଫଳାଫଳ କ’ଣ ଉପରେ ନିର୍ଭର କରେ। ଏହାଠାରେ product, platform ଏବଂ security teamମାନେ website ବ୍ୟବହାର କରୁଥିବା କିଏ, ତାହାର ଏକ ସେୟାର୍ଡ, explainable ଚିତ୍ର ପାଆନ୍ତି।

Route

ନିର୍ଦ୍ଦିଷ୍ଟ interactionମାନଙ୍କୁ allow, adapt, challenge, review କିମ୍ବା limit କରିବା ପାଇଁ ନିଜର policy ବ୍ୟବହାର କରନ୍ତୁ। ଆପଣଙ୍କ documentation ପଢ଼ୁଥିବା verified agentକୁ ଗୋଟିଏ structured response ସର୍ବ କରନ୍ତୁ। human-ନିର୍ଦ୍ଦେଶିତ session ପାଇଁ standard experience ରଖନ୍ତୁ। ଆପଣଙ୍କ ନିଜ conditions ଏହା ଆବଶ୍ୟକ କଲେ ଗୋଟିଏ sensitive account change ପାଇଁ ଅଧିକ କଠିନ check ଚାହନ୍ତୁ। Unknown result ଏବଂ timeout ପାଇଁ route by route ଗୋଟିଏ explicit fallback ବାଛନ୍ତୁ। Enforcement ସବୁବେଳେ ଆପଣଙ୍କ applicationରେ, ଆପଣଙ୍କ ଟିମ୍ ଯେ policy confirm କରିଛି ତାହାର ଅଧୀନରେ, ହୁଏ।

ଆପଣଙ୍କ websiteକୁ ମେଳ ଖାଉଥିବା ଭାବରେ ତିଆରି, ପରିବର୍ତ୍ତେ ଏହାକୁ ବଦଳାଇବା ପାଇଁ ନୁହେଁ

Proof of Actor ଆପଣ ଚଳାଉଥିବା ଟୁଲ୍‌ଗୁଡ଼ିକର ସହିତ ପାଖପାଖି ବସେ। ଏହା ଆପଣଙ୍କ authentication, ଆପଣଙ୍କ authorization model କିମ୍ବା ଆପଣଙ୍କ ପୂର୍ବବର୍ତ୍ତୀ abuse controlକୁ ପରିବର୍ତ୍ତନ କରେନାହିଁ। ଏହା ସେମାନଙ୍କୁ actor context ଯୋଡ଼େ।

ଗୋଟିଏ ସାଧାରଣ website integration ସେହି routeଗୁଡ଼ିକୁ ନେଇ ଆରମ୍ଭ ହୁଏ ଯେଉଁଠାରେ actor context ସବୁଠାରୁ ମହତ୍ତ୍ୱପୂର୍ଣ୍ଣ: public content ଯାହାକୁ agentମାନେ ବହୁତ ପଢ଼ନ୍ତି, signup ଏବଂ onboarding flow, account settings ଏବଂ ଅନ୍ୟ sensitive action, ଏବଂ siteକୁ power କରୁଥିବା କୌଣସି API। Founding teamମାନେ କେଉଁ route ନେବା, scopeରେ କେଉଁ signal agree କରିବା, ଏବଂ code ship ହେବା ପୂର୍ବରୁ data କିପରି handle ହେବ ତାହା confirm କରିବା ପାଇଁ ଆମର engineerମାନଙ୍କ ସହ କାମ କରନ୍ତି।

କାରଣ decision layer ଆପଣଙ୍କ code ମଧ୍ୟରେ ରହେ, ଆପଣ experience ଉପରେ control ରଖନ୍ତି। କୌଣସି rule change ପୂର୍ବରୁ କିଛି ସପ୍ତାହ ଆପଣ internal dashboardରେ ଫଳାଫଳ ଦେଖାଇପାରିବେ, ତାପରେ ଗୋଟିଏ route ପାଇଁ ଗୋଟିଏ ସଙ୍କୀର୍ଣ୍ଣ policy turn on କରିପାରିବେ, ତାପରେ ଫଳାଫଳ ଆପଣଙ୍କ trust ଅର୍ଜନ କରିଲେ ତାହାକୁ ବିସ୍ତାର କରିପାରିବେ। handling unknown traffic ଉପରେ guide ପ୍ରଥମ ruleଗୁଡ଼ିକ କିପରି ଡିଜାଇନ୍ କରିବା ତାହା ଦେଖାଏ।

observation modeରେ ଆରମ୍ଭ କରନ୍ତୁ

AI agent detectionରୁ value ପାଇବାର ସବୁଠାରୁ ତ୍ୱରିତ ଉପାୟ ହେଉଛି block କରିବା ପରିବର୍ତ୍ତେ ପ୍ରଥମେ ନଜର ରଖିବା। observation modeରେ, Proof of Actor ଫଳାଫଳ record କରେ ଯେତେବେଳେ ଆପଣଙ୍କ website ଏହା ବିନା ଯେପରି respond କରୁଥାଏ ସେଇଭଳି respond କରେ। ତାପରେ ଆପଣଙ୍କ ଟିମ୍ ପୂର୍ବରୁ ବୁଝିଥିବା outcomeଗୁଡ଼ିକ ସହିତ classificationଗୁଡ଼ିକ ତୁଳନା କରିପାରିବେ: support ticket, known integration, internal tool, ଏବଂ ଆପଣ ପୂର୍ବରୁ ଚିହ୍ନିଥିବା crawlerମାନେ।

ଏହା enforcement ପୂର୍ବରୁ ଆପଣଙ୍କୁ ତିନୋଟି ଜିନିଷ ଦିଏ:

  1. ଏକ baseline। ଆପଣଙ୍କ trafficର କେତେ ଅଂଶ human-directed, AI-assisted, agent-driven କିମ୍ବା unknown, route ଅନୁସାରେ।
  2. ପ୍ରମାଣରେ confidence। କେଉଁ signal ଆପଣଙ୍କ websiteରେ ଶକ୍ତିଶାଳୀ ଏବଂ coverage କେଉଁଠାରେ ବଢ଼ାଇବା ଦରକାର।
  3. ଉତ୍ତମ policy। ଅନୁମାନ ନୁହେଁ, ବାସ୍ତବ pattern ଉପରେ ଆଧାରିତ rule, false positive କାହାକୁ ପ୍ରଭାବିତ କରିବା ପୂର୍ବରୁ ସମୀକ୍ଷା କରାଯାଇଥିବା।

ଯେତେବେଳେ କୌଣସି policy ପ୍ରସ୍ତୁତ ହୁଏ, ଆପଣ ତାହାକୁ ସେଇ specific workflow ପାଇଁ enable କରନ୍ତି ଯାହା ପାଇଁ ଏହା ଡିଜାଇନ୍ ହୋଇଥିଲା, ଏବଂ ଆପଣ ସମୟ କେବେବି ଏହାକୁ adjust କରିବାର ସମର୍ଥତା ରଖନ୍ତି।

କାହିଁକି opaque score ଠାରୁ ପ୍ରମାଣ-ଆଧାରିତ detection ଜିତେ

ୱେବସାଇଟ୍‌ଗୁଡ଼ିକ ପୂର୍ବରୁ agent, assistant ଏବଂ AI ସହିତ କାମ କରୁଥିବା ଲୋକମାନଙ୍କୁ ପାଖପାଖି ସେବା ଦେଉଛି। ଏହି ଜଟିଳତାକୁ ଭଲଭାବେ ହାତଲ କରୁଥିବା teamମାନେ ସବୁଠାରୁ ଆକ୍ରାମକ filter ଥିବା team ହେବେନାହିଁ। ସେମାନେ ସେହି team ହେବେ ଯେଉଁମାନେ ନିଜ decision explain କରିପାରନ୍ତି।

ପ୍ରମାଣ-ଆଧାରିତ ଫଳାଫଳ ଆପଣଙ୍କୁ ସେଇ explanation ଦିଏ। ଯେତେବେଳେ support agent ପଚାରେ କାହିଁକି ଜଣେ user ଅତିରିକ୍ତ verification step ଦେଖିଲେ, ଆପଣ ପ୍ରମାଣ ଏବଂ ଲାଗୁଥିବା policyକୁ ଦେଖାଇପାରିବେ। ଯେତେବେଳେ agent operator ପଚାରେ କାହିଁକି ତାହାର signed requestକୁ structured response ଦିଆଗଲା, ଆପଣ verified basis ଦେଖାଇପାରିବେ। ଯେତେବେଳେ ପ୍ରମାଣ କମ୍ ଥାଏ, ଫଳାଫଳ Unknown କହେ, ଏବଂ ଆପଣଙ୍କ fallback ଏହାକୁ ଆପଣ ସଚେତନ ଭାବେ ବାଛିଥିବା ଉପାୟରେ handle କରେ।

ଏହି ପ୍ରବନ୍ଧନ ୱେବ ସହିତ ମଧ୍ୟ scale ହୁଏ। ଯେପରି ଅଧିକ agent operatorମାନେ ତାଙ୍କ request sign କରୁଛନ୍ତି ଏବଂ IETF Web Bot Auth working group, ଯାହା automated clientମାନଙ୍କ ପାଇଁ cryptographic authentication standardize କରିବାକୁ chartered, HTTP message signatures ଉପରେ build କରୁଛି, ଆପଣଙ୍କ trafficର ଅଧିକ ଅଂଶ inferred କିମ୍ବା unknown ଠାରୁ verifiedକୁ ଯାଏ, ଏବଂ ଆପଣଙ୍କ policyଗୁଡ଼ିକ ପୁନଲେଖନ ନକରି ଅଧିକ ସଠିକ୍ ହୁଏ।

founding developer programରେ ଯୋଗଦିଅନ୍ତୁ

Proof of Actor କିଛି application team ସହିତ private betaରେ ଅଛି। ଚୟନିତ founding developerମାନେ agreed usage limits ମଧ୍ୟରେ, hands-on product feedback ବଦଳରେ, 12 months ପର୍ଯ୍ୟନ୍ତ ମାଗଣା access ପାଇପାରିବେ। ଆପଣ ଆମର engineerମାନଙ୍କ ଠାରୁ ସିଧା integration support, ଉପଲବ୍ଧ ହେବା ସହିତ capabilities ପାଇଁ early access, ଏବଂ ଆମେ ପରବର୍ତ୍ତୀରେ କ’ଣ ତିଆରି କରୁଛୁ ତାହା ଉପରେ ପ୍ରକୃତ ପ୍ରଭାବ ପାଆନ୍ତି।

ଯଦି ଆପଣଙ୍କ website ଲୋକମାନଙ୍କୁ, AI-assisted userମାନଙ୍କୁ ଏବଂ agentମାନଙ୍କୁ ସେବା ଦେଉଛି, ଏବଂ ପରବର୍ତ୍ତୀରେ କ’ଣ ଘଟିବ ତାହା ଆପଣ ନିଷ୍ପତ୍ତି କରିବା ପୂର୍ବରୁ କିଏ ଏହା ବ୍ୟବହାର କରୁଛି ଜାଣିବାକୁ ଚାହାନ୍ତି, early access ପାଇଁ apply କରନ୍ତୁ। ଆପଣଙ୍କ website ଏବଂ ଯେ interactionକୁ ଆପଣ ସବୁଠାରୁ ଅଧିକ ବୁଝିବାକୁ ଚାହାନ୍ତି, ସେଥି ବିଷୟରେ ଆମକୁ କୁହନ୍ତୁ, ଏବଂ ବର୍ତ୍ତମାନର beta ପାଇଁ ଏହା ଯୋଗ୍ୟ କି ନୁହେଁ ଆମେ ସମୀକ୍ଷା କରିବୁ।

ପ୍ରଥମେ ବିସ୍ତାର ଦେଖିବାକୁ ଚାହାନ୍ତି? Proof of Actor ଅନ୍ବେଷଣ କରନ୍ତୁ, ଏହା କିପରି କାମ କରେ ପଢ଼ନ୍ତୁ, କିମ୍ବା ସଠିକ୍ ଭାବରେ ପ୍ରମାଣ କ’ଣ establish କରିପାରେ ଏବଂ କ’ଣ establish କରିପାରେନାହିଁ ସେଥି ସମୀକ୍ଷା କରନ୍ତୁ।

ସ୍ରୋତଗୁଡ଼ିକ

ବିକାଶକର୍ତ୍ତାମାନଙ୍କ ପାଇଁ

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 ସହିତ ୱେବସାଇଟ୍‌ଗୁଡ଼ିକ ପାଇଁ AI ଏଜେଣ୍ଟ ଚିହ୍ନଟ କିପରି କାମ କରେ?

Proof of Actor ଆପଣଙ୍କ integration ମାଧ୍ୟମରେ ଉପଲବ୍ଧ ସିଗ୍ନାଲ୍‌ଗୁଡ଼ିକ, ଯେପରିକି request signature, client declaration ଏବଂ interaction signal, ସଂଗ୍ରହ କରେ ଏବଂ ତାହାର ଆଧାର ସହିତ ଏକ ବର୍ଗୀକରଣ ଫେରାଇଦିଏ: verified, declared, inferred କିମ୍ବା unknown।

ଏହା ଇନ୍‌ଷ୍ଟଲ୍ କଲେ କିଛି visitor ଅଟକିଯିବେ କି?

ନା। Proof of Actor observation modeରୁ ଆରମ୍ଭ ହୁଏ। ଆପଣଙ୍କ website ପୂର୍ବବତ୍ ଭାବେ ଚାଲିଥାଏ, ଯେତେବେଳେ ଆପଣଙ୍କ ଟିମ୍ ଫଳାଫଳଗୁଡ଼ିକ ସମୀକ୍ଷା କରେ, ଏବଂ ପରେ କୌଣସି policy ଲାଗୁ କରିବେ କି ନାହିଁ ଆପଣ ନିଷ୍ପତ୍ତି କରନ୍ତି।

କେହି ଅନ୍ୟ tabରେ AI ବ୍ୟବହାର କରିଥିଲେ ଏହା ଚିହ୍ନଟ କରିପାରିବ କି?

କୌଣସି website ଅନ୍ୟ tab କିମ୍ବା ଅନ୍ୟ deviceର କାର୍ଯ୍ୟକଳାପ ଦେଖିପାରେନାହିଁ। Proof of Actor ସମର୍ଥିତ integration ମାଧ୍ୟମରେ ଏହା declared କିମ୍ବା observable ହେଲେ AI assistance ରିପୋର୍ଟ କରେ, ଏବଂ design ଅନୁସାରେ ଅନ୍ୟ ସବୁକିଛିକୁ ସ୍ପଷ୍ଟ ରଖେ।

ପ୍ରମାଣ ସ୍ପଷ୍ଟ ନଥିଲେ କ’ଣ ହୁଏ?

ଫଳାଫଳ Unknown ହୁଏ। Unknown ଏକ ପ୍ରଥମ-ଶ୍ରେଣୀର ଫଳାଫଳ, କେବେବି default ଭାବେ human ଭାବରେ ନୁହେଁ ଏବଂ କେବେବି default ଭାବେ malicious ଭାବରେ ନୁହେଁ। ପ୍ରତ୍ୟେକ route ଏହାକୁ କିପରି ହାତଲ କରିବ ସେଥିପାଇଁ ଆପଣଙ୍କ policy ନିଷ୍ପତ୍ତି କରେ।

Proof of Actor କାହା ପାଇଁ ନିର୍ମିତ?

ସେମାନଙ୍କ ପାଇଁ ଟିମ୍‌ଗୁଡ଼ିକ ଯେଉଁମାନେ SaaS application, website, API ଏବଂ MCP server ପରିଚାଳନା କରନ୍ତି ଏବଂ କୌଣସି experience କିମ୍ବା access policy ବାଛିବା ପୂର୍ବରୁ କିଏ କିମ୍ବା କ’ଣ କାର୍ଯ୍ୟ କରୁଛି ତାହା ବୁଝିବାକୁ ଚାହାନ୍ତି।

ମୁଁ access କିପରି ପାଇବି?

Proof of Actor private betaରେ ଅଛି। early access ପାଇଁ apply କରନ୍ତୁ। ଚୟନିତ founding developer ଟିମ୍‌ଗୁଡ଼ିକ agreed usage limits ମଧ୍ୟରେ 12 months ପର୍ଯ୍ୟନ୍ତ ମାଗଣା access ପାଇପାରିବେ।

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

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

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

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