AI ಏಜೆಂಟ್ ಗುರುತింపు

API ಗಳಿಗಾಗಿ AI ಏಜೆಂಟ್ ಗುರುತింపు

ನಿಮ್ಮ API ಈಗಾಗಲೇ ಯಾವ key ವಿನಂತಿ ಮಾಡಿದೆ ಎಂಬುದನ್ನು ತಿಳಿದಿದೆ. Proof of Actor ಅದರ ಹಿಂದೆ ಯಾವ ರೀತಿಯ actor ಇದ್ದನು, ಅದನ್ನು ಯಾವ ಸಾಕ್ಷ್ಯ ಬೆಂಬಲಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನಿಮಗೆ ತಿಳಿಸುತ್ತದೆ, ಮತ್ತು ಮುಂದೇನು ನಡೆಯಬೇಕು ಎಂಬುದನ್ನು ನಿಮ್ಮ ಕೋಡ್ ನಿರ್ಧರಿಸಲು ಬಿಡುತ್ತದೆ.

ಮುಂಗಡ ಪ್ರವೇಶ ಪಡೆಯಿರಿ ಇದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ಅನ್ವೇಷಿಸಿ

ರಚನೆ Toshendra SharmaFounder & CEO, AgentCredia · Updated November 13, 2026

ಸಂಕ್ಷಿಪ್ತ ಉತ್ತರ

ಒಂದು API key ನಿಮಗೆ ಯಾವ account ಕರೆ ಮಾಡುತ್ತಿದೆ ಎಂಬುದನ್ನು ಹೇಳುತ್ತದೆ, ಆದರೆ ವಿನಂತಿಯ ಹಿಂದೆ ಯಾವ ರೀತಿಯ client ಇದೆ ಎಂಬುದನ್ನು ಹೇಳುವುದಿಲ್ಲ. Proof of Actor request signatures ಮತ್ತು client declarations ಲಭ್ಯವಿರುವಲ್ಲಿ ಅವುಗಳನ್ನು ಬಳಸಿಕೊಂಡು, ಪ್ರತಿ API request ಗೆ actor context ಅನ್ನು ಸೇರಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ನೀವು ಪ್ರತಿ actor class ಮತ್ತು route ಗೆ limit ಗಳು ಮತ್ತು ನೀತಿಗಳನ್ನು ಹೊಂದಿಸಬಹುದು.

ನಿಮ್ಮ API ಗೆ key ಗೊತ್ತು. actor ಗೊತ್ತಿಲ್ಲ.

ಪ್ರತಿ API request ಕೆಲವು ಪಾವತಿಯ ಸಾಕ್ಷ್ಯದೊಂದಿಗೆ ಬರುತ್ತದೆ: ಒಂದು API key, ಒಂದು OAuth token, ಒಂದು session. ಆ ಸಾಕ್ಷ್ಯ ಒಂದು ಪ್ರಶ್ನೆಗೆ ಚೆನ್ನಾಗಿ ಉತ್ತರಿಸುತ್ತದೆ. ಅದು ಕರೆಗಾಗಿ ಯಾವ account ಹೊಣೆಗಾರ ಎಂಬುದನ್ನು ಹೇಳುತ್ತದೆ. ಅದು ಈಗ ನಿಜವಾಗಿ ಕರೆ ಮಾಡುತ್ತಿರುವುದು ಏನು ಎಂಬುದನ್ನು ಹೇಳುವುದಿಲ್ಲ.

ಒಂದು single API key ಅನ್ನು terminal ನಲ್ಲಿ ಪರೀಕ್ಷಿಸುತ್ತಿರುವ developer, schedule ಮೇಲೆ ನಡೆಯುವ backend job, AI assistant ಮೂಲಕ ಕೆಲಸ ಮಾಡುತ್ತಿರುವ person, ಮತ್ತು key ಅನ್ನು ಪಡೆದು task ಪೂರ್ಣಗೊಳಿಸಲು ಹೇಳಲಾದ autonomous agent ಎಲ್ಲರೂ ಬಳಸಬಹುದು. ಅವು ಬಹಳ ಬೇರೆ ಬೇರೆ actor ಗಳು. ಅವುಗಳಿಗೆ ಬೇರೆ rhythms, ಬೇರೆ failure modes, ಮತ್ತು ಬೇರೆ risk profiles ಇವೆ. ಅವುಗಳನ್ನೆಲ್ಲ ಒಂದೇ ರೀತಿಯಲ್ಲಿ ನೋಡಿದರೆ, ನಿಮ್ಮ customers ಅವಲಂಬಿಸುವ legitimate automation ಅನ್ನು ನೀವು ಹೆಚ್ಚು restrict ಮಾಡುತ್ತೀರಿ, ಅಥವಾ unattended agent ನಿಂದ ಎಂದಿಗೂ ಚಾಲಿತವಾಗಬಾರದ ನಿಮ್ಮ API ಭಾಗಗಳನ್ನು ಕಡಿಮೆ ರಕ್ಷಿಸುತ್ತೀರಿ.

