Attack your AI before someone else does.

Mongoose turns autonomous agents loose on your models, RAG pipelines and tool-using agents. They fingerprint each target, plan the attack, adapt when they're refused and judge every response. Every finding maps to a control in your own framework, and confirmed ones become runtime blocking rules.

OWASP LLM Top 10 (2025)
Mapped to your control framework
Every agent has an identity
Local & on-prem models via Ollama
attack payload vulnerable needs review safesample verdicts

Tests the models, pipelines and agents you already run

OpenAI
Anthropic
Azure OpenAI
Microsoft Foundry
Google
Vertex AI
AWS Bedrock
DeepSeek
Ollama
Custom models
Custom endpoints
RAG pipelines
Tool-using agents
MCP servers
OpenAI
Anthropic
Azure OpenAI
Microsoft Foundry
Google
Vertex AI
AWS Bedrock
DeepSeek
Ollama
Custom models
Custom endpoints
RAG pipelines
Tool-using agents
MCP servers
Why now

AI is going into production faster than anyone is testing it.

Agents now hold tools, data and credentials. The industry's own numbers say the exposure is already here.

40%

of enterprise apps will include task-specific AI agents by 2026, up from under 5% in 2025.

Gartner · Aug 2025

13%

of organizations reported a breach of an AI model or application. 97% of those had no AI access controls.

IBM Cost of a Data Breach · 2025

$670K

higher average breach cost at organizations with high levels of shadow AI.

IBM Cost of a Data Breach · 2025

25%

of enterprise GenAI apps will have at least five minor security incidents a year by 2028, up from 9% in 2025.

Gartner · Apr 2026

The UK's National Cyber Security Centre says prompt injection attacks “may never be totally mitigated”. The job is to measure the exposure and shrink its impact, on every change. NCSC, Dec 2025

AI-SPM

What is AI Security Posture Management?

AI-SPM is the practice of always knowing how exposed your AI systems are, and keeping that exposure under control. Cloud security posture management did this for infrastructure. AI-SPM does it for the models, RAG pipelines and agents now running in production, where the risks are prompt injection, data leakage, poisoned retrieval and agents with more access than they need.

See the whole AI stack

Every model, RAG pipeline and agent you test sits in one view with its results side by side. Each agent carries an identity, an owner and a policy.

Test continuously, not once

Agents attack each deployment, and batch runs across your fleet compare against a baseline, so a model or prompt change that reopens a hole shows up as a regression.

Map risk to controls

Every finding maps to the OWASP LLM Top 10 (2025) and to the controls in your own framework, so posture reads in the language your auditors use.

Enforce at runtime

Confirmed findings become Vigilant rules. They watch in monitor mode first, then block once you've seen what they catch.

9

attack categories, OWASP-mapped

9

attack and defense frameworks, one runner

24

in-house Malagasy attack modules

3,000+

variations per Deep Scan

The gap

Most AI security tells you something. Very little of it proves anything.

Fixed-payload scanner
Replays last quarter's probe list

It can't react to how your model refuses, and it flags plenty of false positives. Coverage decays every time the model or system prompt changes.

misses: adaptive & multi-turn attacks

Guardrail product
Filters traffic, never tests the model

It blocks known shapes on the way in and out. Nobody measures its own bypass rate against your deployment.

misses: whether you're vulnerable at all

CNAPP / governance module
Inventories models and checks config

Useful posture data, but the risk rating has no adversarial evidence behind it.

misses: proof

Mongoose produces evidence. Every finding carries the full exchange, the judge's verdict and confidence, and the OWASP risk and control it implicates.

See how
Agents as attackers

A refusal changes the next payload.

Mongoose's agents share a blackboard, run under a hard budget, and persist every decision so a run can be audited or resumed. The reasoning agents use their own sandboxed credentials, never the model under test.

