Vaikora › Blog › Product Updates

How to put a pre-execution policy check in front of every MCP tool call, using an open-source proxy

Product Updates · Nov 9, 2026 · 4 min read

Ten seconds is all it takes for an AI agent to call a tool, write a record, or send a request to an external service. The policy question is not what happened after, it is what was checked before.

That is the problem vaikora-guard-mcp solves. It sits inline between an AI agent and any MCP-compatible tool server, and it evaluates every tool call against a deterministic policy before the call reaches the tool. Allow, block, modify, or route to a human for approval. The decision happens before execution, not after.

What "inline" actually means here

A standard MCP setup has the agent call the tool server directly. With vaikora-guard-mcp inserted, the call goes to the proxy first. The proxy inspects the tool name, the arguments, and any context the agent passes, runs the payload through up to six content inspection modules, then applies your policy rules in order.

If the call matches a block rule, the tool never receives it. The agent gets a structured rejection. If the call matches a modify rule, the proxy rewrites the arguments before forwarding. If it matches a require-approval rule, the call is held and a human reviewer sees it before anything runs.

The same input always produces the same decision. There is no probabilistic scoring that lets a slightly different phrasing slip through.

Installing it

The proxy is written in Python and published on PyPI as `vaikora-guard-mcp`. Install it with:

```
pip install vaikora-guard-mcp
```

It is MIT licensed and self-hosted. You run it in your own environment, your tool calls never leave your infrastructure to reach a third-party policy engine.

Configuration is a YAML policy file. A minimal rule that blocks any tool call containing a production database connection string looks like this:

```yaml
rules:
- name: block-prod-db
match:
content_pattern: "prod[-_]db|PROD_DB"
action: block
reason: "Production database identifiers are not permitted in agent tool calls"
```

Add a require-approval rule for any tool that writes to external systems, and your agent cannot exfiltrate data or trigger side effects without a human in the path.

What the audit log gives you

Every decision, allow or block or modify or hold, is written to a SHA-256 hash-chained, tamper-evident audit log. Each entry records the tool name, the arguments (redacted if your policy says so), the rule that matched, the decision, and a timestamp. The chain means you can verify that no entry was deleted or altered after the fact.

That record is what an auditor or incident responder needs. If an agent was involved in a security event, you have an ordered, verifiable sequence of every tool call it attempted and what the policy did with each one. No reconstructing from application logs.

Compliance presets

If you need to demonstrate compliance with HIPAA, PCI-DSS, GDPR, SOC 2, or ISO 27001, Vaikora ships presets that map the relevant controls to concrete policy rules. You apply the preset, and the proxy starts enforcing the matching restrictions on tool calls immediately. You still review and tune the rules for your environment, but the baseline is defined by the standard, not assembled from scratch.

Where the proxy fits in a larger setup

vaikora-guard-mcp is the open-source enforcement layer. The Vaikora Control Plane, the commercial product hosted by Data443, adds centralized policy management across multiple agents and environments, real-time dashboards, approval workflows with audit trails, and integrations with Microsoft Sentinel, CrowdStrike Falcon, SentinelOne, and AWS Security Hub.

If you are running one agent in one environment, the open-source proxy gives you full enforcement with no commercial dependency. If you are running agents across teams or business units, the control plane is where you manage policy centrally and push changes without touching each deployment.

What to check next

Start with the highest-risk tool calls in your current agent setup. File writes, outbound HTTP calls, database mutations, and anything that touches credentials or PII are the right place to begin.

Install vaikora-guard-mcp, write a policy file that blocks or requires approval for those specific tool types, and check the audit log after a day of agent activity. The log will tell you which calls were attempted, which rules fired, and whether any calls were blocked that you did not expect. That is your first real picture of what your agents are actually doing at runtime.

The package is at vaikora-guard-mcp on PyPI and the source is MIT licensed.

More from the Vaikora blog