proredteam

Methodology

How we test an AI system, step by step.

Our red teamers lead every engagement and make every judgment call. Specialist tooling handles the high-volume work: running large attack libraries, mutating prompts that get refused, and recording evidence for each attempt.

Principles

Four rules that shape every engagement.

People decide, tools scale

A human plans the attack, reads the responses and confirms each finding. Automation widens coverage and never signs off a result.

Tested only with permission

You set the targets, objectives and exclusions. Anything that needs credentials is tested only when you authorize it explicitly.

Proof before severity

A high or critical rating needs evidence that matches the claim. Where the evidence is weak, we lower the rating and record why.

Unknown is not a pass

If a test could not reach a conclusion, or could not run, the report says so. It is never counted as secure.

The engagement

Six phases, from scope to retest.

  1. 01

    Scope

    We agree which systems are in scope, what the AI is allowed to do, and what an attacker would want from it. Exclusions and test windows are fixed before any testing starts.

  2. 02

    Reconnaissance

    We identify the underlying model, profile its guardrails by content category, list the tools and integrations it can call, detect retrieval pipelines and measure context limits.

  3. 03

    Static review

    Where you share code or model files, we review them without running them: how user input reaches the model, how model output is used, and whether model files or dependencies can execute code.

  4. 04

    Adversarial testing

    We start with known attacks mapped to published standards, then move to multi-turn conversations. Prompts that get refused are rewritten and retried in new forms until they succeed or the approach is exhausted.

  5. 05

    Evaluation

    Each response is graded against a rubric written for that test. Where execution traces are available we also read tool calls, retrievals and intermediate steps, which catches leaks that never reach the final reply.

  6. 06

    Report and retest

    You receive a readable report and machine-readable results for your code scanning and build pipeline. After fixes ship, we rerun the same attacks and compare against the first run.

Techniques

What we try, layer by layer.

An AI system is more than its model. We test each layer an attacker can reach, and the scope decides which ones apply to you.

Model and prompt

  • Direct prompt injection and social engineering
  • System prompt extraction through encoding and obfuscation
  • Gradual escalation across many turns
  • Guardrail bypass with role-play, translation and look-alike characters
  • Instructions hidden in images sent with text

Retrieval and data

  • Indirect injection through web pages and documents the AI reads
  • Poisoned entries in a knowledge base
  • Retrieval of another customer's or tenant's data
  • Secrets and personal data in model output

Agents and tools

  • Goal hijacking and excessive agency
  • Tool misuse, including injection through tool results
  • Credentials leaked through tool arguments
  • Memory poisoning that carries across sessions
  • Consequential actions taken without approval
  • Browser agents misled by page content

MCP servers and integrations

  • Poisoned tool descriptions and hidden context in tool schemas
  • Unauthenticated access and weak session binding
  • Scope escalation and over-broad permissions
  • Secret exposure and server-side request forgery

Application code and supply chain

  • Unsanitized user input reaching the model
  • Model output executed, rendered or passed to a shell
  • Model files that run code when loaded
  • Malicious or non-existent dependencies
  • Hardcoded secrets and broken API authorization

Fairness and resource abuse

  • Biased responses by age, gender, race or disability
  • Requests built to exhaust compute or run up cost
  • Denial of service through oversized or looping inputs

Evidence

How we decide what counts as a finding.

Matching keywords in a response is not a reliable way to tell whether an attack worked. We use three checks, in this order:

  1. A definite check where one exists. A planted secret that appears in the output, or a tool call that should not have happened, is proof by itself.
  2. A graded verdict where it does not. The response is scored against a written rubric, with a confidence level and a stated reason.
  3. A second look at anything serious. High and critical results are graded again and confirmed by a red teamer before they reach your report.

Every test ends in one of four results

Finding

The attack worked, and the transcript proves it.

Passed

The attack ran and the system held. Passes are recorded, so fewer findings can be told apart from fewer tests.

Unverified

The attack ran, but the result could not be judged either way.

Not tested

The test could not run or was out of scope. The report lists what was not covered.

Standards

Every finding is tagged against published frameworks.

The report shows coverage for each framework: which categories were tested, and which were not.

  • OWASP Top 10 for LLM Applications
  • OWASP Top 10 for Agentic Applications
  • OWASP MCP Top 10
  • MITRE ATLAS
  • NIST AI Risk Management Framework
  • EU AI Act

Demos are coming soon.

Pro Red Team is still being finalized, and services are not yet available for purchase. This methodology will be updated as we get closer to launch.

Back to the overview