API ಗಳಿಗಾಗಿ AI agent ಗುರುತింపు ಆ ಅಂತರವನ್ನು ಮುಚ್ಚುತ್ತದೆ. key ನಿಂದ ಎಲ್ಲವನ್ನೂ infer ಮಾಡುವ ಬದಲು, ಪ್ರತಿ request ಹಿಂದೆ ಇರುವ actor ನ ವರ್ಗೀಕರಣವನ್ನು, ಅದನ್ನು ಬೆಂಬಲಿಸುವ ಸಾಕ್ಷ್ಯದೊಂದಿಗೆ ನೀವು ಪಡೆಯುತ್ತೀರಿ. ಅದನ್ನೇ Proof of Actor ನೀಡಲು ನಿರ್ಮಿಸಲಾಗಿದೆ, ಮತ್ತು APIs use case API ತಂಡಗಳು ಅದನ್ನು route by route ಹೇಗೆ ಅನ್ವಯಿಸುತ್ತಾರೆ ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ.

ಈಗ API ತಂಡಗಳಿಗೆ actor context ಏಕೆ ಬೇಕು

API ಗಳಿಗೆ ಸ್ವಯಂಚಾಲಿತ traffic ಹೊಸದೇನಲ್ಲ. Scripts, integrations ಮತ್ತು crawlers ಸದಾ ಚಿತ್ರದಲ್ಲಿವೆ. ಬದಲಾಗಿರುವುದು automation ನ ಸ್ವರೂಪ. AI agent ಗಳು documentation ಓದಬಹುದು, calls ಗಳನ್ನು ಒಟ್ಟಿಗೆ chain ಮಾಡಬಹುದು, ಸೃಜನಾತ್ಮಕವಾಗಿ retry ಮಾಡಬಹುದು, ಮತ್ತು ಪ್ರತಿಯೊಂದು ಹಂತವನ್ನು ನೋಡದಿರುವ ಜನರ ಪರವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಬಹುದು. ಅವುಗಳಲ್ಲಿ ಬಹುತೆಕ ಉಪಯುಕ್ತ ಮತ್ತು ಸ್ವಾಗತಾರ್ಹ. ಕೆಲವು ಸರಿಯಾಗಿ ನಿರ್ಮಿಸಲ್ಪಟ್ಟಿಲ್ಲ. ಕೆಲವು hostile.

Actor context ಇಲ್ಲದೆ, API ತಂಡಗಳು ಸಾಮಾನ್ಯವಾಗಿ blunt tools ಗೆ ಹಿಂದಿರುಗುತ್ತವೆ:

ಪ್ರತಿ key ಗೆ rate limits, ಇದು ಉತ್ತಮ agents ಮತ್ತು ಕೆಟ್ಟ agents ಎರಡನ್ನೂ ಸಮಾನವಾಗಿ ನಿಧಾನಗೊಳಿಸುತ್ತದೆ.
User-agent ನಿಯಮಗಳು, client ಒಂದು header ಬದಲಿಸಿದ ಕ್ಷಣದಲ್ಲೇ ಮುರಿಯುತ್ತವೆ.
ಸಮಗ್ರ blocks, ಇದು legitimate automation ಅನ್ನು ಬದಲಾಗಿ ನಿಮ್ಮ web app ಅನ್ನು scrape ಮಾಡಲು ತಳ್ಳುತ್ತದೆ.

Actor context ನಿಮಗೆ ನಿಖರವಾಗಿ ಪ್ರತಿಕ್ರಿಯಿಸಲು ಬಿಡುತ್ತದೆ. ನೀವು ಗುರುತಿಸುವ operator ನಿಂದ ಬಂದ signed agent ಗೆ read routes ನಲ್ಲಿ ಹೆಚ್ಚಿನ limit ನೀಡಬಹುದು. write route ಅನ್ನು ತಲುಪುವ unknown caller ಗೆ ಬಲವಾದ credential ಕೇಳಬಹುದು. AI assistant ಬಳಸುತ್ತಿರುವ human ಗೆ ಸಾಮಾನ್ಯ ಅನುಭವ ಉಳಿಸಬಹುದು. ಉದ್ದೇಶ agents ಅನ್ನು ನಿಲ್ಲಿಸುವುದಲ್ಲ. ಪ್ರತಿಯೊಂದು ರೀತಿಯ ಕರೆಗಾರನಿಗೆ ಸರಿಯಾದ ಮಾರ್ಗ ನೀಡುವುದಾಗಿದೆ. Signed request ಏನು ಹೇಳಬಹುದು ಮತ್ತು ಏನು ಹೇಳಲಾರದು ಎಂಬುದನ್ನು ತಿಳಿಯಲು what signed AI agent requests prove ಓದಿ.

