# Set up Operator

Install the complete Go-based Operator package, make a compatible Attack Harness
image available to local Docker, and configure private model and target profiles.
A development Go binary alone does not supply the installed contract package.

## Select packages and an execution account

Start at [official releases](https://releases.intrusive.ai) and
[Operator releases](https://github.com/intrusiveai/operator_sandbox/releases).
Choose the release selected in this documentation and your platform: `linux` or
`darwin`, and `amd64` or `arm64`. Use a matching local Docker runtime and images.

On macOS, use the logged-in Docker Desktop account, not root. On Linux, use the
dedicated Operator account described below. Foreground campaigns need no service
manager. Remote Docker and cross-architecture emulation are outside this workflow.

Follow [Attack Harness setup](https://docs.intrusive.ai/pages/versions/attack_harness/0.1.5/guides/setup.html)
for image acquisition; select its installed release if different from that linked
example. Operator does not pull images automatically. The shared contract version
and exact document digest must match. Interceptor has a separate OpenAPI version
and digest checked by Operator before target attachment.

## Verify and install an archive

Download the archive and matching checksum into a private staging directory.
From there, replace `YOUR_OPERATOR_VERSION` with the selected release number
without the leading `v`. This example uses macOS ARM64:

```sh
OPERATOR_VERSION=YOUR_OPERATOR_VERSION
PLATFORM=darwin_arm64
shasum -a 256 --check "operator_sandbox-v${OPERATOR_VERSION}-${PLATFORM}-SHA256SUMS"
umask 077
mkdir operator-staging
tar -xzf "operator_sandbox-v${OPERATOR_VERSION}-${PLATFORM}.tar.gz" -C operator-staging
./operator-staging/operator_sandbox/bin/operatorctl release check --directory ./operator-staging/operator_sandbox
```

On Linux, select `linux_amd64` or `linux_arm64` and use `sha256sum --check`.
Continue only after checks succeed. Preserve the complete package and `contract/`.

Linux requires a separate administrator provisioning step:

```sh
sudo /absolute/staging/operator_sandbox/bin/operatorctl install provision-linux --grant-docker-access
```

The flag grants the service account access to the local Docker daemon. Complete
installation as that account using an archive and staged executable it can read.
On macOS, use the current account. Set `HARNESS_IMAGE` to the local image reference
chosen in Attack Harness setup:

```sh
./operator-staging/operator_sandbox/bin/operatorctl install \
  --archive "$PWD/operator_sandbox-v${OPERATOR_VERSION}-${PLATFORM}.tar.gz" \
  --image "$HARNESS_IMAGE"
```

Use the installation receipt's executable path and add it to PATH. Default roots
are `/opt/operator` on Linux and
`~/Library/Application Support/Operator/installation` on macOS. Upgrades use the new
staged installer and preserve configuration and retained campaigns.

## Configure host settings

Default config locations are `/etc/operator/config.yaml` on Linux and
`~/Library/Application Support/Operator/config/config.yaml` on macOS. Keep files
private, normally `0600`, owned by the executing account or root. Paths inside the
configuration are absolute and literal: no `~` or environment-variable expansion.

Keep installer-generated settings and configure the existing fields:

| Setting | Purpose |
| --- | --- |
| `engine.image` | Locally available Attack Harness image. |
| `contract.directory`, `version`, `digest` | Complete installed contract and exact interface identity. |
| `model.profile_file` | Private model-provider profile for Attack Harness. |
| `target.profile_file` | Optional default target profile; an environment directory can select one explicitly. |
| `docker.endpoint` | Intended local daemon, independent of incidental shell contexts. |
| `state.root` | Retained private campaign state. |
| `limits` | Installed ceilings that bundle requests can only narrow. |

Use templates from the selected release. Unknown fields fail validation; do not
create duplicate YAML sections when merging configuration fragments.

## Configure the campaign model

The model profile controls **Attack Harness's** model. Interceptor separately
configures the target agent's generation and embeddings.

Use [Model and credential providers](model-and-credential-providers.md) for the
complete provider matrix, native API configuration, cloud identities, and secret
stores. Provider credentials are resolved on the host and are never made available
to the Attack Harness container. Supported stores include AWS Secrets Manager,
Azure Key Vault, Google Cloud Secret Manager, HashiCorp Vault, and 1Password.

Copy the release's `release/templates/model-profile.json`. For the OpenAI
Chat example, select an available tool-capable model, `authentication: api-key-env`,
and `api_key_env` naming an already configured host variable; remove `credential_id`.
The endpoint is the complete operation URL,
`https://api.openai.com/v1/chat/completions`, not a provider base URL. Profiles
contain variable names or credential references, never keys.

For stored keys or direct cloud identity, follow the
[authentication and credential configuration](model-and-credential-providers.md#select-model-authentication).
Choose prompt/completion allowances that fit the model and campaign budget.
Oversized per-call reservations can leave insufficient budget for exploration
and final assessment. Token ceilings are not currency spending guarantees.

## Verify and connect a target

```sh
operatorctl version
operatorctl config check
operatorctl doctor
```

Use `--config /absolute/private/config.yaml` for another configuration. These checks
verify local prerequisites, not live model access or a successful target operation.

Complete [Interceptor setup](https://docs.intrusive.ai/pages/versions/interceptor_sandbox/0.1.5/guides/setup.html),
then [prepare a campaign](campaigns.md). The upstream
[installation guide](https://github.com/intrusiveai/operator_sandbox/blob/v0.1.5/docs/HOST_DISTRIBUTION.md)
has account and upgrade details; choose your installed tag for release-specific steps.
