ಮಾರ್ಗದರ್ಶಿ

Node.js app ಗೆ actor context ಅನ್ನು ಹೇಗೆ ಸೇರಿಸುವುದು

ಪ್ರತಿ request ಹಿಂದೆ ಯಾರಿದ್ದಾರೆ ಅಥವಾ ಏನು ಇದೆ ಎಂಬುದನ್ನು ದಾಖಲಿಸುವ middleware ಅನ್ನು ನಿರ್ಮಿಸುವ ಹಂತ-ಹಂತದ guide, zodat ನೀವು ಯಾವುದಾದರೂ enforcement ಮಾಡುವ ಮೊದಲು real traffic ಅನ್ನು study ಮಾಡಬಹುದು.

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

ಆರಂಭಿಕ · 9 min read

rules ಬದಲು actor context ನಿಂದ ಏಕೆ ಪ್ರಾರಂಭಿಸಬೇಕು?

ತಮ್ಮ traffic ನಲ್ಲಿ AI agents ಕಾಣಿಸುತ್ತಿವೆ ಎಂದು ಗಮನಿಸುವ ಬಹುತೇಕ ತಂಡಗಳು ಮೊದಲು ಒಂದು rule ಗೆ ಹೋಗುತ್ತವೆ. user agent ಅನ್ನು block ಮಾಡಿ, challenge ಸೇರಿಸಿ, rate limit ಅನ್ನು ಬಿಗಿಗೊಳಿಸಿ. ಸಮಸ್ಯೆ ಏನೆಂದರೆ ನೀವು traffic ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೊದಲು ಬರೆಯುವ rule ತಪ್ಪು ಜನರನ್ನು ತಾಗುವ ಸಾಧ್ಯತೆ ಹೆಚ್ಚು. legitimate assistants block ಆಗುತ್ತವೆ, real users ಗೆ challenge ಆಗುತ್ತದೆ, ಮತ್ತು ನೀವು ನಿಜವಾಗಿ ಚಿಂತಿಸಿದ್ದ automation ಮತ್ತೆ ಬರುತ್ತಲೇ ಇರುತ್ತದೆ, ಏಕೆಂದರೆ ಅದು ಮೊದಲೇ ತನ್ನನ್ನು ಗುರುತಿಸಿಕೊಂಡಿರಲಿಲ್ಲ.

Actor context rules ಗೆ ಮುಂಚಿನ ಹಂತ. ಪ್ರತಿಯೊಂದು request ಗಾಗಿ, ನಿಮ್ಮ application ಯಾರಿಂದ ಅಥವಾ ಏನಿಂದ action ಬರುತ್ತಿದೆ ಎಂಬುದರ ಕುರಿತು ಗಮನಿಸಬಲ್ಲದ್ದನ್ನು ನೀವು record ಮಾಡುತ್ತೀರಿ: interactive person, AI assistant ಜೊತೆಗೆ ಕೆಲಸ ಮಾಡುವ person, autonomous agent, ಅಥವಾ ಈಗಾಗಲೇ ಬೇರ್ಪಡಿಸಲಾಗದ ಏನಾದರೂ. ಆ view ಹಿಂದಿನ evidence ಅನ್ನು ನೀವು record ಮಾಡುತ್ತೀರಿ, ಮತ್ತು ಅದನ್ನು request outcome ನೊಂದಿಗೆ ಪಕ್ಕದಲ್ಲೇ ಇಡುತ್ತೀರಿ. ಒಂದು ಅಥವಾ ಎರಡು ವಾರಗಳ ನಂತರ, ಯಾವುದೇ rule template ನೀಡಲಾಗದೊಂದನ್ನು ನಿಮ್ಮ ಬಳಿ ಇರುತ್ತದೆ: ನಿಮ್ಮ own traffic ನ map. agents ನಿಮ್ಮ site ಗೆ ಬರುತ್ತಾರೇ ಇಲ್ಲವೇ ಎಂದು ಇನ್ನೂ ನಿರ್ಧರಿಸುತ್ತಿದ್ದರೆ, ವೆಬ್‌ಸೈಟ್ traffic AI agents ನಿಂದ ಬರುತ್ತಿದೆಯೇ ಎಂದು ಹೇಗೆ ತಿಳಿಯುವುದು ನಿಂದ ಪ್ರಾರಂಭಿಸಿ.