Proof of Actor ನಲ್ಲಿ AI agent ಗುರುತింపు ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ

Proof of Actor ಪ್ರತಿಯೊಂದು request ಗೆ ಒಂದೇ evidence-first flow ಅನುಸರಿಸುತ್ತದೆ. ಸಂಪೂರ್ಣ walkthrough ಅನ್ನು How It Works ನಲ್ಲಿ ಓದಬಹುದು; ಇಲ್ಲಿ API ತಂಡಗಳಿಗೆ ಚಿಕ್ಕ ಆವೃತ್ತಿ ಇದೆ.

1. ನಿಮ್ಮ integration ನಿಂದ signals

ನಿಮ್ಮ integration ಆ context ನಲ್ಲಿ ಲಭ್ಯವಿರುವ signals ಗಳನ್ನು Proof of Actor ಗೆ ನೀಡುತ್ತದೆ. API ಗಾಗಿ, ಇದು ಸಾಮಾನ್ಯವಾಗಿ headers ಮತ್ತು protocol details ಮುಂತಾದ request context, client ಒದಗಿಸುವ ಯಾವುದೇ cryptographic request signatures, ಮತ್ತು client ತನ್ನ ಬಗ್ಗೆ ಮಾಡುವ ಯಾವುದೇ declarations ಅನ್ನು ಅರ್ಥೈಸುತ್ತದೆ. ಪ್ರತಿಯೊಂದು signal ಗೆ ಅದು ಎಲ್ಲಿಂದ ಬಂದಿತು ಎಂಬ ಲೇಬಲ್ ಇರುತ್ತದೆ.

2. ಆಧಾರದೊಂದಿಗೆ classification

Signals ಗಳನ್ನು ಪರಿಶೀಲಿಸಿ, ನಾಲ್ಕು public classes ಗಳಲ್ಲಿ ಒಂದಕ್ಕೆ ಸಂಯೋಜಿಸಲಾಗುತ್ತದೆ:

Human: ಗಮನಿಸಬಹುದಾದ signals ಮಾನವ-ನಿರ್ದೇಶಿತ ಸಂವಹನವನ್ನು ಸೂಚಿಸುತ್ತವೆ.
Human + AI: AI ಸಹಾಯವನ್ನು ಘೋಷಿಸಲಾಗಿದೆ ಅಥವಾ ಅದನ್ನು ಗಮನಿಸಬಹುದಾದ integration ಪತ್ತೆ ಮಾಡಿದೆ.
Agent: ಸ್ವಯಂಚಾಲಿತ ಅಥವಾ agent-origin traffic, ಪರಿಶೀಲಿಸಬಹುದಾದ identity ಅಥವಾ ಜಾಗರೂಕವಾಗಿ qualified inference ನಿಂದ ಬೆಂಬಲಿತ.
Unknown: ಸಾಕ್ಷ್ಯವು ವಿಶ್ವಾಸಾರ್ಹ ನಿರ್ಧಾರವನ್ನು ಬೆಂಬಲಿಸುವುದಿಲ್ಲ.

ಪ್ರತಿ ಫಲಿತಾಂಶಕ್ಕೆ ಅದರ basis ಕೂಡ ಇರುತ್ತದೆ: Verified, Declared, Inferred ಅಥವಾ Unknown. API ತಂಡಗಳು ಹೆಚ್ಚು ಮೌಲ್ಯಮಾಪನ ಮಾಡುವ ಭಾಗ ಇದಾಗಿದೆ. ಪ್ರಕಟಿತ key ಗೆ ವಿರುದ್ಧವಾಗಿ ಮಾನ್ಯಗೊಳ್ಳುವ HTTP message signature, RFC 9421 ನಲ್ಲಿ ವಿವರಿಸಿದಂತೆ, verified ಎಂದು ವರದಿಯಾಗುತ್ತದೆ. ತನ್ನನ್ನು ತಾನೇ agent ಎಂದು ಮಾತ್ರ ಹೆಸರಿಸುವ client declared ಎಂದು ವರದಿಯಾಗುತ್ತದೆ. ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಕಾಣುವ pattern inferred ಎಂದು ವರದಿಯಾಗುತ್ತದೆ. ಫಲಿತಾಂಶ cryptography ಮೇಲೆ ಆಧಾರಿತವೋ ಅಥವಾ heuristic ಮೇಲೆವೋ ಎಂದು ನೀವು ಎಂದಿಗೂ ಅಚಲರಾಗಬೇಕಿಲ್ಲ. evidence basis ಉತ್ತರದ ಭಾಗವಾಗಿದೆ.

