Skip to content
AgentLatch

Human-in-the-loop for AI agents

Put a latch on risky agent actions.

AgentLatch is a TypeScript SDK and API that holds refunds, deletes, emails and shell commands until a policy or a human says yes — with a tamper-evident audit trail. Enforced on the server, not in a prompt.

No signup for the demo · synthetic data · runs in your browser

support-bot-7 · live
  1. email.sendto: jane@example.comAUTO-ALLOWED
  2. refund.createamount: 250 · card: ••••4242HELD

    Policy “Hold refunds over $100” → waiting for a human

  3. file.delete/srv/exports/customers.csvDENIED
✓ audit chain verified · 3 entries · sha256 9f2c…e41a

How it works

Three steps between “the model wants to” and “it happened”.

  1. 01

    Wrap the risky call

    Put latch.guard() around any tool your agent can call — refunds, emails, deletes, shell. Two lines, any framework.

  2. 02

    Policies decide instantly

    Server-side rules match on action, agent and arguments (amount > 100, recipient domain…) and allow, deny or hold.

  3. 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.

agent.ts
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.
Read the quickstart

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
    Start free
  • Most popular

    Pro

    For teams shipping agents to production.

    $29/mo

    • 5 projects
    • 10k approval requests / mo
    • Discord + webhooks
    • Timed grants & CSV export
    Get Pro
  • Team

    For orgs with many agents and reviewers.

    $149/mo

    • Unlimited projects
    • 100k approval requests / mo
    • Longer audit retention
    • SSO (coming later)
    Talk to us

Waitlist

Get early access.

We're letting teams in gradually so we can help each one wire up their first policies. Tell us what your agents do and we'll prioritise accordingly.

Impatient? The live demo and the full dashboard run in demo mode right now.

We only use your email to contact you about AgentLatch.

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.