How to Govern Anthropic Server Tools That Run Outside Your Network
Anthropic server tools such as web search and code execution run on Anthropic-managed infrastructure, so network controls cannot see them. You can still govern them at two points you own: the request before it leaves, and the response when it returns. Enforce policy at both, and record each decision as evidence.
What you can and cannot control
- 1
Available: tool declarations
Decide per use case whether a request may carry a web search or code execution tool at all.
- 2
Available: prompt and tool-input content
Inspect and redact sensitive data before the request leaves your network.
- 3
Available: volume
Rate limit tool-enabled requests per user, application or use case.
- 4
Available: returned content
Inspect search results, citations and code outputs before users or downstream systems receive them.
- 5
Not available: in-flight inspection
You cannot observe or interrupt the provider's tool steps while they run.
- 6
Not available: execution environment controls
Your network policy does not govern where the tool connects or where code runs.
Start from where the tool executes
A server tool is executed by the model provider, not by your application. When you enable web search or code execution, the request leaves your network and the tool loop runs on Anthropic-managed infrastructure. Egress proxies, sandboxes and endpoint tooling cannot inspect or restrict what the tool does after that point.
NIST describes an agent as a system that iteratively prompts a model, processes its outputs, and feeds tool results back into the next prompt. It lists web-browsing and code interpreters as example tools. The same description explains the risk. A tool result containing injected instructions can shape later steps, and NIST names direct and indirect prompt injection as risks that grow once an agent can act through tools.
Without a control point in the request path, enablement is an all-or-nothing setting in the API configuration. Governance for these tools therefore comes down to the two boundaries you still own: what you send and what you accept back.
Define the policy model
A usable policy covers four decisions: which tools, what goes in, what comes out, and when a human must approve.
For enablement, apply least privilege. Zero trust guidance calls for access rules that are as granular as possible for the action in the request. For server tools, that means an allowlist per use case, evaluated on each interaction, not one switch per API key. A support summarization workflow may never need code execution. A research workflow may need web search but not with customer data in the query.
For input, define the data classes that must not leave. NIST lists PII, financial, health, business, security and legal data as sensitive categories. Decide for each class whether to redact, block or allow with approval. Search queries and code inputs are easy to overlook because the model composes them, so apply the same screening to the full prompt context that could feed them.
For output, treat everything returned by a tool as untrusted. Retrieved web content is the standard indirect prompt injection path. NIST also flags model output used to build commands executed without human supervision, which can cause integrity or privacy harm downstream. Code output should not trigger actions in other systems without validation.
For approval, name the conditions that require a person: a sensitive data class in a tool input, a tool not on the use case allowlist, or a result that would feed a downstream action.
Expect tradeoffs. Aggressive redaction can make search queries less useful. Blocking can break tasks. Human approval adds latency. Set thresholds per use case and review them against real traffic.
Enforce in the execution path
Enforcement needs a component that sits between your applications and the provider API and evaluates each interaction and each tool call. The order matters, because anything the provider executes cannot be undone. Preventive controls belong before the request. Result controls protect what happens after.
The prevention steps are the only ones that limit what reaches the tool. Result inspection limits the blast radius afterward but does not change what the tool already did. Design with that asymmetry in mind, and be conservative on inputs for high-sensitivity use cases.
- 1. Resolve the use case: Identify the application, user and use case so the correct allowlist and data rules apply.
- 2. Evaluate the declaration: Allow, or block the request if it carries a tool the use case does not permit.
- 3. Screen and redact inputs: Redact or block sensitive data classes in prompt and tool-input content.
- 4. Rate limit: Cap tool-enabled requests so a manipulated or looping client cannot generate unbounded tool use.
- 5. Inspect results: Check returned content for injected instructions and sensitive data. Allow, redact or block it.
- 6. Escalate: Hold the interaction for human approval when a defined condition is met, and record the outcome.
Capture evidence for each tool call
The test for your evidence is simple: can you show what the tool was allowed to do and what it did? That requires records created by enforcement itself, at the moment of the decision, rather than reconstructed later from application logs.
A practical record for each tool call includes the requesting application, user and use case; the tools declared and the tools permitted; the policy and version applied; the decision taken (allow, redact, block, rate limit or escalate); the data classes detected and redacted; the result inspection outcome; and the approval outcome with approver and time where a person was involved. These fields are a design choice, not a regulatory template, so confirm them with your compliance team against the frameworks that apply to you.
Plan retention and residency at the same time. Evidence from tool-heavy traffic accumulates quickly, and it may itself contain sensitive material. Store it where your data residency rules allow, under a defined retention period, with access limited to the people who need it.
Where Trussed fits
Trussed enforces policy in the execution path across models, agents, tools and MCP servers. It applies allow, redact, block, rate limit and escalate for human approval at the level of individual interactions and tool calls, enforced at runtime, not reviewed after the fact. That enforcement produces audit-ready evidence, mapped to HIPAA, NAIC, NYDFS, the EU AI Act and NIST. It can be self-managed in your cloud, with configurable retention and data residency.
The scope is individual interactions and tool calls. This guide does not assume tracing of a whole agentic workflow or governance at the business transaction level. The pattern above applies with or without Trussed. What matters is that a control point exists in the request path and that it produces evidence as it enforces.
Control points for provider-run tools
Before the request
Check tool declarations and redact prompt and tool-input content.
At the provider
Execution happens outside your network. No in-network inspection applies.
After the response
Treat search results and code outputs as untrusted before release.
Across both
Rate limit, escalate for approval, and record every decision.
Put a control point in front of your server tools
See how policy enforcement and audit-ready evidence work for individual interactions and tool calls in a regulated enterprise.
See How Evidence Is ProducedHow does your AI governance program compare?
See where your program has gaps in less than 2 minutes.