AI ଏଜେଣ୍ଟ ପରିଚୟ

API ଗୁଡ଼ିକ ପାଇଁ AI ଏଜେଣ୍ଟ ପରିଚୟ

ଆପଣଙ୍କ API ପୂର୍ବରୁ ଜାଣେ କେଉଁ key ଏକ request କଲା। Proof of Actor ଆପଣଙ୍କୁ କହେ ତାହାର ପଛରେ କି ପ୍ରକାର actor ଥିଲା, ସେଥିପାଇଁ କେଉଁ ପ୍ରମାଣ ସମର୍ଥନ କରୁଛି, ଏବଂ ଆପଣଙ୍କ code କୁ ପରେ କଣ ହେବ ତାହା ନିର୍ଣ୍ଣୟ କରିବାକୁ ଦିଏ।

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

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

ଆପଣଙ୍କ API key କୁ ଜାଣେ। actor କୁ ଜାଣେ ନାହିଁ।

ପ୍ରତ୍ୟେକ API request କିଛି ପ୍ରମାଣ ସହିତ ଆସେ ଯେ କେଉଁ account ଏଥିପାଇଁ ପେମେଣ୍ଟ କରୁଛି: ଏକ API key, ଏକ OAuth token, ଏକ session। ସେହି ପ୍ରମାଣ ଗୋଟିଏ ପ୍ରଶ୍ନର ଭଲ ଉତ୍ତର ଦିଏ। ସେ ଆପଣଙ୍କୁ କୁହେ call ପାଇଁ କେଉଁ account ଦାୟୀ। ସେ ଆପଣଙ୍କୁ କୁହେ ନାହିଁ ଯେ ଏବେ ଆସଲେ କିଏ call କରୁଛି।

ଗୋଟିଏ API key କୁ terminal ରେ test କରୁଥିବା developer, schedule ଅନୁସାରେ ଚାଲୁଥିବା backend job, AI assistant ମାଧ୍ୟମରେ କାମ କରୁଥିବା person, ଏବଂ task ସମାପ୍ତ କରିବାକୁ key ଦିଆଯାଇଥିବା autonomous agent, ସବୁ ବ୍ୟବହାର କରିପାରେ। ସେଗୁଡ଼ିକ ଖୁବ ଭିନ୍ନ actor। ସେମାନଙ୍କର ଭିନ୍ନ rhythm, ଭିନ୍ନ failure mode ଏବଂ ଭିନ୍ନ risk profile ଅଛି। ସେମାନଙ୍କୁ ସମାନ ଭାବରେ ବ୍ୟବହାର କରିଲେ, ଆପଣ either legitimate automation କୁ ଅତ୍ୟଧିକ ରୋକିଦେବେ ଯାହା ଉପରେ ଆପଣଙ୍କ customer ନିର୍ଭର କରନ୍ତି, କିମ୍ବା ଆପଣଙ୍କ API ର ସେହି ଅଂଶକୁ ଅଳ୍ପ ସୁରକ୍ଷିତ କରିବେ ଯାହା unattended agent ଦ୍ୱାରା କେବେ ବି ଚାଳିତ ହେବା ଉଚିତ୍ ନୁହେଁ।

API ଗୁଡ଼ିକ ପାଇଁ AI ଏଜେଣ୍ଟ ପରିଚୟ ସେ gap କୁ ବନ୍ଦ କରେ। key ରୁ ସବୁକିଛି ଅନୁମାନ କରିବା ପରିବର୍ତ୍ତେ, ଆପଣ ପ୍ରତ୍ୟେକ request ପଛରେ actor ର classification ପାଇବେ, ଏବଂ ସେହି classification କୁ ସମର୍ଥନ କରୁଥିବା ପ୍ରମାଣ ମଧ୍ୟ। ଏହାই Proof of Actor ଦେବା ପାଇଁ ତିଆରି, ଏବଂ APIs use case ଦେଖାଏ API team ମାନେ route ଅନୁସାରେ କିପରି ଏହା ବ୍ୟବହାର କରନ୍ତି।

API team ମାନଙ୍କୁ ଏବେ actor context କାହିଁକି ଦରକାର

