Gatewerk

The open source review layer for AI agents.

One inbox where your agents' actions stop and wait for a person. Review the exact payload, edit it, decide. Every decision on the record.

Your AI agent drafts an email, generates a report, or initiates a transaction. Before it reaches the real world, a human reviews it in a structured form, edits what needs fixing, and sends the decision back. The agent learns from what humans changed.

Works with any agent framework. Self hosted. Open source (AGPL-3.0; client SDKs are Apache-2.0). See LICENSING.md.

Why Gatewerk?

Your agents act for you: they send the proposals, run the campaigns, handle the invoices, write the replies. Before an action leaves the building, a human should decide. Gatewerk is the review layer between your agents and the real world. Human judgment enters the pipeline, exactly where you choose.

• Structured review forms: not just "approve/deny", but rich templates with editable fields.
• Feedback memory: agents query past decisions to improve over time
• Self hosted: your server, your data, no SaaS dependency
• Protocol first: works with any agent framework via REST API, TypeScript/Python SDKs, or MCP

Use Cases

Before Sending

Email drafts, customer support replies, Slack messages, SMS campaigns, outreach to candidates, proposals to clients

Before Executing

Code deployments, database migrations, financial transactions, infrastructure changes, API calls to third-party services

Before Publishing

Blog posts, social media content, ad campaigns, product listings, documentation updates, press releases, reports

Before Approving

Expense reports, refund requests, access permissions, contract terms, insurance claims, purchase orders

Between the gates, agents can also bring you the judgment calls: classify the edge case, pick the path, resolve the exception. Gatewerk makes human judgment callable: agents ask a structured question, you answer typed, and the pipeline continues.

How It Works

sequenceDiagram
    participant Agent
    participant API as Gatewerk API
    participant Reviewer as Reviewer Dashboard
    participant Webhook as Agent via webhook

    Agent->>API: POST /reviews (template + payload)
    API->>Reviewer: Review appears in inbox
    Reviewer->>API: Approve / Reject / Edit
    API->>Webhook: Decision + edited payload
    Webhook->>Agent: Deliver decision
    Agent->>API: GET /feedback (learn from past decisions)

Works With Any Agent Framework

Gatewerk is protocol-first, not framework-specific. Your agent framework already has a way to make HTTP calls or use MCP: that's all you need.

A review, not a yes/no ping

Without a review layer, every agent grows its own approval hack: a Slack button here, a weekend dashboard there, a shared sheet nobody audits. You end up building the same thing over and over, once per workflow. Gatewerk is that layer built once, properly:

• Structured forms: Reviewers see rich templates with text, markdown, JSON, images, not a yes/no dialog
• Edit in place: Reviewers fix the agent's output directly, not just reject it
• Built for more than one human: chains route multi-step approvals, reviews are claimed and reassigned, and the record shows exactly who decided what
• Feedback loop: Agents query past decisions via API to improve over time
• Suggested vs Approved: Every field tracks what the agent proposed vs what the human approved, so agents learn exactly what changed
• Audit everything: HMAC-signed immutable log of every action, included free
• Your infrastructure: Self-hosted, open source (AGPL-3.0), no vendor lock-in

Quick Start

1. Start Gatewerk

Docker is the supported path. quickstart.sh writes a .env with freshly generated secrets, pulls the published images, applies migrations, seeds demo data, and waits until the API is healthy.

git clone https://github.com/gatewerk/gatewerk.git
cd gatewerk
./scripts/quickstart.sh

Dashboard: http://localhost:8880 API: http://localhost:3100

Requirements: Docker and openssl. Nothing else. The images are multi-arch, so amd64 and arm64 both pull prebuilt.

To compile the images from this checkout instead of pulling them, run ./scripts/quickstart.sh --build.

To run the API and dashboard from source with pnpm and hot reload, see Contributing.

2. Log in and create an API key

Open the dashboard and log in with the seed admin account:

• Email: admin@gatewerk.local
• Password: admin123

On first login the dashboard will prompt you to change the password: pick something secure.

