# Bring your agent into Interceptor

Start with a legitimate application interaction. Your first goal is to make that
interaction work inside the synthetic environment with the dependencies it actually
uses. Container startup alone does not establish a faithful test target.

## Inspect the application boundary

Identify the source revision, entry point, invocation inputs/outputs, trusted caller
identity, state between turns, and required dependencies. Inventory databases,
HTTP/MCP APIs, generation and embedding providers, files, caches, and native logging.
Separate static fixture data from state that must change during execution.

| Existing application boundary | Interceptor interface |
| --- | --- |
| HTTP server | `http`, with declared method/path operations and optional health path. |
| CLI invoked once per request | `command`, with argument bindings and stdin/output settings. |
| Long-running line protocol | `stdio`, with explicit completion framing. |
| Interactive terminal program | `repl`, with prompt/terminal detection. |
| Python or Node application API | `code`, optionally using a small sealed invocation adapter. |
| Existing supported adapter | `external`, with its declared protocol and configuration. |

Use the application's natural interface. It does not need an HTTP server solely to
run inside Interceptor. Exact options are in the selected release's
[application-interface reference](https://github.com/intrusiveai/interceptor_sandbox/blob/v0.1.5/docs/application-interfaces.md).

## Package the application

Reuse its Dockerfile and dependency lockfile where suitable. Install the runtime,
application, libraries, and any required tokenizer resources while building the
image. Do not depend on package installation or downloads at isolated startup.
Exclude real `.env` files, credentials, local evidence, and unrelated checkout files
from the build context.

Build a native Linux image and record its actual identity:

```sh
docker build -t my-agent:local /path/to/build-context
docker image inspect --format '{{.Id}}' my-agent:local
```

Use the inspected digest in `application.image`; a source commit or mutable tag is
not an image identity. Interceptor builds a separate wrapper around this image.
Do not install its supervisor into your application's Dockerfile.

## Model the legitimate application path

Create the [blueprint](environment-blueprints.md) and select appropriate
[services](services.md). Use exact HTTP fixtures for fixed responses, managed state
for writable records, MCP tools for the supported MCP interface, and managed
PostgreSQL for native SQL/pgvector access.

For a database-backed target, supply both schema and populated seeds. Synthetic
identities, foreign keys, grants, document vectors, and application configuration
must agree. A query embedding needs the same model, dimensions, and preprocessing
as its stored documents. The embedding connector neither populates the database
nor regenerates vectors automatically.

Configure generation and embeddings at the target's native SDK endpoints. Declare
synthetic SDK credentials, use the sandbox CA for verified TLS, and retain real
provider authentication on the host. Unsupported dependencies remain visible gaps;
do not replace unknown requests with an unconditional success response.

## Make launch and persistence explicit

`application.launch` supplies the command, absolute workdir, and literal environment.
Do not assume Dockerfile `ENTRYPOINT`, `CMD`, `USER`, or undeclared `ENV` supplies
that contract. The application runs with Interceptor's restricted identity and a
read-only root filesystem.

Declare narrow mutable directories for actual writes. Avoid mounting over application
code, virtual environments, or trust bundles. A mutable mount hides image contents;
use sealed filesystem seeds when that location needs initial data. See
[native logging](environment-blueprints.md#retain-the-agents-native-logs).

A code adapter can construct the application and trusted customer session once,
then translate inputs into its normal API. Keep it in `code.adapter_asset` when
the image lacks that calling convention. Snapshots do not save that object's
memory. Leave snapshots disabled unless explicit save/restore hooks preserve all
state needed for correct continuation.

## Verify and hand off

Validate and seal the blueprint, build/verify the wrapper, start it, and exercise
initialization plus a legitimate operation through the printed application endpoint.
Confirm the modeled dependencies actually answered, the returned content is useful,
and required log files were written. For claimed snapshot support, restore and check
the real state rather than inferring it from a successful save.

Export capabilities for Operator and keep the intended campaign instance free of a
throwaway campaign attachment. The [customer-support recipe](https://docs.intrusive.ai/pages/guides/customer-support-environment.html)
provides a concrete example. Continue with [sessions and evidence](sessions-and-evidence.md)
for lifecycle and collection.
