- email.sendto: jane@example.comAUTO-ALLOWED
- refund.createamount: 250 · card: ••••4242HELD
Policy “Hold refunds over $100” → waiting for a human
- file.delete/srv/exports/customers.csvDENIED
How it works
Three steps between “the model wants to” and “it happened”.
- 01
Wrap the risky call
Put latch.guard() around any tool your agent can call — refunds, emails, deletes, shell. Two lines, any framework.
- 02
Policies decide instantly
Server-side rules match on action, agent and arguments (amount > 100, recipient domain…) and allow, deny or hold.
- 03
A human approves the rest
Held actions land in your inbox and Discord. Allow once, allow for 15 minutes, or deny with a reason. The agent proceeds — once.
import { AgentLatch } from "@agentlatch/sdk";
const latch = new AgentLatch({ apiKey: process.env.AGENTLATCH_API_KEY });
// Runs only if a policy or a human allows it — exactly once.
await latch.guard("refund.create", { amount: 250, currency: "USD" },
() => payments.refund(chargeId, 250));What the server decides
- refund ≤ $100 → auto-allowed by policy, runs immediately.
- refund > $100 → held. A reviewer approves in the dashboard; the agent resumes.
- file.delete → denied by policy. Your function never runs.
Features
Controls you can explain to your security team.
Policy engine
Glob action matching, agent scoping, numeric and domain conditions, priorities, expiry. Deny beats allow at equal priority.
Server-side enforcement
The SDK can only ask. Decisions come from your policies or an authenticated reviewer — never from the agent.
Tamper-evident audit log
Every event is SHA-256 hash-chained. Edits, deletions and re-ordering are detected. Export to CSV.
Replay protection
An approval is a single-use execution token. Consume it twice and the second call is rejected.
Hashed API keys
Keys are shown once and stored as hashes. Rotate or revoke instantly; revoked keys stop working on the next call.
Discord alerts
Masked embeds link to the dashboard. Webhook URLs are encrypted at rest and never displayed in full.
Honest limits
What AgentLatch will not do.
Guardrails that oversell themselves are worse than none. Here is exactly where the boundary is.
It only guards what you route through it
AgentLatch can't stop an agent that calls an API directly with its own credentials. Wrap every risky tool, and don't hand agents keys they don't need.
It is not a sandbox
We decide whether an action may run; we don't isolate the code that runs it. Pair AgentLatch with least-privilege credentials and real sandboxes.
No one-click approvals from chat
Discord messages link to the dashboard. Approving always requires a signed-in reviewer — a leaked notification can't approve anything.
It won't judge intent for you
Risk notes and AI summaries are hints. The decision, and the policy that made it, are yours.
Pricing
Simple plans. Pay for approvals, not seats.
We're onboarding from the waitlist. Pick a plan below to reserve your spot.
Developer
For side projects and first agents.
Free
- 1 project
- 500 approval requests / mo
- Policy engine + audit log
- Dashboard approvals
- Most popular
Pro
For teams shipping agents to production.
$29/mo
- 5 projects
- 10k approval requests / mo
- Discord + webhooks
- Timed grants & CSV export
Team
For orgs with many agents and reviewers.
$149/mo
- Unlimited projects
- 100k approval requests / mo
- Longer audit retention
- SSO (coming later)
FAQ
Questions, answered.
How does an agent wait for a human?
guard() submits the action, then long-polls the status endpoint (up to 25 s per call, with backoff) until it is allowed, denied or expires. Your function runs only after an allow.
What stops an agent approving its own request?
API keys can create, read and consume requests — nothing else. Decisions are only accepted from an authenticated dashboard session, and every decision is written to the audit log with the reviewer's identity.
Do you store my tool arguments?
Arguments are stored so policies can evaluate them and reviewers can see context. Sensitive fields (cards, tokens, passwords — plus any keys you list) are masked everywhere humans look, and you can omit fields entirely client-side.
Which agent frameworks work?
Anything that can make an HTTPS call. The TypeScript SDK ships with OpenAI tool-call and LangChain-style examples; the REST API is three endpoints.
What happens if nobody answers?
Pending requests expire after their TTL (10 minutes by default, configurable per call). Expired requests are never executed.
Can I self-host?
The v1 stack is Next.js + Supabase Postgres with row-level security. Self-hosting is on the roadmap; tell us on the waitlist if you need it.