The seed script (packages/db/src/seed.ts) also creates a default project, 6 starter templates (Proposal Review, Email Review, Code Deploy, Content Approval, Expense Report, Customer Reply), and a default API key. The raw key is printed once, by the seed container. Read it back with:

docker compose logs gatewerk-seed

Save that key if you want to skip the next step. It starts with gwk_.

To create a fresh API key from the dashboard, navigate to Settings → Project → API Keys, click New, scope it for your agent, and copy the value. The raw key is shown only once. Use it wherever you see YOUR_API_KEY below.

3. Create a Template

Templates define what gets reviewed. Create one via the dashboard or API:

curl -X POST http://localhost:3100/api/v1/templates \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "slug": "quickstart-email-review",
    "name": "Email Review",
    "instructions": "Check tone and accuracy before approving.",
    "fields": [
      { "name": "subject", "type": "text", "label": "Subject", "editable": true },
      { "name": "body", "type": "markdown", "label": "Body", "editable": true },
      { "name": "recipient", "type": "text", "label": "To", "readonly": true }
    ],
    "actions": ["approve", "reject", "request_changes"],
    "default_priority": "normal",
    "timeout_seconds": 86400,
    "timeout_action": "expire",
    "auto_approve": false
  }'

The three action types are approve, reject, and request_changes (non-terminal, requires reviewer feedback). Inline editing happens automatically on any field with "editable": true, there is no separate "edit" action. Actions can also be declared as { type, label, value } objects for custom button labels.

4. Send a Review Request

Both SDKs and the MCP server are published. Install them with npm install gatewerk, pip install gatewerk, or npx @gatewerk/mcp. No build from source required.

The two mechanisms for delivering decisions back to your agent are distinct:

• callback_url (per-review, used below): a one-shot HTTP destination attached to a single review. Fires the three event types documented in step 5.
• Project-level webhooks (in Settings → Webhooks): event subscriptions that fire across all reviews in a project. Use these when you have one agent/service receiving decisions for many reviews.

Pick one, or use both. The payload shape is identical.

TypeScript:

import { createClient } from "gatewerk";

const gw = createClient({
  apiKey: "gwk_...",
  url: "http://localhost:3100",
});

const { data, error } = await gw.reviews.create({
  template: "quickstart-email-review",
  payload: {
    subject: "Q1 Report",
    body: "Revenue grew 23% YoY...",
    recipient: "ceo@company.com",
  },
  callback_url: "https://example.com/webhook",
  priority: "high",
});

Python:

from gatewerk import create_client

gw = create_client(api_key="gwk_...", url="http://localhost:3100")

review = gw.reviews.create(
    template="quickstart-email-review",
    payload={
        "subject": "Q1 Report",
        "body": "Revenue grew 23% YoY...",
        "recipient": "ceo@company.com",
    },
    callback_url="https://example.com/webhook",
    priority="high",
)

MCP (for Claude, Cursor, Windsurf, etc.):

{
  "mcpServers": {
    "gatewerk": {
      "command": "npx",
      "args": ["@gatewerk/mcp"],
      "env": {
        "GATEWERK_URL": "http://localhost:3100",
        "GATEWERK_API_KEY": "gwk_..."
      }
    }
  }
}

5. Receive the Decision

When a reviewer acts on a review, Gatewerk POSTs one of three event types to your callback_url:

• review.decided: reviewer approved or rejected (terminal; may include edits)
• review.retried: reviewer requested changes and sent feedback (non-terminal; your agent regenerates and submits a new version)
• review.expired: timeout reached with no decision (terminal)

Example review.decided payload:

{
  "type": "review.decided",
  "review_id": "gw_rev_abc123",
  "decision": "edited",
  "decided_at": "2026-03-11T10:30:00Z",
  "was_edited": true,
  "suggested_value": { "subject": "Q1 Report", "body": "Revenue grew 23% YoY..." },
  "approved_value": { "subject": "Q1 2026 Report", "body": "Revenue: $4.2M (+23% YoY)..." },
  "reviewer": "alice@company.com",
  "feedback": "Improved title and added specific numbers",
  "action_value": "approve",
  "action_label": "Approve",
  "auto_approved": false
}