ମୁଖ୍ୟ ବିଷୟବସ୍ତୁକୁ ଛାଡ଼ନ୍ତୁ
MCP କଲର୍ ପରିଚୟ

ଆପଣଙ୍କ MCP ସର୍ଭରକୁ କିଏ ଡାକୁଛି ଜାଣନ୍ତୁ

ଆପଣଙ୍କ MCP ସର୍ଭର AI clients ପାଇଁ tools ଉନ୍ମୁକ୍ତ କରେ, ଯାହାକୁ ଆପଣ ନିୟନ୍ତ୍ରଣ କରନ୍ତି ନାହିଁ। Proof of Actor ପ୍ରତ୍ୟେକ call ର ପଛରେ କ’ଣ ଅଛି, କେଉଁ ପ୍ରମାଣ ଏହାକୁ ସମର୍ଥନ କରେ, ସେଥିରେ ଆପଣଙ୍କୁ କୁହେ, ଏବଂ ପ୍ରତି tool ଅନୁସାରେ policies ସେଟ୍ କରିବାକୁ ଦିଏ।

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

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

ଆପଣଙ୍କ tools ଆପଣ ଦେଖିପାରୁନଥିବା callers ପାଇଁ ଖୋଲା ଅଛି

ଏକ MCP server ଆପଣଙ୍କ product କୁ AI clients ପାଇଁ usable କରେ। ଏହା tools, resources ଏବଂ prompts ଉନ୍ମୁକ୍ତ କରେ, ଯାହା assistants ଏବଂ agents hosts, clients ଏବଂ servers ମଧ୍ୟରେ JSON-RPC 2.0 messages ବ୍ୟବହାର କରି discover ଏବଂ call କରିପାରନ୍ତି, ଯେପରି Model Context Protocol specification ରେ ବର୍ଣ୍ଣିତ। ଏହିକାରଣରୁ teams ଏହାକୁ build କରନ୍ତି: ସେମାନେ ଆପଣଙ୍କ product କୁ ସେହି workflows ଭିତରେ ରଖନ୍ତି ଯେଉଁଠାରେ AI agents ପୂର୍ବରୁ କାମ କରୁଛନ୍ତି।

ଏହାର ଅର୍ଥ ହେଉଛି, ଆପଣଙ୍କ server ସେହି clients ଠାରୁ calls ପାଏ, ଯାହାକୁ ଆପଣ build କରିନଥିଲେ ଏବଂ ସିଧାସଳଖ observe କରିପାରୁନଥିଲେ। ଏକ single tool ସ୍ଥାନୀୟଭାବେ test କରୁଥିବା developer ଦ୍ୱାରା, signed-in person ପକ୍ଷରୁ କାମ କରୁଥିବା desktop assistant ଦ୍ୱାରା, ରାତିଭରି ଲମ୍ବା task ଚଳାଇଥିବା autonomous agent ଦ୍ୱାରା, କିମ୍ବା weakness ଖୋଜିବା ପାଇଁ ଆପଣଙ୍କ server କୁ probe କରୁଥିବା କିଛି ଦ୍ୱାରା invoke ହୋଇପାରେ। protocol ଆପଣଙ୍କୁ କେଉଁ tool call ହେଲା ଏବଂ କେଉଁ arguments ସହିତ ହେଲା, ସେଥି କହେ। ଏହା ନିଜେ, call ର ପଛରେ କେଉଁ ପ୍ରକାରର actor ଅଛି କିମ୍ବା ଆପଣ କେତେ trust କରିବା ଉଚିତ, ସେଥି କୁହେନାହିଁ।

MCP ସର୍ଭର caller identification ସେ gap କୁ fill କରେ। Proof of Actor ପ୍ରତ୍ୟେକ tool call କୁ evidence-backed actor result ଯୋଡ଼େ, ଯାହାଦ୍ୱାରା ଆପଣଙ୍କ server କିଏ କ’ଣ ପାଇବ ତାହା ନେଇ informed decisions ନେଇପାରେ। ସମସ୍ୟା ଉପରେ ଅଧିକ ଦୃଷ୍ଟି ପାଇଁ, who is calling your MCP server ପଢ଼ନ୍ତୁ, ଏବଂ teams ଏହାକୁ କିପରି apply କରନ୍ତି ସେଥିପାଇଁ MCP servers use case ଦେଖନ୍ତୁ।