API ଗୁଡ଼ିକୁ automated traffic ନୂଆ ନୁହେଁ। script, integration ଏବଂ crawler ସଦା ପରିସ୍ଥିତିର ଅଂଶ ଥିଲେ। ଯାହା ବଦଳିଛି ସେହି automation ର ପ୍ରକାର। AI agent ମାନେ documentation ପଢ଼ିପାରନ୍ତି, call ଗୁଡ଼ିକୁ ଏକାଠି କରିପାରନ୍ତି, creatively retry କରିପାରନ୍ତି ଏବଂ ପ୍ରତ୍ୟେକ ପଦକ୍ଷେପ ଦେଖୁନଥିବା people ଙ୍କ ପକ୍ଷରୁ act କରିପାରନ୍ତି। ସେମାନଙ୍କ ମଧ୍ୟରୁ ଅନେକ ଉପଯୋଗୀ ଏବଂ ସ୍ୱାଗତଯୋଗ୍ୟ। କେତେକ ଖରାପ ଭାବେ ନିର୍ମିତ। କିଛି hostiles ମଧ୍ୟ ଅଛନ୍ତି।

Actor context ବିନା, API team ମାନେ ସାଧାରଣତଃ blunt tools କୁ ଫେରନ୍ତି:

Key ପ୍ରତି rate limit, ଯାହା good agent ଏବଂ bad agent ଦୁହେଁକୁ ସମାନ ଭାବେ ଧୀର କରେ।
User-agent rules, ଯାହା client ଏକ header ବଦଳାଇଲେ ଖସିଯାଏ।
Blanket block, ଯାହା legitimate automation କୁ ତାଙ୍କର web app କୁ scrape କରିବାକୁ ଠେଲିଦିଏ।

Actor context ଆପଣଙ୍କୁ ସଠିକତା ସହିତ respond କରିବାକୁ ଦିଏ। ଯେ operator କୁ ଆପଣ ଚିହ୍ନନ୍ତି ସେଠାରୁ ଆସିଥିବା signed agent read route ରେ ଅଧିକ limit ପାଇପାରେ। write route ଉପରେ unknown caller କୁ ଶକ୍ତ credential ମାଗାଯାଇପାରେ। AI assistant ବ୍ୟବହାର କରୁଥିବା human ସାଧାରଣ experience ରଖିପାରେ। ଲକ୍ଷ୍ୟ agent ମାନଙ୍କୁ ରୋକିବା ନୁହେଁ। ଲକ୍ଷ୍ୟ ହେଉଛି ପ୍ରତ୍ୟେକ ପ୍ରକାର caller କୁ ଠିକ path ଦେବା। Signed request କଣ କୁହିପାରେ ଏବଂ କଣ କୁହିପାରେ ନାହିଁ, ସେଥିପାଇଁ what signed AI agent requests prove ପଢ଼ନ୍ତୁ।

Proof of Actor ରେ AI ଏଜେଣ୍ଟ ପରିଚୟ କିପରି କାମ କରେ

Proof of Actor ପ୍ରତ୍ୟେକ request ପାଇଁ ସମାନ evidence-first flow ଅନୁସରଣ କରେ। How It Works ରେ ଆପଣ ସମ୍ପୂର୍ଣ୍ଣ walk-through ପଢ଼ିପାରିବେ; ଏଠାରେ API team ପାଇଁ ସଂକ୍ଷିପ୍ତ ଭାର୍ସନ୍ ଅଛି।

1. ଆପଣଙ୍କ integration ରୁ signals

ଆପଣଙ୍କ integration ସେ context ରେ ଉପଲବ୍ଧ signals କୁ Proof of Actor କୁ ପଠାଏ। API ପାଇଁ, ସାଧାରଣତଃ ଏହାର ଅର୍ଥ request context ଯଥା headers ଏବଂ protocol details, client ଯେକୌଣସି cryptographic request signatures ଦେଲେ ସେଗୁଡ଼ିକ, ଏବଂ client ନିଜ ବିଷୟରେ କରୁଥିବା declarations। ପ୍ରତ୍ୟେକ signal କେଉଁଠୁ ଆସିଛି ସେଥିରେ label ଲାଗିଥାଏ।

2. basis ସହିତ classification

ସେ signal ଗୁଡ଼ିକ ଯାଞ୍ଚ ଏବଂ ମିଶାଯାଇ ଚାରୋଟି public class ମଧ୍ୟରୁ ଗୋଟିଏ ହୁଏ:

Human: observable signal ଗୁଡ଼ିକ human-directed interaction ଦର୍ଶାଏ।
Human + AI: AI assistance declare କରାଯାଇଛି କିମ୍ବା ଏକ integration ଦ୍ୱାରା detect ହୋଇଛି ଯାହା ଏହାକୁ observe କରିପାରେ।
Agent: automated କିମ୍ବା agent-origin traffic, verifiable identity କିମ୍ବା carefully qualified inference ଦ୍ୱାରା ସମର୍ଥିତ।
Unknown: ପ୍ରମାଣ reliable determination କୁ ସମର୍ଥନ କରେ ନାହିଁ।

