home / vendors
Hosted API · live today

A policy gate for the agents you ship to operators.

Your self-storage, voice, SMS or property-management agent drafts an action: waive a late fee, issue a credit, change a gate code, call a tenant at 9 PM. It asks AgentGuard first. The gate reads the operator's policy, answers allow, escalate or block, and signs a receipt of the decision.

An escalation reaches a person by one tap, and that person's answer becomes a second signed receipt chained to the first. The gate needs amounts, action types and references. Your integration sends each reference as a hash or an opaque id, never a name or a phone number; a request with a prompt, message, transcript or other content field is refused.

The sandbox needs no key. The pilot is free for three months, for one of your customers at up to three locations.

Or hear the gate decide on a storage call, or read the nine controls a voice agent needs before it touches money.

Try the sandbox.

hosted sandbox · no key · nothing stored
Request POST /api/gate/authorize

A $50.00 late-fee waiver. The rule holds any waiver above $0 for a person.

{
  "tenant_id": "sandbox",
  "agent_id": "storage-bot",
  "capability_claim": "data_write",
  "action": {
    "type": "waive_fee",
    "amount_cents": 5000,
    "currency": "USD",
    "target_system": "property_management"
  },
  "policy": { "id": "storage-bot-v1", … }
}
Decision

This panel sends the request from your browser. Without JavaScript, the curl in the API section sends the same request.

Receipt signed by the hosted gate, tenant sandbox
The sandbox answers here when the page loads. Verify it
What it sees

Action type, amount, currency, a target-system category, a payee or recipient reference, the recipient's time zone, a consent reference and, if you send them, a 0 to 100 risk score with short reason codes, a customer reference, a job total, a contact purpose and opt-out codes. Send each reference as a hash or an opaque id. A field with a content name such as prompt, messages, transcript or phone, or any string over 256 characters, is rejected with content_rejected; the terms below list every name.

What it decides

Per-action limits in cents or as a percent of the job, a money cap the gate counts itself for money going out, a capability ladder, payee allowlists and per-payee caps, limits per customer over up to 400 days, calling hours per purpose and day in the recipient's local time, a consent requirement, the recipient's opt-outs, per-recipient contact caps over 24 hours and 7 days, fleet caps for the whole tenant, risk score thresholds, actions that always wait for a person, and a pause switch for the operator.

What it writes

An Ed25519-signed receipt for every decision, with the policy hash, the inputs it judged and neutral text such as "outside the calling window set in the policy". Anyone holding a receipt can check it at agentguard.run/verify. How these limits are checked.

How it fits

Four calls, no integration project.

1
Your agent drafts an action

Your runtime already knows the tool call it is about to make. Send its metadata, not its content.

2
POST /api/gate/authorize

With your vendor key. The operator's policy is pinned on the key or sent with the request. The answer comes back in one round trip with a signed receipt.

3
Act on the decision

allow runs the tool. escalate opens a one-tap approval for a person. block stops, and the receipt says why.

4
Keep the receipts

Hand them to the operator, an auditor or an underwriter. They verify at /verify without asking us.

Proof

How these limits are checked.

The gate makes 21 guarantees. Each one has an id and a property test. A property test does not check a few examples: it generates thousands of requests and runs each one through the same request handlers that serve agentguard.run.

21guarantees, each with an id
30properties, 1,000 generated requests each, all passing on November 10, 2026
45 of 45deliberate bugs caught, injected one at a time
4 + 3checked on production in full, and in part

Four guarantees have also been checked on production with real requests:

Three more have been checked on production in part: a receipt verifies and a changed copy fails (G08), a paused tenant's new requests are blocked (G15), and the approval email and page show none of the words an agent chose (G34).

The other fourteen are proven by the test suite and not yet by a production probe. The scorecard says which is which, with the date of each check.

Early access

A free pilot, for three months.

The sandbox needs no key. The pilot is free for three months, for one of your customers at up to three locations.