Recon
deterministic
Canary prompts fingerprint the target: reachability, refusal style, system-prompt leakage, latency and multimodal hints.
Planner
LLM
Reads the fingerprint and the engagement goal, then picks attack categories and depth.
Generator
deterministic
Pulls seeds from the attack catalog and applies mutators: base64, atbash, hypothetical wrapper, role-play, prefix injection, academic framing.
Executor
deterministic
Fires payloads with provider-aware batching and records every response.
Judge
LLM
Scores each exchange inline as vulnerable, safe or needs review, with confidence and reasoning.
Adaptive Strategist
LLM
Drills deeper where findings appear, or stops. Capped at two adaptive iterations.
MultiTurn
deterministic
Runs long-horizon conversations: crescendo, refusal erosion, persona drift, context poisoning, trust-building.
Product tour

What a run leaves behind.

Seven screens from the Mongoose console: from the posture dashboard to the evidence behind a single finding, and the controls that act on it at runtime.

mongoose console /dashboard
Mongoose dashboard showing scan totals, severity distribution, scan activity by engine and monitored models

Demo environment · illustrative data

1 / 7

Posture across every model you run

One view of scans, validated findings by severity and runtime traffic, for every model and agent you've registered.

  • Azure OpenAI, Anthropic, Bedrock, Vertex AI and local Ollama models side by side
  • Risk level, protection status and finding count per model
  • Vigilant traffic: requests inspected, threats detected, requests blocked
Coverage

Nine attack categories, including the ones open-source probe sets barely touch.

RAG, agent tool-use, multimodal, consumption and long-horizon attacks come from Malagasy, the in-house module we built to cover what the open-source tools don't reach.

Injection
LLM01

Direct and indirect prompt injection, jailbreaks, latent injection.

Open-source frameworks

Data
LLM02 · LLM07

Leakage, training-data extraction, system-prompt disclosure.

Open-source frameworks

Safety
LLM09

Bias, toxicity, misinformation, fabricated citations, harmful content.

Open-source frameworks

Encoding
LLM01

Base64, ROT13, atbash, ASCII art, obfuscation, prompt smuggling.

Open-source frameworks · Deep Scan

RAG
LLM08 · LLM04

Knowledge poisoning, retrieval manipulation, context overflow, injection via retrieved docs.

Malagasy

Agent
LLM06

Tool abuse, privilege escalation, agent hijacking, tool-chain exploitation.

Malagasy

Multimodal
LLM01

Image injection, OCR bypass, steganography, cross-modal exploits.

Malagasy

Multi-turn
LLM01

Crescendo, refusal erosion, persona drift, context poisoning.

Malagasy · open-source frameworks

Resource
LLM10

Token flooding, output amplification, recursive reasoning, wallet-drain simulation.

Malagasy (opt-in)

Open-source tools flag a lot of false positives. So Mongoose re-checks every hit they report before it reaches your results. A deterministic detector match stands; anything inferred goes to the judge, which confirms it, rejects it or sends it to review. Open-source frameworks and 24 Malagasy modules report into one schema.

AI harness

Mapped to your framework, not just OWASP.

Register your own control and threat catalog as a harness and sync it from GitHub. Every finding, from an agent run or a scanner, maps to the control it implicates, so an audit question gets answered from the same evidence as the red team.

via=scanner

Direct

The scanner names the control itself. The MCP compliance lens emits one per clause.

via=family-map

Family map

A scanner rule maps to its family in your harness, and from there to the controls, threats and OWASP entries it lists.

via=owasp-crosswalk

OWASP crosswalk

An adversarial finding's OWASP LLM category maps to every control whose crosswalk cites it. Coarser, and labelled that way.

implicateda control is implicated; a person confirms itunmappedyour map says no control states this yetunknownyour map has never seen this rule
Symphony

Catch it before it ships.

Agent runs test live endpoints. Symphony reads source: MCP servers and agent skills, scanned deterministically, with every finding quoting file and line. A clean result means no statically decidable violation, not a safe repository.

MCP Scanner

Four lenses over an MCP server and its client configuration.

  • Compliance, clause by clause against your control catalog
  • Command injection, secrets, SSRF, poisoned tool definitions
  • Client config: plaintext credentials, unpinned packages
  • A judge pass that re-derives every citation