3. ನಿಮ್ಮ ಕೋಡ್ ಕ್ರಮ ಕೈಗೊಳ್ಳಬಹುದಾದ ಫಲಿತಾಂಶ

ಫಲಿತಾಂಶವು ವರ್ಗ, basis ಮತ್ತು ಓದಲು ಸುಲಭವಾದ evidence summary ಜೊತೆಗೆ ನಿಮ್ಮ application ಗೆ ಮರಳುತ್ತದೆ. ಅದೊಂದಿಗೆ ಏನು ಮಾಡಬೇಕೆಂಬುದನ್ನು ನಿಮ್ಮ ಕೋಡ್ ನಿರ್ಧರಿಸುತ್ತದೆ. observation mode ನಲ್ಲಿ, ನೀವು ಅದನ್ನು ದಾಖಲಿಸುತ್ತೀರಿ. ನೀವು ಸಿದ್ಧರಾದಾಗ, ಅದನ್ನು ಆಧರಿಸಿ route ಮಾಡುತ್ತೀರಿ.

ನಿಮ್ಮ ತಂಡಕ್ಕೆ ಏನು ಸಿಗುತ್ತದೆ: Detect, Understand, Route

Proof of Actor ಒಂದು product, ಮೂರು capabilities ಗಳೊಂದಿಗೆ.

Detect

ನಿಮ್ಮ API ನೋಡಬಲ್ಲ actor signals ಗಳನ್ನು ಸಂಗ್ರಹಿಸಿ, verified assertions ಗಳನ್ನು behavioral inferences ಗಳಿಂದ ಬೇರ್ಪಡಿಸಿ. Signed agent requests, declared clients, automation signals ಮತ್ತು Unknown ಫಲಿತಾಂಶಗಳನ್ನು ಎಲ್ಲವನ್ನೂ ಪ್ರತ್ಯೇಕವಾಗಿಯೇ ಇಡಲಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಯಾವುದನ್ನೂ silently ಒಂದು single score ಗೆ ವಿಲೀನಗೊಳಿಸಲಾಗುವುದಿಲ್ಲ.

Understand

ಯಾವ actors ಯಾವ routes ಗಳನ್ನು ಕರೆ ಮಾಡುತ್ತವೆ, ಅದು ಕಾಲದೊಂದಿಗೆ ಹೇಗೆ ಬದಲಾಗುತ್ತದೆ, ಮತ್ತು ಪ್ರತಿ classification ಹಿಂದೆ ಯಾವ ಸಾಕ್ಷ್ಯ ಇದೆ ಎಂಬುದನ್ನು ನೋಡಿ. Unknown rate ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತಲೇ ಇರುತ್ತದೆ, ಇದು ನಿಮ್ಮ coverage ಎಲ್ಲಿ ಕೊನೆಗೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಯಾವೆಲ್ಲಿ ಬಲವಾದ signal ಸಹಾಯ ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಹೇಳುತ್ತದೆ.

Route

ಪ್ರತಿ route ಮತ್ತು ಪ್ರತಿ risk tier ಗೆ ನೀತಿಗಳನ್ನು ಬರೆಯಿರಿ: allow, adapt, challenge, review ಅಥವಾ rate-limit. read-only endpoints ಗಳಲ್ಲಿ verified agents ಗೆ structured, generous ಮಾರ್ಗವನ್ನು ಇರಿಸಿ. high-impact operations ನಲ್ಲಿ ಬಲವಾದ credentials ಕೇಳಿ. Unknown ಮತ್ತು timeouts ಗಾಗಿ ಸ್ಪಷ್ಟ fallback ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ, ಆದ್ದರಿಂದ ಏನೇ ಸಂಭವಿಸಿದರೂ ನಿಮ್ಮ API ಊಹಿಸಬಹುದಾದ ರೀತಿಯಲ್ಲಿ ವರ್ತಿಸುತ್ತದೆ. ಆ route ನಲ್ಲಿ ತಪ್ಪಿನ cost ಆಧರಿಸಿ, ಪ್ರತಿಯೊಂದು ನೀತಿ ಹೇಗೆ fail ಆಗಬೇಕು, open ಅಥವಾ closed, ಎಂಬುದನ್ನು ನೀವು ನಿರ್ಧರಿಸುತ್ತೀರಿ.

Identity evidence, credentials ಮತ್ತು authorization ಮೂರು ವಿಭಿನ್ನ ವಿಷಯಗಳು

