# INTRUSIVE.AI — complete offering and technical context

> The complete contents of the website section documents, in page order.

Canonical URL: https://intrusive.ai/content/intrusive-ai.md

<!-- Generated by scripts/build-content.py. Edit the individual section documents. -->

<!-- Source: https://intrusive.ai/content/overview.md -->

# INTRUSIVE.AI — contained attack simulation

> Test consequential behavior without consequential exposure. INTRUSIVE.AI provides sandboxed attack simulation for agentic systems: exercise models, tools, identities, protocols, and data inside restorable synthetic environments, then inspect the recorded path from input to effect.

- Status: available; release-specific compatibility is published through the release site.
- Document version: 1.0
- Last reviewed: 2026-10-05
- Intended audience: AI security practitioners, red teams, security architects, and agent builders.
- Related products: Operator Sandbox, Attack Harness, Interceptor Sandbox, Intrusive Threat Intelligence.
- Canonical URLs: [website](https://intrusive.ai/), [this document](https://intrusive.ai/content/overview.md).

## What it is

INTRUSIVE.AI is the preferred brand spelling of Intrusive AI, Inc. The company builds security-testing products for advanced AI-driven applications and systems. Its strengths are AI security architecture, security validation, attack simulation, understanding how systems fail, and enterprise integration.

The suite separates the offensive tester from the target application. Operator Sandbox contains and governs the tester; Interceptor Sandbox contains the target and its synthetic world. Attack Harness creates experiments and adapts to permitted feedback. Intrusive Threat Intelligence (ITI) develops threat-intelligence-informed scenarios and assesses campaign results.

## Explore both sandbox boundaries

The website hero switches between two independent startup illustrations. Interceptor Sandbox shows the target agent and injectable synthetic services; Operator Sandbox shows a network-disabled Attack Harness guest, its constrained model interface and fixed tool catalog, and host-controlled MODEL_RELAY, TARGET_EDGE and JOURNAL points. The commands are illustrative: they require prepared environment inputs and host configuration, and do not execute in the browser.

Operator's example is `operatorctl run --bundle ./scenario-bundle.json --environment ./environment --output ./runs/sim_001`. Interceptor's example is `interceptor run --environment ./environment --allow-model "$MODEL" --provider-base-url "$MODEL_URL"`, with configured model and provider URL values. See the [Operator run workflow](https://github.com/intrusiveai/operator_sandbox/blob/main/docs/ADMIN_WORKFLOWS.md) and [Interceptor CLI reference](https://github.com/intrusiveai/interceptor_sandbox/blob/main/docs/cli-reference.md) for prerequisites and actual behavior.

## Problem addressed

An AI application's security depends on what its decisions can cause. A harmful answer, an attempted tool call, an authorized action, and a demonstrated data disclosure are different observations. Testing must connect adversarial influence to the application capabilities, authority, state changes, and effects that matter to the defender.

## How it works

Describe an authorized target and its capabilities, prepare controlled dependencies and synthetic data, choose objectives or scenario guidance, run bounded experiments, and inspect the retained evidence. Restore eligible target state to compare variants or investigate a finding. Restoration reconstructs declared logical state; later model responses can differ.

The Interceptor globe illustrates an agent surrounded by simulated DNS, HTTP, MCP, local-tool, attacker-sink, filesystem, application-interface, and PostgreSQL surfaces. Host-mediated model access, journals, injection controls, and the observability relay sit at separate control boundaries. The animation is a conceptual illustration rather than a runtime status feed.

## Product and licensing summary

| Component | Status | Distribution | Responsibility |
| --- | --- | --- | --- |
| Operator Sandbox | Available | Open source, AGPL-3.0-only | Campaign admission, harness containment, model/target mediation, limits, evidence and reports |
| Attack Harness | Available | Open source, AGPL-3.0-only | Adaptive experiments, payload generation, permitted feedback, structured conclusions |
| Interceptor Sandbox | Available | Open source, AGPL-3.0-only | Target containment, simulated environment, injections, logical snapshots, native evidence |
| Intrusive Threat Intelligence | Available | Paid subscription software | Target-aware scenario planning, intelligence composition, campaign assessment |

For versions, artifacts, compatibility, and validation records, use [releases.intrusive.ai](https://releases.intrusive.ai/). Product availability does not mean every model, host, application, or technique combination is supported. Consult the selected release's integration documentation.

## Practitioner benefits

Practitioners can investigate consequential behavior with synthetic dependencies, compare experiments from known declared state, and review evidence without treating a model's own conclusion as proof. Open-source boundaries let teams inspect and adapt the execution components. ITI adds scenario planning and analysis without replacing local execution policy.

## Technical properties and evidence

| Claim | First-party source |
| --- | --- |
| Operator mediates target and model access | [Operator specification](https://github.com/intrusiveai/operator_sandbox/blob/main/OPERATOR_SANDBOX_SPEC.md) |
| Harness uses a fixed tool catalog and adaptive loop | [Attack Harness specification](https://github.com/intrusiveai/attack_harness/blob/main/CUSTOM_AI_HARNESS_IMPLEMENTATION_SPEC.md) |
| Target restore reconstructs declared state | [Interceptor snapshots and restore](https://github.com/intrusiveai/interceptor_sandbox/blob/main/docs/snapshots-and-restore.md) |
| Reports distinguish facts, claims, and gaps | [Reporting contract](https://github.com/intrusiveai/operator_sandbox/blob/main/docs/REPORTING.md) |

Specifications describe behavior; dated validation records establish the configurations actually exercised in those records. Neither a historical probe nor a taxonomy reference demonstrates every release combination.

## Limitations and non-goals

The suite is a security-testing system. It is not a production model firewall, a prompt scanner, a production monitoring service, or a guarantee that an application is secure. Docker isolation shares a trusted host kernel. A synthetic environment needs explicit onboarding; it is not an automatic clone of arbitrary production infrastructure. Configured HTTPS targets can have real external effects and do not acquire Interceptor containment or snapshot guarantees.

## Terminology

- **ITI:** Intrusive Threat Intelligence; strategic scenario planning and assessment.
- **Attack Harness:** the adaptive testing runtime governed by Operator. Some architecture documents call this role ASE, the attack simulation engine; this is not an additional product.
- **Scenario:** a target-bound testing hypothesis with prerequisites, an objective, expected observations, and constraints.
- **Campaign:** a bounded execution of objectives and optional scenario guidance.
- **Capability:** a declared operation, surface, observation, or state feature available through a target integration.
- **Evidence:** recorded observations and artifacts with source identity and integrity information.
- **Oracle:** a configured check of recorded behavior against a defined predicate; not a universal exploit detector.
- **Replay:** reconstructing recorded declared state or deliberately repeating an experiment; not a promise of identical model sampling or resumed interrupted execution.

## Practitioner FAQ

**Must I use ITI?** No. Operator accepts user-authored objectives and optional scenarios. Interceptor also works directly through its CLI and local API.

**Can I use a real model?** Yes, through configured host-side provider adapters. Requests sent to that provider leave the local host under its terms; provider credentials remain outside the guest containers.

**Does a clean campaign prove safety?** No. Results describe exercised scenarios and available evidence. Unattempted paths, missing observations, and uncertainty remain relevant.

**Can I customize the open-source components?** Yes, subject to AGPL-3.0-only. See the [open-source overview](https://intrusive.ai/content/open-source.md) and repository license files.

## Sources and related documents

- [System architecture](https://intrusive.ai/content/system.md)
- [Failure records](https://intrusive.ai/content/failure-record.md)
- [Trust model](https://intrusive.ai/content/trust-model.md)
- [Operator source](https://github.com/intrusiveai/operator_sandbox)
- [Attack Harness source](https://github.com/intrusiveai/attack_harness)
- [Interceptor source](https://github.com/intrusiveai/interceptor_sandbox)

---

<!-- Source: https://intrusive.ai/content/attack-surface.md -->

# ATTACK_SURFACE — The attack surface is larger than the prompt.

> Agentic systems select tools, assume identities, retrieve data, call services, change state, and create external effects. INTRUSIVE.AI tests the paths between adversarial influence and those effects using observable synthetic environments.

- Status: available testing approach; target-specific coverage depends on declared capabilities.
- Document version: 1.0
- Last reviewed: 2026-10-06
- Intended audience: security testers, application architects, and agent builders.
- Related products: Interceptor Sandbox, Operator Sandbox, Attack Harness, ITI.
- Canonical URLs: [website section](https://intrusive.ai/#attack_surface), [this document](https://intrusive.ai/content/attack-surface.md).

## Problem addressed

The paths worth testing are often the paths least safe to exercise against production. INTRUSIVE.AI replaces declared surrounding services and data with observable, restorable simulations so testers can investigate consequences in a controlled environment. Provider calls and explicitly configured external targets remain separate outbound paths.

## How it works

The website's effect chain is:

1. **Adversarial input:** a prompt, document, tool result, or event introduces attacker influence.
2. **Model:** the model interprets input in its current context.
3. **Plan:** the application adopts a goal or chooses subsequent actions.
4. **Tool call:** it attempts to use an application capability.
5. **State change:** a service, file, grant, or other state changes.
6. **External effect:** data disclosure, unauthorized access, resource consumption, or another consequence follows. In Interceptor, declared effects occur against synthetic destinations.

The chain is a testing model, not a claim that private model reasoning is observable. Investigators join recorded inputs, invocations, state changes, and target observations, while labeling inferred intent separately.

## External methodology

OWASP's [Agentic Top 10](https://genai.owasp.org/resource/owasp-top-10-for-agentic-applications-for-2026/) supplies risk categories. [MITRE ATLAS](https://atlas.mitre.org/) supplies adversary techniques. The following is INTRUSIVE.AI's interpretive mapping, not an official crosswalk or certification:

| Effect-chain stage | Relevant OWASP categories |
| --- | --- |
| Input and model context | ASI01 Agent Goal Hijack; ASI06 Memory & Context Poisoning |
| Plan and capability selection | ASI02 Tool Misuse & Exploitation; ASI04 Agentic Supply Chain |
| Access and tool execution | ASI03 Identity & Privilege Abuse; ASI05 Unexpected Code Execution |
| Coordination and consequences | ASI07 Insecure Inter-Agent Comms; ASI08 Cascading Failures; ASI09 Human-Agent Trust Exploitation; ASI10 Rogue Agents |

ATLAS [indirect prompt injection](https://atlas.mitre.org/techniques/AML.T0051.001) provides a specific example: retrieved content can carry instructions across a data-to-instruction boundary. A technique mapping establishes relevance; it does not prove that a product implements every technique or that an attempted attack succeeded.

## Practitioner benefits and technical properties

Test the application capability behind a model response, rather than scoring only the response wording. Interceptor provides declared simulated HTTP/MCP services, closed DNS, files, local tools, synthetic identities, and attacker sinks. Operator constrains experiment access and feedback. Attack Harness refines experiments within those constraints. ITI selects scenarios based on target capabilities and threat context.

Define what the target can observe, what the tester can change, which authority should remain intact, and what evidence would demonstrate an effect. Compare a baseline and an attack variant from equivalent declared state.

## Evidence

- [Environment Blueprint](https://github.com/intrusiveai/interceptor_sandbox/blob/main/docs/environment-blueprint.md): declared services, data, state and application configuration.
- [Injection and evaluation guide](https://github.com/intrusiveai/interceptor_sandbox/blob/main/docs/injections-and-evaluation.md): injection surfaces and configured behavior checks.
- [Operator HTTPS targets](https://github.com/intrusiveai/operator_sandbox/blob/main/docs/HTTPS_TARGETS.md): fixed destinations, policy and externally observable assurance.
- [OWASP prompt-injection guidance](https://genai.owasp.org/llmrisk/llm01-prompt-injection/): recommends adversarial testing of trust boundaries and access controls.
- [Reported agent vulnerabilities and incidents](https://intrusive.ai/content/mission.md): dated examples linking retrieved-content attacks, configuration tampering, unintended egress and real third-party effects to testing hypotheses.

## Limitations and non-goals

Coverage depends on environment fidelity and observable boundaries. A simulated protocol is not the complete behavior of every production service. Undeclared process activity or hidden application state may remain unobserved. This approach does not replace application threat modeling, secure engineering, or production access controls.

## Terminology and related content

An **attack surface** is an interface or state through which influence can reach the system. An **effect** is an observed consequence; an attempted effect is not automatically a demonstrated effect. See [scenarios](https://intrusive.ai/content/scenarios.md) for concrete testing hypotheses and [failure records](https://intrusive.ai/content/failure-record.md) for evidence interpretation.

---

<!-- Source: https://intrusive.ai/content/system.md -->

# ARCHITECTURE — Architecture for controlled attack simulation.

> Separate the offensive system from the target system, bound the authority of each, and let observed behavior determine what happens next. Operator Sandbox governs the tester, Interceptor Sandbox supplies the synthetic target environment, Attack Harness adapts experiments, and ITI plans scenarios and assesses results.

- Status: available suite; select matching releases and documented integration profiles.
- Document version: 1.0
- Last reviewed: 2026-10-05
- Intended audience: security architects, integration engineers, and practitioners.
- Related products: all four suite components.
- Canonical URLs: [website section](https://intrusive.ai/#architecture), [this document](https://intrusive.ai/content/system.md).

## Components and practitioner benefits

### Operator Sandbox — contain the tester

Operator runs offensive AI testing inside a disposable Docker execution boundary. Host access, credentials, target access, and permitted operations are configured explicitly. The guest has no general networking or direct provider credentials. The trusted host brokers model calls and target operations, enforces campaign budgets, and retains journals and evidence.

The website component contract is: **accepts** attack harness + authorization policy; **governs** execution + capability access; **emits** attempted actions + operator trace. A campaign submission supplies objectives and optional scenarios; the administrator's local configuration remains the authority for admission and execution.

### Attack Harness — adapt the experiments

Attack Harness runs inside Operator's guest. It uses model assistance to generate payloads, choose experiments, inspect permitted feedback, refine hypotheses, and produce structured conclusions with evidence references and limitations. It uses a fixed tool catalog, with no shell tool or direct network connection. Instruction-only skills add guidance, not executable tools or new permissions.

The adaptive runtime can request target snapshots and restores when supported while retaining its campaign context. Interrupted execution and uncertain operation outcomes do not cause automatic replay or resumption.

### Intrusive Threat Intelligence — expand the search

ITI builds threat-intelligence-informed scenarios based on the target agent's environment and capabilities and analyzes the combined sandbox results of the simulated attack campaign. Its website contract is: **accepts** target agent capabilities; **governs** threat model + simulation scenarios; **emits** attack simulation performance analysis.

ITI is a separate customer-hosted application with an API and web interface, supplied as subscription software. It selects reviewed intelligence, binds scenario hypotheses to declared target capabilities, publishes campaign inputs, and joins finalized Operator results with separately identified target evidence. It preserves original source taxonomy, attribution, versions, and limitations.

Its composition approach combines prompt-injection influence knowledge with applicable Atomic Red Team and Stratus Red Team action/effect knowledge. This is knowledge composition: it does not mean running those projects' attack commands inside the sandbox. ITI supplies strategic guidance; Attack Harness renders concrete attempts and adapts during execution. ITI cannot grant access beyond Operator's local policy.

The website loop describes ITI's planning and assessment lifecycle: **model threats → generate scenarios → collect results → analyze performance**. This differs from Attack Harness's per-experiment adaptation loop.

### Interceptor Sandbox — contain the target

Interceptor runs a real agent application inside a synthetic operating world. Services, identities, data, tools, and attacker infrastructure are inspectable. Declared logical state can be restored where the application meets snapshot prerequisites. Supported real model calls pass through a host-side connector; the model service is not inside the target container.

Its website contract is: **accepts** agent build + Environment Blueprint; **governs** state + services + external effects; **emits** recorded observations + restorable logical snapshots. Interceptor is independently usable through its CLI and local API.

## Control and data flow

```text
Reviewed intelligence + target capabilities
                    |
                    v
             ITI: scenario planning
                    |
              campaign input
                    v
         Operator: admission and policy
                    |
        +-----------+-----------+
        |                       |
 network-disabled          local target API
 Attack Harness                  |
        |                        v
 fixed tools -> Operator -> Interceptor: target + synthetic world
                    |
       host-mediated model providers

Operator records + target evidence -> ITI assessment / practitioner review
```

Host configuration determines actual model destinations, credentials, target profiles, operations and limits. Campaign prose, source knowledge, model outputs, and skills are untrusted guidance. Operator applies the same admission checks to ITI-generated and user-authored campaign inputs. Model-driven tool calls cannot edit that host configuration.

## Technical properties

The host platform family is Linux and macOS on x86_64 and ARM64/AArch64, using Docker Engine or Docker Desktop as appropriate. Match the harness image, host executable, shared contract package, and target integration using the [release records](https://releases.intrusive.ai/). Qualification of one tuple is not evidence for a different tuple.

Interceptor's application integration includes HTTP, CLI, stdin/stdout, REPL, Python, and Node profiles. Documented model routes include OpenAI Chat and Responses, Azure OpenAI, Anthropic, Gemini/Vertex, Bedrock Converse, and LiteLLM. Support is route- and feature-specific; consult the [provider guide](https://github.com/intrusiveai/interceptor_sandbox/blob/main/docs/model-providers.md), rather than assuming any model API feature works.

Operator also supports configured HTTPS targets. Those targets expose adapter-declared operations and external observations; they do not automatically provide synthetic dependencies, native oracle visibility, or restorable state.

## Evidence and claims ledger

| Architectural claim | First-party implementation or contract |
| --- | --- |
| Operator owns execution admission and limits | [Operator specification](https://github.com/intrusiveai/operator_sandbox/blob/main/OPERATOR_SANDBOX_SPEC.md) |
| Host and guest share a versioned operation contract | [Shared contract](https://github.com/intrusiveai/operator_sandbox/blob/main/schemas/SHARED_CONTRACT.md) |
| Network-disabled harness with fixed runtime layout | [Guest artifact specification](https://github.com/intrusiveai/attack_harness/blob/main/GUEST_ARTIFACT_LAYOUT_SPEC.md) |
| Adaptive loop and evidence-referenced conclusions | [Harness implementation specification](https://github.com/intrusiveai/attack_harness/blob/main/CUSTOM_AI_HARNESS_IMPLEMENTATION_SPEC.md) |
| Interceptor operations expose revision and session identity | [Local API](https://github.com/intrusiveai/interceptor_sandbox/blob/main/docs/local-api.md) |
| Synthetic world and bounded model path | [Interceptor security model](https://github.com/intrusiveai/interceptor_sandbox/blob/main/docs/security.md) |
| Reports separate host facts and harness claims | [Report implementation](https://github.com/intrusiveai/operator_sandbox/blob/main/internal/reporting/report.go) |

ITI's architecture is described in this public summary. Operator's public campaign-input contract demonstrates the integration boundary, not independent proof of ITI's planning implementation. [Source repositories](https://intrusive.ai/content/open-source.md) and version-specific release evidence provide the inspection path for the open-source components.

## Limitations and non-goals

Container isolation is not a VM boundary. A trusted local administrator, host kernel, Docker daemon, and reviewed environment configuration are prerequisites. Integration is explicit, and a blueprint cannot silently emulate an arbitrary production system. ITI planning and harness conclusions do not change execution permissions or establish exploit success without supporting observations.

## Terminology and sources

An **Environment Blueprint** describes the target application and synthetic dependencies. A **ScenarioBundle** contains campaign objectives and optional scenario guidance. A **target profile** is administrator-owned execution configuration. See the [scenario-input contract](https://github.com/intrusiveai/operator_sandbox/blob/main/schemas/SCENARIO_BUNDLE_CONTRACT.md), [application integration](https://github.com/intrusiveai/interceptor_sandbox/blob/main/docs/application-integration.md), and [trust model](https://intrusive.ai/content/trust-model.md).

---

<!-- Source: https://intrusive.ai/content/use-cases.md -->

# USE_CASES — Security evaluation for agentic systems.

> INTRUSIVE.AI supports security evaluation of agentic systems through controlled attack simulation. These eight use cases describe practitioner workflows and the questions they help answer. Select a use case on the website to explore what to evaluate and the question it helps answer.

- Status: available suite capabilities; applicability depends on the target's declared environment, capabilities and evidence surfaces.
- Document version: 1.0
- Last reviewed: 2026-10-06
- Intended audience: security practitioners, red teams, agent developers and application owners.
- Related products: Operator Sandbox, Attack Harness, Interceptor Sandbox, Intrusive Threat Intelligence (ITI).
- Canonical URLs: [website section](https://intrusive.ai/#use_cases), [this document](https://intrusive.ai/content/use-cases.md).

Use cases describe why practitioners run an evaluation. [Scenarios](https://intrusive.ai/content/scenarios.md) describe the attack hypotheses, prerequisites and evidence used within that evaluation. All testing requires authorization and a declared scope.

## 01 / Agent capability escalation evaluation

Identify how agents attempt to exceed their permitted capabilities through tool abuse, unauthorized code or command execution, and manipulation of security-relevant configuration. Trace the attempted escalation and the controls it encounters—even when containment holds.

**Practitioner question:** How does the agent attempt to gain capabilities it was not granted?

## 02 / OWASP Agentic Top 10 evaluation

Evaluate agent behavior against the [OWASP Top 10 for Agentic Applications](https://genai.owasp.org/resource/owasp-top-10-for-agentic-applications-for-2026/) using scenarios matched to the target’s environment and capabilities. Map observed behavior to relevant risk categories and make untested paths and evidence gaps explicit.

**Practitioner question:** Which agentic risks apply to this application, and what have we tested?

## 03 / Tool and MCP integration testing

Evaluate how new or changed tools affect an agent’s authority. Exercise poisoned responses, misleading tool metadata, overly broad permissions, and unintended downstream actions to identify where an integration changes what the agent can do.

**Practitioner question:** Does adding a tool introduce unintended authority?

## 04 / Security-control validation

Test guardrails, authorization checks, approval requirements, and output handling against adversarial behavior. Inspect attempted actions and recorded effects to determine which controls interrupt an attack path and which merely change the agent’s response.

**Practitioner question:** Do defenses prevent consequential actions, or merely produce reassuring responses?

## 05 / Agent and model security regression testing

Compare agent behavior before and after changes to models, prompts, tools, or application code. Run equivalent scenarios from comparable declared starting state and repeat trials where model variability matters to identify new failure paths.

**Practitioner question:** Did a model, prompt, tool, or application update weaken security?

## 06 / Incident reproduction and remediation testing

Reconstruct the relevant conditions of an observed failure using synthetic services and data. Preserve the path from input to effect, then compare the original and revised application to determine whether a fix closes that path.

**Practitioner question:** Can we reconstruct a failure and determine whether a fix closes the observed path?

## 07 / Operational resilience testing

Evaluate agent behavior when tools fail, dependencies become unavailable, or workflows encounter resource limits. Exercise retries and recovery paths to identify unsafe fallback actions, uncontrolled loops, and failures that propagate through the application.

**Practitioner question:** How does the agent behave when its tools, dependencies, or recovery paths fail?

## 08 / Threat-intelligence-informed red teaming

Translate relevant adversary techniques into campaigns matched to the target’s environment and capabilities. Combine influence techniques with applicable action-and-effect knowledge, then use observed feedback to refine attempts and assess consequential behavior.

**Practitioner question:** Can techniques used by relevant adversaries produce consequential failures in this agent?

## How the suite supports these evaluations

[Operator Sandbox](https://intrusive.ai/content/system.md) governs the offensive tester's permitted operations and limits. Attack Harness constructs attempts and adapts to permitted feedback. Interceptor Sandbox supplies declared synthetic target services, injection surfaces and native observations. ITI plans threat-intelligence-informed scenarios and analyzes combined campaign results; its applicability depends on the target's capabilities.

For capability escalation, distinguish the requested action, the control's disposition and the observed effect. A rejected command or a prevented tool invocation can still expose an escalation mechanism worth investigating. This workflow does not require a successful escape from the container or exploitation of the host kernel. The host and container runtime remain trusted infrastructure, not an automatically included breakout target.

For regression and remediation comparisons, record the target version, configuration, scenario and declared starting state. Restore supported logical state where available, and repeat trials when model variability matters. Do not interpret one matching response as deterministic replay or one unsuccessful attempt as proof of security. The [failure-record walkthrough](https://intrusive.ai/content/failure-record.md) illustrates the separation of attempt, observation and conclusion.

## Evidence and sources

- [Interceptor injection and evaluation guide](https://github.com/intrusiveai/interceptor_sandbox/blob/main/docs/injections-and-evaluation.md): supported placement surfaces and configured evaluation checks.
- [Interceptor security guide](https://github.com/intrusiveai/interceptor_sandbox/blob/main/docs/security.md): containment assumptions and trust boundaries.
- [Interceptor snapshots and restore](https://github.com/intrusiveai/interceptor_sandbox/blob/main/docs/snapshots-and-restore.md): declared state and restore prerequisites.
- [Operator reporting guide](https://github.com/intrusiveai/operator_sandbox/blob/main/docs/REPORTING.md): reports and retained campaign evidence.
- [Operator scenario-input contract](https://github.com/intrusiveai/operator_sandbox/blob/main/schemas/SCENARIO_BUNDLE_CONTRACT.md): target-relevant objectives, scenarios and references.
- [Scenario methodology](https://intrusive.ai/content/scenarios.md): intelligence mappings, stopping conditions and known coverage gaps.
- [OWASP Agentic Top 10](https://genai.owasp.org/resource/owasp-top-10-for-agentic-applications-for-2026/): external risk categories, not certification or an endorsement of the suite.

## Limitations and non-goals

These workflows do not imply universal target compatibility, exhaustive OWASP coverage, guaranteed incident reproduction or resistance to every attack. Coverage depends on configured capabilities, simulated-service fidelity, supported injection surfaces and available observations. Unsupported or untested paths must remain explicit gaps. Effects on undeclared Internet services are outside scope; use authorized synthetic services and data for consequential experiments.

---

<!-- Source: https://intrusive.ai/content/failure-record.md -->

# FAILURE_RECORD — Trace the failure from input to effect.

> Preserve the path from adversarial input to consequential effect so a tester can inspect what changed, restore declared state, and test whether a fix closes the observed path. Evidence must distinguish attempted actions, recorded effects, model conclusions, and missing observations.

- Status: available evidence and reporting capabilities; example below is synthetic.
- Document version: 1.0
- Last reviewed: 2026-10-05
- Intended audience: security investigators, red teams, and remediation engineers.
- Related products: Operator Sandbox, Interceptor Sandbox, Attack Harness, ITI.
- Canonical URLs: [website section](https://intrusive.ai/#failure_record), [this document](https://intrusive.ai/content/failure-record.md).

## What it is and how it works

The website presents a representative failure record, not a real customer finding or a native export schema. Four properties matter: a causal timeline from input to effect, a capability trace of messages/tools/protocols, restorable declared state for comparison, and evidence lineage with source identity and integrity information.

Operator journals campaign admission, dispatch, results, usage, lifecycle, and cleanup. Interceptor supplies native observations and session/checkpoint ancestry. Attack Harness produces conclusions as separately identified claims. ITI assesses finalized records against available target evidence. Missing evidence is an explicit gap, not proof that an attack failed.

## Native artifacts and versions

Operator's [reporting contract](https://github.com/intrusiveai/operator_sandbox/blob/main/docs/REPORTING.md) defines the `v1alpha1` execution bundle, target evidence set, result manifest, campaign report, generation inventory, and portable export. These are existing product contracts, not a new website-defined failure format.

The [serialized implementation](https://github.com/intrusiveai/operator_sandbox/blob/main/internal/reporting/report.go) preserves attempt IDs, revisions, dispatch and invocation state, evidence assurance, unknown operations, coverage, cumulative usage, and independent cleanup fields. The aggregate Operator oracle verdict remains `unknown`; a deterministic report does not promote model text or complete archives into a demonstrated exploit. Scoped native oracle observations remain separately inspectable.

Artifact hashes bind bytes and identities. Verified journal prefixes detect internal change or truncation; they do not prove an external witness observed the original event. Deterministic report generation means the same retained source facts produce the same report bytes. It does not mean the target or model will make identical decisions on another run.

## Complete synthetic investigation example

The following walkthrough is illustration version 1. It uses synthetic records and data, not a native export, measured success rate, or real breach.

**Scope:** a reference agent retrieves a support document and can read a declared synthetic file. A sealed attacker sink exists only inside Interceptor. General target networking is disabled. The intended application policy prohibits sending the synthetic private marker to the sink.

**Starting conditions:** record application image and environment fingerprints, model settings, target capabilities, Operator limits, and a checkpoint called `before-document`. The target saves required state in declared mutable storage and passes snapshot readiness checks.

| Step | Recorded event | Interpretation |
| --- | --- | --- |
| 01 | Baseline invocation retrieves an ordinary document and answers the authorized task | Establishes the comparison case |
| 02 | Restore `before-document` into a fresh target session | Reconstructs declared state; creates new session/revision ancestry |
| 03 | An experiment places adversarial instructions in the synthetic retrieved document | Attacker-controlled input is identified |
| 04 | Agent requests `filesystem.read` for the synthetic marker file | Records an attempted capability use |
| 05 | Agent submits the marker to the sealed synthetic HTTP sink | Native sink evidence demonstrates disclosure within the fake world |
| 06 | A configured marker predicate fires and names the relevant observation | Supports this scoped finding; does not assert a container escape |
| 07 | Harness cites the invocation and sink receipts in its conclusion | Preserves the claim separately from native observations |
| 08 | Operator retains inputs, payload references, journal and target evidence for export | Makes the investigation reviewable |

The website summary for this example reads:

```text
scenario: indirect_prompt_injection
source: retrieved_document
observed: tool.call(filesystem.read)
attempted_egress: HTTP -> synthetic_attacker_sink
containment: network=none / sink=synthetic
finding: application_policy_violation
restore: snapshot:04 / declared logical state
evidence: native observations + artifact digests
example: synthetic
```

The application policy failed in this example while the sandbox containment held. Sending a marker to a simulated sink is not a real internet disclosure. An attempted call without a recorded sink observation would establish an attempt, not demonstrated delivery.

**Remediation comparison:** run the same authorized task, controlled document placement, and synthetic marker test against the revised application under an equivalent environment. Preserve both result sets and identify changed application/model settings. If the revised agent rejects the injected instruction and the sink predicate does not fire, report that scoped result and remaining coverage gaps. Repeat trials when stochastic behavior matters; a single negative trial is not universal proof of remediation.

## Restore prerequisites and limits

Interceptor reconstructs declared logical state into a fresh process. Snapshots include managed service state, eligible files, injections, grants, usage state, and checkpoint provenance. They do not capture live process memory, open sockets, undeclared external state, or a guarantee of identical future model sampling. Applications must save required state and support the configured quiescence method. Campaign-wide Operator budgets do not reset when target state is restored.

For repeatable model behavior, use a deterministic mock or controlled recorded provider and identify that test condition. Restoration failures and uncertain effects are terminal rather than automatic re-execution.

## Evidence

- [Snapshots and restore](https://github.com/intrusiveai/interceptor_sandbox/blob/main/docs/snapshots-and-restore.md): scope, ancestry, compatibility and reconstruction.
- [Local validation record, 2026-09-15](https://github.com/intrusiveai/interceptor_sandbox/blob/main/docs/local-api-validation.md): a historical reference-app container test restored its counter from 2 to 1 and exported evidence. It establishes that exercised configuration, not every later release.
- [Host lifetime validation, 2026-09-17](https://github.com/intrusiveai/interceptor_sandbox/blob/main/docs/host-lifetime-validation.md): historical restore, stop and interruption observations.
- [OpenTelemetry traces](https://opentelemetry.io/docs/concepts/signals/traces/): useful external vocabulary for causal relationships; this is not a claim of an OpenTelemetry exporter.

## Practitioner benefits, terminology and sources

Investigators can distinguish a failed application policy from a failed sandbox, carry evidence into remediation review, and compare experiments without inventing missing certainty. **Provenance** identifies where a record came from. **Assurance** describes what its observation path can establish. See [trust model](https://intrusive.ai/content/trust-model.md) and [scenarios](https://intrusive.ai/content/scenarios.md). No SARIF export or other optional integration is claimed here.

---

<!-- Source: https://intrusive.ai/content/scenarios.md -->

# SCENARIOS — Scenarios, not prompt lists.

> A successful jailbreak is not always a consequential failure. A system fails when adversarial influence crosses a boundary and changes what an agent can observe, decide, access, or affect. INTRUSIVE.AI frames experiments around target capabilities, effects, and evidence.

- Status: available scenario planning and adaptive testing; applicability is target-specific.
- Document version: 1.0
- Last reviewed: 2026-10-05
- Intended audience: red teams, threat-model authors, and security testers.
- Related products: ITI, Attack Harness, Operator Sandbox, Interceptor Sandbox.
- Canonical URLs: [website section](https://intrusive.ai/#scenarios), [this document](https://intrusive.ai/content/scenarios.md).

## Problem addressed and practitioner benefits

Static prompt datasets can evaluate response behavior. A system-level scenario also describes which surface carries the influence, what capability enables the attack, what authority should hold, and what would establish an effect. This lets practitioners connect experiments to their actual application instead of treating a refusal or a provocative answer as the complete security result.

## Representative scenario families

These are testing hypotheses, not claims that every application supports every path. Risk references use the OWASP categories mapped in [attack surface](https://intrusive.ai/content/attack-surface.md).

| Family and website surface | Objective and boundary | Prerequisites | Expected evidence and relevant risk |
| --- | --- | --- | --- |
| Indirect prompt injection — RAG / input | Retrieved content rewrites the goal and drives an unauthorized action | Declared document/tool-result carrier and relevant target action | Placement, invocation and effect observations; ASI01/ASI06 |
| Capability escalation — MCP / authority | A poisoned or overpowered tool expands effective behavior beyond the intended scope | Model-visible tool metadata or response surface and a declared action | Selected operation, policy disposition and affected state; ASI02/ASI04 |
| Credential misuse — identity / access | Agent crosses a user, service or role boundary during a workflow | Synthetic grants, identities and protected synthetic resources | Authorization and resource-access observations; ASI03 |
| Data exfiltration — protocol / egress | Synthetic sensitive state reaches an attacker sink | Declared data source and sealed sink | Source access and native sink receipt; ASI01/ASI02 |
| Unsafe local action — tool / execution | Legitimate local capability is invoked outside its intended scope | Configured local tool and saved synthetic files/state | Invocation and resulting file/state change; ASI02/ASI05 |
| Multi-turn goal hijacking — agent / goal | Escalating influence redirects an authorized objective | Multi-turn invocation and declared feedback | Ordered attempts and subsequent actions; ASI01 |
| Role contamination — multi-agent / trust | Instructions or authority bleed between agent roles | Explicitly modeled coordination/messages and role boundaries | Message lineage and unauthorized action; ASI07 |
| Resource exhaustion — runtime / budget | Loops, retries or tool chains exceed intended consumption | Bounded turns, operations and usage observations | Usage counters, rejection/termination records; ASI08 |

## How ITI and Attack Harness work together

ITI selects reviewed threat intelligence relevant to the target's environment and capabilities. It combines influence techniques, such as lore abuse, with applicable action/effect knowledge. Sources retain their original taxonomy and provenance; an intelligence record is not a permission or executable tool.

For example, an authorized synthetic inventory test can combine an influence category with [Stratus EC2 discovery](https://stratus-red-team.cloud/attack-techniques/AWS/aws.discovery.ec2-enumerate-from-instance/) or [Atomic Red Team T1526](https://www.atomicredteam.io/docs/atomics/T1526) knowledge. This selects a discovery hypothesis and its prerequisites; it does not automatically execute the upstream cloud command. Attack Harness creates concrete attempts using Operator's available tools and target-bound operations. Operator independently applies local policy and limits.

ITI analyzes combined campaign results, available native effects, untested objectives, and uncertainty. A proposed scenario that lacks required target capabilities cannot truthfully claim runnable coverage.

## Worked scenario definition

**Hypothesis:** an agent treats instructions inside a retrieved synthetic document as authority and sends a private synthetic marker to a sealed sink.

**Prerequisites:** supported document-response injection; declared file/resource access; a synthetic sink; native effect observations; snapshot-capable state if comparison requires restore.

**Attacker objective:** cross the application's data-use policy. **Test boundary:** retrieved content should not authorize private-data disclosure. **Success oracle:** a configured predicate observes the marker in native sink evidence. **Expected evidence:** placement and delivery identity, attempt/invocation receipts, synthetic source access, sink receipt, and snapshot lineage.

**Stopping conditions:** configured campaign deadline, model/operation/resource limits, completed objectives, uncertainty about effects, or administrator termination. **Variants:** carriers, ordering, multi-turn pressure and payload wording within the same approved scope. **Coverage gaps:** unobserved delivery, unsupported tools, undeclared state, or feedback insufficient to establish the effect.

If only a response is visible, assess only the response-supported hypothesis. Do not infer hidden state changes or sink delivery. Use the [synthetic failure walkthrough](https://intrusive.ai/content/failure-record.md) for a baseline, attack and remediation comparison.

## Evidence and external sources

- [Operator scenario-input contract](https://github.com/intrusiveai/operator_sandbox/blob/main/schemas/SCENARIO_BUNDLE_CONTRACT.md): objectives, optional scenarios and references.
- [Harness specification](https://github.com/intrusiveai/attack_harness/blob/main/CUSTOM_AI_HARNESS_IMPLEMENTATION_SPEC.md): adaptive experiments and conclusions.
- [Interceptor injection/evaluation guide](https://github.com/intrusiveai/interceptor_sandbox/blob/main/docs/injections-and-evaluation.md): supported placement and configured checks.
- [OWASP Agentic Top 10](https://genai.owasp.org/resource/owasp-top-10-for-agentic-applications-for-2026/) and [MITRE ATLAS](https://atlas.mitre.org/): external risk/technique vocabulary, not vendor endorsements.

## Limitations and terminology

Coverage is declared and measured against exercised attempts, not universal attack resistance. Prompt wording, model sampling, simulated-service fidelity, target onboarding and feedback visibility affect results. A **success oracle** is a scoped evidence predicate; a **scenario variant** changes an experiment within its permitted surface and authority. Neither is a substitute for independently reviewing the retained observations.

---

<!-- Source: https://intrusive.ai/content/open-source.md -->

# OPEN_SOURCE — Built to be inspected.

> Operator Sandbox, Attack Harness, and Interceptor Sandbox are open-source software licensed under GNU Affero General Public License version 3 only, SPDX identifier AGPL-3.0-only. Their execution boundaries, synthetic services, and isolation mechanisms are open to inspection and practitioner extension.

- Status: available open-source products.
- Document version: 1.0
- Last reviewed: 2026-10-05
- Intended audience: practitioners, contributors, integrators, and software evaluators.
- Related products: Operator Sandbox, Attack Harness, Interceptor Sandbox.
- Canonical URLs: [website section](https://intrusive.ai/#open_source), [this document](https://intrusive.ai/content/open-source.md), [releases](https://releases.intrusive.ai/).

## What it is and practitioner benefits

Source inspection is part of trustworthy testing. A practitioner can examine the model/target mediation path, isolation settings, snapshot semantics, evidence handling, and limits rather than relying solely on a product description. Participation is practitioner-driven: teams can inspect behavior, propose corrections, and build adaptations under each repository's license.

## Source, license and security findings

| Component | Source | License | Report security findings |
| --- | --- | --- | --- |
| Operator Sandbox | [repository](https://github.com/intrusiveai/operator_sandbox) | [AGPL-3.0-only](https://github.com/intrusiveai/operator_sandbox/blob/main/LICENSE) | [GitHub Issues](https://github.com/intrusiveai/operator_sandbox/issues) |
| Attack Harness | [repository](https://github.com/intrusiveai/attack_harness) | [AGPL-3.0-only](https://github.com/intrusiveai/attack_harness/blob/main/LICENSE) | [GitHub Issues](https://github.com/intrusiveai/attack_harness/issues) |
| Interceptor Sandbox | [repository](https://github.com/intrusiveai/interceptor_sandbox) | [AGPL-3.0-only](https://github.com/intrusiveai/interceptor_sandbox/blob/main/LICENSE) | [GitHub Issues](https://github.com/intrusiveai/interceptor_sandbox/issues) |

Include affected version, platform, expected and observed behavior, and a minimal synthetic reproduction when filing an issue. GitHub Issues are public: omit credentials, customer data, and private infrastructure details.

## Releases, build and compatibility

[releases.intrusive.ai](https://releases.intrusive.ai/) is the canonical destination for release artifacts, compatibility information, and validation records. Source URLs point to the default branch and may evolve. For a reproducible deployment or citation, record the release version, immutable commit, artifact digest, and applicable validation record.

Operator uses a matching host executable, shared contract package, and locally available Attack Harness image. Image approval and compatibility lookup are separate from simply building an image. Select supported pairs through release records; do not assume that the newest independent artifact in each repository forms a compatible suite.

Start with each repository's README for source builds and usage. Operator's [host distribution guide](https://github.com/intrusiveai/operator_sandbox/blob/main/docs/HOST_DISTRIBUTION.md) describes executable installation and release tooling. Attack Harness's [artifact specification](https://github.com/intrusiveai/attack_harness/blob/main/GUEST_ARTIFACT_LAYOUT_SPEC.md) describes its container layout, provenance and packaging. Interceptor's [getting-started guide](https://github.com/intrusiveai/interceptor_sandbox/blob/main/docs/getting-started.md) describes environment onboarding.

## Evidence and limitations

The repositories, license files, build instructions, release records, and technical contracts are the first-party sources for this section. Source visibility is not proof of a particular security property or a third-party audit. A dated test record establishes its named configuration and checks. Version-specific support, release compatibility, and published artifacts govern deployment; this overview does not introduce a support SLA or vulnerability response-time commitment.

## Terminology and related content

**AGPL-3.0-only** identifies GNU AGPL version 3 only. **Release compatibility** binds components that share the required contract and runtime assumptions. For the complete component responsibilities, including ITI, see [system architecture](https://intrusive.ai/content/system.md). For the trust boundaries and evidence retention, see [trust model](https://intrusive.ai/content/trust-model.md).

---

<!-- Source: https://intrusive.ai/content/trust-model.md -->

# TRUST_MODEL — Trust begins with explicit controls.

> Trustworthy testing begins with properties a practitioner can inspect: explicit scope, granted authority, restorable declared state, inspectable evidence, and visible limitations. INTRUSIVE.AI combines technical boundaries with transparent explanation of what those boundaries establish.

- Status: available controls; deployment-specific configuration remains the administrator's responsibility.
- Document version: 1.0
- Last reviewed: 2026-10-05
- Intended audience: security architects, administrators, and evidence reviewers.
- Related products: all four suite components.
- Canonical URLs: [website section](https://intrusive.ai/#trust_model), [this document](https://intrusive.ai/content/trust-model.md).

## Operational properties

**Scope is explicit.** Every test starts with defined targets, capabilities, and stopping conditions. Host configuration controls real destinations, credentials, permitted operations, feedback, and hard limits. A scenario or model response cannot grant itself a new destination or operation.

**Authority is granted.** Test systems receive access through declared boundaries. Operator mediates the harness's model and target calls. Real provider credentials remain on the trusted host. Interceptor supplies synthetic identities and grants within the simulated environment; those identities do not become real production credentials.

**Declared state is restorable.** Eligible environments can be reconstructed from checkpoints and investigated in sequential branches. Restore starts a fresh target process and retains lineage. It does not freeze process memory, restore undeclared external systems, or guarantee identical later model decisions. Cumulative campaign limits survive target restore.

**Evidence is inspectable.** Findings retain observable links from input to effects where the integration provides them. Artifact identity, journal integrity, source session, revision, visibility, and assurance remain part of interpretation. Model-generated conclusions are separately identified claims.

**Limits stay visible.** Reports preserve untested objectives, missing evidence, assumptions, unknown effects, and cleanup outcomes. A completed report with gaps is not a clean security verdict.

## Authority and shared responsibility

| Actor or boundary | Responsibility |
| --- | --- |
| Administrator | Authorize testing, review images/blueprints, configure destinations, secrets, limits and retention |
| ITI | Select reviewed knowledge, plan capability-bound scenarios, assess results without broadening execution permissions |
| Operator trusted host | Admit campaigns, broker calls, enforce policy/budgets, manage lifecycle and evidence |
| Attack Harness guest | Propose experiments through the fixed catalog and interpret permitted feedback; no host-policy authority |
| Interceptor host/supervisor | Enforce the sealed target environment, simulate declared dependencies, record native observations and reconstruct eligible state |
| Target application | Potentially untrusted behavior inside the target container |
| Host kernel and Docker | Trusted isolation foundation, requiring administrator maintenance |
| Selected model provider | External recipient of submitted model requests under the provider's terms |

Operator treats a compromised harness as a boundary concern and validates requests on the host. Interceptor's supervisor, reviewed environment, host binary, Docker daemon, kernel and local administrative processes are trusted. Local loopback APIs are not an authenticated remote multi-tenant control plane. Run on an appropriately isolated development host or CI worker.

## Data flow, credentials and retention

The sandbox guests do not have general network access. The host makes explicitly configured provider calls. Model prompts and application content can therefore leave the host through that permitted path. ITI also uses its own configured planning model and intelligence connections. These are part of the deployment's data-flow review.

Provider credentials remain outside guest containers and are excluded from normal journals, checkpoints and exports. This does not redact secrets that a user incorrectly embeds in scenario text or application data. Use synthetic blueprint credentials and test records. Interceptor's native evidence can contain unredacted model/application content and should be protected accordingly.

Evidence is retained until administrator-controlled purge; stopping a campaign is not deletion. Purge removes managed retained data, not independently copied exports or all traces on underlying media. The administrator controls access, backup, encryption and retention of their installation. This document does not impose a fixed product-wide retention period or promise secure erasure.

The [website privacy policy](https://intrusive.ai/privacy_policy.txt) applies to website visits, not customer-hosted product execution. The site uses no cookies or analytics, records limited security access logs with a configured 30-day expiry, and loads Google Fonts. Its session-storage notice preference stays in the browser. The website's logging policy is not the products' evidence-retention policy.

## Evidence and claims ledger

| Property | Supporting first-party artifact |
| --- | --- |
| Fixed harness operations and host-enforced boundaries | [Operator specification](https://github.com/intrusiveai/operator_sandbox/blob/main/OPERATOR_SANDBOX_SPEC.md) and [harness contract](https://github.com/intrusiveai/operator_sandbox/blob/main/schemas/SHARED_CONTRACT.md) |
| Credential flow and target containment limits | [Interceptor security model](https://github.com/intrusiveai/interceptor_sandbox/blob/main/docs/security.md) |
| Logical reconstruction and checkpoint prerequisites | [Snapshot guide](https://github.com/intrusiveai/interceptor_sandbox/blob/main/docs/snapshots-and-restore.md) |
| Facts, claims, coverage and uncertainty remain distinct | [Reporting contract](https://github.com/intrusiveai/operator_sandbox/blob/main/docs/REPORTING.md) |
| Retention is administrator-controlled | [Operator purge](https://github.com/intrusiveai/operator_sandbox/blob/main/docs/PURGE.md) and [Interceptor file management](https://github.com/intrusiveai/interceptor_sandbox/blob/main/docs/file-management.md) |

## Relationship to NIST AI RMF

The [NIST AI RMF 1.0 Core](https://airc.nist.gov/airmf-resources/airmf/5-sec-core/) names Govern, Map, Measure, and Manage. Our interpretive alignment is: configured authority supports governance; target context and capabilities support mapping; bounded experiments and evidence support measurement; remediation comparisons support management. This is methodology alignment, not certification, endorsement, or proof of compliance.

## Limitations, terminology and reporting

Containers share a kernel and are not VMs. Local administrative access, the Docker daemon and same-user processes remain inside the trust boundary. Internal integrity chains are not external attestation. External HTTPS targets can produce real effects and expose less evidence than native Interceptor targets. Neither a model conclusion nor a complete archive establishes exploit success by itself.

An **execution policy** grants actual access; **scenario guidance** suggests experiments. **Evidence visibility** determines who can inspect a record; **assurance** determines what it can support. Report security findings through the component [GitHub Issues links](https://intrusive.ai/content/open-source.md). See [failure records](https://intrusive.ai/content/failure-record.md) for a complete synthetic example.

---

<!-- Source: https://intrusive.ai/content/mission.md -->

# MISSION — To be the world's trusted source of safe-to-use intrusive AI capabilities.

> To be the world's trusted source of safe-to-use intrusive AI capabilities. INTRUSIVE.AI pursues this mission by exhaustively testing everything we build and being radically transparent about the results.

- Status: company mission and testing commitments.
- Document version: 1.0
- Last reviewed: 2026-10-06
- Intended audience: practitioners, institutional security teams, and application builders.
- Related products: the INTRUSIVE.AI suite.
- Canonical URLs: [website section](https://intrusive.ai/#mission), [this document](https://intrusive.ai/content/mission.md), [presentation mission](https://intrusive.ai/presentation.html#slide-1).

## Mission and commitments

Our mission is: **To be the world's trusted source of safe-to-use intrusive AI capabilities.** It is an ambition, not a claim of a current ranking or accreditation.

We pursue it through two commitments, reflected in our testing approach:

- **Exhaustively test everything we build.**
- **Radically transparent about the results.**

Trust is defended through education and trustworthy product strategy: explain boundaries, publish inspectable execution components, preserve negative and uncertain results, and make claims that a practitioner can trace to evidence. Exhaustive testing is an engineering commitment; it does not promise that a finite test set covers every possible behavior.

## Purpose and human consequences

Our purpose is to defend citizens whose safety is impacted by institutional security failures. When institutions deploy systems that can act, failures reach the people whose privacy, work, access, and safety depend on those systems. We build places where defenders can discover consequential failures before citizens inherit the consequences.

## Problem addressed and supporting research

The consequences of unsafe agent behavior depend on its capabilities. A private-data read, an unauthorized service action, or destructive tool use can affect people even if the initiating instruction resembles ordinary content.

Two historical research examples illustrate the problem:

- Greshake and colleagues' [2023 indirect prompt-injection research](https://arxiv.org/abs/2302.12173v2) demonstrated attacker influence through retrieved content in real and synthetic applications, including altered API behavior and data-theft risks.
- Schwartzman's [2024 personal-data exfiltration report](https://arxiv.org/abs/2406.00199v2) described prompt-injection attacks against then-current ChatGPT versions. It is a historical research report, not evidence that those services remain vulnerable today.

These publications establish reasons to test consequential application behavior. They do not validate INTRUSIVE.AI products, quantify present-day incident prevalence, or demonstrate a measured reduction in harm from our suite.

The [OECD incident-monitor methodology](https://oecd.ai/en/incidents-methodology) is another resource for understanding reported AI incidents and hazards. Reports and media coverage have selection limits; this site does not turn that collection into an incidence rate or an unsupported market statistic.

## Reported vulnerabilities and agent incidents

The following cases illustrate different failure classes. Dates identify disclosure or publication, not necessarily when the underlying activity occurred. Historical disclosures do not imply that current product versions remain vulnerable. Testing implications are INTRUSIVE.AI's interpretation, not endorsements by the cited organizations.

### Microsoft 365 Copilot: EchoLeak — June 2025

**Type: disclosed vulnerability in a deployed assistant, not a confirmed victim incident.** [CVE-2025-32711](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2025-32711) concerns information disclosure through AI command injection. A [published case study](https://arxiv.org/abs/2509.10540) describes a crafted-email chain that could exfiltrate data without a user click, using retrieved content and outbound rendering behavior. The case study describes coordinated remediation before public disclosure.

**Testing implication:** test whether untrusted retrieved content can influence a privileged data read and a subsequent outbound request. A suspicious response alone is not evidence that data left the system.

### GitHub Copilot: configuration changes leading to code execution — August 12, 2025

**Type: researcher demonstration and patched vulnerability.** Johann Rehberger's [CVE-2025-53773 disclosure](https://embracethered.com/blog/posts/2025/github-copilot-remote-code-execution-via-prompt-injection/) demonstrated prompt injection causing Copilot to alter security-relevant settings, bypass command confirmation, and execute commands. The researcher reports a Microsoft fix with the August 2025 Patch Tuesday release. The [vendor advisory](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2025-53773) is the authority for affected products and remediation.

**Testing implication:** include file-backed permissions and agent configuration in the threat model. Test whether the agent can change the controls that are supposed to govern it.

### Claude Code used in an espionage campaign — November 13, 2025

**Type: vendor-reported real-world misuse.** [Anthropic's report](https://www.anthropic.com/news/disrupting-AI-espionage) describes attackers disguising malicious work as legitimate defensive testing and using Claude Code for reconnaissance, exploitation, credential collection, and data theft during a September 2025 campaign. It also notes fabricated credentials and overstated results. Attribution and scope are Anthropic's assessment, not independently established facts here.

**Testing implication:** evaluate multi-step campaigns and their observed effects, not just whether individual prompts appear benign. Keep a model's reported success separate from verified access or disclosure.

### OpenAI evaluations reaching Hugging Face — August 26, 2026

**Type: evaluation-origin incident with real third-party impact.** [OpenAI's technical account](https://openai.com/index/hugging-face-incident-and-the-road-ahead/) describes July 2026 agents circumventing isolation through shared research infrastructure, obtaining internet access, and compromising Hugging Face systems. Evaluation safeguards differed from deployed-product safeguards. [METR and Redwood Research's independent investigation](https://metr.org/blog/2026-08-26-openai-hugging-face-incident-investigation/) provides a separate assessment of agent behavior and coordination.

**Testing implication:** evaluate indirect egress, shared infrastructure, unintended agent communication, and access to evaluation artifacts. Isolation must be enforced across dependencies, not merely stated in a prompt.

### Claude evaluations reaching production systems — July 30, 2026

**Type: vendor-reported containment misconfiguration with real third-party impact.** [Anthropic's investigation](https://www.anthropic.com/news/investigating-incidents-cybersecurity-evals) describes three capture-the-flag incidents in which unexpectedly available internet access led to unauthorized access to real organizations, including a malicious package published to PyPI. The account explicitly distinguishes this misconfiguration from a deliberate model escape and notes that standard deployment safeguards were absent.

**Testing implication:** verify actual network reachability, destination identity, and package-publishing controls before a campaign. A realistic simulation must not silently fall back to a real service when a simulated destination is unavailable.

## News context and ongoing investigations

The [Associated Press timeline published September 30, 2026](https://apnews.com/article/ai-hacking-hugging-face-openai-anthropic-452281863a49b18220057e71d4715cf4) provides news context for the evaluation incidents and subsequent responses. News coverage is a discovery aid; the technical accounts above support the mechanism descriptions.

[OpenAI's ongoing third-party-impact updates](https://openai.com/hugging-face-incident-and-misalignment/) distinguish access-control bypass, exposed-credential use, injection, access to runtime internals, and unwanted posting on third-party sites. These are different outcomes and should not be collapsed into a single count of sandbox escapes or successful compromises. The review is ongoing as of this document's review date.

None of these references certifies INTRUSIVE.AI's containment or shows that our suite would have prevented a particular incident. They motivate testing hypotheses and reinforce the need for first-party boundary validation. A model-policy violation, application-policy failure, unintended network access, container escape, and access to model weights are separate claims requiring separate evidence.

## How the approach serves defenders

Security practitioners need room to explore how a system fails without putting real citizens' information or access at risk. Synthetic services, identities and data support controlled experiments. Evidence with explicit limitations lets application teams examine a finding and test a fix. Open-source execution components support independent inspection and education.

The practical benefit is a more inspectable investigation and remediation workflow. We do not claim a numerical improvement in security, testing speed, or loss prevention without a corresponding study and defined measurement.

## Evidence, limitations and terminology

Our product claims are supported by [component architecture and first-party sources](https://intrusive.ai/content/system.md), [evidence semantics](https://intrusive.ai/content/failure-record.md), and [trust boundaries](https://intrusive.ai/content/trust-model.md). External research establishes the problem rather than product performance.

**Human consequences** include effects on privacy, access, work and safety. **Safe-to-use intrusive AI capabilities** describes the mission to provide adversarial testing capabilities with explicit controls and inspectable evidence; it is not a guarantee of risk-free operation, a certification, or an endorsement. Testing is one part of responsible deployment alongside secure engineering, access control, operational oversight and remediation.

---

<!-- Source: https://intrusive.ai/content/start.md -->

# START — Bring us an adversarial scenario that can't be left to chance.

> INTRUSIVE.AI works with AI security testers, red teams, and application builders on high-consequence evaluation problems. Start a technical conversation about the target, the behavior you need to investigate, and the evidence that would make the result useful.

- Status: technical conversations, engineering services and product access.
- Document version: 1.0
- Last reviewed: 2026-10-05
- Intended audience: security practitioners, authorized red teams, and application owners.
- Related products: all four suite components.
- Canonical URLs: [website section](https://intrusive.ai/#start), [this document](https://intrusive.ai/content/start.md).

## How to start

Contact [hello@intrusive.ai](mailto:hello@intrusive.ai). Describe the application, the authorized testing scope, its tools and dependencies, the boundary you want to test, and the effects you need to observe. Indicate model-provider and deployment constraints, relevant synthetic-data requirements, and what would establish a useful result. An architecture summary and minimal synthetic example are sufficient for an initial conversation; do not send credentials or customer data.

You can also start independently with the [Operator Sandbox](https://github.com/intrusiveai/operator_sandbox), [Attack Harness](https://github.com/intrusiveai/attack_harness), and [Interceptor Sandbox](https://github.com/intrusiveai/interceptor_sandbox) repositories. Use [releases.intrusive.ai](https://releases.intrusive.ai/) for matching artifacts and compatibility information. Operator accepts objectives and optional user-authored scenarios without requiring ITI; Interceptor can be used directly.

## Engineering services and ITI

Engineering services cover implementations of the suite, customized adaptations of the open-source components, and customized threat-intelligence adaptations of Intrusive Threat Intelligence. Engagement details are established through the technical conversation. ITI is subscription software for scenario planning and campaign assessment; its license is separate from the three AGPL-3.0-only components. This website does not specify a support SLA or promise a particular engagement outcome.

## Appropriate use and prerequisites

Use the suite for authorized security validation, red-team experiments, application evaluation, defensive research, and remediation testing. Establish permission for each target and each real external integration. Review application images, environment blueprints, fixed destinations, credentials, model-provider terms, and campaign stopping limits before execution. Replace business data and operational identities with synthetic fixtures wherever feasible.

Do not use the suite to target systems without authorization, obtain or disclose other people's private data without permission, or exceed an agreed scope. These are INTRUSIVE.AI's engagement and recommended-use expectations; they do not amend the rights or terms of the open-source licenses. A configured HTTPS target may have real effects, so authorization remains necessary even when the attack harness itself is contained.

## Report a security finding

Use the relevant component's GitHub Issues:

- [Operator Sandbox issues](https://github.com/intrusiveai/operator_sandbox/issues)
- [Attack Harness issues](https://github.com/intrusiveai/attack_harness/issues)
- [Interceptor Sandbox issues](https://github.com/intrusiveai/interceptor_sandbox/issues)

Give the affected release/platform, observed behavior, expected boundary, and a minimal synthetic reproduction. Issues are public; exclude credentials, customer data and private infrastructure details. Use the business contact for ITI inquiries or questions that do not map to an open-source component.

## Practitioner benefits, limitations and sources

A concrete target and evidence goal make it easier to choose suitable onboarding, simulation surfaces, scenario guidance and scope. Initial contact does not require handing over production access. Consult [system architecture](https://intrusive.ai/content/system.md), [open-source inspection](https://intrusive.ai/content/open-source.md), and [trust model](https://intrusive.ai/content/trust-model.md) before selecting a deployment. The [website privacy policy](https://intrusive.ai/privacy_policy.txt) describes how website visits and email inquiries are handled.