We agree the goal of the pilot with you up front. It takes one engineer's afternoon to wire the call and a real operator policy to run. You keep every receipt whatever happens next.

  • Your vendor key, issued for the pilot and stored hashed.
  • The approvers who receive one-tap links, set on the key with you.
  • The operator's policy, pinned on the key so an agent cannot send itself a looser one.

Request a pilot

Answer one question about what your agent does for an operator. We reply with a starting policy that fits, in the request shape below.

Connect

Connect in ten minutes.

Three ways in, same gate, same receipts. Pick the one your platform already speaks.

Contact humans with tool calls, enforced: the pause and resume code.

MCP: three hosted tools

If your agent platform connects to MCP servers, add https://agentguard.run/api/mcp and send your vendor key on the connection as Authorization: Bearer agk_vendor_... (or as an X-AgentGuard-Vendor-Key header where the platform reserves Authorization). Tools: gate_authorize, gate_approval_status, gate_policy_example. Without a key the tools run only for tenant sandbox.

// tools/call gate_authorize, the same request body as the REST route
{ "name": "gate_authorize", "arguments": {
    "tenant_id": "sandbox", "agent_id": "storage-bot", "capability_claim": "data_write",
    "action": { "type": "waive_fee", "amount_cents": 5000, "currency": "USD", "target_system": "property_management" },
    "policy": { "id": "storage-bot-v1", "version": 1, "on_unavailable": { "default": "stop" },
                "rules": { "waive_fee": { "required_capability": "data_write", "review_above_cents": 0 } } } } }
// structuredContent: { decision: "escalate", decision_text: "held for a person under the policy", receipt: {...}, on_unavailable_effective: "stop" }

Setup for Claude Code, Cursor and ChatGPT is on the hosted MCP page; the gate tools are listed there with the six public ones.

Webhook: one file, no dependencies

If your platform calls an HTTPS URL on each tool call, run one of these handlers next to your agent. Each receives a small event, asks the gate, and answers proceed or not, with the approval id or the block text. The approval link itself goes to your approver, never back to the agent. When the gate does not answer within two seconds the handler reads your own on_unavailable setting for that action type and notes the gap.

handler.js (Node, standard library) · handler.py (Python, standard library) · README

# the event your platform posts to the handler; metadata only
{ "tool": "waive_fee", "arguments": { "amount_cents": 5000, "currency": "USD", "target_system": "property_management" },
  "tenant_id": "acme-storage", "agent_id": "storage-bot" }
# what the handler answers
{ "proceed": false, "approval_id": "apr_...", "text": "held for a person under the policy" }

REST: one POST

The curl examples in the API section run as is in sandbox. With your key, drop tenant_id; the key names the tenant.

API

The whole contract on one page.

Authentication

Send Authorization: Bearer agk_vendor_.... The key binds every request to your tenant, counts toward that tenant's fleet totals and may open approvals. Without a key the gate runs only in sandbox for the public demos: tenant sandbox or demo, nothing stored. The response says sandbox: true; inside the signed receipt the markers are tenant_id "sandbox" or "demo" and vendor_key_id: null. Any other tenant without a key is a 401. Keys are issued on the order form and stored hashed; they never appear in receipts.

Which policy decides

The operator's policy can be pinned on your vendor key. We pin it on the operator's request through an administered endpoint, POST /api/vendor/policy; an agent holding the key cannot change it. A pinned policy decides every request made with the key, and any policy a request carries is ignored. The receipt then says policy_source: "pinned", carries the policy's canonical SHA-256 in policy_hash, and sets request_policy_ignored: true when a request sent its own.

A key can also require a pinned policy: until one is pinned, every request is refused with 403 pinned_policy_required. Without a pinned policy the request's policy decides and the receipt says policy_source: "request". A pinned policy is checked once, when it is written: whole-cent limits, known capabilities, a window of per_day or per_hour, well formed payee controls, risk thresholds and the controls under More request fields, at most 32 KB.

Authorize a money action

This example runs in sandbox, so you can paste it as is.