Agent Skills Scanner

Skill and agent-pack definitions against the OWASP Agentic Skills Top 10.

  • Findings mapped to AST01 through AST10
  • Gate: zero findings outside a reviewed suppression baseline
  • Every finding quotes file and line
  • States what it can't decide, like natural-language-only attacks
Agent Identity

Every agent has an owner, a token and a policy.

When an agent calls a tool, you know which agent it was, which person launched it and whether it was allowed. Nothing blocks by default: rules start in monitor mode and only take effect once promoted, so onboarding a policy never breaks a run that worked yesterday.

Registry

One record per agent, whether it's a platform agent, MCP server, coding agent or custom. Each has an accountable owner and a tool manifest.

Delegation tokens

Every dispatched agent gets a signed, short-lived token naming the agent, the person who launched it, the run and its scope.

Policy broker

Plans, drills, tool calls and agent-to-agent messages are decided as auto, hold for a person, or block. New rules start in monitor mode.

Hash-chained audit

Every entry carries the hash of the one before it. Filter the trail by agent or by run.

OIDC issuer

Standard discovery and JWKS endpoints, so your identity provider can trust Mongoose as an issuer. Keys rotate without breaking tokens in flight.

Tested from both sides

An identity attack category covers delegation abuse, confused deputy and owner impersonation (LLM06). Vigilant detects the same shapes in live traffic.

Not covered yet

  • Argument-level policy: the broker decides whether a tool call runs, not what it's called with
  • Agents that never touch the platform
Vigilant runtime protection

Findings become controls. Nothing blocks until you've watched it.

Vigilant inspects production LLM traffic inline. A confirmed attack becomes a rule, the rule runs in monitor mode, and you promote it to enforcement once its false-positive rate holds up.

An agent confirms a bypass

The evidence is the full exchange, the judge's verdict and the OWASP mapping.

The finding becomes a detection

Pattern, regex, semantic similarity, category or custom rule.

The rule records, it doesn't block

Hits land in the human-in-the-loop threat review queue.

Promoted after review

Only once the false-positive rate is acceptable for that endpoint.
Also inline:PII detection and redactionRate limitingLive threat streamLLM inventory
Why Mongoose

Proof, not a posture score.

Other tools inventory your AI, filter its traffic or replay a probe list. Mongoose attacks it the way an adversary would, shows you the evidence, and turns what it finds into controls.

Agents that adapt, not a probe list

A refusal changes the next payload. Recon, planning, multi-turn conversations and drill-down find what a replayed probe list walks past.

How it attacks

Evidence you can defend

Every finding carries the full exchange. Confirmed means a deterministic detector matched or two judges agreed. Likely false positives are called out, not counted.

See a session

Your controls, not just OWASP

Register your own control and threat catalog. Findings map to it, so the audit answer and the red-team result come from the same evidence.

AI harness

Findings become runtime rules

A confirmed attack becomes a Vigilant rule. It watches in monitor mode first and blocks only once you've seen what it catches.

Vigilant

Every agent has an identity

An owner, a signed delegation token, a policy broker and a hash-chained audit trail. You know which agent acted, for whom, and whether it was allowed.

Agent identity

Independent of the platform you're testing

OpenAI, Anthropic, Azure and Foundry, Bedrock, Vertex AI, DeepSeek and local models in one schema. A second party checking the guardrails your platform vendor sells you.

Compare

Built for the enterprise

  • Self-hosted on your own Kubernetes (AKS or GKE), so prompts, findings and evidence stay with you
  • Single sign-on with an authorized-user allowlist, and Admin, User and Viewer roles
  • Hash-chained audit trail for every scan, decision and agent action
  • Fleet batch testing with baselines, schedules and CI gates through the API

Ready for anyone shipping AI

  • Start with one scoped test against one chatbot, RAG pipeline or agent
  • Standalone CLI that runs the same tests with no platform to install
  • Any OpenAI-compatible or custom endpoint, plus local models through Ollama
  • Findings in plain language, with the fix to apply first
Ask Mongoose