Agent-aware API design ನಲ್ಲಿ ಅತ್ಯಂತ ಸಾಮಾನ್ಯ ತಪ್ಪು ಎಂದರೆ ಮೂರು ಪ್ರತ್ಯೇಕ ಪ್ರಶ್ನೆಗಳನ್ನು ಒಂದಾಗಿ ಸೇರಿಸುವುದು. Proof of Actor ಅವುಗಳನ್ನು ಬೇರ್ಪಡಿಸಿ ಇಡುತ್ತದೆ, ಮತ್ತು ನಿಮ್ಮ design ಕೂಡ ಹಾಗೆಯೇ ಇರಬೇಕು.

Identity evidence: ಯಾವ ರೀತಿಯ actor ಕರೆ ಮಾಡುತ್ತಿದೆ, ಮತ್ತು ಅದನ್ನು ಏನು ಸಾಬೀತುಪಡಿಸುತ್ತದೆ? ಇದನ್ನು AI agent ಗುರುತింపు ಒದಗಿಸುತ್ತದೆ. Verified signature ಒಂದು request ಅನ್ನು key ಮತ್ತು ಅದರ published operator identifier ಜೊತೆಗೆ ಸಂಪರ್ಕಿಸುತ್ತದೆ. IETF Web Bot Auth working group ಸ್ವಯಂಚಾಲಿತ clients ಗಾಗಿ ಈ ರೀತಿಯ cryptographic authentication ಅನ್ನು standardize ಮಾಡಲು charter ಮಾಡಲಾಗಿದೆ, ಮತ್ತು ಅದರ ವ್ಯಾಪ್ತಿ end user ಗಿಂತ agent ನ authentication ಅನ್ನು ಒಳಗೊಂಡಿದೆ.
Credentials: ಈ call ಗೆ ಯಾವ account ಹೊಣೆಗಾರ? ಇದು ನಿಮ್ಮ API key, token ಅಥವಾ session, ನೀವು ನೀಡಿದ ಮತ್ತು ನಿರ್ವಹಿಸಿದ.
Authorization: ಈ ಕರೆಗಾರನು ಈ ನಿರ್ದಿಷ್ಟ ಕೆಲಸ ಮಾಡಲು ಅನುಮತಿಸಿದ್ದಾನೆಯೇ? ಇದು ನಿಮ್ಮ permission model.

Verified agent ಸ್ವಯಂಚಾಲಿತವಾಗಿ authorized agent ಆಗುವುದಿಲ್ಲ. Valid signature ಒಂದು person agent ಗೆ authority ನೀಡಿದ್ದಾನೆ ಎಂಬುದನ್ನು ಸಾಬೀತುಪಡಿಸುವುದಿಲ್ಲ, ಮತ್ತು ಕೇಳಲಾದ action ಸುರಕ್ಷಿತ ಎಂದು ಮಾಡುವುದಿಲ್ಲ. Proof of Actor ಮೊದಲ ಪ್ರಶ್ನೆಗೆ ವಿಶ್ವಾಸಾರ್ಹ context ನೀಡುತ್ತದೆ ಮತ್ತು ಎರಡನೇ ಮತ್ತು ಮೂರನೇ ಪ್ರಶ್ನೆಗಳನ್ನು ಅವುಗಳ ಸ್ಥಳದಲ್ಲೇ ಬಿಡುತ್ತದೆ: ನಿಮ್ಮ application ನಲ್ಲಿ. agent authorization ಕುರಿತು ಮತ್ತು ಸಾಕ್ಷ್ಯ ಏನು ಸ್ಥಾಪಿಸಬಹುದು ಮತ್ತು ಏನು ಸ್ಥಾಪಿಸಲಾರದು ಎಂಬುದನ್ನು Detection & Limitations ನಲ್ಲಿ ಓದಿ.

Unknown ಒಂದು feature, failure ಅಲ್ಲ

Request signing ಐಚ್ಛಿಕ, ಮತ್ತು unsigned client ತನ್ನನ್ನು ತಾನು ಹೇಗೆ ಇಷ್ಟವೋ ಹಾಗೆ ವಿವರಿಸಬಹುದು. ಪ್ರತಿಯೊಂದು request ಅನ್ನು Human ಅಥವಾ Agent ಗೆ ಒತ್ತಾಯಿಸುವ system ಕೆಲವೊಮ್ಮೆ ಆತ್ಮವಿಶ್ವಾಸದಿಂದ ತಪ್ಪಾಗಿರುತ್ತದೆ, ಮತ್ತು ನೀವು ಯಾವಾಗ ಎಂದು ತಿಳಿಯುವುದಿಲ್ಲ.