# a $50 late-fee waiver; the policy holds anything above $0 for a person
curl -s https://agentguard.run/api/gate/authorize \
  -H "content-type: application/json" -d '{
    "tenant_id":"sandbox","agent_id":"storage-bot","capability_claim":"data_write",
    "action":{"type":"waive_fee","amount_cents":5000,"currency":"USD","target_system":"property_management"},
    "policy":{"id":"storage-bot-v1","version":1,"window":"per_day","window_cap_cents":50000,
      "fleet_caps":{"money_cents_per_day":200000,"contacts_per_day":400},
      "rules":{"waive_fee":{"required_capability":"data_write","review_above_cents":0,"hard_block_above_cents":50000},
               "issue_refund":{"required_capability":"data_write","review_above_cents":10000,"hard_block_above_cents":50000}}}
  }' | jq '{decision, decision_text, receipt_id: .receipt.receipt_id}'

Amounts are whole cents, zero or more. A string, negative, fractional or oversized amount is refused with invalid_money_input, never read as zero.

Name the payee

A money action can name its payee in action.recipient_ref: a Stripe profile handle such as @acme, a connected account, a bank or wallet reference, 1 to 256 characters. The gate keeps only a keyed hash, compared without regard to case or spaces; the receipt carries action.recipient_ref_hash, never the identifier. A policy can allowlist payees and cap each one over a rolling 24 hours:

"recipients": {
  "allowlist": ["@acme-supplies", "acct_1ExampleConnected"],
  "on_unlisted": "escalate",
  "velocity_per_24h": {
    "max_count": 3,
    "max_amount_cents": 200000,
    "on_exceed": "block"
  }
}

The allowlist, up to 500 entries, is hashed on the way in and the raw values are not stored. When a recipients rule applies, a payee that is not on the list, or a money action that names no payee, is held for a person (on_unlisted: "escalate", the default) or blocked ("block"). A payee past max_count payments or max_amount_cents in 24 hours is blocked (on_exceed: "block", the default) or held ("escalate"). With a key the gate keeps those counts per tenant and payee; in sandbox nothing is counted. rules[type].recipients replaces the block for one action type, and "recipients": false turns payee checks off for that type. gate_policy_example with name: "vendor-payouts-v1" returns this sample.

Authorize a call or a text

Contact actions are place_call and send_sms. Send the recipient reference and the consent reference as a hash or an opaque id your system already holds, never a phone number or a name. The gate checks only their shape, 4 to 128 letters, digits, _, ., : or - with no @, so a phone number written as digits passes. The contact receipt carries both references as sent, and with a key the gate keeps the recipient reference as sent to count contacts per recipient. In sandbox you can supply recipient_contacts_24h to simulate the per-recipient count and evaluated_at to pick the moment; with a key the gate keeps that count itself and its own clock decides.

# a collections call at 9:15 PM in the recipient's time zone
curl -s https://agentguard.run/api/gate/authorize \
  -H "content-type: application/json" -d '{
    "tenant_id":"sandbox","agent_id":"collections-bot","capability_claim":"data_write",
    "evaluated_at":"2026-10-19T01:15:00.000Z",
    "action":{"type":"place_call","recipient_ref":"rcp_7f3a9c","recipient_tz":"America/New_York","consent_ref":"cns_01HZX"},
    "policy":{"id":"storage-bot-v1","version":1,
      "calling_window":{"start":"08:00","end":"20:00"},"consent_required":true,
      "velocity_cap":{"per_recipient_per_24h":2},"fleet_caps":{"contacts_per_day":400},
      "rules":{"place_call":{"required_capability":"data_write"},"send_sms":{"required_capability":"data_write"}}}
  }' | jq '{decision, decision_text, local: .receipt.recipient_local_time_at_evaluation}'

More request fields (optional)

Four more fields let a policy hold or refuse on facts only your system knows. Each one is a number, a short code or a reference, never a name, a phone number or what someone said. A field that is not well formed is refused with invalid_money_input on a money action and invalid_contact_input on a call or text.