ಈ guide ಅನ್ನು plain middleware ಬಳಸಿ Node.js application ನಲ್ಲಿ ಈ layer ಅನ್ನು ನಿರ್ಮಿಸುತ್ತದೆ. ಇದು Express ಜೊತೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ, ಮತ್ತು ಅದೇ ideas ಗಳು Fastify, Koa, Hono ಅಥವಾ Next.js route handler ಗೆ ಸಹ ಅನ್ವಯಿಸುತ್ತವೆ.

ನೀವು ಏನು ನಿರ್ಮಿಸುವಿರಿ

ಅಂತ್ಯದಲ್ಲಿ ನಿಮಗೆ ಇವು ಇರುತ್ತವೆ:

ಪ್ರತಿಯೊಂದು request ನಿಂದ actor evidence ಅನ್ನು ಹೊರತೆಗೆಯುವ middleware.
ಪ್ರತಿಯೊಂದು result ಗೆ stated basis ಇರುವ ಸಣ್ಣ, ಸ್ಪಷ್ಟ classification.
request ಹೇಗೆ handle ಆಗುತ್ತದೆ ಎಂಬುದನ್ನು ಎಂದಿಗೂ ಬದಲಾಯಿಸದ structured observation logs.
ನಂತರದ handlers ಅದನ್ನು ಓದಿಕೊಳ್ಳಲು request ಗೆ result ಅನ್ನು attach ಮಾಡುವ ವಿಧಾನ.

ಇಲ್ಲಿ ಯಾವುದೂ request ಅನ್ನು block ಮಾಡುವುದಿಲ್ಲ. ಅದು ಉದ್ದೇಶಿತವಾಗಿದೆ.

ಹಂತ 1: ನಿಮ್ಮ server ನಿಜವಾಗಿ ಯಾವ evidence ಅನ್ನು ನೋಡಬಹುದು?

Server ಜನರು ಊಹಿಸುವುದಕ್ಕಿಂತ ಕಡಿಮೆ ನೋಡುತ್ತದೆ. code ಬರೆಯುವ ಮೊದಲು, ನಿಮ್ಮ edge ನಲ್ಲಿ ಲಭ್ಯವಿರುವ signals ಅನ್ನು ಪಟ್ಟಿ ಮಾಡಿ:

Request signatures. ಕೆಲವು automated clients HTTP Message Signatures ಬಳಸಿ requests ಅನ್ನು sign ಮಾಡುತ್ತವೆ (RFC 9421), Signature-Input ಮತ್ತು Signature headers ಅನ್ನು ಕಳುಹಿಸುತ್ತವೆ, ಹಾಗೂ ಸಾಮಾನ್ಯವಾಗಿ operator ನ published keys ಗೆ ಸೂಚಿಸುವ Signature-Agent header ಜೊತೆ, IETF Web Bot Auth protocol draft ನಲ್ಲಿ ವಿವರಿಸಿದಂತೆ.
Declared identity. Clients ತಮ್ಮನ್ನು User-Agent header ನಲ್ಲಿ, From header ನಲ್ಲಿ, ಅಥವಾ protocol metadata ಮೂಲಕ, ಉದಾಹರಣೆಗೆ MCP client name ಮೂಲಕ ಹೆಸರಿಸಬಹುದು. MCP clients 2025-11-25 revision ನ initialize request ನಲ್ಲಿ self-chosen clientInfo name ಅನ್ನು report ಮಾಡುತ್ತವೆ, ಮತ್ತು 2026-07-28 revision client identity ಅನ್ನು per-request metadata ಆಗಿ ಸಾಗಿಸುತ್ತದೆ. ಇವು declarations, ಮತ್ತು ಯಾರಾದರೂ ಅವುಗಳನ್ನು copy ಮಾಡಬಹುದು.
Authentication context. Request ನಲ್ಲಿ session cookie, bearer token ಅಥವಾ API key ಇದೆಯೇ, ಮತ್ತು ಅದು ಯಾವ kind of credential ಎಂಬುದು.
Protocol shape. Accept headers, client HTML ಅಥವಾ JSON ಅನ್ನು request ಮಾಡುತ್ತದೆಯೇ, ಅದು page assets ಅನ್ನು load ಮಾಡುತ್ತದೆಯೇ, ಮತ್ತು redirects ಮತ್ತು cookies ಅನ್ನು ಹೇಗೆ handle ಮಾಡುತ್ತದೆ ಎಂಬುದು.
Application declarations. ನಿಮ್ಮ own product network ನೋಡಲಾಗದ ವಿಷಯಗಳನ್ನು ತಿಳಿದಿರಬಹುದು, ಉದಾಹರಣೆಗೆ ಬಳಕೆದಾರನು "AI assisted" option ಆಯ್ಕೆ ಮಾಡುವುದು, ಅಥವಾ request ನಿಮ್ಮ built-in assistant feature ನಿಂದ ಬರಲುಬಹುದು.