ଶବ୍ଦ ସମ୍ପର୍କରେ ଏକ ଟିପ୍ପଣୀ। "Caller identity" cloud infrastructure ରେ ମଧ୍ୟ ଏକ well-known ଅର୍ଥ ରଖେ। ଉଦାହରଣସ୍ୱରୂପ, AWS STS GetCallerIdentity ସେହି IAM user କିମ୍ବା role ସମ୍ପର୍କରେ details ଫେରାଇଥାଏ, ଯାହାଙ୍କର credentials operation କୁ call କରିବାରେ ବ୍ୟବହୃତ ହୁଏ। ସେଥି କୁହେ କେଉଁ cloud credential call କରିଥିଲା। ଏହି ପୃଷ୍ଠାର MCP server caller identification ଏକ ଭିନ୍ନ ପ୍ରଶ୍ନର ଉତ୍ତର ଦେଉଛି: Human, Human + AI, Agent କି Unknown, କେଉଁ ପ୍ରକାରର actor ଆପଣଙ୍କ MCP server କୁ ଏକ tool call ର ପଛରେ ଅଛି, ଏବଂ ସେଇ ଉତ୍ତରକୁ କେଉଁ evidence support କରେ।

MCP callers କୁ ଭିନ୍ନ କରୁଥିବା କଥା କ’ଣ

MCP callers browser visitors ଏବଂ traditional API clients ଠାରୁ policy ପାଇଁ ଗୁରୁତ୍ୱପୂର୍ଣ୍ଣ ଉପାୟରେ ଅଲଗା।

  • ସେମାନେ ପ୍ରାୟ ସବୁବେଳେ automated ହୋଇଥାନ୍ତି। ପ୍ରଶ୍ନଟି "human କି bot?" ଠାରୁ କମ୍, ଏବଂ "କେଉଁ agent, କେମିତି କାମ କରୁଛି, କେଉଁ evidence ସହିତ?" ଠାରୁ ଅଧିକ।
  • ସେମାନେ ପ୍ରାୟତଃ ଏକ person ପାଇଁ କାମ କରନ୍ତି। ଏକ assistant user ର request ପାଇଁ your tool କୁ call କରିପାରେ, କିମ୍ବା autonomous ଭାବେ କାମ କରିପାରେ। ସେହି case ଗୁଡିକର treatment ଅଲଗା ହେବା ଉଚିତ।
  • ସେମାନେ ନିଜକୁ describe କରନ୍ତି। MCP lifecycle specification client କୁ ଏକ clientInfo object ନାମ ଏବଂ version ସହିତ ତାହାର initialize request ରେ send କରିବାକୁ କହେ। ସେଇ declaration useful context, କିନ୍ତୁ ଏହା declaration, proof ନୁହେଁ।
  • Tools ର impact ବହୁତ ଭିନ୍ନ ହୁଏ। ଏକ search tool ଏବଂ records delete କରୁଥିବା tool କୁ ଗୋଟିଏ policy ଅଂଶୀଦାର କରିବା ଉଚିତ ନୁହେଁ।

ଭଲ MCP caller identification କୁ ଏହି ଚାରୋଟିକୁ respect କରିବାକୁ ହେବ।

Proof of Actor MCP callers କୁ କିପରି identify କରେ

ଆପଣଙ୍କ server ର signals

ଆପଣଙ୍କ MCP integration ପ୍ରତ୍ୟେକ call ପାଇଁ ଉପଲବ୍ଧ context Proof of Actor କୁ pass କରେ: client ର declared details, transport ଏବଂ request context, client ଯେକୌଣସି cryptographic request signatures, ଯେପରି RFC 9421 ରେ defined HTTP Message Signatures, ଏବଂ call ହେଉଥିବା tool। ପ୍ରତ୍ୟେକ signal କେଉଁଠାରୁ ଆସିଛି ସେଠାରେ label କରାଯାଇଥାଏ।

