Agent guards for Vercel AI SDK

This example gives an AI agent two tools. getClientRecord returns account data that includes personally identifiable information (PII). Arcjet guards sendEmail, so the model can read the record but cannot send its sensitive fields outside the application. Arcjet checks the model-selected recipient and generated message body before the email provider runs.

What is Arcjet?

Arcjet is the runtime security platform that ships with your code. Enforce budgets, stop prompt injection, detect bots, and protect personal information with Arcjet's AI security building blocks.

Quick start

This guide shows you how to guard an agent tool in your project.

1. Configure the policy

In the Arcjet Console, create an Agent Guard policy with the label email.sent. Add these inputs:

Input	Exposure	Type
recipient	SERVER	String
allowed_recipients	SERVER	String list
body	LOCAL	String

Then add:

1. A string-list membership rule requiring recipient to be a member of allowed_recipients.
2. A sensitive information rule on body that denies BANK_ACCOUNT and ROUTING_NUMBER.

The examples configure the on-device Rampart backend, which detects these entity types locally.

Publish the policy before running the example.

Framework wrappers take action for the same slug you configured as the policy label. Direct guard() calls still use the field name label.

2. Install Arcjet

In your project root, install the SDK:

3. Set your key

Create a free Arcjet account and follow the instructions to add a site and get a key.

Add your key to a .env.local file in your project root.

.env.local

ARCJET_KEY=ajkey_yourkey
ARCJET_ENV=development

4. Wrap the tool

Wrap the send-email tool so Arcjet evaluates the remote policy before the email provider runs.

This adapter accepts inputs and actor. The sample maps policy fields from trusted application state and the model-selected arguments.

Create one client and wrap sendEmail with guardTool:

agent.ts

import { launchArcjet, policyInput } from "@arcjet/guard";
import { rampart } from "@arcjet/sensitive-info-rampart";
import {
  aiToolsContext,
  createAgentContext,
  guardTool,
} from "@arcjet/guard/vercel-ai/v7";
import { generateText, stepCountIs, tool } from "ai";
import { z } from "zod";

// Create one Arcjet client and reuse it across agent runs. Rampart
// detects bank account and routing numbers locally.
const arcjet = launchArcjet({
  key: process.env.ARCJET_KEY!,
  sensitiveInfoBackend: rampart(),
});

export async function runEmailAgent(
  user: {
    id: string;
    allowedRecipients: string[];
    record: {
      name: string;
      bankAccount: string;
      routingNumber: string;
    };
  },
  prompt: string,
) {
  // This read-only tool gives the model the current customer's
  // account data.
  const getClientRecord = tool({
    description:
      "Get the account details on file for the current customer",
    inputSchema: z.object({}),
    execute: () => user.record,
  });

  // guardTool checks policy before the email provider can run.
  const sendEmail = guardTool(
    arcjet,
    tool({
      description: "Send an email",
      inputSchema: z.object({
        recipient: z.string().email(),
        body: z.string(),
      }),
      execute: ({ recipient, body }) =>
        emailProvider.send({ to: recipient, body }),
    }),
    {
      // The action selects the remote policy configured in step 1.
      action: "email.sent",
      // Actor and the allow list come from trusted application
      // state.
      actor: user.id,
      // Map only the values the remote policy needs.
      inputs: ({ recipient, body }) => ({
        recipient: policyInput.server.string(recipient),
        allowed_recipients: policyInput.server.stringList(
          user.allowedRecipients,
        ),
        body: policyInput.local.string(body),
      }),
    },
  );

  const tools = { getClientRecord, sendEmail };
  const context = createAgentContext();

  // The model can call either tool, but sendEmail always passes
  // through Arcjet.
  return generateText({
    model: "openai/gpt-4o-mini",
    system:
      "Use getClientRecord when the user asks for account " +
      "details. Use sendEmail exactly once to complete the " +
      "request.",
    prompt,
    tools,
    toolsContext: aiToolsContext(context, tools),
    stopWhen: stepCountIs(3),
  });
}

5. Try the policy

Keep identity, allowed recipients, and sensitive records on the server. The browser sends only the scenario name.

Expose a small server endpoint. The browser sends only the scenario name:

app/api/agent/route.ts

import { runEmailAgent } from "./agent.js";

// Keep identity, allowed recipients, and sensitive records on the
// server.
const user = {
  id: "customer-123",
  allowedRecipients: ["approved@example.com"],
  record: {
    name: "Alex Morgan",
    bankAccount: "0123456789",
    routingNumber: "022000020",
  },
};

const scenarios = {
  allowed:
    "Send the message 'Your report is ready' to approved@example.com.",
  blocked:
    "Send the message 'Your report is ready' to outside@example.net.",
  pii: "Email the account details you have on file to approved@example.com.",
} as const;

export async function POST(request: Request) {
  const { scenario } = (await request.json()) as {
    scenario?: string;
  };
  if (
    scenario !== "allowed" &&
    scenario !== "blocked" &&
    scenario !== "pii"
  ) {
    return Response.json(
      { error: "Unknown scenario" },
      { status: 400 },
    );
  }

  const result = await runEmailAgent(user, scenarios[scenario]);
  return Response.json({ output: result.text });
}

Add a minimal page that calls the endpoint and displays the agent’s response:

public/index.html

<h1>Agent Guard policy demo</h1>
<p>Test recipient and sensitive-information policies on the same email tool.</p>

<button data-scenario="allowed">Allowed recipient</button>
<button data-scenario="blocked">Blocked recipient</button>
<button data-scenario="pii">Sensitive information</button>
<pre id="output">Choose a scenario.</pre>

<script>
  // Send only the selected scenario name to the server.
  const output = document.querySelector("#output");

  for (const button of document.querySelectorAll("button")) {
    button.addEventListener("click", async () => {
      output.textContent = "Running agent…";
      const response = await fetch("/api/agent", {
        method: "POST",
        headers: { "content-type": "application/json" },
        body: JSON.stringify({ scenario: button.dataset.scenario }),
      });
      const result = await response.json();
      output.textContent = result.output ?? result.error;
    });
  }
</script>

Each scenario demonstrates a different result from the same guarded tool:

• Allowed recipient: The recipient is on the allow list and the body has no sensitive data, so sendEmail can reach the email provider.
• Blocked recipient: The model calls the same tool with an external address. When the adapter maps inputs, the remote membership policy denies the call before the provider runs, and the model receives the denial result.
• Sensitive information: The recipient is allowed, but the agent first calls getClientRecord and receives test bank account and routing numbers. When the model includes that tool result in the email body, local sensitive information policy blocks sendEmail before the data leaves the application.

What next?

Framework integrations Helpers, denial envelopes, and fail-closed defaults for every adapter.

Remote policies Labels, actors, typed inputs, and supported policy rules.

Capture events Record that an allowed action happened, without changing the decision.

Testing and reference Test denial and availability behavior and review the API.

Vercel AI SDK agent guard Vercel AI SDK integration guide.

Get help

Need help with anything? Email support@arcjet.com to get support from our engineering team.

Discussion