ପ୍ରତ୍ୟେକ result ସହିତ ଏହାର basis ମଧ୍ୟ ଥାଏ: verified, declared, inferred କିମ୍ବା unknown। API team ମାନଙ୍କ ପାଇଁ ଏହି ଅଂଶଟି ସବୁଠାରୁ ମୂଲ୍ୟବାନ। ଯେ request ର HTTP message signature, RFC 9421 ରେ ଉଲ୍ଲେଖିତ ଭାବରେ, published key ସହିତ validate ହୁଏ, ସେହିଟି verified ଭାବରେ report ହୁଏ। ଯେ client ସରଳଭାବେ ନିଜକୁ agent ଭାବରେ ନାମ ଦିଏ, ସେ declared ଭାବରେ report ହୁଏ। ଯେ pattern automated ଲାଗେ, ସେ inferred ଭାବରେ report ହୁଏ। ଗୋଟିଏ result cryptography ଉପରେ ଭରସା କରୁଛି କି ହେଉଛି heuristic, ସେଥିପାଇଁ ଆପଣଙ୍କୁ କେବେ ବି ଅନୁମାନ କରିବାକୁ ପଡ଼େ ନାହିଁ। evidence basis answer ର ଅଂଶ ଅଟେ।

3. ଆପଣଙ୍କ code କାର୍ଯ୍ୟ କରିପାରୁଥିବା result

Result ଆପଣଙ୍କ application କୁ class, basis ଏବଂ readable evidence summary ସହିତ ଫେରେ। ତାହା ସହିତ କଣ କରିବେ ତାହା ଆପଣଙ୍କ code ନିଷ୍ପତ୍ତି କରେ। observation mode ରେ, ଆପଣ ସେଥିକୁ କେବଳ record କରନ୍ତି। ଯେତେବେଳେ ପ୍ରସ୍ତୁତ, ଆପଣ ତାହା ଉପରେ route କରନ୍ତି।

ଆପଣଙ୍କ team କଣ ପାଏ: Detect, Understand, Route

Proof of Actor ହେଉଛି ତିନୋଟି capability ସହିତ ଗୋଟିଏ product।

Detect

ଆପଣଙ୍କ API ଯେ actor signals ଦେଖିପାରେ, ସେଗୁଡ଼ିକ ସଂଗ୍ରହ କରନ୍ତୁ ଏବଂ verified assertions କୁ behavioural inferences ଠାରୁ ପୃଥକ କରନ୍ତୁ। Signed agent request, declared client, automation signal ଏବଂ Unknown result ସବୁ distinct ରହେ, ଯାହାଦ୍ୱାରା କିଛି ନୀରବରେ single score ଭିତରେ ମିଶେ ନାହିଁ।

Understand

କେଉଁ actor ଗୁଡ଼ିକ କେଉଁ route କୁ call କରୁଛନ୍ତି, ସେଥିରେ ସମୟ ସହିତ କିପରି ପରିବର୍ତ୍ତନ ଆସୁଛି, ଏବଂ ପ୍ରତ୍ୟେକ classification ପଛରେ କେଉଁ evidence ଅଛି, ଦେଖନ୍ତୁ। Unknown rate visible ରହେ, ଯାହା ଆପଣଙ୍କୁ ସଠିକ୍ କହିଦିଏ coverage କେଉଁଠି ଶେଷ ହୁଏ ଏବଂ କେଉଁଠି stronger signal ଉପକାରୀ ହେବ।

Route

route ଏବଂ risk tier ଅନୁସାରେ policy ଲେଖନ୍ତୁ: allow, adapt, challenge, review କିମ୍ବା rate-limit। read-only endpoint ଉପରେ verified agent ପାଇଁ structured, generous path ରଖନ୍ତୁ। high-impact operation ଉପରେ stronger credential ମାଗନ୍ତୁ। Unknown ଏବଂ timeout ପାଇଁ ଏକ explicit fallback ନିର୍ଦ୍ଦିଷ୍ଟ କରନ୍ତୁ, ଯାହାଦ୍ୱାରା ଯାହା ଘଟିଲେ ମଧ୍ୟ ଆପଣଙ୍କ API predictable ଭାବରେ behave କରେ। ସେ route ରେ mistake ର cost ଅନୁସାରେ ପ୍ରତ୍ୟେକ policy କେମିତି fail କରିବ open କି closed, ସେହିଟି ଆପଣ ନିଷ୍ପତ୍ତି କରନ୍ତି।