basis ସହିତ classification

Proof of Actor ଚାରିଟି class ମଧ୍ୟରୁ ଗୋଟିଏ, Human, Human + AI, Agent କି Unknown, ଫଳାଫଳ ପାଇଁ basis ସହିତ ଫେରାଇଥାଏ:

  • verified ଯେତେବେଳେ cryptographic check, ଯେପରି published key ବିରୁଦ୍ଧରେ request signature, pass ହୁଏ;
  • declared ଯେତେବେଳେ client କିମ୍ବା ଆପଣଙ୍କ application ଏହାକୁ କହିଥାଏ, ଯେପରି session ରେ client name;
  • inferred ଯେତେବେଳେ result call ମଧ୍ୟରେ ଥିବା patterns ଉପରେ ଭିତ୍ତି କରେ;
  • unknown ଯେତେବେଳେ evidence ଏକ determination କୁ support କରେନାହିଁ।

declared client name କୁ କେବେବି verification ଭାବେ ପ୍ରଦର୍ଶିତ କରାଯାଇନାହିଁ। ଯେତେବେଳେ evidence ପତଳା ଥାଏ, result confident guess ପରିବର୍ତ୍ତେ Unknown ହୁଏ, ଏବଂ ଆପଣଙ୍କ server ଠିକ୍ ଭାବେ ଜାଣେ ଯେ ଏହା କ’ଣ ସହିତ କାମ କରୁଛି।

ଏକ result ଯାହାକୁ ଆପଣଙ୍କ tools ବ୍ୟବହାର କରିପାରିବ

actor result tool call ସହିତ ସାଥିରେ ଆସେ, ଆପଣଙ୍କ server ର logic ପାଇଁ ready। observation mode ରେ ଆପଣ ଏହାକୁ record କରନ୍ତି। ଆପଣ ପ୍ରସ୍ତୁତ ହେଲେ, ଆପଣଙ୍କ tool-level policies ଏହା ଉପରେ କାମ କରେ।

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

Detect

ପ୍ରତ୍ୟେକ tool call ରେ ଉପଲବ୍ଧ caller evidence capture କରନ୍ତୁ ଏବଂ verified, declared ଏବଂ inferred evidence କୁ ଅଲଗା ରଖନ୍ତୁ।

Understand

କେଉଁ clients କେଉଁ tools କୁ call କରୁଛନ୍ତି, କେତେ ବାର, କେଉଁ evidence ସହିତ, ଏବଂ ସେଥି ସମୟ ସହିତ କିପରି ବଦଳୁଛି ଦେଖନ୍ତୁ। ମୁଖ୍ୟତଃ Unknown callers ଆକର୍ଷିତ କରୁଥିବା tools, behaviour ବଦଳାଉଥିବା clients, ଏବଂ verifiable identity ବୋକାଇଥିବା calls ର share ଚିହ୍ନଟ କରନ୍ତୁ।

Route

ପ୍ରତି tool ଏବଂ ପ୍ରତି risk tier ପାଇଁ policies ଲେଖନ୍ତୁ। ସାଧାରଣ patterns:

  • Low-impact tools ଯେପରି search କି read-only lookups: ଏକ standard rate limit ସହିତ broadly allow କରନ୍ତୁ।
  • Moderate-impact tools ଯେପରି drafts ସୃଷ୍ଟି କରିବା: verified ଏବଂ declared callers କୁ allow କରନ୍ତୁ, Unknown କୁ rate-limit କରନ୍ତୁ।
  • High-impact tools ଯେପରି data delete କରିବା, settings ବଦଳାଇବା କିମ୍ବା user ର behalf ରେ messages send କରିବା: ଆପଣଙ୍କ strongest authorization ଆବଶ୍ୟକ କରନ୍ତୁ, ଏବଂ caller Unknown ହେଲେ କିମ୍ବା autonomously କାମ କରୁଥିଲେ confirmation କି review ଯୋଡ଼ନ୍ତୁ।

