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.

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:

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 and select appropriate services. 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.

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 provides a concrete example. Continue with sessions and evidence for lifecycle and collection.