ಪ್ರತಿಯೊಂದು signal ಗೆ ಬೇರೆ strength ಇರುತ್ತದೆ. validated signature ಪರಿಶೀಲಿಸಬಹುದಾದುದು. user agent string ಒಂದು claim. missing cookie ಎಂದರೆ ಕೇವಲ missing ಅಷ್ಟೇ. ಇವುಗಳನ್ನು separate ಆಗಿ ಇಡುವುದೇ ಈ exercise ನ ಮುಖ್ಯ ಉದ್ದೇಶ.

ಹಂತ 2: ಫಲಿತಾಂಶವನ್ನು ಸ್ಪಷ್ಟವಾಗಿ model ಮಾಡಿ

Detection logic ಬರೆಯುವ ಮೊದಲು actor result ನ shape ಅನ್ನು define ಮಾಡಿ. ಸಣ್ಣ, typed model classification ಎಂದರೇನು ಎಂಬುದರಲ್ಲಿ ಎಲ್ಲರಿಗೂ ಸ್ಪಷ್ಟತೆ ನೀಡುತ್ತದೆ. ಇಲ್ಲಿ ಬಳಸಿರುವ ನಾಲ್ಕು classes ಅನ್ನು Human, AI-assisted ಅಥವಾ agent: application traffic ಗೆ practical taxonomy ನಲ್ಲಿ ವಿವರಿಸಲಾಗಿದೆ.

export type ActorClass = "human" | "human_ai" | "agent" | "unknown";
export type EvidenceBasis = "verified" | "declared" | "inferred" | "unknown";

export interface ActorEvidence {
  signaturePresent: boolean;
  signatureAgent?: string;
  declaredClient?: string;
  credentialType: "session" | "api_key" | "bearer" | "none";
  acceptsHtml: boolean;
  appDeclaredAssist: boolean;
}

export interface ActorResult {
  actor: ActorClass;
  basis: EvidenceBasis;
  reasons: string[];
  evidence: ActorEvidence;
  observedAt: string;
}

ಎರಡು fields ಮುಖ್ಯ. actor class ಆಗಿದೆ. basis ನೀವು ಅದನ್ನು ಏಕೆ ನಂಬುತ್ತೀರಿ ಎಂದು ಹೇಳುತ್ತದೆ. validated signature ಆಧಾರಿತ agent result ಮತ್ತು user agent string ಆಧಾರಿತ agent result ಎರಡೂ "agent" ಆಗಿರಬಹುದು, ಆದರೆ ನಂತರದ ಹಂತದಲ್ಲಿ ಅವುಗಳಿಗೆ ತುಂಬಾ ವಿಭಿನ್ನ treatment ಬೇಕಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಅವುಗಳನ್ನು ಎಂದಿಗೂ collapse ಮಾಡಬೇಡಿ.

