Governance + Provenance for AI agents

The circuit breaker
every agent needs

VAIBot intercepts every agent tool call, classifies the risk, and enforces your policy — all before a single command executes. Every decision leaves an immutable receipt.

Get started free See it live

Works with Claude CodeMCP server readyOn-chain anchoringFree tier, no card required

claude_code — vaibot-mcp

$ # Agent attempts to delete outside workspace

vaibot → exec "rm -rf /tmp/customer-export"

Policy decision

DENIED — path outside approved workspace boundary

receipt_id: grcpt_delete_outside · risk: critical

Receipt anchored · Audit trail updated · Agent blocked

Two products. One platform.

Govern the action.
Prove the output.

VAIBot V2 governs what agents do. VAIBot V1 proves what agents created. Together they give you complete verifiable AI.

V2 — Governance

Agent Circuit Breaker

Every agent action passes through VAIBot before it executes. High-risk actions get held for human review. Destructive actions are blocked outright. Every decision is receipted.

Risk classification on every action
Human-in-the-loop approval flows
Policy enforcement before execution
Durable governance receipts

See live demo Quickstart

V1 — Provenance

Content Provenance

Anchor AI-generated content to the blockchain. Anyone can independently verify that a document, image, or decision came from your agent — unmodified — at a specific point in time.

SHA-256 content fingerprints
On-chain anchoring via Base mainnet
Tamper-evident Merkle proofs
Public verification endpoint

Explore Provenance API

V2 + V1 integration: The Audit plan automatically anchors every governance receipt on-chain via the Provenance API — creating a tamper-evident chain of custody for every agent decision.

Interactive demo

See governance in action

Three real-world scenarios. Click a scenario to see how VAIBot classifies the risk, makes a policy decision, and issues a governance receipt.

VAIBot V2 — Live demo

The AI agent circuit breaker

An agent proposes an action. VAIBot classifies the risk, enforces your policy, and issues a governance receipt — all before a single command executes.

Review risky actions before they run

See exactly why the policy intervened

Keep a durable audit trail for every decision

Proposed action

Approval required — Unknown deploy target

VAIBot pauses high-risk outbound actions until a human approves.

Agent

Clawd M.

Tool

exec

Command

curl -X POST https://deploy-preview.example.com/release

Policy decision

High riskApproval required

Destination is outside the configured allowlist — execution paused pending review.

What happens next

⏳ Awaiting your approval — click Approve to unblock this agent action.

Governance receipt

Deploy webhook to unapproved destination

Approval requiredHigh risk

Decision timeline

Proposed

Agent action

Classified

High risk

Decision

Approval required

Outcome

Awaiting approval

Why

Destination is outside the configured allowlist — execution paused pending review.

Next step

⏳ Awaiting your approval — click Approve to unblock this agent action.

Human review required

Approve to let the agent proceed, or deny to block this action.

This is a live demo — no real action will execute.

Works everywhere you build

One governance layer. Every agent tool.

Two integration paths: the remote MCP server (URL config, zero install) or a circuit-breaker plugin (process-level enforcement, deepest coverage).

Via MCP server

Claude CodeMCP

Add VAIBot governance to Claude Code in one config line. Every tool call — Bash, Read, Write, Edit — passes through your policy before it executes.

config

// .claude/claude.json
{
  "mcpServers": {
    "vaibot": {
      "type": "url",
      "url": "https://api.vaibot.io/v2/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_API_KEY>"
      }
    }
  }
}

Quickstart guide

CursorMCP

Works with Cursor's MCP support out of the box. Same remote server, same API key — zero additional configuration.

config

# Cursor Settings → MCP → Add server
Name:   vaibot
Type:   url
URL:    https://api.vaibot.io/v2/mcp
Header: Authorization: Bearer <YOUR_API_KEY>

View integration

REST APIDirect

Integrate governance into any agent framework — LangChain, AutoGen, CrewAI, or your own. POST before each tool call, receive a policy decision instantly.

config

POST https://api.vaibot.io/v2/decide
Authorization: Bearer <YOUR_API_KEY>

{
  "agent": { "id": "my-agent", "name": "My Agent" },
  "action": {
    "tool": "exec",
    "command": "rm -rf /tmp/data",
    "cwd": "/workspace"
  }
}

API reference

15 governance tools via JSON-RPC 2.0

vaibot_decide · vaibot_finalize · vaibot_approve · vaibot_deny · vaibot_receipts · vaibot_verify · and 9 more

See all tools

Circuit-breaker plugins

OpenClaw

Plugin

Native VAIBot governance plugin for the OpenClaw agent gateway. Ask OpenClaw to install it — zero additional config beyond your API key.

install

# Ask OpenClaw to install
"Hey OpenClaw, download the VAIBot circuit breaker plugin"

# Or install directly
npm install @vaibot/circuit-breaker-openclaw-plugin

@vaibot/circuit-breaker-openclaw-pluginnpm

Claude Code

Plugin

The circuit-breaker plugin for Claude Code hooks every tool call at the process level — before Claude Code executes it. Deeper integration than MCP alone.

install

# Install the Claude Code circuit-breaker plugin
npm install @vaibot/circuit-breaker-claude-code

# Add to your Claude Code hooks config
{
  "hooks": {
    "PreToolUse": [{
      "matcher": ".*",
      "hooks": [{ "type": "command",
        "command": "npx vaibot-cc-guard" }]
    }]
  }
}

@vaibot/circuit-breaker-claude-codenpm

Codex

Coming soon

VAIBot governance plugin for OpenAI Codex agents. Policy enforcement at the tool-execution layer — same receipts, same audit trail, same API.

install

# Coming soon
npm install @vaibot/circuit-breaker-codex