Identity evidence, credentials ଏବଂ authorization ତିନୋଟି ଅଲଗା ଜିନିଷ

agent-aware API design ରେ ସବୁଠାରୁ ସାଧାରଣ mistake ହେଉଛି ତିନୋଟି ପୃଥକ ପ୍ରଶ୍ନକୁ ଗୋଟିଏରେ ମିଶାଇଦେବା। Proof of Actor ସେମାନଙ୍କୁ ପୃଥକ ରଖେ, ଏବଂ ଆପଣଙ୍କ design ମଧ୍ୟ ତେଣୁ ରଖିବା ଉଚିତ୍।

Identity evidence: କି ପ୍ରକାର actor ଡାକୁଛି, ଏବଂ ତାହା କଣ ପ୍ରମାଣ କରେ? ଏହାই AI ଏଜେଣ୍ଟ ପରିଚୟ ଦେଉଛି। ଏକ verified signature request କୁ ଏକ key ଏବଂ ତାହାର published operator identifier ସହିତ ଯୋଡ଼େ। IETF Web Bot Auth working group automated client ପାଇଁ ଏହି ପ୍ରକାର cryptographic authentication standardize କରିବାକୁ charter କରାଯାଇଛି, ଏବଂ ଏହାର scope end user ନୁହେଁ, agent କୁ authenticate କରିବାକୁ cover କରେ।
Credentials: ଏହି call ପାଇଁ କେଉଁ account ଦାୟୀ? ଏହା ଆପଣଙ୍କ API key, token କିମ୍ବା session, ଯାହା ଆପଣଙ୍କ ଦ୍ୱାରା issued ଏବଂ managed।
Authorization: ଏହି caller କୁ ଏହି specific thing କରିବାକୁ ଅନୁମତି ଅଛି କି? ଏହା ଆପଣଙ୍କ permission model।

ଏକ verified agent ସ୍ୱୟଂଚାଳିତ ଭାବେ authorized agent ନୁହେଁ। ଏକ valid signature ଏହା ପ୍ରମାଣ କରେ ନାହିଁ ଯେ ଜଣେ person agent କୁ authority delegate କରିଛନ୍ତି, ଏବଂ requested action safe କି ନୁହେଁ ତାହା ମଧ୍ୟ ପ୍ରମାଣ କରେ ନାହିଁ। Proof of Actor ପ୍ରଥମ ପ୍ରଶ୍ନ ପାଇଁ trustworthy context ଦିଏ ଏବଂ ଦ୍ୱିତୀୟ ଏବଂ ତୃତୀୟକୁ ସେମାନଙ୍କ ଯୋଗ୍ୟ ସ୍ଥାନରେ ଛାଡ଼ିଦିଏ: ଆପଣଙ୍କ application ଭିତରେ। agent authorization ଉପରେ ଏବଂ Detection & Limitations ରେ evidence କଣ establish କରିପାରେ ଏବଂ କଣ କରିପାରେ ନାହିଁ, ସେଥିରେ ଅଧିକ ପଢ଼ନ୍ତୁ।

Unknown ଏକ feature, failure ନୁହେଁ

Request signing optional, ଏବଂ unsigned client ଯେପରି ଚାହିଁବ ସେପରି ନିଜକୁ ବର୍ଣ୍ଣନା କରିପାରେ। Human କିମ୍ବା Agent ଭିତରେ ପ୍ରତ୍ୟେକ request କୁ ଠେଲିଦେଉଥିବା system କେତେବେଳେ ଆତ୍ମବିଶ୍ୱାସରେ ଭୁଲ ହେବ, ଏବଂ ଆପଣ କେବେ ଜାଣିପାରିବେ ନାହିଁ କେତେବେଳେ।