action.subject_ref
all
The customer, tenant or account the action is for: an opaque id your system already holds, 1 to 256 characters. The gate keeps only a keyed hash of it, compared without regard to case or spaces, and the receipt carries action.subject_ref_hash, never the reference. A rule with per_subject counts this customer's earlier actions of that type; sent without one, such an action is held for a person.
action.basis_cents
money
The job or invoice total in whole cents, 1 or more. A rule with a percent limit measures amount_cents against it; sent without one, such an action is held for a person. The receipt keeps the total and the percent under percent_limits.
action.purpose
contact
informational, marketing or collections. It picks the calling window for that purpose and is checked against action.opted_out. The receipt records it.
action.opted_out
contact
The recipient's opt-outs your system has on file, up to 4 codes from informational, marketing, collections and all. A call or text whose purpose is on the list is refused, and so is every call or text when all is. When an opt-out is on file and no purpose was sent, the action is held for a person. The receipt records the list as you sent it: a record of what your system reported and what the gate decided. The gate does not check the list against anything.
recipient_contacts_7d subject_prior_count
sandbox
Top-level, sandbox only, beside recipient_contacts_24h: a recipient's contacts in 7 days, and a customer's earlier actions of this type in the rule's period. With a key the gate keeps both counts itself and ignores these.
# a $66 discount on a $300 job; the policy refuses a discount above 15% of the job
curl -s https://agentguard.run/api/gate/authorize \
  -H "content-type: application/json" -d '{
    "tenant_id":"sandbox","agent_id":"service-bot","capability_claim":"data_write",
    "action":{"type":"apply_discount","amount_cents":6600,"basis_cents":30000,"currency":"USD","target_system":"field_service"},
    "policy":{"id":"home-services-default-v1","version":1,
      "rules":{"apply_discount":{"required_capability":"data_write","review_above_cents":0,"hard_block_above_cents":30000,
        "review_above_percent":0,"hard_block_above_percent":15}}}
  }' | jq '{decision, decision_text, percent: .receipt.percent_limits}'

gate_policy_example with name: "storage-default-v1" or "home-services-default-v1" returns the self-storage and home-services pilot policies, which use every field on this list, each with a worked request.

gate_policy_example with name: "finance-ap-v1" or "legal-billing-v1" returns a starting policy for an accounts payable agent and for a law firm's billing agent, each with a worked request. Every number in a sample is an operator's setting, not a recommendation, and a receipt records what the policy permitted: it is not legal advice.

Risk signal (optional)

If your own system scores how risky a caller's request looks, send that score with the action as action.risk: a whole-number score from 0 to 100, a source code naming the system that scored it, and up to five reasons codes. Only the number and the short codes are sent, never what the caller said. A source is 1 to 32 lower case letters, digits, _ or -; a reason is 1 to 40 lower case letters or _. Anything else is refused with invalid_risk_input.

# a $25 fee waiver the rule permits without a person; a score of 78 holds it for one
curl -s https://agentguard.run/api/gate/authorize \
  -H "content-type: application/json" -d '{
    "tenant_id":"sandbox","agent_id":"storage-bot","capability_claim":"data_write",
    "action":{"type":"waive_fee","amount_cents":2500,"currency":"USD","target_system":"property_management",
      "risk":{"score":78,"source":"vendor","reasons":["fee_waiver_pressure"]}},
    "policy":{"id":"storage-risk-v1","version":1,
      "risk":{"escalate_at":60,"block_at":90,"when_missing":"ignore"},
      "rules":{"waive_fee":{"required_capability":"data_write","review_above_cents":5000,"hard_block_above_cents":50000}}}
  }' | jq '{decision, decision_text, risk: .receipt.risk}'

