# 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).