ಹಂತ 3: Middleware ನಲ್ಲಿ evidence ಅನ್ನು ಹೊರತೆಗೆಯಿರಿ

Extraction step headers ಮತ್ತು request state ಅನ್ನು ಓದುತ್ತದೆ. ಅದು ಇನ್ನೂ ಏನನ್ನೂ ನಿರ್ಧರಿಸುವುದಿಲ್ಲ.

import type { Request, Response, NextFunction } from "express";

const KNOWN_AGENT_TOKENS = ["bot", "crawler", "spider", "agent", "gpt", "claude"];

export function extractEvidence(req: Request): ActorEvidence {
  const ua = (req.get("user-agent") || "").toLowerCase();
  const auth = req.get("authorization") || "";
  const hasSession = Boolean(req.cookies?.session);

  let credentialType: ActorEvidence["credentialType"] = "none";
  if (hasSession) credentialType = "session";
  else if (auth.toLowerCase().startsWith("bearer ")) credentialType = "bearer";
  else if (req.get("x-api-key")) credentialType = "api_key";

  const declaredToken = KNOWN_AGENT_TOKENS.find((t) => ua.includes(t));

  return {
    signaturePresent: Boolean(req.get("signature") && req.get("signature-input")),
    signatureAgent: req.get("signature-agent") || undefined,
    declaredClient: declaredToken ? ua.slice(0, 200) : undefined,
    credentialType,
    acceptsHtml: (req.get("accept") || "").includes("text/html"),
    appDeclaredAssist: req.get("x-app-assist") === "1",
  };
}

ಈ code ಬಗ್ಗೆ ಕೆಲವು ಟಿಪ್ಪಣಿಗಳು:

signaturePresent signature headers ಇವೆ ಎಂಬುದನ್ನು ಮಾತ್ರ record ಮಾಡುತ್ತದೆ. Validation ಬೇರೆ step, signed agent requests ಅನ್ನು verify ಮಾಡುವ guide ನಲ್ಲಿ ಅದನ್ನು ಒಳಗೊಂಡಿದೆ.
user agent token list intentionally ಸರಳವಾಗಿದೆ. ಇದು declaration ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ, verification ಅನ್ನು ಎಂದಿಗೂ ಅಲ್ಲ.
x-app-assist ನಿಮ್ಮ own frontend ಬಳಕೆದಾರನು ನಿಮ್ಮ built-in AI feature ಮೂಲಕ ಕೆಲಸ ಮಾಡುವಾಗ ಕಳುಹಿಸುವ ಯಾವುದೇ mechanism ಗೆ placeholder ಆಗಿದೆ. ಅದನ್ನು ನಿಮ್ಮ real mechanism ನಿಂದ replace ಮಾಡಿ.

ಹಂತ 4: stated basis ಜೊತೆಗೆ classify ಮಾಡಿ

ಈಗ evidence ಅನ್ನು result ಆಗಿ ಪರಿವರ್ತಿಸಿ. rules ಗಳನ್ನು ಚಿಕ್ಕದಾಗಿ ಇಡಿ, strongest evidence ಇಂದ weakest evidence ವರೆಗೆ ಕ್ರಮಬದ್ಧವಾಗಿ ಇಡಿ, ಮತ್ತು ಯಾವಾಗಲೂ Unknown ಗೆ fall through ಆಗಲಿ.