The operator's policy sets the thresholds. At or above escalate_at, an action the policy would permit is held for a person through the same one-tap approval; at or above block_at, it is refused. rules[type].risk changes them for one action type. A score only makes a decision stricter: a block stays a block, and a hold becomes a block only at block_at. With when_missing: "escalate" an action sent without a score is held for a person; the default, "ignore", decides without one. The score, its source and reasons, and the thresholds that applied are in the signed receipt under risk. The gate does not check how a score was made.

What comes back

{
  "decision": "escalate",                 // allow | escalate | block
  "decision_reason": "amount_above_review_threshold",
  "decision_text": "held for a person under the policy",
  "spend_reserved_cents": 0,              // money counts only on allow
  "policy_source": "pinned",              // pinned | request
  "on_unavailable_effective": "stop",     // your policy's setting for this action type
  "receipt": { "receipt_type": "money_action_authorization", "receipt_id": "rcpt_...", "tenant_id": "...",
               "policy_hash": "...", "decision": "escalate", "signature": "...", "public_key_hex": "..." },
  "approval": { "id": "apr_...", "expires_at": "...",
                "status_url": "https://agentguard.run/api/gate/approvals/apr_.../status",
                "link": "https://agentguard.run/api/gate/approvals/apr_...?t=..." },  // link: only with deliver_link_in_response
  "approval_delivery": { "email": { "sent": true, "reason": null }, "sms": null },
  "verify_url": "https://agentguard.run/verify"
}

The response carries approval.link only when your key has deliver_link_in_response turned on. By default the link goes only to the approver set on your vendor key.

Policy fields

rules[type].required_capability
all
Ladder read_only < data_write < payment_initiate < payment_execute. A claim below the rule's level blocks.
rules[type].review_above_cents
money
Above this amount the action escalates to a person. Set 0 to hold every waiver or credit.
rules[type].hard_block_above_cents
money
Above this amount the action blocks, no person asked.
rules[type].auto_approve_max_cents
money
The most that may run without a person. An amount above it is held for a person. When a rule sets both this and review_above_cents, the lower of the two applies.
window_cap_cents window
money
Ceiling on the money the gate allows under one vendor key in each window: per_day, the default, or per_hour. With a key the gate counts the window itself and debits it on allow, so concurrent requests cannot together spend past the cap. A window_spent_cents in the request is not used for the decision; when it differs from the gate's own figure the receipt keeps both. An amount a person approved counts once its result is reported to POST /api/gate/outcomes as succeeded, pending or unknown. In sandbox nothing is counted: send window_spent_cents to simulate the window.
recipients rules[type].recipients
money
Payee allowlist and per-payee caps over 24 hours, as in Name the payee. false in a rule turns them off for that type; any other value that is not an object is refused with 400. The gate counts up to 200 payments per payee in 24 hours, so max_count is at most 200, and a payee past 200 payments is blocked while an amount cap applies, until older payments leave the window.
rules[type].always_review
all
true holds every action of this type for a person, even one the rest of the policy would permit, with the text "held for a person: this action always needs a person". A risk score at block_at still refuses it. For actions that move no money, such as removing an overlock, changing contact details or cancelling a membership.
rules[type].money
money
out, the default, in or none. Only money going out counts toward window_cap_cents, fleet_caps.money_cents_per_day and per-payee caps. An in amount (a payment taken, a payment link) or a none amount (a quote) is recorded on the receipt as action.money_direction and checked against this rule's own limits, and is never counted.
rules[type].per_subject
all
{ max_count, period_days, on_exceed }: at most max_count actions of this type for one customer in period_days, whole numbers from 1 to 1000 and from 1 to 400. With a key the gate counts, per tenant and customer, the actions it allowed and the ones a person approved, from action.subject_ref. At the limit the action is held for a person (on_exceed: "escalate") or refused ("block"), and the same happens when the gate cannot count the whole period, never a short count. The receipt shows the count under subject_limit. In sandbox nothing is counted: send subject_prior_count.
rules[type].review_above_percent rules[type].hard_block_above_percent
money
Limits on amount_cents as a percent of action.basis_cents, from 0 to 100, whole or with one decimal. Above review_above_percent the action is held for a person; above hard_block_above_percent it is refused. They apply beside the limits in cents, and the stricter answer stands.
calling_window.start / end
contact
Recipient local time, start inclusive, end exclusive. An unknown time zone escalates instead of guessing. Per-action override under rules[type].
calling_window.days calling_window.skip_dates
contact
Optional. days lists the days the window runs, 1 to 7 of mon, tue, wed, thu, fri, sat and sun; skip_dates lists up to 366 dates it does not run, written YYYY-MM-DD. Both are read in the recipient's time zone at the moment of the request. A call on another day is refused with outside_calling_days, on a listed date with skip_date.
calling_windows.informational calling_windows.marketing calling_windows.collections
contact
A window for one purpose, with its own start, end, days and skip_dates. A call or text sent with that action.purpose uses it; any other uses calling_window. A rule's own calling_windows and calling_window replace the policy's for that action type.
consent_required
contact
Blocks any call or text without a consent_ref. Per-action override under rules[type].
velocity_cap.per_recipient_per_24h
contact
Blocks the next contact to the same recipient once the count is reached. At most 50, the contacts the gate counts per recipient in 24 hours. Per-action override under rules[type].
velocity_cap.per_recipient_per_7d
contact
Blocks the next contact to the same recipient once its count over the last 7 days is reached. At most 50, the contacts the gate keeps per recipient over 7 days. With a key concurrent requests cannot together pass it; in sandbox send recipient_contacts_7d. A velocity_cap under rules[type] replaces the whole block for that action type.
risk.escalate_at risk.block_at
all
Thresholds for action.risk.score, whole numbers from 1 to 100, with block_at at or above escalate_at. At or above escalate_at an action the policy would permit is held for a person; at or above block_at it is refused. Per-action override under rules[type].risk; a key the rule leaves out comes from the top-level block.
risk.when_missing
all
ignore, the default, or escalate, which holds an action sent without a score for a person. Per-action override under rules[type].risk. See Risk signal.
fleet_caps.contacts_per_day fleet_caps.money_cents_per_day
all
Tenant-wide daily totals across every agent. See Fleet limits and pause.
on_unavailable[type] on_unavailable.default
all
Your own answer to "what if the gate does not reply": proceed or stop, default stop. The gate never decides this; it echoes the setting back as on_unavailable_effective so your runtime can honor it on a timeout and your records can show the gap.

