Skip to content
AI & MCP security

Secure the AI infrastructure you deploy.

Managed AI services, MCP servers, copilots and agents, and the databases and systems they connect to. We check how you wire and expose it, with special depth on the agent and MCP layer that standard scanners barely touch, and back every finding with a runnable proof of concept.

What this is about

Your AI reads outside content and acts with your permissions.

A copilot reads emails, an agent opens tickets and documents, an MCP server passes on access to databases, inboxes and internal tools. If one of those contents carries a hidden instruction, the AI may carry it out, with exactly the permissions you gave it. We test what your AI is allowed to do, where it can be abused and how to scope its permissions so that a mistake does not turn into damage.

The situation

A tool-calling agent is a confusable deputy.

Once a model executes tools with your credentials while reading untrusted content, the threat model flips: an instruction embedded in a page, an issue or a document can steer the agent into writes or deletes, a 'read-only' switch often holds only on paper, and a transport without real authentication hands the server's full authority to anyone who can reach the port. These are not theoretical risks, they are the patterns we found in real MCP servers.

For technical teams: all attack classes
The attack surface

Every layer that makes an AI environment exploitable.

From the client through the agent, the MCP server, execution and the network to your data, the supply chain and inter-agent communication. This map shows the classes we check at every layer, with references to the OWASP MCP Top 10 and the OWASP Top 10 for Agentic Applications.

statically detectable only visible in behaviour critical severity
Client / Host
Access, reverse channel
Indirect prompt injectionMCP 3 · ASI01
Reverse channel (sampling, elicitation)MCP 7
Auto-approve, consent bypasshuman-in-the-loop
Human-agent trust exploitationASI09
Agent / planning
Orchestration, memory
Goal hijackASI01
Memory & context poisoningASI06
Tool misuseASI02
Rogue agentsASI10
Cascading failuresASI08
Model / LLM
the model itself
Jailbreak & prompt injectionLLM01
Improper output handlingLLM10
Excessive agencyLLM03
Sensitive data & prompt leakLLM02 · LLM08
Misinformation & overrelianceLLM07
MCP server / tools
full rights, the only door
Transport & authenticationMCP 1
OAuth trust anchorMCP 2
Tool poisoningMCP 3
Confused deputyMCP 7 · ASI03
Over-broad capabilityMCP 8
Bypassable controlsMCP 4
Execution / sandbox
where code runs
Command & code injectionMCP 6 · ASI05
Unsafe deserialization, YAML, XXEMCP 6
Sandbox escapeASI05
DoS & resource exhaustionMCP 10
Egress / network
what leaves the box
SSRF & unfiltered fetchesMCP 5
DNS rebindingMCP 1
Metadata endpoints169.254.169.254
Data / connections
databases, APIs, files
BOLA / IDOR (ownership)MCP 8 · ASI03
Secret & credential leaksMCP 7
Path traversal & zip slipMCP 10
Insecure defaultsMCP 9
Supply chain
what you pull in
Tool definitions & templatesASI04
Frameworks & registriesASI04
Model artifactsASI04
Inter-agent
multi-agent systems
Insecure inter-agent commsASI07
Spoofing & replayASI07
Cross-cutting: how we check
Invariant checklist, static
Refute-by-default verification
Proof of concept per finding
Every finding verified before reporting
Prioritized fixes and retest
EU-native, coordinated disclosure
What we check

The attack classes a scan will not find.

01

Transport & authentication

Fail-open auth, default bind on all interfaces, endpoints with no credential check.

02

Origin/Host & DNS rebinding

Locally bound servers a web page can drive via DNS rebinding.

03

Indirect prompt injection

Untrusted content verbatim in context, next to destructive tools and egress (lethal trifecta).

04

SSRF & egress

Server-side fetches with no scheme/IP allowlist, redirects without revalidation, metadata endpoints.

05

Command/code injection & sandbox

Shell execution, bypassable guards, sandbox escapes up to host compromise.

06

File access & path traversal

Unbounded paths, symlink escapes, arbitrary read and write.

07

Confused deputy

Passthrough tools that allow arbitrary backend calls with your credentials.

08

Bypassable controls

readonly/allowlist/denylist checks defeated by unicode, quoting or wrappers.

09

Secret leaks & insecure defaults

Credentials in logs/argv/config resources, shipped defaults that expose instead of protect.

Why depth

Every finding with executed evidence.

We have reviewed dozens of open-source MCP servers under coordinated disclosure. A finding is only reported once it has been demonstrated against the real code. Publicly verifiable: CVE-2026-15583 (Grafana MCP Server), CVE-2026-114123 (d365fo-mcp-server), CVE-2026-104776 (mcp-server-kubernetes), CVE-2026-110787 (pREST), reported under coordinated disclosure and fixed by the maintainers. We apply the same method to your server.

Dozens of MCP servers reviewed Every finding verified Findings in vendor code PoC per finding See all findings →
How we work

The MCP Security Snapshot.

Step 1

Capability & attack-surface map

We map tools, transports, credentials and data flows, and mark where authority meets influenceable input.

Step 2

Depth review & evidence

We test against a fixed list of rules that must never break, and try to refute every finding before we report it. What remains is demonstrated against the real code.

Step 3

PoC, policy & retest

A proof of concept per finding, a deny-by-default policy, prioritized fixes and a retest after remediation.

Honest, not a feeling of safety. We verify every finding adversarially against the real code before we report it. And where a server is clean, we say so; 'no finding' is never the same as 'secure'.

Let us test your MCP server before someone else does.

A free initial call of your agentic feature. We name the one property your security depends on and tell you whether it holds.