protecting sensitive actions without blocking agents ଉପରେ ଗାଇଡ୍ ଏହି tiers କିପରି design କରିବେ ସେଥି ଦେଖାଏ।

Identity evidence, credentials ଏବଂ authorization ଅଲଗା

MCP security ସବୁଠାରୁ ଭଲ କାମ କରେ ଯେତେବେଳେ ତିନୋଟି ପ୍ରଶ୍ନ ଅଲଗା ରହେ:

  1. Identity evidence: କେଉଁ ପ୍ରକାରର client call କରୁଛି, ଏବଂ କ’ଣ ଏହାକୁ ପ୍ରମାଣ କରେ? Proof of Actor ଏହା ଦେଇଥାଏ।
  2. Credentials: କେଉଁ account କି token ସହିତ ଏହି call କରାଯାଇଛି? ଆପଣଙ୍କ MCP server ର authentication ଏହା ଦେଇଥାଏ। MCP authorization specification authorization କୁ optional କରେ ଏବଂ HTTP-based transports ପାଇଁ OAuth 2.1 ଉପରେ ଭିତ୍ତି କରେ, ଯେଉଁଠାରେ MCP server ଏକ resource server ଭାବେ କାମ କରି access tokens validate କରେ।
  3. Authorization: ଏହି caller ଏହି account ପାଇଁ, ଏହି arguments ସହିତ, ଏହି tool ବ୍ୟବହାର କରିପାରିବ କି? ଆପଣଙ୍କ permission model ଏହା ଦେଇଥାଏ।

ଏକ recognised client ସ୍ୱୟଂଚାଳିତ ଭାବେ authorized ନୁହେଁ। ଏକ valid signature session ରେ ଥିବା person ଏହି specific action ପାଇଁ authority delegate କରିଥିଲେ ବୋଲି ଦେଖାଏ ନାହିଁ। delegated authority ଏବଂ agent authorization ସମ୍ପର୍କରେ ଅଧିକ ପଢ଼ନ୍ତୁ। Proof of Actor ପ୍ରଥମ ପ୍ରଶ୍ନ ପାଇଁ ଆପଣଙ୍କ server କୁ ଭଲ context ଦିଏ, ଯାହାଦ୍ୱାରା ଦ୍ୱିତୀୟ ଏବଂ ତୃତୀୟ ପ୍ରଶ୍ନର ଉତ୍ତର ଅଧିକ informed ହୁଏ।

କାହିଁକି କେବଳ client name କୁ trust କରିବେ ନାହିଁ?

କାରଣ ଯେକୌଣସି client ଯେକୌଣସି name send କରିପାରେ। ଏକ declared name କୁ proof ଭାବେ ଦେଖିବା imitation କୁ ଆମନ୍ତ୍ରଣ ଦିଏ: ଏକ hostile client କେବଳ popular assistant ର name କୁ copy କରିବାକୁ ପଡ଼େ। Proof of Actor name କୁ declared evidence ଭାବେ record କରେ, ଯାହା ଅଧିକ ଶକ୍ତ evidence ଅଛି ତାହା ସହିତ combine କରେ, ଏବଂ basis କୁ ଆପଣଙ୍କୁ କୁହେ। ତାପରେ ଆପଣଙ୍କ policy verified callers କୁ କେବଳ ନିଜେ ଘୋଷଣା କରିଥିବା callers ଠାରୁ ଅଧିକ room ଦେଇପାରିବ, ଏବଂ କୌଣସିଟି ନଥିଲେ ଆପଣଙ୍କ Unknown fallback apply କରିପାରିବ।

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

