Write an approval policy for your AI agent

Tick what your agent does and say what should happen to each kind of action. You get a written policy to keep with your other policies, the VariantGate rules that enforce it, and the agent code. No sign-up, and nothing leaves this page.

1Say what your agent does

Start from
What the agent does

2Your approval policy

The written policy

The rules that enforce it

Add them under Rules in VariantGate, or send them to the API signed in as a workspace owner. When rules disagree the most cautious one wins, so a broader “always allow” you write later cannot get past these limits. How rules work

[
  {
    "action": "read.*",
    "effect": "allow"
  },
  {
    "action": "records.*",
    "effect": "ask"
  },
  {
    "action": "email.*",
    "effect": "ask"
  },
  {
    "action": "refund.*",
    "effect": "allow",
    "limit_amount": "50.00",
    "limit_currency": "EUR"
  },
  {
    "action": "refund.*",
    "effect": "ask",
    "limit_amount": "50.00",
    "limit_currency": "EUR"
  },
  {
    "action": "refund.*",
    "approvals": 2,
    "effect": "ask",
    "limit_amount": "1000.00",
    "limit_currency": "EUR"
  }
]

Two-person approval needs Team or above. On Free, every request waits for one person instead.

The agent’s side

The agent sends each action under the names in the policy and acts only on allowed: true. Make an agent key under Agents first.

import { ApprovalClient } from "@variantgate/agent";

const approvals = new ApprovalClient({
  agent: "Support agent",
  apiUrl: "https://api.variantgate.com",
  key: process.env.VARIANTGATE_KEY ?? "",
});

// For a wait this long, save the work and resume it from a
// webhook instead of keeping the process open: see /docs/webhooks.
// Runs only on allowed: true. Denied, expired or paused throws.
await approvals.guard(
  {
    action: "refund.create",
    summary: "What the agent wants to do, for the person deciding",
    amount: order.amount, // such as "49.00"
    currency: "EUR",
    ttlSeconds: 3600,
  },
  () => doTheThing()
);

What a policy for an AI agent has to answer

A policy that says “a human stays in the loop” and stops there tells nobody what to do at 3am. These are the six questions the generated policy answers, each with a control behind it.

  • Which actions, under which names

    Each kind of action gets a family of names, such as refund.*, so a rule can match it and the record can count it. Anything the policy does not list waits for a person.

  • Up to how much

    A limit lets small amounts through and sends the rest to a person. An amount that is missing or in another currency counts as above the limit, so leaving it out never gets an agent past one. More in spending limits for AI agents.

  • Who says yes

    A named person, never the agent, and for the actions you cannot undo, two different people. When two people are worth it.

  • What silence means

    A request nobody answers expires, and an expired request is a no. The agent never acts because time ran out.

  • How to stop everything

    Anyone on the team can pause every agent at once, and while paused nothing is approved. Only an owner can resume. See the emergency stop.

  • What is kept

    Every request and answer, with who decided and when, in a record nobody can edit. It is what you show an auditor, and where you find the next rule worth writing. See the audit trail.

Where it fits with OWASP and the EU AI Act

OWASP lists excessive agency (LLM06:2025, now LLM03) among the top risks of LLM applications, and one of its causes is a high-impact action that runs without anyone checking and approving it. Its Top 10 for Agentic Applications asks for a person’s confirmation before destructive, high-privilege or irreversible actions. The EU AI Act’s Article 14 asks that people overseeing a high-risk system can decide not to use its output, override it, and stop it. The generated policy writes those controls down for one agent, and the rules make them hold. It is a starting point for your own review, not legal advice.

Put the policy to work

Free for one person and 100 requests a month, with no card. Make an agent key, add the rules, and the next action that needs a person waits for a yes in email, Slack, Teams, Discord or a phone notification.

Questions

Do you see what I type?

No. The generator runs in your browser and sends nothing anywhere: not your team's name, not the agent's, not the policy. You can check it in your browser's network tab.

How do I share a draft with my team?

Press "Copy a link to this" and send the link. It opens the generator with every choice filled in, so the people who must agree can change it and send a new link back. The policy rides after the # sign, which browsers never send to a server.

Why both a document and rules?

A written policy only says what should happen. The rules make it happen: once they are in VariantGate, an action the policy says needs a person cannot run until a person approves it, and one it forbids is refused at once. Without enforcement, a policy for an AI agent is a hope.

Does this make us compliant with the EU AI Act?

It is a starting point, not legal advice. It writes down the controls that human oversight asks for: a person can approve, refuse or stop the agent, and every decision is recorded with who made it. Have whoever owns compliance at your company read it against the rules that apply to you, such as Article 14 of the EU AI Act for high-risk systems.

What if I am on the Free plan?

On the Free plan nothing is decided in advance, so every request waits for a person. That is stricter than the policy, never looser. Rules, amount limits and daily totals need Pro; two-person approval needs Team.

Why must the agent use these action names?

VariantGate matches an action by its name, or by every name with the same start, such as refund.*. The generator uses one start per kind of action, so the agent's code should send names like refund.create or email.send. If your agent already uses other names, change the patterns in the rules to match them.

What happens when nobody answers in time?

Then the request expires and counts as a no: the agent does not act. Pick a wait that fits how fast your team answers. For waits longer than a few minutes, the agent should save its work and resume when a webhook says the request was decided, instead of keeping a process open.