Technical brief · seven minute read

What Interpose checks, records, and proves.

Interpose installs as a native hook in the agent harness, or as a gateway beside a sandboxed one, and checks every tool call before it runs, with no model in the decision. It runs live on multiple harnesses; Claude Code is the integration we deploy today. This page is written for the person who has to answer for it in production: what you can prove, what you can control, and what you can audit.

Three questionsScope and limitsBeside a sandboxThe hook modelThe four checksWhat you getThe policyThe signed trailModel escalationCoverage and deployment

Three questions a security architect asks first.

Why not Claude Code's own hooks?
Interpose builds on them. Native hooks are the strongest free primitive and the floor Interpose stands on. What a raw hook does not give you: policy set centrally instead of per developer, a console across every endpoint, a baseline of what each role normally does, a signed trail, and a way to handle false positives without turning the control off.
Why not a gateway or proxy?
A proxy sees traffic, not intent. It sits outside the agent, so it never sees which tool was called, which file was read, or whether the action matched the task the developer typed. Put a model in the block path and it inherits the same prompt injection surface as the agent it is judging. In process, Interpose has neither problem.
Why in process and deterministic?
The block decision is a rule, not a judgment. Hard rules and scope give the same answer to the same input every time, with no model on the block path. The baseline is observational and never blocks. The limits of that model are stated in the next section.

Scope and limits, stated plainly.

What it is
A guardrail with a verifiable record, not a sandbox. Enforcement happens where the harness asks to run a tool, before it runs. Where a sandbox exists, Interpose renders the sandbox policy from its own and runs beside it.
The trail
Tamper evident, not tamper proof. The trail is hash chained and signed, so tampering or a deleted entry is detectable and provable. The value is proof, not prevention of the edit. Who holds the signing key is a deployment choice: a host the agent cannot reach, or the developer's own machine with the off host witness as backstop.
Two shapes
In process, on a developer machine: the hook runs beside the agent, so a process determined to route around it on that host can, and the signed trail is the backstop. Gateway, with a sandbox: the agent runs inside an isolated sandbox and every tool call crosses the sandbox proxy to an Interpose gateway on the host. The agent has no path to the trail, the key or the policy. Measured in OpenShell; the division of labor is in the next section.
Detection
The baseline is observational. It surfaces anomalies in reports as a signal to investigate, not as an enforcement control.

Interpose beside a sandbox. Who stops what.

Three controls were in the sandbox: the sandbox's own filesystem and network policy, the agent runtime's native guards, and Interpose. Each attempt was probed without a model, so a refusal counts only for the layer that made it.

AttemptSandboxRuntime's own guardInterpose
Read a file outside the workspaceRefusesNo gateRefuses before the call
Read a credential file inside the workspaceAllows, the workspace is writableAdvisory, and its message names the way roundRefuses before the call
Reach an unlisted hostRefuses at the proxy, after the command has startedDid not fireRefuses before the command runs
Write into Interpose's own installAllows, a nested read only path under a writable parent is not enforcedAllowsRefuses, in every mode

The sandbox holds the perimeter: what the process can reach at all. Interpose is the only control on the agent's own install surface, on the workspace contents it may touch, and on the order of operations: a refusal before execution instead of a failure after it. interpose render-openshell-policy writes the sandbox policy from the launch policy and stamps the policy hash the daemon attests on /health, so the two cannot drift.

The hook model. Three checkpoints.

Interpose registers as a native hook and intercepts the agent at three points. MCP tool calls pass the same pre-execution checkpoint as any other tool call. In the gateway shape the same three checkpoints arrive over hook routes, admitted on a hook token and a per session credential.

pre-prompt (UserPromptSubmit)

A declared task is captured and the session scope, if declared, is set. Drift from the task is scored for a person; scope is enforced.

pre-execution (PreToolUse)

Every tool call is checked before it runs. This is where blocks happen, so the side effect never lands.

post-execution (PostToolUse)

Outcomes are recorded and compared against the baseline for the role.

The four checks, in order.

1 · Hard rules
Credentials, keys, cloud configs, and system directories are denied in block mode. The floor ships with the policy and is never released by a developer. In transparent mode the finding is signed and marked unenforced.
2 · Role scope
Each agent runs under a role with a scope. Actions outside it are logged in alert mode and denied in block mode.
3 · Task match
Each action is measured against the one line task the developer declared at the top of the prompt. Drift from it is scored and surfaced on the record for a person. It flags, it does not block.
4 · Baseline
Deviation from what this role normally does is surfaced for a person to look at. It flags for investigation. It does not block.

What the security owner gets.

Prevent

Policy enforced before execution.

Every tool call is checked against your policy and allowed or denied before it runs, not flagged afterward. Out of the box the policy protects credential stores, private keys, cloud configs, and system directories. A network allowlist gates tool level requests.

Detect

A baseline per agent.

