Home | Blog | Open-Sourcing the Vaikora Agent Policy Layer: Architecture, Enforcement, and What to Do With It

Open-Sourcing the Vaikora Agent Policy Layer: Architecture, Enforcement, and What to Do With It

Eight milliseconds is fast enough to run a policy check on every AI agent tool call without the agent noticing. That is the median enforcement latency for Vaikora Guard MCP, the MIT-licensed, self-hosted proxy Data443 published for teams who need policy decisions before execution rather than log review after.

This article explains what the package does technically, how it fits into an MCP deployment, and what you actually gain by running it in-line.

The Core Problem It Solves

AI agents calling tools through the Model Context Protocol (MCP) execute those calls immediately when the LLM decides to. There is no built-in hook for policy, no native approval gate, and no audit record of what was called with what arguments. The agent might read a file, write to a database, call an external API, or chain several of those in sequence.

Without a policy layer sitting inline, your only options are post-hoc log inspection (if you have logs at all) or restricting what tools the agent can see in the first place. Neither gives you deterministic, per-call enforcement with an auditable record.

How the Proxy Works

Vaikora Guard MCP runs as a proxy between the agent and the MCP server. Every tool call passes through it before reaching the target.

For each call, the proxy:

  • Receives the tool name and arguments from the agent
  • Evaluates them against the configured policy
  • Returns one of four decisions: allow, block, modify, or require-approval
  • Writes the decision to a SHA-256 hash-chained audit log entry

The same input always produces the same decision. That determinism matters for compliance teams who need to show that a given class of action was consistently blocked or allowed, not just that some were caught.

A concrete example: an agent is configured to call a `write_file` tool. The policy blocks writes to paths under `/etc/` and paths matching `/home//.` (dotfiles). The agent sends a call with `path=/home/user/.bashrc`. The proxy blocks it, records the decision with the full argument set and a timestamp, and returns a structured error to the agent. The LLM sees the rejection and can respond accordingly. The file is never touched.

What "MIT-Licensed and Self-Hosted" Means Operationally

The package, `vaikora-guard-mcp`, is published on PyPI and written in Python. MIT license means no restriction on internal deployment, modification, or integration with your own tooling. You are not calling out to a hosted service for policy decisions; the enforcement runs in your own environment.

This matters for air-gapped or regulated deployments where data about agent actions cannot leave the network boundary. The audit log stays on your infrastructure.

The gateway ships six content inspection modules and adapters for major hosted model APIs. It supports MCP natively, so there is no SDK migration required against existing MCP servers.

What You Lose Without the Enterprise Control Plane

The open-source proxy enforces policy locally. What it does not provide is centralized policy management across many agents, a UI for reviewing approval queues, real-time alerting, or integration with security tooling like Microsoft Sentinel, CrowdStrike Falcon, or SentinelOne.

That is what the Vaikora Control Plane adds. It is the commercial product, hosted by Data443, and it connects to the same enforcement layer the open-source proxy uses. Teams running more than a handful of agents, or operating in environments with formal compliance requirements (the platform ships presets for HIPAA, PCI-DSS, GDPR, SOC 2, and ISO 27001) will generally reach for the control plane.

For teams standing up an initial deployment, or evaluating whether inline policy enforcement fits their architecture, the open-source package is the right starting point. You get real enforcement, real audit output, and no dependency on an external service.

Throughput and Latency in Practice

At P50, enforcement adds 8ms. At P99 it adds 45ms. The gateway handles over 10,000 actions per second. For most agent workflows these numbers are not relevant constraints. For high-frequency tool-calling agents, they are worth knowing before you deploy.

The 99.9% detection accuracy figure comes from testing. That is not the same as 100%, so policy design still matters. Write specific, testable rules. Test them against representative agent traffic before promoting to production.

What to Check Next

If you want to evaluate the proxy before committing to anything:

  • Install `vaikora-guard-mcp` from PyPI and point it at an existing MCP server
  • Write a minimal policy that blocks a specific tool call you would not want to execute in production
  • Trigger that call from an agent and confirm the block appears in the audit log
  • Inspect the hash chain to verify log integrity

That sequence takes under an hour and gives you a working enforcement layer with a verifiable audit record. Once you have that running, the next decision is whether centralized policy management and security tooling integration are requirements for your environment.