export async function classify(
  evidence: ActorEvidence,
  verifySignature: () => Promise<boolean>,
): Promise<ActorResult> {
  const reasons: string[] = [];
  const observedAt = new Date().toISOString();

  if (evidence.signaturePresent && (await verifySignature())) {
    reasons.push("request signature validated");
    return { actor: "agent", basis: "verified", reasons, evidence, observedAt };
  }

  if (evidence.appDeclaredAssist) {
    reasons.push("application reported its built-in assistant");
    return { actor: "human_ai", basis: "declared", reasons, evidence, observedAt };
  }

  if (evidence.declaredClient) {
    reasons.push("client declared itself as automated");
    return { actor: "agent", basis: "declared", reasons, evidence, observedAt };
  }

  if (evidence.credentialType === "session" && evidence.acceptsHtml) {
    reasons.push("interactive browser session");
    return { actor: "human", basis: "inferred", reasons, evidence, observedAt };
  }

  reasons.push("insufficient evidence");
  return { actor: "unknown", basis: "unknown", reasons, evidence, observedAt };
}

ಇದು ಏನು ಮಾಡುವುದಿಲ್ಲ ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ಇದು declaration ಅನ್ನು ಎಂದಿಗೂ verification ಆಗಿ upgrade ಮಾಡುವುದಿಲ್ಲ. interactive signal ಇಲ್ಲದ request ಗೆ Human ಅನ್ನು assign ಮಾಡುವುದಿಲ್ಲ. ಅದು ಹೇಳಲಾಗದಿದ್ದರೆ, Unknown ಎಂದು ಹೇಳುತ್ತದೆ. Unknown ಒಂದು ಮಾನ್ಯ, ಉಪಯುಕ್ತ answer ಆಗಿದೆ, ಮತ್ತು ನಿಮ್ಮ visibility ಎಲ್ಲಿ ಮುಗಿಯುತ್ತದೆ ಎಂಬುದನ್ನು ನಿಖರವಾಗಿ ತಿಳಿಸುತ್ತದೆ. AI traffic ಗೆ Unknown ಮಾನ್ಯ result ಏಕೆ ಎಂಬುದನ್ನು Unknown AI traffic ಗೆ ಮಾನ್ಯ ಫಲಿತಾಂಶ ಏಕೆ ನಲ್ಲಿ ಸಂಪೂರ್ಣವಾಗಿ ವಿವರಿಸಲಾಗಿದೆ.

ಹಂತ 5: ಅದನ್ನು observation mode ನಲ್ಲಿ wire ಮಾಡಿ

Middleware ಅನ್ನು ಆರಂಭದಲ್ಲೇ mount ಮಾಡಿ, result ಅನ್ನು request ಗೆ attach ಮಾಡಿ, ಮತ್ತು ಅದನ್ನು log ಮಾಡಿ. ಅದರ ಆಧಾರದಲ್ಲಿ branch ಮಾಡಬೇಡಿ.

import express from "express";
import cookieParser from "cookie-parser";

const app = express();
app.use(cookieParser());

app.use(async (req, res, next) => {
  try {
    const evidence = extractEvidence(req);
    const result = await classify(evidence, async () => false);
    res.locals.actor = result;

    res.on("finish", () => {
      logActor({
        route: req.route?.path ?? req.path,
        method: req.method,
        status: res.statusCode,
        actor: result.actor,
        basis: result.basis,
        reasons: result.reasons,
      });
    });
  } catch {
    res.locals.actor = undefined;
  }
  next();
});

ಈ ವ್ಯವಸ್ಥೆಯನ್ನು ಸುರಕ್ಷಿತವಾಗಿಡುವ ಮೂರು ವಿವರಗಳು:

try block detection ನಲ್ಲಿ failure ಆಗಿದ್ದರೂ response ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ ಎಂಬುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ. Observation fail open ಆಗಿರಬೇಕು.
Logging finish ಮೇಲೆ ನಡೆಯುತ್ತದೆ, ಆದ್ದರಿಂದ ನೀವು real status code ಅನ್ನು capture ಮಾಡುತ್ತೀರಿ ಮತ್ತು ನಂತರ classifications ಅನ್ನು outcomes ಜೊತೆ compare ಮಾಡಬಹುದು.
Real validation implement ಮಾಡುವವರೆಗೂ verifySignature ಅನ್ನು false ಗೆ stub ಮಾಡಲಾಗಿದೆ. ಇದು signed requests ಅನ್ನು declared ಅಥವಾ unknown buckets ನಲ್ಲಿ ಇಟ್ಟುಕೊಳ್ಳುತ್ತದೆ, ಅವುಗಳನ್ನು ಅತಿಯಾಗಿ ಹೇಳುವುದನ್ನು ತಪ್ಪಿಸುತ್ತದೆ.