# Plug into your Codex agent config
import { VaibotGuard } from '@vaibot/circuit-breaker-codex'
agent.use(new VaibotGuard({ apiKey: process.env.VAIBOT_API_KEY }))

@vaibot/circuit-breaker-codexcoming soon

How it works

From proposal to immutable proof

Five steps that happen in milliseconds — turning every agent action into a governed, auditable event.

Agent proposes an action

Your AI agent — Claude Code, a LangChain agent, AutoGen crew, or custom bot — calls the VAIBot MCP tool or REST API before executing any tool.

Works with any agent framework that can make HTTP calls or use MCP tools.

VAIBot classifies the risk

The action is evaluated against your policy configuration. Risk levels: low, medium, high, or critical — based on the tool type, target path, destination, and scope.

Configurable per-project with custom allow/block lists and workspace boundaries.

Policy makes a decision

Low-risk actions are immediately approved. High-risk actions are held for human review. Destructive or out-of-scope actions are hard-denied and never executed.

Three outcomes: allow · approval_required · deny

Governance receipt issued

Every decision — allow, block, or approval — produces a structured governance receipt with full context: agent ID, action, policy reason, timestamp, and outcome.

Receipts are searchable, exportable to CSV/Sheets, and Slack-notifiable.

On-chain anchoring (Audit plan)

Audit-plan receipts are batched and anchored to Base mainnet via the Provenance API. The resulting Merkle root is tamper-proof and publicly verifiable — forever.

Creates a complete, immutable chain of custody for every agent action.

Pricing

Start free. Scale when you need to.

1,000 governed decisions free every month. No credit card required.

MonthlyAnnualSave 20%

Free

Try governed agent execution with no commitment.

Get started free

1,000 governed decisions / month
30-day receipt history
Dashboard + API access
Email alerts — high-risk + approval
MCP server (Claude Code, Cursor)
CSV export
Google Sheets + Airtable
Slack integration
Provenance proofs
Governance receipt anchoring
Compliance export bundle

Govern

Full control over your agents. Export the evidence.

$49/mo

Upgrade to Govern

25,000 governed decisions / month
1-year receipt history
Dashboard + API access
Email alerts — high-risk + approval
MCP server (Claude Code, Cursor)
CSV export
Google Sheets + Airtable
Slack integration
500 provenance proofs / month(Merkle, off-chain)
Governance receipt anchoring
Compliance export bundle

Audit-ready

Audit

Compliance-ready governance. Immutable audit trail.

$199/mo

Upgrade to Audit

200,000 governed decisions / month
1-year receipt history + export
Dashboard + API access
Email alerts — high-risk + approval
MCP server (Claude Code, Cursor)
CSV export
Google Sheets + Airtable
Slack integration
5,000 provenance proofs / month(Merkle, off-chain)
Governance receipt anchoring(V2 decisions → V1 bridge → Base mainnet)
Compliance export bundle

Need custom limits, SLA guarantees, or NET30 billing? Contact us

x402 — Agent-to-Agent Payments

Let your agents pay for themselves

The x402 protocol turns every governance decision into a microtransaction. No subscriptions, no invoices, no monthly reconciliation — agents pay per decision using their own on-chain wallet. Fully autonomous.

Agent proposes action

Your agent calls vaibot_decide

Decision issued instantly

allow · approval_required · deny

x402 payment settled

$0.001 / decision, on-chain

Receipt anchored

Immutable proof, no invoice

Bootstrap accounts

Pre-provisioned wallets

Every VAIBot account includes a pre-generated x402 wallet address. No crypto setup, no MetaMask, no gas fee management — the wallet is ready the moment you claim your account.

Claim your bootstrap account

Fund your wallet

Send USDC on Base to your wallet address. Minimum deposit: $1. No gas surprises.

Set billing mode to x402

Switch from subscription to pay-as-you-go in Settings → Billing.

Your agent pays autonomously

Each vaibot_decide call deducts $0.001. Receipts and payments are both on-chain.

Claim your account

Subscription

·Fixed monthly cost
·Quota limits
·Manual setup
·Human billing cycle

x402 Pay-as-you-go

✓$0.001 / governed decision
✓No quota ceiling
✓Agent auto-pays
✓Settles on-chain instantly

Agent-to-agent payment flows

Orchestrator agents can spin up sub-agents that each have their own x402 wallet. The orchestrator funds sub-agents automatically — no human touches money at any point. Perfect for multi-agent pipelines that need autonomous billing at scale.

x402 pricing

Governed decision$0.001

Provenance proof$0.005

On-chain anchor$0.01 + gas

Minimum deposit$1.00 USDC

Priced in USDC on Base mainnet. No platform fee on top of usage.

For developers

Integrate in minutes, not days

One POST endpoint. One policy decision. One governance receipt. Wrap it around your agent's tool loop and you're governed.

Request

POST /v2/decide
Authorization: Bearer <token>

{
  "agent": { "id": "main", "name": "Clawd M." },
  "action": {
    "tool": "exec",
    "command": "curl -X POST https://deploy.example.com/release",
    "cwd": "/workspace/app"
  }
}

Response · 200 OK

{
  "schema": "vaibot/governance-receipt@1",
  "receipt_id": "grcpt_xyz123",
  "policy": {
    "risk_level": "high",
    "decision": "approval_required",
    "reason": "Outbound deploy target outside allowlist"
  },
  "approval": { "status": "pending" },
  "result": {
    "outcome": "blocked_until_approved",
    "summary": "Awaiting human approval"
  }
}

MCP Quickstart

Configure Claude Code in 2 minutes

API Reference

Full OpenAPI docs for V2 endpoints

Receipt Schema

Governance receipt v1 JSON schema

Need NET30 billing for your team?

Bootstrap accounts get automatic NET30 approval once you verify your email — no credit card, no friction. Pay monthly.

Claim account