Approvals

When the decision is escalate, the response carries approval.id and approval.status_url, never the link. The link goes only to the approver set on your vendor key: an email address, and a phone number where SMS delivery is enabled for your tenant. We set these with you when we issue the key; a request cannot name its own approver, so an agent cannot route an approval to itself. If your own server shows the owner an Approve button (a platform connector, for example), we can turn on the link in the response for that server's key only. Never give that key to an agent. The link works once and expires in 24 hours. The person sees the action, why the policy held it and two buttons. The email, text and page give the reason in one line, such as "Held because: risk score 78 is at or above 60 (reasons: fee_waiver_pressure)" or "Held because: amount $30.00 is above the $20.00 review limit": the decision text, the amounts and any risk reason codes, never what a caller said. Their decision is signed and chained to the request receipt, with the approver's label and time. On a held request's receipt, human_review_recorded: true means the action was routed to a person, not that a person decided; human_decision: "pending" says so. The person's decision receipt carries human_decision: "approved" or "denied". Receipts made before this field existed do not carry it. Your agent polls the status with its key:

curl -s https://agentguard.run/api/gate/approvals/apr_YOUR_ID/status \
  -H "authorization: Bearer $AGENTGUARD_VENDOR_KEY" | jq '{status, decided_at, approver_label}'
# status: pending | approved | denied | expired; receipt holds the signed decision once settled

Fleet limits and pause

