---
title: "Verosek: AI + MCP Gateway for AI Agent Security"
description: "Verosek is an AI + MCP Gateway for AI agent security. It routes model calls and, for the tools it runs, reads what each call does, down to the SQL statement, then decides it against the agent key's rules before it runs. Scanning and a sealed record of each request ship in the same product."
url: https://verosek.com
---

ROUTE. DECIDE. SCAN. AUDIT.

One layer between your AI agents and the models and tools they call. Every tool call decided before it runs, with a tamper-evident record of every step.

[ AI + MCP Gateway ]

# Govern what your AI assets do, before they do it.

One gateway for model calls and tool calls. The rules, the scanning and the record are built in, so security is not a second vendor.

[Book a call](https://cal.com/verosek-solutions-u9ztip/30min)

Shield

With Shield on, each request, response and tool output is scanned for prompt injection, PII and off-topic drift, and handled under that key's settings.

[Explore Shield](https://verosek.com/shield)

AI Gateway

One endpoint for your providers. Route LLM calls with per-key access control, rate limits, and instant failover.

[Explore AI Gateway](https://verosek.com/ai-gateway)

Audit Vault

Every interaction signed and hash-chained into tamper-evident receipts. On a self-hosted deployment, an auditor you give the verification key can verify them offline.

[Explore Audit Vault](https://verosek.com/audit-vault)

MCP Tools

Grant, scope, and revoke MCP tool access per key — with a full execution log behind every call.

[Explore MCP Tools](https://verosek.com/mcp-tools)

Where it sits

## One gateway between your agents, models and tools.

Routing, tool rules, scanning and the record ship together. One place routes each model call and decides each tool call.

Your AI agents, your apps and MCP clients call through Verosek, an AI + MCP Gateway: an SDK or client changes only its base URL and its key. On Enterprise it runs air-gapped or in your VPC. Verosek sends model calls to your models (OpenAI, Claude, Gemini, Azure, Mistral, Ollama, any OpenAI-compatible server, or your own proxy behind Verosek) and tool calls to your tools (100 connectors, credentials sealed, among them PostgreSQL, Slack, Jira, GitHub, Snowflake, Stripe). Read the orders table reaches your tool; drop the orders table is blocked at Verosek. Inside Verosek: AI Gateway: Your SDK to your providers. Routing, fallback, caching and residency per key. Identity: Give each agent its own key. Budget, rate limits, expiry and scope on each. Rules: Decided before the call runs. By rules, not a model. MCP Tools: 100 connectors, credentials sealed. A call not offered never runs. Shield: Scans what goes in and out. In prompts, replies and tools. Audit Vault: One sealed record per request. No record, no run, by default. Agents: Agents as governed tools. Versioned, on their own keys and run limits. Red Teaming: Attacks your agents and MCP servers. Findings you can recompute yourself. Rules allow, modify, hold or block; SELECT id FROM orders is allowed and DROP TABLE orders is blocked. Shield scans for PII, secrets, injection, toxicity and grounding. The record carries approvals, and EU AI Act and NIST reports. Agents speak A2A. Red Teaming runs from attack to finding to rule.

## What routing alone leaves unguarded

Routing gets a call to a model. These five decide what happens next.

[ Gap 01 ]

### Pre-execution policy verdicts

Every request gets a verdict before anything runs. ALLOW, BLOCK, MODIFY, or held for a named person — decided deterministically, not by a model. Nothing executes until the policy says so.

[ Gap 02 ]

### Hallucination grounding via a local judge

On an Enterprise deployment in your environment, a judge model runs entirely inside your infrastructure. With Shield on, figures in a reply are checked against the reference you pass, and a judge model can flag the rest for review.

[ Gap 03 ]

### Two allowed calls, one leak

One call reads a customer record, the next sends it out. Each passes its own rule. Verosek follows where each value came from, so personal data heading somewhere it is not allowed is flagged or refused.

[ Gap 04 ]

### Reads what each call does

Not just which tool. For a tool Verosek runs, a rule reads a SQL statement's operation and tables, a payment's amount, a file path, a message's recipient. Each key carries its own rules, tool by tool.

[ Gap 05 ]

### One sealed record for each request

What was asked, what the model proposed, what each scan found, what each rule decided and why, and what ran. Change a word without the key and the check fails for the whole record.

Verosek reads a SQL statement, DELETE FROM orders: the operation is DELETE and the table is orders. The key's rule is read only, so the call is refused.

How it works

## Four components. One product. No integration gap.

Routing, tool rules, scanning and the record ship together on one key. A security check is not a second vendor to buy, review, pay and log in to, and what it found lands in the same sealed record as the call.

[ Layer #01 ]

```
import openai

client = openai.OpenAI(
    api_key="vsk_prod_04",        # Verosek virtual key
    base_url="https://gateway.your-domain/v1",  # ← your Verosek gateway
)

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Summarise Q3 results"}],
)
# Policy enforced. Every step audited.
print(response.choices[0].message.content)
```

### AI Gateway

Route your SDK to your providers. Twelve OpenAI endpoints plus native Anthropic and Gemini. Change two values: base_url and key. Cross-SDK translation runs on the fly. Weighted fallback, priority routing, 3-fail cooldown. Under 30ms P99 overhead.

15 endpoints · 3 SDKs · <30ms P99

[ Layer #02 ]

| # | CHECK | VERDICT | LATENCY |
| --- | --- | --- | --- |
| 01 | Prompt injection | BLOCK | 4ms |
| 02 | Jailbreak attempt | PASS | 4ms |
| 03 | PII in input | MODIFY | 6ms |
| 04 | Secrets in input | PASS | 3ms |
| 05 | Toxicity in response | PASS | 5ms |
| 06 | PII in response | PASS | 4ms |
| 07 | Indirect injection | PASS | 8ms |
| 08 | Session drift | WARN | 2ms |

8 checks run:

1 blocked

1 modified

1 warning

### Shield

24 security checks across input, output, tool output, and session drift. Deterministic where possible. Offline ML everywhere — nothing about your prompts leaves your network. Four profiles: none, baseline, strict, custom. Watch first, then enforce.

24 checks · 4 profiles

[ Layer #03 ]

Agent Request

query_payments → "show all payments"

Policy · 4 Rules Applied

READ Allowed

Write blocked

limit added

card_number flagged

### MCP Tools

100 tool connectors across databases, SDLC, knowledge, search, and observability. Per-tool, per-key access control. A rule can rewrite a call's arguments, such as adding a row limit, and both that and PII redaction in prompts, replies and tool results are recorded as MODIFY in the trace. Credentials encrypted with AES-256-GCM at rest.

100 connectors · 17 access rule types · AES-256-GCM

[ Layer #04 ]

allow 9f3c…a71b

modify b82e…4c0d

block 1d77…e9af

Verified

checked with your own key

### Audit Vault

HMAC-SHA256 signed receipt for every decision, each one chained to the last. Tamper-evident — change a byte and the chain breaks. SessionTrace per request: ordered steps, aggregate counters, signature. On a self-hosted deployment, an auditor you give the verification key can verify offline with one CLI command, no call back to Verosek. NIST AI RMF and EU AI Act evidence bundles drawn from real trace data.

HMAC-SHA256 · SELF-HOSTED OFFLINE VERIFY · NIST + EU AI ACT

## All that with just 2 lines of code.

Keep your SDK. Keep your models. Keep your code.

```
import openai

client = openai.OpenAI(
    api_key="vsk_...",        # Verosek virtual key
    base_url="http://your-gateway/v1",  # ← your Verosek gateway
)

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "How many users are in the database?"}],
)
```

```
import anthropic

client = anthropic.Anthropic(
    api_key="vsk_...",        # Verosek virtual key
    base_url="http://your-gateway",  # ← your Verosek gateway
)

response = client.messages.create(
    model="claude-sonnet-4",
    messages=[{"role": "user", "content": "How many users are in the database?"}],
)
```

```
from google import genai

client = genai.Client(
    api_key="vsk_...",        # Verosek virtual key
    http_options={"base_url": "http://your-gateway"},  # ← your Verosek gateway
)

response = client.models.generate_content(
    model="gemini-2.5-flash",
    contents="How many users are in the database?",
)
```

Keep your OpenAI, Anthropic or Gemini SDK and change two values.

Receipts, not claims

## Every decision signed. Every trace verifiable.

On a self-hosted deployment, an auditor verifies each receipt with no network call back to Verosek.

The proof

## We don't just claim Shield works, we prove it.

[Assay](https://github.com/VatsSShah/assay), an open MCP security benchmark we maintain, was presented at Black Hat India Arsenal. Our red-team framework holds 205 attack techniques, 68 for MCP, with findings anyone can recompute. Attacks become findings, and findings become rules on the key.

[See the red-team results](https://verosek.com/red-teaming)

205 Attack techniques

68 Built for MCP

98% Grader agreement

Testimonials

## See what people are saying about Verosek

And we are just getting started...

Indirect injection through tool returns is the gap in agent safety. Verosek scans for it. The cumulative session-level monitoring also catches the slow distributed version. From a research standpoint, that's the right place to put the work

Sumeet Motwani

Oxford ML PhD, ex-BAIR, alignment researcher

When you're running agents in production, key-level access isn't enough. I want one agent to read a table but not modify it, or hit one endpoint but not the next. Verosek draws that line per tool and per argument.

Sarvagya Kulshrestha

Founder, Backdoor (Ex-Antler, Seekho, OTPless)

Keep building, you do great stuff

Dane Knecht

CTO, Cloudflare

Fifteen years in infra, same lesson every time: fail-open is a fiction people end up regretting. Verosek's fail-closed default with an SDK circuit breaker is the right posture for production. If the policy layer is down, the call doesn't land. Full stop.

Rushabh Shah

15+ yrs infra & security leadership (EY Parthenon, Lyft, Dialpad, Cisco, Vox)

Building across multiple AI surfaces, you end up writing wrapper code per provider. Verosek lets the same client hit OpenAI, Anthropic, or Gemini without rewriting anything. One integration point, one audit trail, regardless of which model is running underneath.

Viren Inaniyan

Co-Founder/CEO, TruCommerce (IIT Bombay)

Coming from fintech ops, the compliance posture is what stands out. Mapped reports for NIST AI RMF and EU AI Act, signed traces an outside auditor can verify offline, deployment that keeps data inside your VPC. That's the unglamorous list that decides whether AI agents clear procurement.

Tanish Shah

EIR @ Trueway, ex-PhonePe, ex-Roland Berger (IIM Calcutta, BITS)

The interesting design choice: the policy engine is deterministic and version-controlled. A table of checks you can read, diff, and reason about. Not an LLM judging each call. For something in the request path, that's the only approach that holds up under review.

Pratham Grover

ML, Microsoft Core AI (Ex- Siemens, Samsung)

Pricing

## Govern your AI agents. Prove every decision.

One price per request: routing, rules, Shield and a sealed record are all in it. You pay your model providers directly, with no markup from us. Enterprise can run wholly in your environment, with your own signing key.

[ Team ]

$999 / month, billed yearly.

Overage: $0.50 / 1k requests. Shield and the sealed record come with every request.

- 25 virtual keys
- 5 MCP connections
- 500k requests / month
- All Shield profiles: baseline, strict, custom
- HMAC-signed receipts
- 5 Users (admin/user/auditor)
- SSO (SAML 2.0, OIDC)
- Email Support 24hr response
- 30-day audit retention

[ Enterprise ]

Contact Us

For when compliance needs the evidence — custom terms, custom limits.

- Everything in Team
- Unlimited Keys & Connections
- 90+ day audit retention
- Custom PII recognizers
- Named account manager · 4-hour SLA
- On-prem, VPC, or air-gapped deployment

[Talk with Sales](https://cal.com/verosek-solutions-u9ztip/30min)

## Frequently Asked Questions

### What is Verosek?

Verosek is an AI + MCP Gateway for AI agent security. It routes model calls and, for the tools it runs, reads what each call does, down to the SQL statement, then decides it against the agent key's rules before it runs. Scanning and a sealed record of each request ship in the same product.

### Who is Verosek for?

Platform and infrastructure teams putting AI agents into production on real data, and the security reviewers who sign off on them.

### How is Verosek different from LiteLLM or Portkey?

Verosek decides SQL from the statement itself, and seals a record of each request, on one key with routing, budgets and scanning. Many gateways now route model calls and cover MCP tools, so choose by how far a rule must read a tool's arguments, what should happen when a check fails, and who has to check the record later. Our [comparison page](https://verosek.com/compare) sets six tools side by side and lists its sources at the foot.

### How do I start with Verosek?

Verosek starts with a call. We set it up with you, and you get a gateway URL and a first key. On the Enterprise plan we deploy it with you in your environment. Then two values change in your code: the SDK's base URL and its API key. [See how it works](https://verosek.com/how-it-works).

### How much does Verosek cost?

Team is $999 a month, billed yearly, with 25 virtual keys, 5 MCP connections and 500k requests a month. Enterprise has custom terms and limits. Both plans start with a call. [See pricing](https://verosek.com/pricing).

### How is Verosek deployed?

We set it up with you on a call, and you get a gateway URL and a first key. On the Enterprise plan we deploy it with you in your environment: your own VPC or on-prem. The gateway runs where it can reach your MCP servers and databases.

### Can I run Verosek in an air-gapped environment?

Yes. The self-hosted and on-prem deployments run fully offline — no outbound calls to Verosek are required for the gateway, Shield, or audit signing.

### What's the latency overhead?

Under 30ms P99 for routing and deterministic checks; offline ML checks add a few milliseconds depending on the profile you enable.

### How are credentials encrypted at rest?

All credentials are encrypted at rest with AES-256-GCM.

### Who holds the audit signing key?

On a self-hosted deployment, on the Enterprise plan, you do.

### Can audit receipts be verified without calling Verosek?

On a self-hosted deployment, yes. Every receipt is HMAC-SHA256 signed and chained; an auditor you give the verification key can verify the full chain offline with a single CLI command, no call back to Verosek.