Interpose learns each agent's normal pattern of work and surfaces deviations in reports, for the novel behavior a fixed list will not catch.

Prove

A signed record of every tool call.

Every decision, allowed or denied, is appended to a per agent, hash chained, Ed25519 signed trail anchored by a signed manifest. Alter or delete an entry and verification fails.

Assess

See the blast radius first.

interpose scan lists the files an agent could reach, scored by how sensitive each looks by path pattern. Read only. Tighten policy before it matters.

The policy.

init writes a starter policy, and Interpose recommends tightening from the actions your developers approve and deny. Every control has an alert setting and a block setting, so the security team decides which risks it watches and which it stops. Policy is set centrally and cannot be edited from a developer machine.

# .interpose.yaml
policy:
  allow:
    actions: [file_read, file_write, tool_invocation, network_request, command_exec]
    targets:            # logged if outside, denied in block mode
      - "src/**"
      - "test/**"
    networkHosts:       # network_request denied unless listed
      - "api.anthropic.com"
      - "github.com"
  forbid:
    targets:            # hard deny, never released
      - "secrets/**"
      - "/etc/**"
enforcement:
  mode: block           # alert runs every check, signs every finding, enforces nothing but self protection
  restrictAfter: 2      # eligible violations, per session, inside a 24 hour window
  quarantineAfter: 3    # quarantine after this many
scopeBoundarydefault advisory
enforce denies out of scope file reads and writes. Advisory logs a scope violation but still runs.
egressScreendefault off
Screens shell network commands against the allowlist. Alert first: it logs interpreter and obfuscated egress rather than blocking it.
askOnDestructivedefault on
Routes a curated set of irreversible destructive shell commands to Claude Code's confirmation prompt.
unknownToolsdefault warn
Disposition for unrecognized tool names. warn allows and logs. deny blocks, with an allowlist escape hatch.

The signed audit trail. Prove what ran.

entry 4810 sig ok · hash ok entry 4811 sig ok · hash ok entry 4812 · edited hash mismatch entry 4813 chain broken upstream interpose --verify-audit INVALID · break at 4812 Each entry carries the hash of the one before it and its own Ed25519 signature. Edit or delete any entry and the verdict names the exact point. Unaltered, the same command returns VALID.
Verify
interpose --verify-audit re-walks the whole hash chain and checks every Ed25519 signature, then returns a single VALID or INVALID verdict you can hand to a reviewer.
Read
interpose --show-audit prints the signed entries behind that verdict, newest first. Paths and commands are redacted to shape by default. A deny names the file that was reached, not the secret it would expose.
Recover
On a soft flag the developer releases a blocked action in one click. A restricted or quarantined agent is restored with interpose release from a separate terminal. Interpose reconstructs why the stop fired and proposes a narrow, expiring exception for a person to approve. Nothing is applied on its own.

Model escalation. Optional, in your boundary.

When
Only genuinely ambiguous cases. Hard rules are always decided by the deterministic core. The model never sits on the block path for anything you have already made a rule.
Where
Out of process, on an endpoint you bring. You choose the model. It runs on your infrastructure, never on Tuent's.
Direction
Tightening only. The advisor can recommend a tighter rule for a person to approve. It acts on nothing, cannot loosen a deny, and never sees a credential.
Fallback
If the endpoint is unreachable, the deterministic decision stands. The core does not wait on a model to keep the agent safe.

Coverage, deployment, and present state.

Agents
Interpose runs live on multiple agent harnesses. Claude Code, through its native hook, is the integration we deploy today; sandboxed harnesses run through the Interpose gateway. No runtime is claimed here before it has run.
Claude Code updates
Interpose uses Claude Code's documented hook interface rather than patching the binary, and each release is tested against current Claude Code before it ships to a pilot.
Runtime cost
The decision happens before the tool runs, on the block path. Trail writes and console sync happen after it. In the in process shape there is no network hop; in the gateway shape the hook crosses your sandbox proxy. Numbers are measured per deployment in the audit and reported in the Rollout Evidence Report, not quoted here.
Boundary
On your machines, under your keys. Nothing about your agents, code, or actions reaches Tuent, including on model escalation.
Deployment
Deployed by Tuent inside your boundary. Interpose is not self serve. The entry is the Agent Exposure Audit, two weeks in transparent mode at a fixed fee, then the pilot, then the subscription.
Standing
Listed on the CSA AARM Builders Registry. AARM standing is Aligned, self declared. The registry listing reflects builder alignment.
State
Current release. The signed audit trail and the false positive recovery are live end to end.

This page reflects the present shipped state and moves as the product ships. Figures elsewhere on this site are illustrative unless marked otherwise.

Scope it against your environment.

Thirty minutes to map where your agents run and agree the fixed fee for the audit. Two weeks in transparent mode, so nothing is blocked while you watch, and the report is yours either way.

Questions on anything above? [email protected] or [email protected]. A founder answers.