ಸಾಕ್ಷ್ಯ ನಿರ್ಧಾರಕ್ಕೆ ಬೆಂಬಲ ನೀಡದಾಗ Proof of Actor Unknown ಅನ್ನು ವರದಿಸುತ್ತದೆ. Unknown ಅನ್ನು ಎಂದಿಗೂ Human ಆಗಿ ಪರಿವರ್ತಿಸಲಾಗುವುದಿಲ್ಲ, ಮತ್ತು default ಆಗಿ malicious ಎಂದು ಪರಿಗಣಿಸಲಾಗುವುದಿಲ್ಲ. ನಿಮ್ಮ policy ಪ್ರತಿ route ಗೆ Unknown ಏನು ಅರ್ಥ ಎಂಬುದನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ: public reads ಮೇಲೆ ಅದನ್ನು allow ಮಾಡಿ, account changes ಮೇಲೆ ನಿಮ್ಮ existing checks ಉಳಿಸಿ, stakes ಹೆಚ್ಚು ಇರುವಲ್ಲಿ review ಗೆ queue ಮಾಡಿ. Unknown ಅನ್ನು ಕಾಣಿಸಿಕೊಳ್ಳುವಂತೆ ಇರಿಸುವುದೇ ನಿಮ್ಮ ಇತರ classifications ಗಳನ್ನು ವಿಶ್ವಾಸಾರ್ಹವಾಗಿಸುತ್ತದೆ. handling unknown traffic ಕುರಿತ guide ಅದನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸುವುದನ್ನು ತೋರಿಸುತ್ತದೆ.

ನಿಮ್ಮ stack ನಲ್ಲಿ AI agent ಗುರುತింపు ಎಲ್ಲಿಗೆ ಹೊಂದಿಕೊಳ್ಳುತ್ತದೆ

Proof of Actor ನಿಮ್ಮ existing gateway, authentication ಮತ್ತು rate limiting ಜೊತೆಗೆ ಇರುತ್ತದೆ. ಅದು ಅವುಗಳಲ್ಲಿ ಯಾವುದನ್ನೂ ಬದಲಿಸುವುದಿಲ್ಲ. ಸಾಮಾನ್ಯ placements ಗಳಲ್ಲಿ ಇವು ಸೇರಿವೆ:

Server-side middleware ನಿಮ್ಮ route handlers ಗಿಂತ ಮುಂಚಿತವಾಗಿ, ಆದ್ದರಿಂದ ನಿಮ್ಮ business logic ನಡೆಯುವ ಮೊದಲು ಪ್ರತಿಯೊಂದು request ಮೌಲ್ಯಮಾಪನವಾಗುತ್ತದೆ.
At the edge, ಆದ್ದರಿಂದ requests ನಿಮ್ಮ origin ಗೆ ತಲುಪುವ ಮೊದಲು signals ಮೌಲ್ಯಮಾಪನವಾಗುತ್ತವೆ.
ಒಂದು generic HTTP integration, ಆದ್ದರಿಂದ ಯಾವುದೇ stack request context ಕಳುಹಿಸಿ basis ಜೊತೆಗೆ ಫಲಿತಾಂಶವನ್ನು ಸ್ವೀಕರಿಸಬಹುದು.

Onboarding ಸಮಯದಲ್ಲಿ ಪ್ರತಿಯೊಂದು founding team ಜೊತೆ integrations ಕೈಯಲ್ಲಿ ನೀಡಿ ಒದಗಿಸಲಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಮಾರ್ಗವು ನಿಮ್ಮ architecture ಗೆ ಹೊಂದಿಕೊಳ್ಳುತ್ತದೆ, ಬೇರೆ ರೀತಿ ಅಲ್ಲ. developer hub ಇಂದು ಲಭ್ಯವಿರುವ integration paths ಗಳನ್ನು ತೋರಿಸುತ್ತದೆ. ನೀವು agents ಗಾಗಿ tools ಚಲಾಯಿಸಿದರೆ, MCP Servers use case tool calls ಗಳಿಗೆ ನಿರ್ದಿಷ್ಟ patterns ಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.

Observation mode ನಲ್ಲಿ ಆರಂಭಿಸಿ

