Agents execute before anyone sees the action
Autonomous tools can mutate production data, access secrets, and change permissions with no deterministic gate between intent and execution.
ApprovalLayerAI Safety Gateway
Zelta
AI Infrastructure for Autonomous Agents
ApprovalLayer is Zelta's AI Safety Gateway that helps autonomous AI agents safely execute high-impact actions using policies, hybrid AI risk classification, human approvals, audit trails, and execution tokens.
gateway · proposal review
financial.refundReview required
agent_prod_01 · issue_refund · cus_demo · INR 50,000
Policy: review_required
Risk: high · confidence 0.82
Reviewer approved
Token issued · expires 5m
Review deadline
14:32 UTC
Effective decision
Approved · token pending
Hybrid mode escalated high-severity ML signal to human review.
Trusted by AI builders
AgentForge
SynthOps
RunLayer
ToolMesh
Guardrail AI
FlowPilot
The problem
Autonomous agents need guardrails
before execution, not after.
Policy and risk live in different systems
Security rules sit in one place, ML signals in another, and human review in a third — making consistent decisions slow and error-prone.
Audit trails break at execution time
Without binding approval to a one-time execution token, teams cannot prove who authorized what ran, when, and with which payload.
How ApprovalLayer works
Propose → decide → tokenize → execute
Every agent tool call flows through the same deterministic pipeline. Review and risk signals compose into one effective decision.
- 01
Propose
Your agent sends tool intent, payload, and context to the gateway before running anything.
- 02
Policy Engine
Deterministic rules evaluate action type, scope, and org policy — allow, block, or route to review.
- 03
Hybrid Risk Classifier
Shadow or hybrid ML analysis scores severity and confidence without blocking the deterministic path.
- 04
Human Review
Reviewers approve, reject, or escalate with SLA deadlines and notification routing.
- 05
Execution Token
A single-use token binds the approved payload hash — replay and tampering are rejected at verify time.
- 06
Verify & Execute
The agent verifies the token against the exact action, then executes with a full immutable audit record.
Features
Enterprise controls for agent execution
Six core capabilities that compose into a single pre-execution decision — no bolt-on dashboards required.
Policy Engine
Deterministic allow, block, and review rules keyed on action type, agent identity, and org-scoped policy configuration.
Hybrid AI Risk Classifier
Shadow, hybrid, or enforce modes combine ML severity signals with policy outcomes — escalate high-confidence risks to human review.
Human Review
Structured review queues with approve, reject, escalate, timeout handling, and reviewer notifications.
Audit Logs
Every proposal, policy decision, risk signal, human verdict, and execution attempt is recorded for compliance and forensics.
Execution Tokens
One-time, payload-bound tokens issued only after approval — consumed on successful verify to prevent replay.
Notifications
Email and in-app alerts when review is required, with deduplicated delivery and gateway event tracking.
Architecture
One gateway.
Every control point connected.
ApprovalLayer centralizes propose, policy, risk, review, token issuance, audit, and notifications — without replacing your agent runtime.
agent
AI Agent
SDK / HTTP
gateway
Gateway API
Propose · Status · Verify
policy
Policy Engine
Deterministic rules
risk
Risk Classifier
Shadow / Hybrid / Enforce
review
Review Service
Human decisions
tokens
Token Store
Single-use issuance
audit
Audit Log
Immutable events
notify
Notifications
Email & alerts
Agents never bypass the gateway — policy, risk, and human review compose a single effective decision before any token is issued.
Developers
Integrate in minutes
Propose actions over HTTP with agent API keys. Poll status for review outcomes, then verify execution with a one-time token.
POST /api/v1/actions/propose
const baseUrl = "https://your-app.approvalayer.app";
const apiKey = process.env.AGENT_API_KEY!;
const response = await fetch(`${baseUrl}/api/v1/actions/propose`, {
method: "POST",
headers: {
Authorization: `Bearer ${apiKey}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
agentId: "agent_prod_01",
toolName: "issue_refund",
actionType: "financial.refund",
payload: {
customerId: "cus_demo",
amount: 50000,
currency: "INR",
},
}),
});
if (!response.ok) {
throw new Error(await response.text());
}
const proposal = await response.json();
console.log(proposal);SDK helpers available via ApprovalLayerClient
Pricing
Plans that scale with your agents
Start free with the gateway API. Upgrade for hybrid enforcement, analytics, and team controls.
Free
Explore the platform with limited usage.
$0
- 1,000 API calls / month
- 500 MB log storage
- Up to 3 users
- Basic risk scoring
- Email notifications
Most popular
Professional
For teams that need full approval workflows and AI analysis.
$29/mo
- 50,000 API calls / month
- 25 GB log storage
- Up to 25 users
- Advanced risk classifier
- Slack, Teams & email alerts
Team
For growing teams that need integrations and higher limits.
$99/mo
- 250,000 API calls / month
- 100 GB log storage
- Up to 100 users
- All Professional features
- Integrations & API keys
FAQ
Frequently asked questions
Agents call the gateway before executing a tool. Propose returns allow, block, or review_required. After approval, agents fetch an execution token and verify it immediately before running the action.
Put approval in front of execution
Create an agent API key, propose your first action through ApprovalLayer, and wire the gateway into your tool-calling loop in under an hour.