@vaibot/mcp-server
OfficialClick on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@@vaibot/mcp-serverRun a risk decision before I deploy the latest release to production."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
@vaibot/mcp-server
VAIBot governance circuit-breaker as an MCP server.
Exposes 4 tools to any MCP-compatible AI agent (Claude Code, Codex, ChatGPT, OpenClaw):
Tool | Description |
| Pre-execution risk + policy decision. Call before any risky action. |
| Report actual outcome after execution. Closes the governance receipt. |
| List recent governance receipts with optional filters. |
| Approve or deny a pending action from the dashboard or agent. |
Quick start
VAIBOT_API_KEY=vb_live_xxx \
VAIBOT_API_BASE_URL=https://api.vaibot.io \
npx @vaibot/mcp-serverRelated MCP server: @vorionsys/mcp-server
Claude Desktop config
Add to ~/Library/Application Support/Claude/claude_desktop_config.json:
{
"mcpServers": {
"vaibot": {
"command": "npx",
"args": ["-y", "@vaibot/mcp-server"],
"env": {
"VAIBOT_API_KEY": "vb_live_xxx",
"VAIBOT_API_BASE_URL": "https://api.vaibot.io"
}
}
}
}Claude Code / Codex (stdio)
# .mcp.json in your project root
{
"mcpServers": {
"vaibot": {
"command": "npx",
"args": ["-y", "@vaibot/mcp-server"],
"env": {
"VAIBOT_API_KEY": "vb_live_xxx"
}
}
}
}OpenClaw gateway plugin (coming in Phase 6 final)
The vaibot-guard-bridge plugin will point guardBaseUrl at the MCP server endpoint instead of localhost:39111. Config change only — no plugin code changes needed.
Remote URL transport (HTTP)
If your agent supports MCP over HTTP (Remote URL mode), connect directly to the VAIBot API without installing anything:
URL: https://api.vaibot.io/v2/mcp
Token: Bearer <your-api-key>The HTTP endpoint speaks JSON-RPC 2.0 and supports all 4 tools. Auth is the same API key as the stdio transport.
Environment variables
Variable | Required | Default | Description |
| ✅ | — | VAIBot API key ( |
| — |
| API base URL |
Governance flow
Agent wants to run: curl -X POST https://deploy.example.com/release
1. Agent calls vaibot_decide:
→ VAIBot: APPROVAL_REQUIRED (high risk — outbound network call)
→ Returns: run_id, content_hash
2. Human reviews in dashboard, clicks Approve
3. Agent calls vaibot_approve (or dashboard fires callback):
→ VAIBot: ✅ APPROVED
4. Agent executes the action
5. Agent calls vaibot_finalize:
→ VAIBot: receipt updated, outcome=allowedAvailable Tools
4 toolsvaibot_approveA
Approve or deny a pending governance action. Use content_hash from vaibot_decide or vaibot_receipts. action="approve" allows the blocked action to proceed; action="deny" permanently blocks it.
| Name | Required | Description | Default |
|---|---|---|---|
| action | Yes | Whether to approve or deny the pending action | |
| content_hash | Yes | Content hash of the receipt to approve or deny (returned by vaibot_decide or vaibot_receipts) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden of behavioral disclosure. It reveals a critical irreversible consequence: 'deny permanently blocks the action.' This is exactly the kind of behavioral trait agents need to know. It could be more detailed about permissions or error handling, but the core behavior is well disclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the primary purpose, and every word earns its place. The second sentence elaborates on parameters and behavioral effects without unnecessary fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple 2-parameter tool with no output schema, the description covers purpose, parameter sourcing, and consequences. It could explicitly state prerequisites like governance admin permission or that the action must be pending, but these are largely implied. Overall, it is complete enough for an agent to invoke this tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already documents both parameters (100% coverage), but the description adds meaningful context: it explains what the action enum value does ('allows the blocked action to proceed' vs 'permanently blocks it'). It also reinforces the provenance of content_hash. This goes beyond the schema's basic descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: approve or deny a pending governance action. This specific verb+resource combination distinguishes it from sibling tools like vaibot_decide, vaibot_receipts, and vaibot_finalize, which handle other parts of the workflow.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides clear context on how to use the tool: source content_hash from vaibot_decide or vaibot_receipts, and explains the two possible actions. However, it doesn't explicitly discuss when not to use this tool or how it relates to vaibot_finalize, so it stops short of full guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
vaibot_decideA
Ask VAIBot whether an agent action should be allowed, requires approval, or is denied. Call this BEFORE executing any tool that could be risky (exec, file writes, network calls). Returns a run_id to use with vaibot_finalize after execution.
| Name | Required | Description | Default |
|---|---|---|---|
| cwd | No | Working directory for the action | |
| tool | Yes | Name of the tool the agent wants to execute | |
| params | No | Additional tool parameters | |
| target | No | Target URL or file path (for network/file operations) | |
| command | No | The exact command or action string (e.g. "rm -rf /tmp/export") | |
| agent_id | Yes | Agent identifier (e.g. "main", "claude-code", "gpt-4o") | |
| session_id | Yes | Current agent session or conversation ID | |
| workspace_dir | No | Root workspace boundary for path classification |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It discloses the ordering (before risky actions) and the run_id return. However, it does not state whether the call itself is side-effect-free, whether it blocks, or any authentication or rate-limit implications. It adds some context but remains incomplete.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with zero waste. The first sentence states purpose, the second explains when to call and what to expect (run_id). Front-loaded and efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the critical workflow (call before risky actions, use run_id with finalize) and explains the decision outcomes. However, with no output schema, it does not fully describe the response structure beyond run_id, leaving some ambiguity about how the decision is returned. Reasonably complete but with a notable gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all 8 parameters. The description mentions risky action types (exec, file writes, network calls) but does not add specific parameter-level details beyond what the schema provides. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Ask VAIBot whether an agent action should be allowed, requires approval, or is denied.' It also distinguishes itself from siblings by specifying a return value (run_id) for use with vaibot_finalize.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicit usage guidance is provided: 'Call this BEFORE executing any tool that could be risky (exec, file writes, network calls).' This indicates when to use it and implicitly when not to (for non-risky actions). References to vaibot_finalize clarify the post-execution flow.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
vaibot_finalizeA
Report the actual outcome of an action back to VAIBot after execution. Always call this after a vaibot_decide allow decision to close the governance receipt.
| Name | Required | Description | Default |
|---|---|---|---|
| error | No | Error message if execution failed | |
| run_id | Yes | The run_id returned from vaibot_decide | |
| outcome | Yes | What actually happened | |
| exit_code | No | Exit code if the command ran | |
| duration_ms | No | Execution duration in milliseconds |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the behavioral disclosure burden. It adds the context of closing the governance receipt, which is a meaningful side effect. But it omits details on idempotency, auth requirements, or error behavior, leaving some ambiguity.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with purpose and usage, with zero filler or repetition. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with clear schema coverage, the description is complete enough for an agent to understand when and why to call it. It notes the governance receipt closure and the tie-in to vaibot_decide. Minor gaps exist around edge cases (e.g., finalizing after non-allow outcomes), but overall it is sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema descriptions cover 100% of the 5 parameters, so the structured fields already provide meaning. The description reinforces that run_id comes from vaibot_decide but does not add substantial new semantics beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool reports the actual outcome of an action after execution, with a specific verb ('report') and resource ('outcome of an action'). It also mentions closing the governance receipt, which distinguishes it from siblings like vaibot_decide and vaibot_receipts.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly instructs to always call this after a vaibot_decide allow decision to close the governance receipt, providing clear temporal and contextual guidance. However, it does not discuss when not to use or mention alternatives, so it falls short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
vaibot_receiptsA
List recent governance receipts for the current agent. Use to review what actions were allowed, denied, or are pending approval.
| Name | Required | Description | Default |
|---|---|---|---|
| tool | No | Filter by tool name | |
| limit | No | Maximum number of receipts to return | |
| decision | No | Filter by policy decision | |
| risk_level | No | Filter by risk level | |
| approval_status | No | Filter by approval status |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It conveys that the tool is a read-only listing operation and shows the kinds of decisions it reports (allow, deny, pending). However, it does not disclose details like whether the list is ordered, what 'recent' means, or whether there are any rate limits or auth requirements. While the 'list' verb implies non-destructiveness, it is not explicitly stated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences, front-loading the main action ('List recent governance receipts') and then explaining the use case. It contains no redundant words or irrelevant details, making it highly efficient and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is straightforward: listing receipts with optional filters and no output schema. The description explains what the receipts contain (allowed/denied/pending actions) and the scope (current agent), which is sufficient for most use cases. It could be more complete by detailing the response structure, but given the simple nature of the tool and the well-documented filters, it is adequately complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 100% description coverage for all five parameters, each with clear descriptions and enums where applicable. The tool description does not add parameter-specific semantics beyond what the schema provides, but the schema itself is sufficient. The description's mention of 'recent' and 'governance' provides context that aligns with the parameters, but the heavy lifting is done by the schema, earning the baseline score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists governance receipts for the current agent, using a specific verb ('List') and resource ('governance receipts'). It also specifies the purpose (reviewing allowed, denied, or pending actions), which distinguishes it from the sibling tools that perform actions (vaibot_decide, vaibot_finalize, vaibot_approve) rather than read receipts.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says 'Use to review what actions were allowed, denied, or are pending approval,' providing clear context for when to use the tool. It does not explicitly mention when not to use it or name alternatives, but the sibling tool names and the read-only nature of receipts make the usage context clear and unambiguous.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
4 tool updates
v0.1.0- First observed
vaibot_approve - First observed
vaibot_decide - First observed
vaibot_finalize - First observed
vaibot_receipts
TDQS
Each tool has a distinct role in the governance workflow: decide pre-checks actions, finalize reports outcomes, receipts lists history, and approve handles pending decisions. There is no overlap or ambiguity between them.
All tools share the 'vaibot_' prefix and mostly use verb-based naming (decide, finalize, approve). 'receipts' is a noun rather than a verb, deviating slightly from the action-oriented pattern, but the prefix and clear purpose keep it readable.
Four tools provide a well-scoped governance surface: pre-check, post-report, list, and approve. This is neither too thin nor excessive for the stated purpose.
The workflow is fully covered: initiate with decide, execute, finalize with the run_id, review via receipts, and handle pending approvals with approve. There are no obvious missing operations for the governance domain.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Zero-secret MCP gateway for AI agents: risk-scored, audited calls with human-in-the-loop approval.
AI governance MCP server for EU AI Act compliance and jurisdiction verification
Human-in-the-loop review and approval for AI agents. Audit trail, approval policies, native MCP.
MCP enforcement layer that intercepts AI agent actions and blocks rule violations before execution.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceAn MCP server that enforces runtime governance on AI agent actions — file access, command execution, delegation chains, and permission escalation.MIT

@vorionsys/mcp-serverofficial
AlicenseAqualityBmaintenanceMCP server for AI-agent governance using trust scoring, behavioral signals, and pre-flight action checks.10241Apache 2.0- FlicenseNot gradedqualityCmaintenanceMCP server that enforces governance on agentic decisions with auditable evidence records, providing tools for understanding, calibrating confidence, and navigating handoffs based on policy.1-

Oakallow MCP Serverofficial
AlicenseNot gradedqualityCmaintenanceRuntime permission, approval, and audit governance for AI agent tool execution, enabling human oversight of risky actions via an MCP server.1MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/vaibot-io/mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server