ପ୍ରମାଣ determination କୁ ସମର୍ଥନ ନକଲେ Proof of Actor Unknown report କରେ। Unknown କେବେ Human କୁ convert କରାଯାଏ ନାହିଁ ଏବଂ default ଭାବରେ malicious ଭାବରେ treat ହୁଏ ନାହିଁ। ଆପଣଙ୍କ policy ପ୍ରତ୍ୟେକ route ପାଇଁ Unknown ର ଅର୍ଥ କଣ ସେ ନିର୍ଦ୍ଦିଷ୍ଟ କରେ: public read ଉପରେ allow କରନ୍ତୁ, account change ଉପରେ ଆପଣଙ୍କ existing checks ରଖନ୍ତୁ, stakes ଉଚ୍ଚ ଥିବାଠାରେ review ପାଇଁ queue କରନ୍ତୁ। Unknown କୁ visible ରଖିବା ହିଁ ଆପଣଙ୍କ ଅନ୍ୟ classifications କୁ trustworthy କରେ। handling unknown traffic ଉପରେ guide ଏହା ପାଇଁ design କିପରି କରିବେ ଦେଖାଏ।

ଆପଣଙ୍କ stack ରେ AI ଏଜେଣ୍ଟ ପରିଚୟ କେଉଁଠି fit କରେ

Proof of Actor ଆପଣଙ୍କ existing gateway, authentication ଏବଂ rate limiting ସହିତ ପାଖପାଖି ରହେ। ଏହା କୌଣସିଟିକୁ replace କରେ ନାହିଁ। ସାଧାରଣ placement ମାନେ:

Server-side middleware route handler ଗୁଡ଼ିକର ସାମ୍ନାରେ, ଯାହାଦ୍ୱାରା ଆପଣଙ୍କ business logic ଚାଲିବା ପୂର୍ବରୁ ପ୍ରତ୍ୟେକ request evaluate ହୁଏ।
At the edge, ଯାହାଦ୍ୱାରା request origin ପହଞ୍ଚିବା ପୂର୍ବରୁ signal evaluate ହୁଏ।
A generic HTTP integration, ଯାହାଦ୍ୱାରା କୌଣସି stack request context ପଠାଇ ଏବଂ ତାହାର basis ସହିତ result ପାଇପାରେ।

Founding team ପ୍ରତ୍ୟେକଙ୍କ ସହ onboarding ସମୟରେ integration ଗୁଡ଼ିକ hands-on ଭାବରେ deliver କରାଯାଏ, ଯାହାଦ୍ୱାରା path ଆପଣଙ୍କ architecture ସହିତ fit ହୁଏ, ତାହାର ବିପରୀତ ନୁହେଁ। developer hub ଆଜି ଉପଲବ୍ଧ integration paths ଦେଖାଏ। ଯଦି ଆପଣ agent ପାଇଁ tool ଚଳାନ୍ତି, MCP Servers use case tool call ପାଇଁ specific pattern ଗୁଡ଼ିକ କଭର୍ କରେ।

Observation mode ରୁ ଆରମ୍ଭ କରନ୍ତୁ

Proof of Actor install କଲେ ଆପଣଙ୍କ API କିପରି respond କରେ ସେଥିରେ ପରିବର୍ତ୍ତନ ଆସେ ନାହିଁ। Result ଗୁଡ଼ିକ record ହୁଏ ଯାହାଦ୍ୱାରା ଆପଣଙ୍କ team ସେଗୁଡ଼ିକୁ ଆପଣ ପୂର୍ବରୁ ଜାଣିଥିବା outcome ସହିତ compare କରିପାରେ, agent ମାନେ ଆସଲେ କେଉଁଠି ଯାଆନ୍ତି ଦେଖିପାରେ, ପ୍ରତ୍ୟେକ route ଉପରେ unknown rate measure କରିପାରେ, ଏବଂ ଭୁଲ ଲାଗୁଥିବା କୌଣସି classification କୁ review କରିପାରେ। ତାହା ପରେ ମାତ୍ର, evidence ସମର୍ଥନ କରୁଥିବା ସ୍ଥାନରେ, ଆପଣ route by route ଏକ policy enable କରନ୍ତି।

ଏହାହେଉଛି କିପରି ଆପଣ customers କୁ ଆଶ୍ଚର୍ଯ୍ୟଚକିତ କରିବା କିମ୍ବା ସେମାନେ ନିର୍ଭର କରୁଥିବା integration ଭାଙ୍ଗିବା ବିନା AI ଏଜେଣ୍ଟ ପରିଚୟ roll out କରନ୍ତି। rolling out actor-aware policies safely ଉପରେ guide step by step sequence ଦେଖାଏ।

Founding developer program ରେ join କରନ୍ତୁ

Proof of Actor private beta ରେ ଛୋଟ ଗୋଟିଏ founding development team ଗୋଷ୍ଠୀ ସହିତ ଅଛି। Selected team ମାନେ onboarding ସମୟରେ agreed usage limits ଭିତରେ up to 12 months ମାଗଣା access ପାଇପାରିବେ, ଆମ engineer ମାନଙ୍କର direct integration support ଏବଂ ଆମେ ପରେ କଣ build କରିବୁ ସେଥିରେ real influence ସହିତ।