Ask what a finding means, and what to fix first.

The built-in assistant reads your results with you. It explains a finding, separates confirmed from unproven, and tells you what to change.

  • Attach the evidence

    Point it at a scan, a finding or a model, and it answers about that.

  • Grounded, or it says so

    Claims about a result come from the attached context. When the context doesn't say, neither does it.

  • Fixes mapped to OWASP

    Mitigations come tied to the OWASP LLM category, and a judge score is treated as a signal, not a verdict.

  • Advisory only

    It answers questions. It doesn't launch scans or change rules.

  • In the app and the CLI

    Ask Mongoose in the web app, Orion in the CLI. Bring your own Anthropic or OpenAI key.

Getting started

The best proof is your own model.

Start with a scoped, authorized test against one real deployment. The findings make the case better than any slide.

Start here
Start here
Scoped test

One deployment you own, one written scope, one agentic run.

  • 30-minute scoping call before any testing
  • Fingerprint and attack plan
  • Confirmed, partial and refused findings with evidence
  • OWASP-mapped report
Book a scoped test
Then
Continuous testing

The same suite on every model and system-prompt change.

  • Fleet batch testing with baselines
  • CI gates through the API or CLI
  • Scheduled scans
Talk to us
And
Runtime protection

Vigilant in front of production traffic.

  • Rules from your own findings
  • Monitor before enforce
  • Threat review queue
Talk to us

One engine behind the UI, the API and the CLI.

Run it in CI on every model version and system-prompt change, so "we tested it once" becomes "we know if the new version regressed." Targets OpenAI, Anthropic, Azure OpenAI and Microsoft Foundry, Google and Vertex AI, AWS Bedrock, DeepSeek, Ollama, custom models and custom endpoints.

WebFleet batch testing with baselines and regression tracking
APIPOST /api/agentic/scan
CLImongoose test support-bot --framework all
Scoped test

Bring one deployment. We'll bring the agents.

Tell us what you're running. A scoped test is the fastest way to see what the agents find on your own system.

One deployment

A model, RAG pipeline or agent you own or have written permission to test.

Written scope

A 30-minute scoping call agrees target, categories and budget before any traffic is sent.

One agentic run

Fingerprint, adaptive attack plan and judged findings with the full exchange.

OWASP-mapped report

Confirmed, partial and refused findings, with likely false positives called out.

Request a scoped test

Offensive testing runs only against systems you own or have written permission to test.

This form is protected by reCAPTCHA and the Google Privacy Policy and Terms of Service apply.

Questions buyers ask

Straight answers.

Mongoose runs them for you, and adds what they lack: an adaptive agent loop, the surfaces they barely cover (RAG, agent tool-chains, multimodal, consumption and multi-turn), and a judge. Open-source tools report a lot of false positives, so every hit they return is re-checked before it lands in your results. You also stop maintaining a separate adapter and result format for every tool.

Provider guardrails protect the provider. The exploitable surface is usually your system prompt, your RAG corpus and your tool permissions, and the provider sees none of them.

Not blindly. The judge produces false positives. That's why every finding carries the full exchange, low-confidence scores go to review, and Vigilant rules start in monitor mode.

Yes. Register your control and threat catalog as a harness and sync it from GitHub. Findings map to your controls as well as OWASP. Where nothing in your catalog fits, the mapping says unmapped instead of guessing.

Every agent run carries a signed delegation token naming the agent and the person who launched it. The Vigilant proxy verifies it, and every detection is attributed to both. Nothing is logged as "the system did it".

Every session has hard ceilings on wall time, target calls and tokens. Runs are resumable, so an interrupted engagement doesn't start over. Deep Scan's 3,000+ variations are opt-in.

Yes. Ollama support covers local and on-prem models as targets. To keep every request inside your network, run the reasoning agents (planner, judge and strategist) on a local model through Ollama too; by default they call a hosted model provider.

A pen test is a point-in-time engagement. Mongoose runs on every model version and every new tool you give an agent. The two complement each other, and the human engagement starts from a better baseline.