Fleet caps are tenant-wide and reset each UTC day. When fleet_caps.contacts_per_day is reached, every further call or text for the tenant returns block with the text "fleet cap reached for today in the policy"; fleet_caps.money_cents_per_day does the same for allowed refunds, credits and waivers, counting approved escalations too. An operator can also pause a tenant: every action then returns block with "tenant paused by operator" until the pause is cleared. A hold that was already waiting cannot be approved or denied while the tenant is paused: the approver's link answers 409 tenant_paused, no receipt is signed and the hold stays pending. Pauses are set by us on the operator's request today, through an administered endpoint. There is no self-serve switch yet.

Decision texts

The exact text on the receipt for each decision.

allow
permitted under the policy
escalate
held for a person under the policyrecipient time zone not recognized; held for a person
block
above the per-action limit set in the policyabove the daily money cap set in the policyfleet cap reached for today in the policycapability below the level the policy requiresno rule for this action in the policytenant paused by operatoroutside the calling window set in the policyno consent reference supplied; the policy requires onerecipient contact count reached the cap set in the policyrecipient contacts in 24 hours are more than the gate can countpayee payments in 24 hours are more than the gate can count
escalate or block
payee not on the allowlist set in the policypayee payment count reached the cap set in the policypayee amount reached the cap set in the policyno recipient reference supplied; the policy requires onePayee checks follow on_unlisted and on_exceed in the policy. A call or text without a recipient reference always blocks.
escalate or block on a risk score
held for a person: risk score 78 is at or above 60refused: risk score 95 is at or above 90held for a person: no risk score was sent and the policy asks for oneThe numbers are the score sent and the threshold in the policy.
escalate on always_review, percent, customer or opt-out checks
held for a person: this action always needs a personheld for a person: 15.0% of the total is above the 0% review limitheld for a person: no job or invoice total was sent and the policy sets a percent limitheld for a person: no customer reference was sent and the policy limits actions per customerheld for a person: this person opted out of some contacts and no purpose was sentThe numbers are the request's and the policy's. See More request fields.
block on percent, opt-out, calling-hour or 7-day checks
refused: 22.0% of the total is above the 15% limitrefused: this person opted out of marketing callsrefused: marketing calls run Monday to Friday, 10:00 to 19:00refused: no marketing calls on 2026-11-26, a date the policy skipsrecipient contact count in 7 days reached the cap set in the policyrecipient contacts in 7 days are more than the gate can countA call or text outside a window that sets days or a purpose names the hours and days that apply; without them the text is "outside the calling window set in the policy".
escalate or block per customer
held for a person: 1 waive fee action for this customer in the last 365 days, the limit is 1refused: 2 apply credit actions for this customer in the last 30 days, the limit is 2held for a person: actions for this customer in the period are more than the gate can countThese follow on_exceed in per_subject.
allow / block by a person
permitted by a person under the policydenied by a person under the policy

Errors

400 content_rejected
A field named prompt, messages, transcript, phone or another content name, or any string over 256 characters. Nothing is stored.
400 invalid_money_input
An amount, rule limit, payee reference or recipients block that is not well formed, or on a money action an action.subject_ref that is not a reference of 1 to 256 characters or an action.basis_cents that is not a whole number of cents, 1 or more.
400 invalid_contact_input
On a call or text: an action.purpose other than informational, marketing or collections, an action.opted_out that is not a list of at most 4 of those codes and all, or an action.subject_ref that is not a reference of 1 to 256 characters.
400 invalid_policy
A control from More request fields that is not well formed in the policy that decides: always_review that is not true or false, money other than out, in or none, a per_subject block outside its ranges or with a key it does not take, a percent limit outside 0 to 100 or with more than one decimal, a per_recipient_per_7d above 50, or a calling_windows, days or skip_dates entry the gate cannot read. Pinning such a policy is refused the same way.
400 invalid_risk_input
An action.risk or a policy risk block that is not well formed: a score that is not a whole number from 0 to 100, a missing or malformed source, more than five reasons or a reason that is not a short code, a key the gate does not know, or block_at below escalate_at.
400 invalid_action_shape
An action.type that is not a string, an action.currency that is not a three-letter code, or an action.target_system that is not a short code of letters, digits, _, ., : or -. Nothing is decided, signed or stored.
400 approver_set_by_operator
The request named approver_email or approver_phone. Approvers live on the key.
400 missing_action_or_policy
No action.type, or no policy with rules from the request or the key.
401 vendor_key_required 401 invalid_vendor_key
A tenant other than sandbox or demo without a key, or a key that is unknown or revoked.
403 pinned_policy_required
The key requires a pinned policy and none is pinned yet.
429 rate_limited
Too many requests in one minute on one key. The limit is 240 a minute on each server instance, so it is a guard against a runaway loop, not an exact quota.
503 gate_unavailable
The gate could not read its state or sign a receipt. It fails closed: the body says decision: "block" with decision_reason: "gate_unavailable". Your on_unavailable setting is for a gate that does not answer at all.