ಹಂತ 6: ಕೇವಲ debugging ಗೆ ಅಲ್ಲ, analysis ಗಾಗಿ log ಮಾಡಿ

ನೀವು aggregate ಮಾಡಬಹುದಾದ logs ಬರೆಯಿರಿ. ಪ್ರತಿಯೊಂದು request ಗೆ ಒಂದು structured line ಸಾಕು.

function logActor(entry: Record<string, unknown>) {
  process.stdout.write(JSON.stringify({ type: "actor_observation", ...entry }) + "\n");
}

ಈ logs ಗಳಿಂದ personal data ಅನ್ನು ದೂರವಿಡಿ. ನಿಮಗೆ route, class, basis, reasons ಮತ್ತು outcome ಬೇಕು. ನಿಮ್ಮ traffic mix ಅನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸಂಪೂರ್ಣ IP addresses, raw cookies ಅಥವಾ request bodies ಬೇಕಾಗುವುದಿಲ್ಲ. correlation ಗಾಗಿ ಯಾವುದಾದರೂ identifier ಅನ್ನು ಉಳಿಸಬೇಕಾದರೆ, ಅದನ್ನು rotating salt ನೊಂದಿಗೆ hash ಮಾಡಿ ಮತ್ತು short retention period ನ್ನು ಹೊಂದಿಸಿ.

ಹಂತ 7: ಕ್ರಮ ಕೈಗೊಳ್ಳುವ ಮೊದಲು data ಅನ್ನು ಓದಿ

ಸಾಧಾರಣ weekly patterns ಕಾಣುವಷ್ಟು ಸಮಯ observation mode ನಲ್ಲಿ ಚಲಾಯಿಸಿ. ನಂತರ ಕೆಲವು ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರಿಸಿ:

ಯಾವ routes ಗೆ agents ಹೆಚ್ಚು ಬರುತ್ತವೆ? Documentation, catalog ಮತ್ತು search endpoints ಸಾಮಾನ್ಯವಾಗಿ ಬರುತ್ತವೆ. Account ಮತ್ತು checkout flows ಸಾಮಾನ್ಯವಾಗಿ ಬಾರಬಾರದು.
Agent results ಗಳಲ್ಲಿ verified ಮತ್ತು declared ಗಳ ಪಾಲು ಎಷ್ಟು? ನೀತಿಗಳನ್ನು ಬರೆಯುವಾಗ identity ಮೇಲೆ ಎಷ್ಟು ಸುರಕ್ಷಿತವಾಗಿ ಅವಲಂಬಿಸಬಹುದು ಎಂಬುದನ್ನು ಆ ratio ಹೇಳುತ್ತದೆ.
Unknown ಎಲ್ಲಿ ಹೆಚ್ಚು ಕೇಂದ್ರೀಕೃತವಾಗಿದೆ? ಒಂದು route ನಲ್ಲಿ Unknown rate ಹೆಚ್ಚು ಇದ್ದರೆ, ಅಲ್ಲಿ ನೀವು signal ಕಳೆದುಕೊಂಡಿರಬಹುದು, ಉದಾಹರಣೆಗೆ ನಿಮ್ಮ frontend code ಎಂದಿಗೂ run ಆಗದ page.
Class ಪ್ರಕಾರ outcomes ಬೇರೆಯಾಗುತ್ತವೆಯೇ? Error rates, conversion steps ಅಥವಾ abuse reports ಗಳನ್ನು classes across compare ಮಾಡಿ. ಇಲ್ಲಿ ನಿಜವಾದ policy ideas ಬರುತ್ತವೆ.

