Every MCP-compatible AI agent can call tools: read a file, POST to an API, delete a record. By default, nothing checks whether that call is allowed before it runs. The agent decides, the tool executes, and your logs record what already happened.
Vaikora Guard MCP is an open-source proxy that sits between the agent and its tools and enforces a policy decision before each tool call executes. It is published on PyPI as `vaikora-guard-mcp`, MIT-licensed, written in Python, and self-hosted. This post explains what it actually does at the code level and how to wire it into an existing agent.
What the Proxy Does at Runtime
When an agent issues a tool call, the request hits the Vaikora Guard MCP proxy instead of the tool directly. The proxy evaluates the call against a deterministic policy: the same input always produces the same decision. The outcome is one of four verdicts: allow, block, modify, or require-approval.
- Allow: the call passes through unchanged.
- Block: the proxy returns an error to the agent; the tool never sees the request.
- Modify: the proxy rewrites the request (for example, stripping a parameter that would leak PII) and forwards the sanitized version.
- Require-approval: the call is held and routed to a human reviewer before it proceeds.
Every decision is written into a SHA-256 hash-chained audit log. Each entry references the previous entry’s hash, so any tampering breaks the chain. This is not application logging. It is a tamper-evident record ordered by decision sequence.
Installing and Running It
Install from PyPI:
“`
pip install vaikora-guard-mcp
“`
The proxy exposes an MCP-compatible interface. Point your agent’s MCP client at the proxy endpoint instead of the tool endpoint directly. The proxy handles the forwarding; your agent code does not change.
A minimal configuration block specifies which tools are covered and what policy applies to each. For example, you can allow read operations on a file tool unconditionally, block any write operation outside a defined directory prefix, and require approval for any call that touches an endpoint matching a pattern like `/admin/*`.
Policies are expressed as structured rules rather than natural-language prompts, which is what makes the enforcement deterministic. There is no model interpreting your intent at decision time.
A Concrete Scenario
Suppose an agent has access to a database query tool and a file-write tool. Without a policy layer, nothing prevents the agent from writing query results to an arbitrary path, including paths that contain credentials or configuration the agent should never touch.
With Vaikora Guard MCP in front of the file-write tool, you define an allow rule: writes are permitted only to `/tmp/agent-output/`. Any write call targeting a different path is blocked before the tool executes. The agent receives an error. The blocked call and its full context are written to the audit log with a timestamp and the specific rule that triggered.
If you later need to investigate why an agent wrote a file (or tried to), the audit chain gives you a verifiable sequence of decisions, not just application logs that could be modified after the fact.
Connecting to the Enterprise Control Plane
The open-source proxy is self-contained. For teams that need centralized policy management across multiple agents, real-time visibility into decision telemetry, or native integration with security tooling, the Vaikora Control Plane is the hosted commercial layer on top of the same enforcement engine.
Data443 ships packaged integrations with Microsoft Sentinel, Microsoft Defender, SentinelOne, CrowdStrike Falcon, and AWS Security Hub. When an AI agent threat is detected at the proxy layer, that signal can flow into your existing security operations tooling without custom engineering. For SentinelOne specifically, Vaikora pushes threats as Threat Intelligence indicators with numeric severity values: Critical at 100, High at 75, Medium at 50, Low at 25.
The proxy also ships compliance presets for HIPAA, PCI-DSS, GDPR, SOC 2, and ISO 27001. These are pre-built policy configurations, not marketing labels. They define which tool call patterns are blocked or flagged to satisfy the relevant control requirements.
What to Check Before Deploying
Before you wire the proxy into production:
- Confirm your agent framework supports MCP. The proxy is MCP-compatible by design.
- Map which tools your agent currently calls and what data each call touches. Policy rules are only as complete as your tool inventory.
- Decide which actions need human approval versus which can be blocked automatically. Require-approval adds latency; block is instant.
- Review the audit log format and confirm it feeds into wherever your team does incident review. The hash-chained structure is most useful when something queries it after an incident, not just during.
The source is on PyPI at `vaikora-guard-mcp`. Review the policy rule schema before writing your first configuration. The rule structure determines what the proxy can and cannot enforce, and understanding its limits before you deploy prevents gaps you discover after an agent does something unexpected.