ଆପଣଙ୍କ MCP server ରେ Proof of Actor install କଲେ ଯେକୌଣସି tool ର response କେମିତି ହୁଏ ତାହା ବଦଳାଏ ନାହିଁ। Results record କରାଯାଇଥାଏ, ଯାହାଦ୍ୱାରା ଆପଣ ଦେଖିପାରିବେ କିଏ ଆପଣଙ୍କ tools କୁ call କରୁଛି, evidence କେତେ strong, ଏବଂ କେଉଁଠାରେ policies ସାହାଯ୍ୟ କରିପାରିବ। ଆପଣ confident ହେଲେ, single high-impact tool ଉପରେ ଗୋଟିଏ policy enable କରନ୍ତୁ, outcomes ଦେଖନ୍ତୁ, ତାପରେ ବିସ୍ତାର କରନ୍ତୁ। How It Works ସମ୍ପୂର୍ଣ୍ଣ flow କୁ cover କରେ, ଏବଂ Detection & Limitations ପ୍ରତ୍ୟେକ ପ୍ରକାରର evidence କ’ଣ establish କରିପାରେ ଏବଂ କ’ଣ କରିପାରେନି, ସେଥି ବ୍ୟାଖ୍ୟା କରେ।

MCP servers ଏବଂ APIs ଚଳାଉଥିବା teams ପାଇଁ built

Proof of Actor ଆପଣଙ୍କ existing authentication, rate limiting ଏବଂ logging ସହିତ ଆପଣଙ୍କ server ଭିତରେ ବସେ। Integrations ପ୍ରତ୍ୟେକ founding team ସହିତ hands-on ଭାବେ deliver କରାଯାଇଥାଏ, ଯାହାଦ୍ୱାରା setup ଆପଣଙ୍କ transport, hosting ଏବଂ tool design ସହିତ fit ହୁଏ। MCP Servers ଏବଂ APIs use cases ଦେଖାଏ କିପରି ସେଇ approach ଆପଣଙ୍କ tools ଏବଂ ଆପଣଙ୍କ API ଅନୁସାରେ apply ହୁଏ।

ଆପଣ expose କରୁଥିବା ପ୍ରତ୍ୟେକ tool ବିଷୟରେ ପଚାରିବା ଉଚିତ ପ୍ରଶ୍ନ

tool-level policies ଲେଖିବା ପୂର୍ବରୁ, ଆପଣଙ୍କ MCP server ଯେଉଁ ପ୍ରତ୍ୟେକ tool expose କରେ, ସେଥିକୁ ଏକ ସଂକ୍ଷିପ୍ତ checklist ସହିତ review କରିବା ଉପକାରୀ:

  • ଏହି tool କ’ଣ ବଦଳାଇପାରେ? read-only tools ଏବଂ data modify କରୁଥିବା, messages send କରୁଥିବା କି billing affect କରୁଥିବା tools ଭିନ୍ନ treatment ଯୋଗ୍ୟ।
  • ଏହା କାହା ପାଇଁ? କେତେକ tools signed-in person ପକ୍ଷରୁ କାମ କରୁଥିବା assistants ପାଇଁ ରହେ; ଅନ୍ୟଗୁଡିକ autonomous workflows ପାଇଁ। expected caller ହିଁ right policy କୁ shape କରେ।
  • ଏକ mistake ର cost କ’ଣ ହେବ? ଭୁଲ search result ର cost କମ୍। ଭୁଲ deletion ତେଣୁ ନୁହେଁ। ପ୍ରତ୍ୟେକ tool କୁ risk tier ରେ map କରନ୍ତୁ।
  • କେଉଁ evidence ଆବଶ୍ୟକ ହେବା ଉଚିତ? ଏକ declared client ପର୍ଯ୍ୟାପ୍ତ କି, କିମ୍ବା tool କୁ verified identity plus ଆପଣଙ୍କ strongest authorization ଦରକାର କି, ସେଥି ନିର୍ଣ୍ଣୟ କରନ୍ତୁ।
  • Unknown ରେ କ’ଣ ହୁଏ? ପ୍ରତ୍ୟେକ tool ପାଇଁ explicit fallback ବାଛନ୍ତୁ: allow, rate-limit, user କୁ confirm କରିବାକୁ କହନ୍ତୁ, କି review କୁ route କରନ୍ତୁ।
  • ଏହା କାମ କରୁଛି ବୋଲି ଆପଣ କିପରି ଜାଣିବେ? କୌଣସି enforcement ପୂର୍ବରୁ observation mode ରେ କେଉଁ outcomes ଆପଣ watch କରିବେ, ସେଥି ନିର୍ଦ୍ଧାରଣ କରନ୍ତୁ।