Proof of Actor ಅನ್ನು install ಮಾಡುವುದರಿಂದ ನಿಮ್ಮ API ಹೇಗೆ ಪ್ರತಿಕ್ರಿಯಿಸುತ್ತದೆ ಎಂಬುದು ಬದಲಾಗುವುದಿಲ್ಲ. ಫಲಿತಾಂಶಗಳನ್ನು ದಾಖಲಿಸಲಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ನಿಮ್ಮ ತಂಡವು ಅವುಗಳನ್ನು ನಿಮಗೆ ಈಗಾಗಲೇ ಗೊತ್ತಿರುವ outcomes ಗಳೊಂದಿಗೆ ಹೋಲಿಸಬಹುದು, agents ನಿಜವಾಗಿ ಎಲ್ಲಿಗೆ ಹೋಗುತ್ತಾರೆ ಎಂಬುದನ್ನು ನೋಡಬಹುದು, ಪ್ರತಿ route ನಲ್ಲಿ unknown rate ಅನ್ನು ಅಳೆಯಬಹುದು, ಮತ್ತು ತಪ್ಪಾಗಿ ಕಾಣುವ ಯಾವುದೇ classification ಅನ್ನು ಪರಿಶೀಲಿಸಬಹುದು. ಅದರ ನಂತರ ಮಾತ್ರ ನೀವು ನೀತಿಯನ್ನು, route by route, ಸಾಕ್ಷ್ಯ ಅದನ್ನು ಬೆಂಬಲಿಸುವಲ್ಲಿ enable ಮಾಡುತ್ತೀರಿ.

ಇದೇ ರೀತಿಯಲ್ಲಿ ನೀವು AI agent ಗುರುತింపನ್ನು ನಿಮ್ಮ customers ಗೆ ಅಚ್ಚರಿ ಮೂಡಿಸದೆ ಅಥವಾ ಅವರು ಅವಲಂಬಿಸಿರುವ integrations ಗಳನ್ನು ಮುರಿಯದೆ rollout ಮಾಡುತ್ತೀರಿ. rolling out actor-aware policies safely ಕುರಿತ guide ಕ್ರಮವನ್ನು ಹಂತ ಹಂತವಾಗಿ ವಿವರಿಸುತ್ತದೆ.

founding developer program ಗೆ ಸೇರಿ

Proof of Actor private beta ನಲ್ಲಿ, founding development teams ಗಳ ಸಣ್ಣ ಗುಂಪಿನೊಂದಿಗೆ ಇದೆ. ಆಯ್ಕೆಯಾದ teams onboarding ಸಮಯದಲ್ಲಿ agreed usage limits ಒಳಗೆ up to 12 months free access ಪಡೆಯಬಹುದು, ನಮ್ಮ engineers ನಿಂದ ನೇರ integration support ಮತ್ತು ನಾವು ಮುಂದೇನು ನಿರ್ಮಿಸುತ್ತೇವೆ ಎಂಬುದರ ಮೇಲೆ ನಿಜವಾದ ಪ್ರಭಾವದೊಂದಿಗೆ.

ನೀವು ಒಂದು API ನಡೆಸುತ್ತಿದ್ದರೆ ಮತ್ತು ಅದನ್ನು ನಿಜವಾಗಿ ಯಾರು ಕರೆ ಮಾಡುತ್ತಿದ್ದಾರೆ ಎಂಬುದನ್ನು ತಿಳಿಯಲು ಬಯಸಿದರೆ, apply for early access. ನಿಮ್ಮ API, ನೀವು ಹೆಚ್ಚು ಕಾಳಜಿ ವಹಿಸುವ routes, ಮತ್ತು actor context ಜೊತೆಗೆ ನೀವು ಬೇರೆ ರೀತಿಯಲ್ಲಿ ತೆಗೆದುಕೊಳ್ಳುವ ನಿರ್ಧಾರಗಳ ಬಗ್ಗೆ ನಮಗೆ ಹೇಳಿ. Proof of Actor ಹೇಗೆ ಹೊಂದಿಕೊಳ್ಳುತ್ತದೆ ಎಂದು ನಾವು ನಿಮಗೆ ಹೇಳುತ್ತೇವೆ.

Sources

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

DEVELOPERS ಗಾಗಿ

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: ಫಲಿತಾಂಶದ ಹಿಂದೆ ಇರುವ signals, ಇದರಿಂದ ನಿಮ್ಮ ತಂಡಕ್ಕೆ ಕಾರಣ ಕಾಣುತ್ತದೆ.

observation mode ನಲ್ಲಿ ಪ್ರಾರಂಭಿಸಿ: ನಿಮ್ಮ logs ಗಳ ಪಕ್ಕದಲ್ಲಿ ಫಲಿತಾಂಶಗಳನ್ನು ದಾಖಲಿಸಿ ಮತ್ತು ನೀವು ಒಂದು policy ಆಯ್ಕೆ ಮಾಡುವವರೆಗೆ ಏನನ್ನೂ ಬದಲಾಯಿಸಬೇಡಿ. Node.js ಏಕೀಕರಣ ಮಾರ್ಗದರ್ಶಿಯನ್ನು ಓದಿ

ಪದೇಪದೇ ಕೇಳಲಾಗುವ ಪ್ರಶ್ನೆಗಳು

AI agent ಗುರುತింపు API key authentication ನಿಂದ ಹೇಗೆ ಭಿನ್ನವಾಗಿದೆ?