Verify a receipt

jq '{receipt: .receipt}' response.json | curl -s https://agentguard.run/api/verify \
  -H "content-type: application/json" -d @- | jq .ok
# change one byte of the receipt and run it again: ok becomes false

Every response carries its receipt, and a decision receipt arrives in the status poll. Keep them with your records; they verify without us. A per-tenant export shaped for an operator, an insurer or an auditor is part of the order form, not a public endpoint yet.

What the gate does not do: it does not move money, place calls or send texts; it does not read conversations; it does not decide whether an action was lawful or appropriate. It records what the operator's policy permitted or held, and who said yes.
Terms

Terms for the hosted gate.

Draft terms for early access. The signed order form controls.

  1. The policy is the operator's setting. Every threshold, window, cap and consent rule in a policy is chosen by the operator or the vendor acting for them. AgentGuard applies it as written and does not choose the numbers.
  2. Metadata in, minimized by the vendor. The gate evaluates the action type, amounts, currency, target system category, references, a time zone and an optional risk score with short reason codes that the vendor sends, and, when sent, a job or invoice total, a contact purpose and opt-out codes. The vendor sends every reference, and the agent id, as a hash or an opaque id, never a name, phone number or card number. The server refuses a request, and stores nothing from it, when a field at the top level or nested up to four objects deep is named prompt, completion, content, messages, input, output, text, customer, pii, card, pan, phone, phone_number, email_body or transcript in any letter case, or when any string in it is longer than 256 characters. It cannot tell whether an accepted value is personal data.
  3. A receipt records what the policy permitted. It is a signed record of the evaluation and of who said yes. It is not legal advice and not a statement that any action met a law, a regulation or a contract.
  4. No warranty about the action itself. AgentGuard does not warrant that any call, text, refund, credit or waiver was lawful, timely, appropriate or authorized by the customer. The gate does not move money, place calls or send texts.
  5. The vendor and the operator answer for their agents. Each remains responsible for what its agents do and say, for the accuracy of the metadata it sends, and for the policy it sets, and indemnifies AgentGuard and Dunecrest Ventures Inc. against claims arising from those actions and that content.
  6. Liability is limited. AgentGuard's total liability under these terms is limited to the fees the vendor paid for the gate in the three months before the claim. No party is liable for indirect or consequential loss.
  7. Availability is a setting you own. Each action type carries the vendor's own on_unavailable choice, proceed or stop. When the gate cannot answer, the vendor's runtime applies that choice and the receipt chain shows the gap. No uptime is promised in early access.
  8. Data kept, keys revoked, law applied. AgentGuard keeps payee and customer references only as keyed hashes, and with a key it keeps a customer's action times for up to 400 days to count per-customer limits. With a key it keeps the contact recipient reference as sent to count contacts per recipient, and an escalation's approval record keeps its signed receipt, which carries the agent id, any contact references as sent, any risk score and reason codes, and any contact purpose and opt-out codes. It also keeps amounts, action types, decisions and signatures. Vendor keys can be revoked by the vendor or by AgentGuard at any time. These terms are governed by the law of the State of Wyoming.