ಉತ್ತರಗಳು ನಿಮಗೆ ಬಹುಮಾನವಾಗಿ ಆಶ್ಚರ್ಯವಾಗುತ್ತವೆ. ತಂಡಗಳು ತಮ್ಮ "bot problem" ನ ದೊಡ್ಡ ಭಾಗ actually legitimate automation ಆಗಿದ್ದು, structured endpoint ಇದ್ದರೆ ಅದು ಸಂತೋಷದಿಂದ ಬಳಸುತ್ತಿತ್ತೆಂದು ನಿಯಮಿತವಾಗಿ ಕಂಡುಕೊಳ್ಳುತ್ತವೆ.

ಹಂತ 8: ಫಲಿತಾಂಶವನ್ನು ನಿಮ್ಮ app ನ ಉಳಿದ ಭಾಗಗಳಿಗೆ expose ಮಾಡಿ

Data ಹರಿಯಲು ಆರಂಭಿಸಿದ ನಂತರ, non-enforcing uses ಗಾಗಿ handlers ಗೆ res.locals.actor ಓದುವ ಅವಕಾಶ ನೀಡಿ: analytics tags, response format ಆಯ್ಕೆಮಾಡುವುದು, ಅಥವಾ support ticket ಒಂದು AI-assisted session ನಿಂದ ಬಂದಿತು ಎಂದು record ಮಾಡುವುದು. ಈ uses ಗಳು ಯಾರನ್ನೂ lock out ಮಾಡಿಸುವ ಅಪಾಯವಿಲ್ಲದೆ experience ಅನ್ನು ಉತ್ತಮಗೊಳಿಸುತ್ತವೆ.

app.get("/docs/:page", (req, res) => {
  const actor = res.locals.actor as ActorResult | undefined;
  if (actor?.actor === "agent" && req.accepts("text/markdown")) {
    return res.type("text/markdown").send(renderMarkdown(req.params.page));
  }
  return res.render("doc", { page: req.params.page });
});

Challenges, rate limits ಅಥವಾ step-up checks ಮುಂತಾದ enforcement ನಂತರ ಬರುತ್ತದೆ, false positives ಅನ್ನು ನೀವು measure ಮಾಡಿದ ನಂತರ. actor-aware policies ಅನ್ನು rollout ಮಾಡುವ guide ಆ process ಅನ್ನು ಒಳಗೊಂಡಿದೆ.

ನೀವು ಯಾವ ತಪ್ಪುಗಳನ್ನು ತಪ್ಪಿಸಬೇಕು?

User agent ಅನ್ನು identity ಎಂದು ಪರಿಗಣಿಸುವುದು. ಇದು ಬದಲಾಯಿಸಲು ಅತ್ಯಂತ ಸುಲಭವಾದ header. ಅದನ್ನು declaration ಆಗಿ record ಮಾಡಿ. AI operators ಸಹ ಹಾಗೆಯೇ ಹೇಳುತ್ತಾರೆ: Anthropic ನ its hosted browser agent ಗೆ ಮಾರ್ಗದರ್ಶನ ಯಲ್ಲಿ ಯಾರಾದರೂ ಅದೇ User-Agent header ಅನ್ನು ಕಳುಹಿಸಬಹುದು ಎಂದು ಸೂಚಿಸಲಾಗಿದೆ ಮತ್ತು traffic ಅನ್ನು genuine ಎಂದು ಪರಿಗಣಿಸುವ ಮೊದಲು ಅದರ published IP addresses ಅನ್ನು ಪರಿಶೀಲಿಸಲು ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ.
Human ಗೆ default ಆಗುವುದು. ನಿಮ್ಮ code bot signals ಕಂಡುಕೊಳ್ಳಲಾಗದಾಗಲೆಲ್ಲ Human ಎಂದು ಹೇಳಿದರೆ, ನಿಮ್ಮ Human ಸಂಖ್ಯೆಗಳು ಹೆಚ್ಚಾಗಿ ಕಾಣುತ್ತವೆ ಮತ್ತು ನಿಮ್ಮ policies ತಪ್ಪು traffic ಮೇಲೆ ನಂಬಿಕೆ ಇಡುತ್ತವೆ.
Class ಮತ್ತು basis ಅನ್ನು mix ಮಾಡುವುದು. ಯಾವಾಗಲೂ ಎರಡನ್ನೂ store ಮಾಡಿ. ಕೇವಲ "Agent" ತೋರಿಸುವ dashboard verified operator ಮತ್ತು copied string ನಡುವಿನ ವ್ಯತ್ಯಾಸವನ್ನು ಮರೆಮಾಡುತ್ತದೆ.
Observation ಸಮಯದಲ್ಲಿ block ಮಾಡುವುದು. ತಾತ್ಕಾಲಿಕ block ಕೂಡ ನಿಮ್ಮ measurements ಅನ್ನು invalid ಮಾಡುತ್ತದೆ, ಏಕೆಂದರೆ blocked clients ತಮ್ಮ behavior ಅನ್ನು ಬದಲಾಯಿಸುತ್ತಾರೆ.