ಒಂದು API key ನಿಮಗೆ ಯಾವ account ಒಂದು request ಕಳುಹಿಸಿದೆ ಎಂಬುದನ್ನು ಹೇಳುತ್ತದೆ. AI agent ಗುರುತింపు ನಿಮಗೆ request ಹಿಂದೆ ಯಾವ ರೀತಿಯ actor ಇದ್ದಾನೆ ಮತ್ತು ಆ ತೀರ್ಮಾನವನ್ನು ಯಾವ ಸಾಕ್ಷ್ಯ ಬೆಂಬಲಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಹೇಳುತ್ತದೆ. ನಿಮಗೆ ಎರಡೂ ಅಗತ್ಯ, ಮತ್ತು ಅವು ವಿಭಿನ್ನ ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರಿಸುತ್ತವೆ.

Proof of Actor ನನ್ನ API ಅನ್ನು ಕರೆ ಮಾಡುವ ಪ್ರತಿಯೊಂದು AI agent ಅನ್ನು ಗುರುತಿಸಬಹುದೇ?

Proof of Actor ಅದು ಕಾಣುವ ಪ್ರತಿಯೊಂದು request ಅನ್ನು Human, Human + AI, Agent ಅಥವಾ Unknown ಎಂದು ವರ್ಗೀಕರಿಸುತ್ತದೆ, ಮತ್ತು ಪ್ರತಿ ಫಲಿತಾಂಶಕ್ಕೆ ಆಧಾರವನ್ನು ಹೇಳುತ್ತದೆ. ಸಾಕ್ಷ್ಯ ಸಾಕಷ್ಟು ಬಲವಾಗಿಲ್ಲದಿದ್ದರೆ, ಫಲಿತಾಂಶ ಅಂದಾಜಿನ ಬದಲು Unknown ಆಗಿರುತ್ತದೆ.

ಒಂದು agent ಅನ್ನು ಗುರುತಿಸುವುದು ಅದು ಕಾರ್ಯ ಮಾಡಲು ಅನುಮತಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ಅರ್ಥ ಮಾಡುತ್ತದೆಯೇ?

ಇಲ್ಲ. ಗುರುತింపు ಮತ್ತು authorization ಪ್ರತ್ಯೇಕ. Proof of Actor ಕರೆಗಾರನ ಬಗ್ಗೆ ನಿಮ್ಮ application ಗೆ context ನೀಡುತ್ತದೆ, ಮತ್ತು ನಿಮ್ಮ ಸ್ವಂತ authorization ನಿಯಮಗಳು ಆ ಕರೆಗಾರ ಏನು ಮಾಡಬಹುದು ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸುತ್ತವೆ.

Proof of Actor ನನ್ನ API ಗೆ ಬಂದ request ಗಳನ್ನು block ಮಾಡುತ್ತದೆಯೇ?

ನೀವು ಅದನ್ನು ಹಾಗೆ ಇರಬೇಕು ಎಂದು ನಿರ್ಧರಿಸದ ಹೊರತು ಅಲ್ಲ. ಪ್ರತಿ integration ಮೊದಲಿಗೆ observation mode ನಲ್ಲಿ ಆರಂಭವಾಗುತ್ತದೆ, ಮತ್ತು enforcement ನಿಮ್ಮ ತಂಡ ಬರೆಯುವ ಮತ್ತು enable ಮಾಡುವ ನೀತಿಗಳ ಮೂಲಕ ಮಾತ್ರ ನಡೆಯುತ್ತದೆ.

ನನಗೆ ಪ್ರವೇಶವನ್ನು ಹೇಗೆ ಪಡೆಯಬಹುದು?

Proof of Actor private beta ನಲ್ಲಿ ಇದೆ. ಆರಂಭಿಕ access ಗೆ apply ಮಾಡಿ, ಮತ್ತು ಆಯ್ಕೆಯಾದ founding developer ತಂಡಗಳು agreed usage limits ಒಳಗೆ up to 12 months free ಪಡೆಯಬಹುದು.

ನಿಮ್ಮ app ಅನ್ನು ಯಾರು ಬಳಸುತ್ತಿದ್ದಾರೆ ಎಂಬುದನ್ನು ತಿಳಿಯಿರಿ.

founding developers ನ ಸಣ್ಣ ಗುಂಪಿಗಾಗಿ private beta.

ಮುಂಗಡ ಪ್ರವೇಶ ಪಡೆಯಿರಿ ಮೌಲ್ಯವನ್ನು ವೀಕ್ಷಿಸಿ

ಮೊದಲು ಮಾತನಾಡಲು ಇಷ್ಟವಿದೆಯೆ? ಸ್ಥಾಪಕರೊಂದಿಗೆ ಮಾತನಾಡಿ