Gatekept — Agent Governance Infrastructure

ALLOW — payment $4,200 within policy

BLOCK — PII export 45k rows exceeds threshold

ESCALATE — production deploy outside approved window

ALLOW — calendar invite, no sensitive data detected

BLOCK — bulk email to 12k contacts, unreviewed

ALLOW — customer record read, authorised agent

ESCALATE — code push to main, requires sign-off

ALLOW — payment $4,200 within policy

BLOCK — PII export 45k rows exceeds threshold

ESCALATE — production deploy outside approved window

ALLOW — calendar invite, no sensitive data detected

BLOCK — bulk email to 12k contacts, unreviewed

ALLOW — customer record read, authorised agent

ESCALATE — code push to main, requires sign-off

Agent Governance Infrastructure

GATEKEPT

A drop-in SDK that intercepts every agent action before it fires. Allow, block, or escalate based on your policies. Every decision logged immutably for audit.

Try the live demo Read the docs

<200ms

Target verdict latency

Import to integrate

Actions: allow, block, escalate

Integration

Your agent, before Gatekept

from langchain.agents import agent

def process_payment(amount, recipient):
    # No policy check. No audit trail.
    # Nothing between intent and action.
    transfer_funds(amount, recipient)
    notify_customer(recipient)
    log_transaction(amount)

# When something goes wrong,
# you have no record of why.

With Gatekept — one import

from langchain.agents import agent
import gatekept as gk

def process_payment(amount, recipient):
    gk.gate("transfer_funds", {
        "amount": amount,
        "recipient": recipient
    })
    transfer_funds(amount, recipient)

# Every action evaluated against
# your live policy rules. Logged.
# Auditable. Under control.

ALLOW
transfer_funds
amount $4,200 — within $25k threshold
BLOCK
export_records
45,210 PII rows — exceeds 10k limit
ESCALATE → human
deploy_to_production
Outside approved deploy window

How it works

Wrap any action

Add one import. Wrap the action with gk.gate(). Works with LangChain, CrewAI, AutoGen, and raw API agents. No infrastructure changes.

Evaluate against policy

Every action is evaluated in milliseconds against your team's live policy rules. Spend limits, data thresholds, time windows, identity checks.

Verdict and audit log

Allow proceeds instantly. Block stops execution. Escalate routes to a human for one-tap approval. Every decision is written to the tamper-evident audit log.

Built for any agent

Finance

Your AI agent pays invoices automatically. One bad input and it could wire $50,000 to the wrong place.

Payments under $5k run instantly. Anything bigger pauses for approval. Unknown accounts are blocked.

Customer support

Your support AI can read and export customer data. One wrong move and it dumps your whole database.

Small lookups are allowed. Bulk exports over 10,000 records are blocked. Account deletions escalate to a human.

Developers

You built an AI coding agent to ship features while you sleep. You don't want it deploying to production unsupervised at 3am.

It writes code and opens pull requests freely. Production deploys pause for your approval. Touching secrets is blocked.

Procurement

Your AI agent renews subscriptions and buys tools on its own. Costs can spiral before anyone notices.

Purchases under a set limit go through. Anything above needs a manager's sign-off. Unapproved vendors are blocked.

Internal ops

Your AI assistant sends emails and updates records across the company. One mistake reaches every customer.

Routine updates run normally. Mass emails pause for review. Changes to sensitive fields are blocked.

The common thread

Different jobs, same problem: AI agents act fast, and some actions you can't undo.

Gatekept decides every action before it happens: allow, block, or escalate.

Policy rules

payment_amount > $25,000 → ESCALATE to CFO

pii_export_rows > 10,000 → BLOCK

deploy_env == "production" AND time NOT IN approved_window → ESCALATE to engineering_lead

bulk_email_count > 1,000 AND template NOT IN reviewed_list → BLOCK

customer_record_access AND agent_id NOT IN authorised_agents → BLOCK

ELSE

→ ALLOW and log verdict

Policies are defined in plain code. Your compliance officer writes the rules in language they understand. Your developer implements them in minutes.

Rules update live. No redeploy. A policy change takes effect on the next verdict.

Escalation tickets route to the right person based on the policy that fired. The approver sees the full action payload, the triggered rule, and the agent identity. One tap to approve or block.

Every verdict is reconstructible. Months or years later, you know exactly what happened, why, and who approved it.

Two buyers, one deal

Champion

THE DEVELOPER

Reads the docs. Integrates in minutes. Champions it internally because it gives them a safe path to ship agent features fast. No more back-and-forth with compliance. No more manual approval flows built in-house.

Open-source intercept layer

Economic buyer

THE COMPLIANCE OFFICER

Approves budget because Gatekept is the answer to the question their auditors are already asking: "What controls do you have over your AI agents?" Now they have a real answer with a real audit trail.

Audit-ready exports