Proof of Actor ಎಲ್ಲಿ ಹೊಂದಿಕೊಳ್ಳುತ್ತದೆ

ಮೇಲಿನ middleware ಒಂದು solid starting point ಆಗಿದೆ, ಮತ್ತು ಅದು core model ಅನ್ನು ತೋರಿಸುತ್ತದೆ: ಮೊದಲು evidence, ಪ್ರತಿಯೊಂದು result ಗೆ explicit basis, Unknown visible ಆಗಿ ಉಳಿಯುವುದು, ಮತ್ತು decisions ಅನ್ನು ನಿಮ್ಮ application ಗೆ ಬಿಡುವುದು. Proof of Actor ಇದೇ model ಮೇಲೆ ನಿರ್ಮಿತವಾಗಿದೆ, server, edge, browser ಮತ್ತು MCP contexts across deeper signal coverage ಜೊತೆಗೆ, ಮತ್ತು Detect, Understand ಮತ್ತು Route ಅನ್ನು confidence ಜೊತೆ ಬಳಸಲು ಅವಕಾಶ ನೀಡುವ analytics ಜೊತೆಗೆ.

ನೀವು production app ನಲ್ಲಿ ಇದನ್ನು ಇನ್ನಷ್ಟು ಮುಂದಕ್ಕೆ ತೆಗೆದುಕೊಂಡು ಹೋಗಲು ಸಹಾಯ ಬಯಸಿದರೆ, early access ಗೆ apply ಮಾಡಿ. ಸಂಪೂರ್ಣ decision flow ನೋಡಲು, Proof of Actor ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ ಅನ್ನು ಓದಿ.

Sources

RFC 9421: HTTP Message Signatures: signed requests ಹಿಂದೆ ಇರುವ standard
draft-ietf-webbotauth-httpsig-protocol: Signature-Agent header ಅನ್ನು define ಮಾಡುವ IETF Web Bot Auth draft (November 2026 ರವರೆಗೆ work in progress)
RFC 9110: HTTP Semantics, User-Agent and From: self-reported client identification headers
MCP specification 2025-11-25: Lifecycle: initialize request ಮತ್ತು clientInfo
MCP specification 2026-07-28: Versioning and Compatibility: per-request version, identity ಮತ್ತು capability metadata
Anthropic: Anthropic-hosted browsers ತಮ್ಮನ್ನು ಹೇಗೆ ಗುರುತಿಸಿಕೊಳ್ಳುತ್ತವೆ: user agent token, published IP addresses ಮತ್ತು header ಅನ್ನು copy ಮಾಡಬಹುದು ಎಂಬ ಎಚ್ಚರಿಕೆ

ನಮ್ಮೊಂದಿಗೆ ಅದನ್ನು ನಿರ್ಮಿಸಿ.

Proof of Actor founding developer program ಗೆ ಸೇರಿ.

ಮುಂಗಡ ಪ್ರವೇಶ ಪಡೆಯಿರಿ ಡೆವಲಪರ್ ಕೇಂದ್ರ

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