Home | Blog | Vaikora Guard MCP Is Open Source: Here Is What That Means for AI Agent Policy Enforcement

Vaikora Guard MCP Is Open Source: Here Is What That Means for AI Agent Policy Enforcement

Publishing a policy enforcement library as open-source MIT code changes what security teams can verify, audit, and modify. Vaikora Guard MCP is on PyPI as `vaikora-guard-mcp`, written in Python, and the source is available for inspection without a sales call or vendor agreement.

This post explains what the library does, what "open source" means operationally in this context, and what a team deploying AI agents in production should actually check.

What Problem This Solves

AI agents built on the Model Context Protocol call external tools, APIs, and data sources. Each call is a potential policy violation: exfiltrating sensitive data, hitting a restricted endpoint, writing to a production record, or escalating privilege beyond what the agent should have. The question is not whether agents will attempt these actions. It is whether a control is in place before the action executes.

Without an inline enforcement layer, the only options are post-hoc logging or hoping the model respects a system prompt. Neither is policy enforcement.

What the Library Actually Does

Vaikora Guard MCP sits between an AI agent and the tools it calls. Before each tool call executes, the library applies a deterministic policy check and returns one of four decisions: allow, block, modify, or require-approval. The same input always produces the same output. There is no probabilistic judgment, no second LLM deciding whether something is risky.

A concrete example: an agent is given access to a file-write tool and a customer database. A policy rule specifies that any tool call writing to a path under `/var/data/customers/` requires human approval if the agent session is not tagged `admin-approved`. The agent sends the tool call. Vaikora Guard MCP intercepts it, matches the path pattern, checks the session tag, and blocks with a require-approval response before the write touches the filesystem. The agent receives a structured error. The decision is logged.

Every decision the library writes goes into a SHA-256 hash-chained audit log. Each entry references the previous entry’s hash, so tampering with one record breaks the chain. This gives you an ordered, tamper-evident record of every enforcement decision, which matters when you are defending a compliance audit or an incident investigation.

What "Open Source" Changes Operationally

Three things change when enforcement code is open-source:

  • Auditability of the control itself. You can read exactly how the policy engine evaluates a rule. You are not trusting a vendor’s claim about determinism.
  • Self-hosting without a dependency on vendor infrastructure. The proxy runs in your environment. The enforcement logic does not phone home for a decision.
  • Forkability. If a team needs a custom rule type or a different audit format, they can modify the library and maintain their own build without waiting for a vendor roadmap.

The commercial product, the Vaikora Control Plane, is hosted by Data443 and adds the management layer: policy authoring, centralized audit review, SIEM integrations, and compliance presets for HIPAA, PCI-DSS, GDPR, SOC 2, and ISO 27001. The open-source library is the enforcement runtime. The separation is deliberate.

Deployment and Performance

The library is an MCP-compatible proxy. It supports 12 LLM providers with no SDK migration. You point your existing agent at the proxy endpoint instead of directly at the model API. No rewriting of agent logic.

Enforcement latency is P50 8ms and P99 45ms, measured at the proxy layer. At scale, the gateway handles 10,000 or more actions per second. For most production agent workloads, this does not register as a performance concern.

The library ships six content inspection modules covering prompt injection detection, data pattern matching, and tool call validation. These run at the enforcement layer, not at the model layer, so they apply regardless of which LLM the agent is using.

What to Check Before You Deploy

If you are evaluating Vaikora Guard MCP for a production agent deployment, the specific things worth verifying:

  • Review the policy rule schema in the source before writing production rules. The rule structure is what determines whether your intent maps correctly to enforcement behavior.
  • Test the hash chain on your audit log by modifying a record manually and verifying that the chain validation fails. If you are relying on this for compliance auditability, confirm the mechanism works in your environment before you need it.
  • Check the require-approval workflow. If your agent needs a human in the loop for certain actions, trace the full path from the blocked call to the approval notification to the resumption of execution. Gaps in this path are where agents stall in production.
  • If you are integrating with the Vaikora Control Plane and pushing decisions into Microsoft Sentinel, SentinelOne, or CrowdStrike Falcon, confirm the severity mapping matches your SOC’s triage thresholds before go-live.

The PyPI package is `vaikora-guard-mcp`. Start with the source, map your policy requirements to the rule schema, and run enforcement in a staging environment against real agent traffic before promoting to production.