ଯଦି ଆପଣ ଏକ API operate କରନ୍ତି ଏବଂ କେଉଁ ଆସଲେ ଏହାକୁ call କରୁଛି ତାହା ଜାଣିବାକୁ ଚାହାନ୍ତି, apply for early access। ଆପଣଙ୍କ API, ଆପଣଙ୍କୁ ସବୁଠାରୁ ଗୁରୁତ୍ୱପୂର୍ଣ୍ଣ route ଗୁଡ଼ିକ, ଏବଂ actor context ସହିତ ଆପଣ ଭିନ୍ନଭାବେ କରିଥାନ୍ତେ ଯେଉଁ decision ଗୁଡ଼ିକ, ସେଥିରେ ଆମକୁ କହନ୍ତୁ। Proof of Actor କିପରି fit ହୁଏ ଆମେ ଆପଣଙ୍କୁ କହିଦେବୁ।

Sources

RFC 9421: HTTP Message Signatures, IETF, February 2024.
Web Bot Auth (webbotauth) working group charter, IETF.

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

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 ପଢନ୍ତୁ

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

API key authentication ସହିତ AI ଏଜେଣ୍ଟ ପରିଚୟ କିପରି ଭିନ୍ନ?

ଏକ API key ଆପଣଙ୍କୁ କେଉଁ account request ପଠାଇଛି ତାହା କୁହେ। AI ଏଜେଣ୍ଟ ପରିଚୟ ଆପଣଙ୍କୁ କୁହେ request ପଛରେ କି ପ୍ରକାର actor ଅଛି ଏବଂ ସେହି ନିଷ୍କର୍ଷକୁ କେଉଁ ପ୍ରମାଣ ସମର୍ଥନ କରୁଛି। ଆପଣଙ୍କୁ ଦୁଇଟି ଉଭୟ ଆବଶ୍ୟକ, ଏବଂ ସେମାନେ ଭିନ୍ନ ପ୍ରଶ୍ନର ଉତ୍ତର ଦେଇଥାନ୍ତି।

Proof of Actor ମୋ API କୁ ଡାକୁଥିବା ପ୍ରତ୍ୟେକ AI ଏଜେଣ୍ଟକୁ ଚିହ୍ନଟ କରିପାରିବ କି?

Proof of Actor ଯେତେ request ଦେଖେ, ସେଗୁଡ଼ିକୁ Human, Human + AI, Agent କିମ୍ବା Unknown ଭାବରେ ବର୍ଗୀକୃତ କରେ, ଏବଂ ପ୍ରତ୍ୟେକ result ପାଇଁ basis କୁହେ। ପ୍ରମାଣ ପର୍ଯ୍ୟାପ୍ତ ଶକ୍ତିଶାଳୀ ନୁହେଲେ, result ଅନୁମାନ ନୁହେଁ, Unknown ହୁଏ।

କୌଣସି agent କୁ ଚିହ୍ନଟ କରିବା ମାନେ ସେ act କରିବାକୁ ଅନୁମତି ପାଇଛି କି?

ନା। ପରିଚୟ ଏବଂ authorization ଅଲଗା। Proof of Actor ଆପଣଙ୍କ application କୁ caller ବିଷୟରେ context ଦିଏ, ଏବଂ ଆପଣଙ୍କ ନିଜ authorization rules ନିଷ୍ପତ୍ତି କରେ ସେ caller କଣ କରିପାରିବ।

Proof of Actor ମୋ API କୁ ଯାଉଥିବା request ଗୁଡ଼ିକୁ block କରିବ କି?

ଆପଣ ସେହିପରି ଚାହିଁଲେ ଛଡ଼ା ନୁହେଁ। ପ୍ରତ୍ୟେକ integration observation mode ରେ ଆରମ୍ଭ ହୁଏ, ଏବଂ enforcement କେବଳ ଆପଣଙ୍କ team ଲେଖି ଏବଂ enable କରିଥିବା policy ମାଧ୍ୟମରେ ହୁଏ।

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

Proof of Actor private beta ରେ ଅଛି। early access ପାଇଁ apply କରନ୍ତୁ, ଏବଂ selected founding developer teams agreed usage limits ଭିତରେ up to 12 months free ପାଇପାରିବେ।

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

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

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

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