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.
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", … }
}
This panel sends the request from your browser. Without JavaScript, the curl in the API section sends the same request.
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.
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.
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.
Your runtime already knows the tool call it is about to make. Send its metadata, not its content.
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.
allow runs the tool. escalate opens a one-tap approval for a person. block stops, and the receipt says why.
Hand them to the operator, an auditor or an underwriter. They verify at /verify without asking us.
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.
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.
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.
Answer one question about what your agent does for an operator. We reply with a starting policy that fits, in the request shape below.
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.
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.
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" }
The curl examples in the API section run as is in sandbox. With your key, drop tenant_id; the key names the tenant.
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.
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.
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.
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.
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}'
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_refaction.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_centsamount_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.purposeinformational, marketing or collections. It picks the calling window for that purpose and is checked against action.opted_out. The receipt records it.action.opted_outinformational, 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_countrecipient_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.
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.
{
"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.
rules[type].required_capabilityread_only < data_write < payment_initiate < payment_execute. A claim below the rule's level blocks.rules[type].review_above_cents0 to hold every waiver or credit.rules[type].hard_block_above_centsrules[type].auto_approve_max_centsreview_above_cents, the lower of the two applies.window_cap_cents windowper_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].recipientsfalse 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_reviewtrue 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].moneyout, 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{ 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_percentamount_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 / endrules[type].calling_window.days calling_window.skip_datesdays 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.collectionsstart, 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_requiredconsent_ref. Per-action override under rules[type].velocity_cap.per_recipient_per_24hrules[type].velocity_cap.per_recipient_per_7drecipient_contacts_7d. A velocity_cap under rules[type] replaces the whole block for that action type.risk.escalate_at risk.block_ataction.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_missingignore, 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_dayon_unavailable[type] on_unavailable.defaultproceed 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.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 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.
The exact text on the receipt for each decision.
on_unlisted and on_exceed in the policy. A call or text without a recipient reference always blocks.on_exceed in per_subject.400 content_rejectedprompt, messages, transcript, phone or another content name, or any string over 256 characters. Nothing is stored.400 invalid_money_inputaction.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_inputaction.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_policyalways_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_inputaction.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_shapeaction.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_operatorapprover_email or approver_phone. Approvers live on the key.400 missing_action_or_policyaction.type, or no policy with rules from the request or the key.401 vendor_key_required 401 invalid_vendor_keysandbox or demo without a key, or a key that is unknown or revoked.403 pinned_policy_required429 rate_limited503 gate_unavailabledecision: "block" with decision_reason: "gate_unavailable". Your on_unavailable setting is for a gate that does not answer at all.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.
Draft terms for early access. The signed order form controls.
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.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.