ପ୍ରତ୍ୟେକ tool ପାଇଁ ଏହାକୁ once answer କରିବା caller identification କୁ clear, testable rules ରେ ପରିଣତ କରେ, ଏବଂ ଆପଣଙ୍କ server ର behaviour କୁ ଏହା ସହିତ integrate କରୁଥିବା clients କୁ explain କରିବା ସହଜ କରେ।

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

Proof of Actor private beta ରେ ଅଛି। Selected founding development teams agreed usage limits ଭିତରେ up to 12 months free access ପାଇପାରିବେ, ଏବଂ ଆପଣ tool-level policies design କରୁଥିବାବେଳେ ଆମ engineers ଠାରୁ direct support ପାଇପାରିବେ।

ଯଦି ଆପଣ ଏକ MCP server ଚଳାନ୍ତି ଏବଂ ଏହାକୁ କିଏ call କରୁଛି ଜାଣିବାକୁ ଚାହାନ୍ତି, apply for early access କରନ୍ତୁ। ଆପଣଙ୍କ server, ଆପଣ expose କରୁଥିବା tools, ଏବଂ ଆପଣ ସବୁଠାରୁ ଅଧିକ ଚିନ୍ତା କରୁଥିବା calls ବିଷୟରେ ଆମକୁ କୁହନ୍ତୁ।

Sources

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

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

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

ଏକ MCP ସର୍ଭରକୁ caller identification କାହିଁକି ଦରକାର?

MCP servers AI clients କୁ tools ଉନ୍ମୁକ୍ତ କରେ, ଯେଉଁମାନେ people ଙ୍କ ପକ୍ଷରୁ କାମ କରେ କିମ୍ବା ସ୍ୱୟଂଚାଳିତ ଭାବେ ଚାଲେ। ଏକ tool call ର ପଛରେ କେମିତି caller ଅଛି ଜାଣିଲେ, ଆପଣ low-impact tools କୁ ମୁକ୍ତଭାବେ allow କରିପାରିବେ ଏବଂ high-impact ଗୁଡିକ ପାଇଁ ଅଧିକ ଆବଶ୍ୟକତା ରଖିପାରିବେ।

MCP session ରେ client name କି verification ଅଟେ?

ନାହିଁ। client name ହେଉଛି client ଦ୍ୱାରା ଦିଆଯାଇଥିବା declaration। Proof of Actor ଏହାକୁ declared evidence ଭାବେ ରେକର୍ଡ କରେ ଏବଂ cryptographically verified identity ଠାରୁ ଅଲଗା ରଖେ।

Caller identification କି MCP authorization କୁ ପରିବର୍ତ୍ତନ କରେ?

ନାହିଁ। caller identity evidence, ବ୍ୟବହୃତ credential ଏବଂ caller କ’ଣ କରିପାରିବ ସେଗୁଡିକ ଅଲଗା ପ୍ରଶ୍ନ। Proof of Actor ପ୍ରଥମଟି ପାଇଁ context ଯୋଡ଼େ ଏବଂ authorization କୁ ଆପଣଙ୍କ server ଉପରେ ଛାଡ଼େ।

Proof of Actor କି tool calls କୁ block କରିବ?

କେବଳ ତେବେ, ଯଦି ଆପଣଙ୍କ policies ସେହିଭଳି କୁହେ। ପ୍ରତ୍ୟେକ integration observation mode ରେ ଆରମ୍ଭ ହୁଏ, ଏବଂ ଆପଣ ପ୍ରସ୍ତୁତ ହେଲେ tool-level policies enable କରନ୍ତି।

ମୁଁ ଏହାକୁ କିପରି try କରିପାରିବି?

early access ପାଇଁ apply କରନ୍ତୁ। selected founding developer teams agreed usage limits ଭିତରେ up to 12 months free ଏବଂ hands-on integration support ପାଇପାରିବେ।

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

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

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

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