Coding-Agent Workstation Baseline (Claude Code)
Put Claude Code on developer workstations and build agents as privileged automation: one device-delivered managed policy per surface, lock flags that stop rules merging upward, command hooks for enforcement and HTTP hooks only for evidence, the OS sandbox where it runs, telemetry by policy, and the workstation recorded as a processing location. Dated to November 2026.
- Version
- 0.1.0
- Owner
- DEIXEI
- Last reviewed
- Reading time
- 59 min
For Cto · Ai Architect · Platform Engineer · Security Engineer · Soc · Risk And Assurance · Internal Audit · Data Protection
Sources and details
- Section
- Build the platform
- Source works
- Book 3 · Research Series
- Source chapters
- 5, 6, 8, 9, 10, 12
- Source appendices
- 04:B
- Refresh trigger
- vendor release
A coding agent on a developer workstation reads the repository, runs shell commands with the developer’s privileges, edits code and calls external tools. Treat it as privileged automation with its own identity, policy and telemetry, not as a chat assistant with a terminal. The workstation is the least production-like place an agent runs, which is why it is the place most often left ungoverned. Distance from production does not remove the path to production.
This page is deliberately vendor-specific. It sets out a baseline for Claude Code on a Microsoft-managed Windows estate with WSL2, Linux workstations and hosted CI. The generic principle, that a client-side setting is never the enforcement boundary, is on identity and secrets. MCP server admission is on the connector broker. Model allow-lists and version pinning are governed on model governance.
How to read the vendor facts on this page
Settings keys, paths, flags and version numbers change with almost every release. Research Paper 3 records three releases in the five days before its check. Every vendor statement here carries its date and source.
| Marker | Meaning |
|---|---|
| Per WP3 (10 Nov 2026) | Research Paper 3, Securing Claude Code in the Enterprise. Its author verified it against the Claude Code documentation as served on 10 November 2026 (changelog head: version 2.1.322). The paper notes that the documentation was checked, not a running binary. This is the primary source for this page, and wins where it conflicts with Book 3. |
| Per Book 3 Ch 8 (Aug 2026) or App B (May 2026) | Deploying Claude Safely. These facts are older and were not re-verified by WP3. They carry a [FACT-CHECK: …] marker. |
| Recommendation | A design choice made by this page or by the cited author. It is not a vendor statement. |
| Bank A | Bank A is a composite example from Book 3, not a real institution. Its numbers are illustrative. |
WP3 itself labels its baseline policy, split pipeline, monitors and roadmap as untested design proposals. This page inherits that status. Regulatory article mapping and dates are kept on the regulatory map and are not restated here.
The baseline in one table
WP3 §3.3 names four layers of defence (identity, policy, runtime, observability) and trusts none of them alone. This page splits network and data out of the runtime layer as a fifth row, because it has different owners.
| Layer | What it decides | Primary mechanism | Owner | What it cannot do |
|---|---|---|---|---|
| Identity and tenancy | Who may call which model endpoint, under which contract | SSO into the firm’s Claude organisation; login and provider pinned by device policy; workload credentials for pipelines | Identity engineering | Govern a developer who calls the API from another tool |
| Managed policy | What the agent may do | One version-controlled managed settings document, locked with the allowManaged*Only flags, plus managed hooks | Security engineering (content); platform (delivery) | Resist a local administrator or a modified client |
| Runtime isolation | What the operating system lets spawned commands touch | Claude Code sandbox (bubblewrap on Linux/WSL2, Seatbelt on macOS); dev containers for high-risk repositories | Platform engineering | Cover file tools, MCP servers or hooks, or run on native Windows |
| Network and data | Where traffic may go, what leaves, what is kept locally | Egress allow-list at firewall or web gateway; Tenant Restrictions; secret placement; local retention | Network and data protection | Inspect prompt content inside the TLS session to the model endpoint |
| Monitoring and evidence | What can be seen and proved afterwards | OpenTelemetry export set by policy; hook events to the SIEM; host process telemetry as the independent record | SOC and security engineering | Prove anything the user’s own client could have fabricated, without host corroboration |
Why the settings file is not the boundary
The vendor says so
Per WP3 §3.3 (10 Nov 2026), Anthropic’s documentation describes server-managed settings as a client-side control and not a security boundary. A developer who is a local administrator can edit the managed source. A user running a modified client can bypass any client-side control. Managed settings bind only Claude Code, so a developer calling the API from another tool is outside them. The permission engine runs as configuration inside the process it constrains. Every high-risk context therefore needs an operating-system or network control behind the policy file.
Threats the baseline is built against (WP3 §3.2)
| # | Threat | Typical vector | Main controls on this page |
|---|---|---|---|
| T1 | Indirect prompt injection | Instructions in a README, dependency, web page, ticket or MCP response | Sandbox with no unsandboxed retry; WebFetch denied; MCP lock; review of agent output |
| T2 | Leakage to the model endpoint | Source, secrets or client data sent to an unapproved endpoint or personal account | Login and provider pinning; Tenant Restrictions; repository tiering |
| T3 | Over-privileged execution | Bypass mode, broad allow rules, approval fatigue | Bypass mode disabled; managed-only rules; auto-mode decision |
| T4 | Secrets in reach | .env, ~/.ssh, cloud CLI caches, kubeconfig | Read deny rules + sandbox read restrictions + short-lived credentials |
| T5 | Malicious MCP server, hook or plugin | Unvetted extensions | allowManagedHooksOnly, MCP allow-list by URL/command, plugin locks, sideload flags |
| T6 | Shadow usage | Personal accounts, unmanaged keys | Device-delivered login keys; identity monitors; Tenant Restrictions |
| T7 | CI/CD abuse | A pull request steers an agent holding pipeline credentials | CI profile in the image; split pipeline; no privileged credential in the agentic stage |
| T8 | Configuration tampering | A user weakens local policy | No local admin; ConfigChange hook; source-drift and telemetry-gap monitors |
Rule matching has documented limits. A deny for curl does not match /usr/bin/curl or sh -c 'curl …'. WP3 cites a March 2026 third-party test (Ona) in which an agent reached a denied binary through /proc/self/root/…. The bubblewrap sandbox stopped it. The agent then asked to run the command unsandboxed, and only the human prompt held. The baseline removes that retry route by setting allowUnsandboxedCommands: false.
Guidance versus control: sort every policy line
Book 3 Ch 8 §4.1 divides the surfaces on which a firm can express policy into two columns. The division rests on Anthropic’s June 2026 description of its steering mechanisms. Only two surfaces enforce: managed settings and hooks. CLAUDE.md, .claude/rules/, skills, subagent definitions, output styles and system-prompt additions steer the model, and the model can fail to follow them. The permissions documentation says the same: permission rules are enforced by Claude Code, and prompt or CLAUDE.md instructions do not change what Claude Code allows.

Guidance steers the model; only managed settings and hooks enforce. Source: Deploying Claude Safely (Book 3), Chapter 8, Figure 8.1.
| Column | Surfaces | Counts in the RCSA as |
|---|---|---|
| Control | Managed settings (with lock flags); managed hooks; OS sandbox; network egress | Preventive or detective control |
| Guidance | Repository CLAUDE.md, rules, skills, subagents, output styles | Training or awareness measure only |
Rule (Book 3 Ch 8 §4.1; adopted here). A risk-and-control self-assessment must not carry a control assertion sourced from the guidance column. “Our CLAUDE.md forbids touching production configuration” is a training statement. Book 3 also notes that a developer can skip a repository CLAUDE.md through claudeMdExcludes, while a CLAUDE.md delivered by device management cannot be excluded [FACT-CHECK: claudeMdExcludes behaviour and the managed CLAUDE.md location, as of Aug 2026]. Acceptance check: for each control assertion about Claude Code, name the mechanism that enforces it. If the answer is “the model reads the file”, move the assertion to the training column or move the policy into settings or a hook.
Step 1 — Choose the identity route and pin it
Approved routes (per WP3 §4.1, 10 Nov 2026)
| Route | Authentication | Suits | Notes |
|---|---|---|---|
| Claude for Enterprise | SSO into the firm’s Claude organisation | Interactive developer use | SSO, domain capture, SCIM, audit logs, Compliance API, server-managed settings |
| Claude for Teams | SSO | Smaller groups | SSO and server-managed settings; no SCIM, domain capture, audit logs or Compliance API |
| Claude API (Console) | API key or OAuth profile in a Console organisation | Pipelines, services | A Console organisation is separate from the claude.ai organisation; settings and audit do not cross over |
| Claude in Microsoft Foundry | Entra ID or API key against the firm’s Azure resource | Azure-native pipelines | See the hosting facts below |
| LLM gateway in front of any route | Gateway-issued credential | Central policy, inspection | Server-managed settings are not fetched on this route |
Foundry facts that are often misreported (per WP3 §4.1, which cites Microsoft Learn articles dated June–September 2026 and Anthropic pages, all accessed 10 November 2026). Microsoft offers each Claude model in up to two versions: “hosted on Azure” and “hosted on Anthropic infrastructure”, and the second may process data outside the selected Azure geography. The hosting option is chosen per deployment. On the day WP3 checked, the newest model families were Anthropic-hosted only. Deployment types are Global Standard and Data Zone Standard (US), and the data zone exists only for Azure-hosted versions. There is no EU data zone. On both options Anthropic is the seller and operator and an independent data processor. WP3 found no zero-data-retention option documented for the Foundry route. The data residency and processor consequences belong on data classes and lanes and the third-party register.
Amazon Bedrock and Google Cloud routes (per WP3 §4.3, which rests on Anthropic’s provider pages only; AWS and Google documentation was not opened).
| Property | Amazon Bedrock | Google Cloud (Agent Platform, formerly Vertex AI) |
|---|---|---|
| Switch | CLAUDE_CODE_USE_BEDROCK=1 plus the AWS credential chain | CLAUDE_CODE_USE_VERTEX=1 plus project ID and region |
| People | IAM Identity Center profiles | Application Default Credentials |
| Workloads | Instance or task roles; short-term Bedrock API keys only where no role is available | Service accounts or certificate-based Workload Identity Federation |
| Permissions | bedrock:InvokeModel, bedrock:InvokeModelWithResponseStream, bedrock:ListInferenceProfiles, bedrock:GetInferenceProfile | roles/aiplatform.user (Book 3 Ch 8 §7.1 names the permission aiplatform.endpoints.predict) |
| EU residency | Cross-region inference profiles with an eu. prefix | eu multi-region or a single European region |
| Extras and gaps | Guardrails on the request path; WebSearch unavailable | — |
Both routes share three gaps: no server-managed settings, no user email in telemetry (Step 9), and model aliases that resolve to provider defaults which can lag the newest release, so pin versions. The pipeline identity pattern is the same on all three clouds: a workload role, never a stored key. [FACT-CHECK: IAM action names, role names and eu. profile availability against current AWS and Google documentation.]
Identity rules (per WP3 §4.2, 10 Nov 2026)
- Exclude personal accounts by setting, not by request. Set
forceLoginMethodandforceLoginOrgUUID. Claude Code exits at startup if the claude.ai credential belongs to an organisation not on the list. Deliver these keys by device management: server-managed settings arrive only after the user has signed in, so they cannot redirect a first login. WP3 documents two gaps. The login screen pre-selects the method but does not enforce it.claude setup-tokenchecks the method but not the organisation. - Restrict the provider.
allowedProviderslists the services the machine may reach Claude through. Other providers are refused at startup. WP3 gives the minimum version as 2.1.285. - SSO and SCIM before rollout, so access follows joiner–mover–leaver.
- No raw API keys on endpoints. With both login keys deployed, sessions that authenticate with
ANTHROPIC_API_KEY,ANTHROPIC_AUTH_TOKENorapiKeyHelperare blocked at startup. The interactive profile therefore cannot be reused on build agents; see the CI profile below. - One route per use case, written down.
- Know where server-managed settings stop. Claude Code skips the server-managed fetch whenever a cloud-provider variable or a non-default
ANTHROPIC_BASE_URLis set. On any gateway, Bedrock, Google Cloud or Foundry route, the device-delivered policy is the only policy.
Credential precedence is the bypass surface
Per Book 3 Ch 5 §4.2 (Aug 2026), Claude Code resolves credentials in this order [FACT-CHECK: current order in the Claude Code authentication documentation]:
- a signed-in gateway session (above everything else);
- cloud-provider variables
CLAUDE_CODE_USE_BEDROCK,CLAUDE_CODE_USE_VERTEXorCLAUDE_CODE_USE_FOUNDRY; ANTHROPIC_AUTH_TOKEN;ANTHROPIC_API_KEY;apiKeyHelper;CLAUDE_CODE_OAUTH_TOKEN;- subscription OAuth.
If a developer exports one of these variables, the session changes identity, billing account and policy channel. The controls are:
- route and provider variables only in the managed
envblock, never in the shell; allowedProvidersset to the firm’s provider;- the login keys, which block environment credentials on the interactive profile.
Organisation pinning and a vault-helper key are mutually exclusive on the Anthropic API path. If the firm wants vault-issued credentials and organisation pinning together, the options are workload federation, the Claude apps gateway or cloud IAM. Setting both keys does not work. A workload whose federated token cannot be obtained must fail with an audit record. It must not fall back silently to a forgotten API key.
Where the Claude apps gateway fits
Per Book 3 Ch 6 §5.2, Anthropic shipped a self-hosted Claude apps gateway in June 2026 [FACT-CHECK: product status, configuration keys and supported upstreams as of Nov 2026]. It provides OIDC sign-in (SAML and LDAP are not supported), per-user spend caps and ordered upstream failover. It enforces model allow-lists server-side and blocks sessions at startup if the gateway is unreachable. WP3 §4.2 says it supplies remote settings delivery for cloud-provider routes, and that WP3 did not evaluate it.
Scope limit (Book 3). The apps gateway fronts Claude Code only. It has no DLP, tokenisation or policy-decision call-out, it disables WebSearch, and it has no service-token flow for CI. Use it for the developer credential boundary. Keep the general-purpose model gateway (APIM or equivalent) for anything that touches institutional data. A pipeline still authenticates against the provider directly with a workload identity.
Step 2 — Deliver one managed policy per surface
Settings scopes and how permission rules combine
Per WP3 §5.1, managed settings rank above user, project and local settings and above a --settings value. Nothing in lower files overrides a managed key, except a small set of restrictive keys where a stricter value from a lower level is still honoured. Book 3 App B §2 sets out the full five scopes, highest first:
- managed;
- command-line arguments;
.claude/settings.local.json(git-ignored);.claude/settings.json(committed);~/.claude/settings.json.
Permission rules merge across scopes rather than replace one another, and a deny at any level wins. That behaviour suits denies. For allows it is a trap. A developer’s settings.local.json allow combines with the managed floor until allowManagedPermissionRulesOnly is set (see the lock flags below).
Delivery mechanisms per OS (per WP3 §5.1, 10 Nov 2026)
| Mechanism | Location | When read |
|---|---|---|
| Server-managed | claude.ai admin console; cached locally | At startup; polled hourly |
| MDM / OS policy | Windows: REG_SZ or REG_EXPAND_SZ value named Settings under HKLM\SOFTWARE\Policies\ClaudeCode, holding the JSON. macOS: managed-preferences domain com.anthropic.claudecode | At startup; re-checked every 30 minutes |
| File | managed-settings.json plus optional managed-settings.d/*.json in C:\Program Files\ClaudeCode\ (Windows), /etc/claude-code/ (Linux and WSL), /Library/Application Support/ClaudeCode/ (macOS) | At startup; reloaded on change |
| User registry | Settings under HKCU\SOFTWARE\Policies\ClaudeCode | Only when no administrator source is present |
The old Windows path C:\ProgramData\ClaudeCode\ is no longer read. Drop-in files merge alphabetically: lists combine and later single values win. A managed file that is present but contains invalid JSON stops Claude Code from starting. Validate the document in the deployment pipeline before it ships.
The sources do not merge: choose one
Per WP3 §5.1, by default Claude Code uses the highest-ranked source that delivers at least one policy key, in the order server-managed → MDM → file → user registry. It ignores the rest without warning. Some keys are read from every administrator source regardless: the sandbox locks, the MCP allow-list lock, deniedMcpServers, forceRemoteSettingsRefresh and, from 2.1.223, the env block merged per variable. Login keys are taken from the device policy ahead of the server.
The failure mode is easy to miss. One key saved in the admin console silently displaces the whole device policy.
Recommendation (WP3; adopted here).
- On managed devices, make the device-delivered policy the only policy. Leave the console’s managed settings empty, or use them only for populations without device management.
- If server-managed settings are also needed (cloud sessions do not read device policy), set
managedSourcesBehavior: "merge"in the highest-ranked source (2.1.242+). Treat both sources as one controlled document. Under merge, locks take the strictest value and lists combine. - Confirm on each surface with
/status, whoseSetting sourcesline names the source in use, and withclaude doctor. Across the fleet, themanaged_settings_resolvedtelemetry event (2.1.274+) reports the same thing.
Consequence for cohort fragments (inference from WP3 §5.1–5.2; test before relying on it). On Windows the HKLM registry value outranks the file source. A cohort drop-in placed in C:\Program Files\ClaudeCode\managed-settings.d\ beside a registry policy would therefore be ignored, apart from the always-read keys. Book 3 App B §3.2 points the same way from another angle: it supports the drop-in directory on the file route only, not on the registry route. On the registry route, deliver one complete policy document per device group (repository tier or cohort). Keep the tier documents generated from a common base in version control. Drop-ins remain usable on Linux file delivery and inside images.
Per surface
| Surface | Channel | Specifics |
|---|---|---|
| Windows 11, Windows 365, personal AVD | Intune configuration writing the HKLM Settings value | Needs admin rights to write. Anthropic publishes Intune, Group Policy and Jamf templates (per WP3). If a file is preferred, an Intune Remediation re-asserts its hash and ACL on a schedule |
| WSL2 on a Windows host | The Windows policy, inherited | Per WP3 §7.1, /etc/claude-code inside WSL is user-writable: the developer controls the distribution, so a file there is not an administrator source. Set wslInheritsWindowsSettings: true in the HKLM policy or in a file under C:\Program Files\ClaudeCode\ (2.1.282+). WSL then reads the Windows chain, and reads /etc/claude-code only when no Windows administrator document exists |
| Linux workstation | Configuration management places /etc/claude-code/managed-settings.json, root-owned | Install from Anthropic’s signed apt repository or an internal mirror. Package-manager installs do not self-update |
| macOS | MDM profile for com.anthropic.claudecode, or the file path | Seatbelt sandbox is built in |
| Multi-session AVD | As Windows, strictest tier | See the shared-host notes below |
| Build agent | Policy baked into the image’s system directory | See the CI profile |
Use the Intune Windows Subsystem for Linux settings to disable WSL1 and the inbox WSL version, and to remove user control of kernel, networking and firewall configuration (per WP3 §7.1, citing Microsoft’s Intune WSL page, Oct 2026). The sandbox requires WSL2.
Source conflict — Book 3 Appendix B §3.2–3.3 (May 2026) versus WP3 (Nov 2026). Appendix B gives the Windows registry path as
HKEY_LOCAL_MACHINE\SOFTWARE\Anthropic\ClaudeCode\Settings. It says “registry takes precedence if both present”. It also treats/etc/claude-code/managed-settings.jsoninside WSL2 as the governing administrator floor. WP3, verified later against the documentation, givesHKLM\SOFTWARE\Policies\ClaudeCode. It shows that sources do not merge (the first source with any key wins, silently), and that/etc/claude-codeis user-writable on WSL. This page follows WP3. Book 3 Chapter 8 §4.2 (August 2026) already uses thePoliciespath andwslInheritsWindowsSettings. The Appendix B error is recorded for correction in the manuscript.
Fail-closed settings fetch
Book 3 App B Block 1 and Ch 8 §4.3 set forceRemoteSettingsRefresh: true. Per Book 3, this setting blocks startup until managed settings have been freshly fetched, and exits if the fetch fails. WP3 confirms that the key is read from every administrator source. Use it where server-managed settings are part of the design: merge mode, or a population without device management. In that case a session that cannot fetch policy should not run on stale or absent policy.
Do not rely on App B’s rationale as written. App B says that without the key “an offline workstation falls back to user scope”. WP3 instead describes a device policy that stays in force regardless of the server. Under this page’s single-source recommendation (device policy only, console empty), the key’s effect needs testing [FACT-CHECK: forceRemoteSettingsRefresh behaviour when the console holds no managed settings, and its interaction with device-delivered policy].
Step 3 — Ship the baseline policy
The base document (per WP3 §5.2, 10 Nov 2026)
This is WP3’s Linux and WSL2 profile for interactive use on the Enterprise route, delivered through the Windows HKLM policy with WSL inheritance or as the Linux file. It is reproduced as configuration. Replace the placeholders.
{
"forceLoginMethod": "claudeai",
"forceLoginOrgUUID": ["00000000-0000-0000-0000-000000000000"],
"allowedProviders": ["anthropic"],
"requiredMinimumVersion": "2.1.302",
"permissions": {
"defaultMode": "default",
"disableBypassPermissionsMode": "disable",
"blockReadsOutsideWorkingDirectories": true,
"deny": [
"Read(./.env)", "Read(./.env.*)", "Read(./secrets/**)",
"Read(~/.ssh/**)", "Read(~/.azure/**)", "Read(~/.aws/**)", "Read(~/.kube/**)",
"Bash(curl *)", "Bash(wget *)", "WebFetch", "WebSearch"
]
},
"allowManagedPermissionRulesOnly": true,
"allowManagedHooksOnly": true,
"allowManagedMcpServersOnly": true,
"allowedMcpServers": [ { "serverUrl": "https://mcp.example.internal/*" } ],
"sandbox": {
"enabled": true,
"failIfUnavailable": true,
"allowUnsandboxedCommands": false,
"network": {
"allowedDomains": ["packages.example.internal"],
"allowManagedDomainsOnly": true
}
},
"env": {
"CLAUDE_CODE_ENABLE_TELEMETRY": "1",
"OTEL_METRICS_EXPORTER": "otlp",
"OTEL_LOGS_EXPORTER": "otlp",
"OTEL_EXPORTER_OTLP_PROTOCOL": "grpc",
"OTEL_EXPORTER_OTLP_ENDPOINT": "http://127.0.0.1:4317",
"CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1"
},
"cleanupPeriodDays": 14
}
| Group | Keys | What it does (per WP3) |
|---|---|---|
| Login and provider | forceLoginMethod, forceLoginOrgUUID, allowedProviders | Firm organisation and provider only; see Step 1 |
| Version floor | requiredMinimumVersion | Read only from managed settings. Older clients exit at startup. WP3 chose 2.1.302 because from that version non-interactive runs with no mode set start in Manual mode, and it is above every other key’s minimum |
| Modes | permissions.defaultMode: "default", permissions.disableBypassPermissionsMode: "disable" | Sessions start in Manual mode; bypass mode removed |
| File reach | permissions.blockReadsOutsideWorkingDirectories, Read denies | File tools refuse reads outside working directories (cross-scope from 2.1.257). ~/ is home-relative, ./ is working-directory-relative, and an absolute path needs // |
| Locks | allowManagedPermissionRulesOnly, allowManagedHooksOnly, allowManagedMcpServersOnly | Managed rules, hooks and MCP allow-list are the only ones. Rules from user/project/local files and --allowedTools are ignored |
| Sandbox | sandbox.* | Sandbox on (off by default). Refuses to start where the sandbox cannot run. No retry outside the sandbox. Only managed domains, without prompting |
| Telemetry | env block | OTel export to a local receiver. A managed env value overwrites the user’s shell export |
| Retention | cleanupPeriodDays | Local transcript retention; default 30, minimum 1 |
Variants (per WP3 §5.2).
- Native Windows: the sandbox does not run, so
failIfUnavailablewould stop Claude Code starting (see Step 6 for the decision). - Repository tiers: deliver a different document to a different device group. Lower tiers may re-allow WebFetch for named documentation domains.
- Build agents: see the CI profile.
Regulated-tier overlay (Book 3 additions, not re-verified by WP3)
Book 3 Ch 8 §4.3–§7 and PR-2 (August 2026) add controls that WP3’s base document does not set. WP3 mentions some of them and deliberately leaves them as decisions for the firm. Hold them as a separate, reviewable layer: a drop-in on file delivery, or merged into the tier document on registry delivery. Do not blend them silently into the base. Every key below is [FACT-CHECK: key name, placement (top level or under permissions/sandbox) and minimum version against the Claude Code settings reference, as of Nov 2026].
{
// Sideload closure (Book 3 Ch 8 §4.3). WP3 lists the plugin locks and leaves them to the firm.
"strictPluginOnlyCustomization": true,
"disableSideloadFlags": true,
"strictKnownMarketplaces": [ { "hostPattern": "^git\\.example\\.internal$" } ],
// Model gating (Book 3 Ch 8 §4.3; v2.1.175+ per Book 3). Full IDs, not aliases.
"availableModels": ["<full-approved-model-id>", "<full-approved-model-id>"],
"enforceAvailableModels": true,
// Autonomy (Book 3 Ch 8 §4.5) — per-tier decision, see Step 4.
"disableWorkflows": true,
// Bound HTTP hooks from every source (Book 3 Ch 8 §5.2).
"allowedHttpHookUrls": ["https://siem-ingest.example.internal/claude/*"],
"httpHookAllowedEnvVars": ["SIEM_TOKEN"],
// Sandbox read and socket restrictions (App B Block 5; Ch 8 §6.2).
"sandbox": {
"filesystem": {
"allowManagedReadPathsOnly": true,
"denyRead": ["~/.ssh", "~/.aws", "~/.kube"]
},
"network": { "strictAllowlist": true },
"allowUnixSockets": false
},
// Retention and feedback (Ch 8 §7; 7 days is the composite Bank A value).
"cleanupPeriodDays": 7,
"env": { "DISABLE_FEEDBACK_COMMAND": "1" }
}
On drop-in merge semantics, WP3 says that lists combine and later single values win. Book 3 App B adds that objects deep-merge. Check the merged result with /status and /permissions rather than predicting it.
Lock flags and sideload closure
The three allowManaged*Only flags turn the managed tier from a starting point into a floor. Without them, permission rules and the MCP allow-list merge upward from user files.
| Flag | Closes | Note |
|---|---|---|
allowManagedPermissionRulesOnly | A developer broadening permissions in settings.local.json, ~/.claude/settings.json or --allowedTools | Claude Code also stops offering to save “always allow” answers (WP3) |
allowManagedHooksOnly | Replacing the audit hook with a no-op; adding an exfiltrating hook | Per Book 3, a user or project disableAllHooks cannot touch a managed hook [FACT-CHECK] |
allowManagedMcpServersOnly | Developer-added MCP servers | Independent of the rules flag. allowManagedPermissionRulesOnly does not enforce the MCP allow-list. Book 3 calls this the commonest mis-assumption it meets |
strictPluginOnlyCustomization | Skills, agents, hooks and MCP servers arriving from user or project sources | Book 3 Ch 8 §4.3 [FACT-CHECK] |
disableSideloadFlags | --plugin-dir, --plugin-url, --agents, --mcp-config at start-up | Per Book 3, without it marketplace policy can be bypassed for a single run [FACT-CHECK] |
Verification (Book 3 Ch 8 §9). Run /permissions on a sample of workstations and read the source column. Any rule sourced from user settings proves that the lock is missing. After fixing, re-sample weekly for one quarter.
Permission-rule authoring standard
Evaluation order, per Book 3 Ch 8 §4.4: deny, then ask, then allow; first match wins; specificity does not reorder. A bare tool name used as a deny ("WebFetch") removes the tool from the model’s context entirely. That reduces the attack surface, not only the runtime outcome.
The rules this page adopts:
- Whole-command denies, not argument-constraining allows. Write
Bash(curl *), notBash(curl http://github.com/ *). The vendor calls argument patterns fragile: options before the URL, protocol changes, redirects, shell variables and doubled spaces all defeat them. Put real command parsing in aPreToolUsecommand hook. - Never allow-list an environment runner.
npx,docker exec,devbox runand similar pass the rest of the command through.Bash(devbox run *)authorises everything afterrun. Allow the named inner commands instead, and deny the pass-through forms. - Path rules only on
ReadandEdit. Per Book 3 Ch 8 §4.4, rules written againstWrite,MultiEdit,GloborNotebookEditwith a path are accepted but never consulted [FACT-CHECK]. AWrite(**/.git/config)rule does nothing, so useEdit(**/.git/config). - Anchor paths correctly. Use
~/for home,./for the working directory and//for an absolute filesystem path, for exampleRead(//mnt/c/**)in WSL. A single leading slash anchors at the settings source, not the filesystem root (WP3 §7.2). - Do not rely on denies for subprocesses.
Readdenies cover the file tools and the file commands Claude Code recognises in a shell line. They do not cover arbitrary subprocesses that open files themselves. The sandbox carries theReaddeny paths to sandboxed commands (WP3 §5.2). - WebFetch alone does not stop network access. If Bash is allowed,
curlor any other client can reach the URL. Network control is the sandbox proxy and the egress allow-list. - There is no
.claudeignore. The documentation says such a file has no effect (WP3 §9.2). Exclude files withReaddenies.
Source conflict — Book 3 Appendix B Block 7. The appendix’s deny list includes
Write(**/.git/config),Write(/etc/**)andWrite(/usr/**). By Book 3 Chapter 8’s own later rule, these are never consulted. It also usesBash(curl http*), an argument-constraining pattern. This page follows Chapter 8 and WP3: whole-command denies,Edit/Readpath rules only.
Why the deny list stays at all (WP3 §5.2). It removes the easy cases and produces a telemetry signal when it fires. The file is built so that it does not rest on the denies. The sandbox and the egress allow-list carry the weight.
Model gating
availableModels is the enterprise model allow-list. Per Book 3 Ch 8 §4.3, used alone it leaks by design: the picker’s “Default” entry resolves to the account’s runtime default, which may sit outside the list. enforceAvailableModels: true (v2.1.175+ per Book 3) closes the leak. Book 3’s composite Bank A shipped the list without the flag. During cohort 1, four engineers on “Default” resolved to an unapproved model for a week, and the model usage registry detected it before anyone reported it.
Pin full model IDs, not the floating sonnet/opus/haiku aliases, whenever the register has to name a version. Aliases resolve to per-provider defaults that move on the provider’s schedule. Per Book 3 Ch 8 §7.1, the server-enforced model restriction on Claude Enterprise does not apply on Bedrock or Google routes. There, availableModels plus enforceAvailableModels is client-side software on an endpoint the user controls. The registry, alias-drift and upgrade lifecycle live on model governance.
Source difference. Book 3 App B Block 6 (May 2026) uses aliases (
["sonnet", "haiku"]), gates Opus through a cohort fragment, and setsalwaysThinkingEnabled: false. Book 3 Ch 8 (August 2026) pins full IDs and addsenforceAvailableModels. This page follows Chapter 8. Cohort gating stays valid. On registry delivery, implement it as a tier document, not as a drop-in.
Step 4 — Decide the autonomy defaults before rollout
| Decision | Facts | Options | This page’s recommendation |
|---|---|---|---|
| Auto mode (a classifier model approves actions) | Per WP3 §5.2: from 2.1.283 it is the built-in starting mode for interactive sessions on every plan and provider. Explicit ask and deny rules still apply. A disableAutoMode control set to "disable" exists, but WP3 found the pages inconsistent about whether it sits at the top level or under permissions, so WP3 leaves it out | (a) Start sessions in Manual (defaultMode: "default") but leave auto mode selectable; (b) disable it; (c) allow it only inside a sandbox or container | Manual mode outside a sandbox for regulated tiers; auto mode only inside a sandbox or dev container, after a pilot (WP3 author’s judgement). Book 3 Ch 8 §4.4 adds a caution: banning auto mode without reducing prompt volume pushes engineers towards bypass. Its composite Bank A disables auto mode in production repositories, allows it in the sandboxed development estate, and reviews quarterly [FACT-CHECK: disableAutoMode placement] |
| Bypass mode | The vendor reserves it for isolated containers or VMs without internet access, and says it offers no protection against prompt injection. Claude Code refuses bypass mode as root or under sudo on Linux and macOS | Disable on every managed endpoint | permissions.disableBypassPermissionsMode: "disable" everywhere. In CI use dontAsk instead |
| Dynamic workflows (Claude writes orchestration scripts that run many parallel subagents) | Per Book 3 Ch 8 §4.5 (Aug 2026): enabled by default on Team and Enterprise and disabled on Pro. Subagents nest up to five levels, and their intermediate reasoning does not reach the transcript a supervisor reads [FACT-CHECK] | Leave on; disable per tier with disableWorkflows: true | Disable for repositories at the highest risk tiers until a hook-based supervision pattern exists. Book 3’s Bank A disabled them for payments and core banking only |
| Sandbox auto-allow vs regular permissions | Auto-allow runs sandboxed commands without prompting. Regular permissions keeps prompting inside the sandbox | Per tier | Regular permissions in production-adjacent repositories; auto-allow in the sandboxed development estate (Book 3 Ch 8 §6.3). On Linux, auto-allow absorbs most of the friction of locked rules (WP3) |
Step 5 — Hooks: enforcement and evidence
Hooks are shell commands, or HTTP calls, that run on lifecycle events. They are the only per-action enforcement point the firm controls at the workstation, and the workstation’s evidence stream. Treat approved hooks as code: reviewed, version-controlled and deployed only through managed settings, with allowManagedHooksOnly set.
Operating semantics (per Book 3 Ch 8 §5.2 and App B §6.2)
[FACT-CHECK: all items in this table against the Claude Code hooks reference, as of Nov 2026.]
| Property | Behaviour | Design consequence |
|---|---|---|
| Blocking | PreToolUse and ConfigChange run synchronously and the session pauses | Decide locally and fast; Bank A’s hooks decide in under two seconds and emit to the SIEM asynchronously |
| Timeout | Ch 8 gives a default of 600 seconds for command and HTTP handlers. App B writes per-hook values of 2000–5000, which suggests milliseconds | Confirm the unit before copying App B’s values; a mis-read unit turns a 5-second bound into 83 minutes |
| Block signal | Exit code 2 blocks, and stderr is returned to Claude, so the block also explains itself. Exit 0 with JSON may carry permissionDecision (allow, deny, ask, defer) and rewrite arguments via updatedInput | Put a policy reference in the stderr text |
| Malformed output | From v2.1.214, exit 0 with malformed JSON on PreToolUse blocks | Fail-closed, as wanted |
| Precedence | A hook’s allow does not bypass deny or ask rules. Several hooks on one event run in parallel, and the most restrictive decision wins | Hooks add restrictions on top of the floor and cannot lower it |
| Env expansion | HTTP header variables expand only if listed in allowedEnvVars | Provision the SIEM token at image bake; rotate through the secret workflow |
| HTTP hooks fail open | A non-2xx response, a timeout or a connection failure is a non-blocking error. Only a 2xx carrying a block decision blocks | Every blocking hook is a command hook. HTTP hooks carry telemetry only. Bound them with allowedHttpHookUrls (an empty array blocks all HTTP hooks) and httpHookAllowedEnvVars, which apply to hooks from every source |
The required hook bundle
Book 3 Appendix B §6.1 (May 2026) specifies six hooks. Chapter 8 §5.1 (August 2026) adds a seventh, PreCompact. This page follows Chapter 8.
| # | Event (matcher) | Type | Role | What it does |
|---|---|---|---|---|
| 1 | UserPromptSubmit | HTTP | Evidence | Posts session ID, working directory and host metadata (OS, WSL2 attestation) to the SIEM. Book 3 adds an inline PII redaction pass (IBAN, email, card number) that warns rather than blocks. Prompt content in the SIEM is a works-council and DPIA decision; see Step 8 |
| 2 | PreToolUse (Bash) | command | Enforcement | Parses the full command string, which the pattern matcher cannot do. Blocks rm -rf on system paths, curl/wget to domains off the allow-list, nc, /dev/tcp, reverse-shell shapes and environment runners used as pass-throughs. This is the compensating control for fragile Bash patterns |
| 3 | PreToolUse (Edit; App B uses Edit|Write) | command | Enforcement | Sensitive-file guard: **/.env*, **/secrets/**, **/keystore.*, .git/config and per-project patterns |
| 4 | PreToolUse (mcp__.*) | command | Enforcement | Checks the requested server against the connector broker registry and exits 2 if it is unregistered. In Book 3’s Chapter 1 incident (a composite), this is the line that would have stopped the unregistered server |
| 5 | PostToolUse (all) | HTTP | Evidence | Tool name, input and result (truncated to the first 4 KB) for every successful call. Joins gateway logs on session ID and time. This is evidence, not enforcement, because the call has already run |
| 6 | ConfigChange (all) | command | Tamper detection | Blocks when the source of a settings or skills change is not policy_settings, and raises a high-severity SOC alert. It answers the auditor’s question of who changed the agent’s own policy mid-session |
| 7 | PreCompact (all) | command | Evidence preservation | Ships the full transcript before compaction summarises earlier turns away. Per Book 3 this is the only documented point at which the pre-compaction transcript can be guaranteed. It is the hook teams most often miss |
Optional: if auto mode is enabled, add PermissionDenied, which Book 3 gives as the documented logging point for classifier denials [FACT-CHECK: whether a permissions.deny match also emits a hook event]. SessionStart can record which context files loaded (see CLAUDE.md below).
Configuration shape (field names per Book 3 Ch 8 PR-3 and App B §6.1; illustrative).
{
"hooks": {
"UserPromptSubmit": [{ "matcher": "", "hooks": [{ "type": "http",
"url": "https://siem-ingest.example.internal/claude/prompts",
"headers": { "Authorization": "Bearer $SIEM_TOKEN" },
"allowedEnvVars": ["SIEM_TOKEN"] }] }],
"PreToolUse": [
{ "matcher": "Bash", "hooks": [{ "type": "command", "command": "/opt/claude-code/hooks/bash_guard" }] },
{ "matcher": "Edit", "hooks": [{ "type": "command", "command": "/opt/claude-code/hooks/sensitive_file_guard" }] },
{ "matcher": "mcp__.*", "hooks": [{ "type": "command", "command": "/opt/claude-code/hooks/mcp_registry_check" }] }
],
"PostToolUse": [{ "matcher": "", "hooks": [{ "type": "http", "url": "https://siem-ingest.example.internal/claude/tool_calls",
"headers": { "Authorization": "Bearer $SIEM_TOKEN" }, "allowedEnvVars": ["SIEM_TOKEN"] }] }],
"ConfigChange": [{ "matcher": "", "hooks": [{ "type": "command", "command": "/opt/claude-code/hooks/config_change_guard" }] }],
"PreCompact": [{ "matcher": "", "hooks": [{ "type": "command", "command": "/opt/claude-code/hooks/transcript_ship" }] }]
}
}
Two warnings about hooks themselves.
- Per WP3 §5.4, hooks and MCP servers run outside the sandbox. A hook script is unconstrained code on the host, so review it as you would privileged code.
- Hooks run as the user, and so do their HTTP posts. Treat what they emit as a signal to corroborate against host process telemetry, not as tamper-proof evidence.
Source difference — HTTP hooks versus OTel. Book 3 builds the evidence stream from HTTP hooks to Microsoft Sentinel, and its Appendix B disables vendor telemetry (“out-of-band telemetry beyond the gateway path”). WP3 does not use hooks for evidence. It switches on Claude Code’s OpenTelemetry export by policy, and notes that the hooks’ evidence role was outside its scope. These do not conflict:
CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFICswitches off Anthropic’s operational telemetry, while OTel export goes to the firm’s own backend. This page uses both layers: OTel for fleet-wide signals and source-drift detection, and command hooks for enforcement and its evidence. Whether App B’sDISABLE_TELEMETRYalso suppresses OTel export is unverified [FACT-CHECK].
Step 6 — Sandbox: what it contains, and the Windows decision
Coverage and limits (per WP3 §5.4, 10 Nov 2026)
The sandbox applies operating-system limits on files and network to shell commands and their children. macOS uses the built-in Seatbelt. Linux and WSL2 use bubblewrap, which needs the bubblewrap and socat packages. Native Windows and WSL1 have no sandbox. By default sandboxed commands can write only to the working and temporary directories. Network traffic goes through a proxy that checks each host against an allow-list, which starts empty.
| Limit | Consequence | Compensating control |
|---|---|---|
| Covers shell commands only. File tools, MCP servers and hooks run outside it | Protection for file tools comes from permission rules; MCP and hook code is unconstrained | Set both permission rules and sandbox. Run high-risk MCP work in a dev container or VM |
Default read access covers most of the machine, including ~/.ssh | Credentials readable by sandboxed commands | Read denies (carried into the sandbox); Book 3’s sandbox.filesystem.denyRead, allowManagedReadPathsOnly and sandbox.credentials (v2.1.187+ per Book 3; no built-in list, only what you add) [FACT-CHECK] |
| Silent fallback to unsandboxed if the sandbox cannot start (Book 3 Ch 8 §6.2) | A broken image runs unprotected | failIfUnavailable: true |
| Claude may ask to retry a blocked command outside the sandbox | The Ona escape route | allowUnsandboxedCommands: false |
Proxy does not terminate or inspect TLS. Broad domains such as github.com create exfiltration paths, and domain fronting may reach hosts outside the list | Hostname allow-listing is evadable | A tight list with every entry justified and reviewed quarterly; TLS-inspecting proxy at the boundary for high-trust flows. Book 3 calls the in-sandbox tlsTerminate experimental as of August 2026 and not a basis for a control narrative [FACT-CHECK] |
Inside a container the sandbox needs enableWeakerNestedSandbox, which considerably weakens it | Nested sandbox is not a boundary | Rely on the container’s own isolation and network policy |
excludedCommands has no managed-only lock; developers can always append (Book 3 Ch 8 §6.2) | Commands can be taken out of the sandbox | Keep the managed list narrow; detect excluded-command use from the PostToolUse stream [FACT-CHECK] |
Unix sockets (e.g. /var/run/docker.sock) give effective host access | Privilege escalation | allowUnixSockets: false (App B); exceptions per project and per socket through change advisory [FACT-CHECK: key name and default] |
| The environment, including any secrets in it, passes to sandboxed commands | Secrets in env are readable | Keep secrets out of the agent’s environment (Step 8) |
The vendor summary, as WP3 quotes it, is that sandboxing reduces risk but is not a complete isolation boundary. It needs both halves: without network isolation files can be exfiltrated, and without filesystem isolation a network path can be opened. Where a whole-process boundary is required, use a per-repository dev container with only that repository mounted, a firewall on its network and no host credentials. Book 3 classes Anthropic’s @anthropic-ai/sandbox-runtime wrapper as a beta research preview, and not a control to anchor a compliance claim on (Aug 2026) [FACT-CHECK].
Platform prerequisites
| Platform | Requirement | Verify with |
|---|---|---|
| macOS | Seatbelt is built in | /status |
| Linux, WSL2 | bubblewrap and socat in the image. Ubuntu 24.04+ needs an AppArmor profile for bubblewrap’s user namespaces, without which sessions fall back to unsandboxed (Book 3 App B §3.3, Ch 8 §6.1). The optional seccomp filter for Unix-socket routes installs separately [FACT-CHECK] | bwrap --version; aa-status | grep claude; /status shows sandbox enabled |
| WSL1 | Not supported; needs kernel namespaces | Intune WSL settings disable WSL1 |
| Native Windows | Not supported; commands run unsandboxed | — |
Native Windows or WSL2
Per WP3 §6.5, Anthropic’s own table marks sandboxing “Not supported” on native Windows and “Supported” on WSL 2. Telemetry from WSL carries wsl.version and os.type, so the split is visible without extra tagging.
| Stance | Source | Mechanism | Accept when |
|---|---|---|---|
| WSL2 by default; native Windows allowed under a stricter variant | WP3 §6.5 | Omit failIfUnavailable from the native-Windows document. File-reach key, locks, endpoint application control and EDR carry more weight. Expect locked rules to be felt (no sandbox auto-allow) | Windows-native development (for example .NET desktop) in lower tiers |
| WSL2 (or container/VM) only | Book 3 Ch 8 §6.1, App B §3.2 | Intune compliance blocks Claude Code on hosts without WSL2 attestation. Inference, to be tested: with failIfUnavailable: true in the single HKLM document that WSL inherits, a native Windows session refuses to start while WSL2 sessions run sandboxed | Regulated tiers; the firm cannot accept permission prompts as the only enforcement layer |
Recommendation. Use WSL2 for all agentic work in regulated tiers. Allow native Windows only for named lower-tier populations, as a recorded exception. One friction, per Book 3: sandboxed commands in WSL2 cannot call Windows binaries under /mnt/c/, and the workaround (excludedCommands) runs them outside the sandbox. Keep Windows-native tooling as a separate surface rather than carving exceptions into the Claude Code one. Book 3’s composite Bank A granted one of three WSL2 exceptions, carving a legacy tooling group out of Claude Code entirely until migration.
In WSL, blockReadsOutsideWorkingDirectories stops the file tools reading Windows files under /mnt/c. Where an explicit rule is wanted, use Read(//mnt/c/**).
Windows endpoint posture and the processWrapper gap
- No local administrator rights for developers. An administrator can edit the managed policy (WP3 §6.2).
- EDR, application control over what spawned processes may run, and credential protection form the outer wall. The user-profile installer needs no admin rights, so application control is the only way to stop unaided installs. The binary is signed by “Anthropic, PBC”, which gives a publisher to write rules against. WP3 did not test such a rule. The
HKLMpolicy applies to whatever the user installs. - Do not enable WebDAV or let Claude Code reach paths that may contain WebDAV subdirectories. The vendor warns that this can trigger network requests that bypass the permission system. Claude Code prompts before commands naming UNC paths.
- Per Book 3 Ch 12 §4.9 (Aug 2026),
processWrapperforces every process Claude Code launches through a corporate launcher on macOS, Linux and WSL, and refuses to start rather than run unwrapped. On Windows it is ignored, because the mechanism depends onexec. The architecture isprocessWrapperwhere it works, and AppLocker/WDAC plusHKLMmanaged settings on native Windows. Record the Windows residual as an accepted risk signed by the CISO, not as coverage [FACT-CHECK:processWrapperkey and platform support].
Multi-session virtual desktops (WP3 §6.3)
Prefer personal host pools or cloud desktops for agentic work. Where multi-session hosts are used:
- keep profiles separate and give each user a separate working directory;
- apply the strictest tier;
- treat
~/.claudeas confidential; - remember that Windows credentials sit in a profile file protected only by profile ACLs;
- remember that a loopback telemetry receiver is shared by every user on the host (Step 7).
Bake the client version, policy and telemetry agent into the image, so that a rebuilt host is compliant at first boot. A dedicated cloud desktop is a sound default for contractors: it applies firm policy and the firm’s network path, and keeps code off unmanaged hardware.
Step 7 — Network, proxy and mutual TLS
Egress allow-list. Per WP3 §9.1, the essential hosts for the Anthropic route are:
api.anthropic.comfor model requests;claude.ai,claude.comandplatform.claude.comfor sign-in;sso.claude.comwhere SSO is used;downloads.claude.aifor the installer and updates.
Book 3 Ch 6 §4.3 lists the full published table as of August 2026, including mcp-proxy.anthropic.com, storage.googleapis.com, bridge.claudeusercontent.com, raw.githubusercontent.com, code.claude.com and two Datadog intake hosts [FACT-CHECK: current list on the network-configuration page]. Enforce the list at the cloud firewall for desktops and build agents, and at the secure web gateway for laptops.
Residual Anthropic egress on third-party routes. On a Bedrock, Google or Foundry route, model traffic goes to the provider. However, WebFetch still sends the hostname to api.anthropic.com for a safety check unless skipWebFetchPreflight is set. Per Book 3 Ch 10 §5.3, CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC does not stop that check. Update traffic to downloads.claude.ai also continues unless updates are pinned and disabled (Book 3 Ch 6 §4.3). Book 3’s closed-perimeter profile (Ch 6 §4.3; repeated in Ch 12’s landing-zone checklist) is:
CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1;skipWebFetchPreflight: true, compensated by explicit WebFetch permission rules, or WebFetch denied as in the WP3 baseline;DISABLE_UPDATES, which obliges the firm to run an internal binary channel, since security fixes then arrive only when the pin moves.
Name these flows in the data-flow inventory either way.
Proxy mechanics (per Book 3 Ch 6 §4.3 and WP3 §9.1).
HTTPS_PROXY,HTTP_PROXYandNO_PROXYare honoured, can be set in the managedenvblock, and are read once at startup.- SOCKS is not supported.
- Proxy authentication beyond Basic is out of scope. For an NTLM- or Kerberos-only estate, Book 3 gives the documented remedy as an LLM gateway in the path.
- The client trusts the OS certificate store. A TLS-inspecting proxy (Book 3 names Zscaler and CrowdStrike Falcon) works once its root is installed there.
- For mutual TLS to the gateway,
CLAUDE_CODE_CLIENT_CERTandCLAUDE_CODE_CLIENT_KEYcarry the client certificate. Book 3 says they are re-read on settings change, so rotation is a file replacement, and thatCLAUDE_CODE_CERT_STOREselects the CA store [FACT-CHECK: variable names and re-read behaviour]. - Per Book 3 Ch 12, in app-managed sessions these variables are read only from managed settings and the user’s own file, so a checked-out repository cannot redirect the TLS path.
Tenant Restrictions. A TLS-inspecting proxy injects an anthropic-allowed-org-ids header on requests to Anthropic’s domains. Anthropic then blocks organisations not on the list (Enterprise plans and Console organisations; API-key and OAuth authentication). Per WP3 §9.1, the help article does not name Claude Code, although the Claude Code documentation points to it. Test it before relying on it.
Route binding through the managed env block. Per Book 3 Ch 8 §7, the managed env block replaces inherited shell values at start-up, and setting a variable to "" force-unsets a shell export. That makes it the enforcement point for ANTHROPIC_BASE_URL (gateway route) or CLAUDE_CODE_USE_BEDROCK/CLAUDE_CODE_USE_VERTEX plus region (cloud routes). A route deviation then shows up as a deployment failure, not as an engineer’s choice.
Open compatibility question. Book 3 App B combines
forceLoginMethod: "claudeai"with anANTHROPIC_BASE_URLpointing at the bank’s APIM. WP3’s baseline uses the Enterprise route with no base URL, and notes that a non-default base URL turns off the server-managed fetch. Whether claude.ai sign-in sessions can be routed through a customer gateway in this way, and what valueallowedProvidersthen takes, is unverified [FACT-CHECK]. Book 3 Ch 8 PR-2 also uses"oauth"as theforceLoginMethodvalue where App B and WP3 use"claudeai". This page follows WP3.
Step 8 — Data on and from the workstation
What leaves the machine (WP3 §9.2)
The prompt and its context leave the machine: code, file contents and command output. Under commercial terms, Anthropic does not train on Claude Code prompts or code. Standard retention for Team, Enterprise and API is 30 days. Zero data retention is available for Claude Code only to qualified Enterprise accounts, enabled per organisation. It disables features that need server-side storage, and on cloud-provider routes the provider’s retention applies. Per Book 3 Ch 10, ZDR follows the authenticated organisation, not the device, so the login pin is also the ZDR precondition. Endpoint DLP does not see inside the TLS session to the model endpoint, so do not count on it for this channel. Use a gateway route if inline inspection is required. Decide which data classes and repository tiers may be worked on with Claude Code at all, and on which route.
Secrets
Services use workload identity against the secret store, pipelines use store-linked variables, and developers use short-lived tokens. The sandbox passes Claude Code’s environment, including any secrets in it, to the commands it runs. Any user on a machine can read managed-mcp.json, so it must hold no credentials. Scan agent-written changes before merge, because an agent shown a credential may repeat it (WP3 §9.3). See identity and secrets.
The workstation is a processing location
ZDR is a server-side property and does nothing to the laptop. Per WP3 §9.4 and Book 3 Ch 10 §5.3:
- Transcripts are stored in plaintext under
~/.claude/projects/for 30 days by default, to support session resumption. Book 3 found no supported way to disable local persistence entirely [FACT-CHECK]. - On Windows and Linux, credentials are protected by file permissions only. The same endpoint holds the transcripts and the token.
- The feedback commands (
/feedback,/bug,/share) send conversation history, including code, to Anthropic with five-year retention (per Book 3) [FACT-CHECK].
A board pack can therefore say “zero data retention” while thousands of laptops hold weeks of cleartext source excerpts. Each statement is true on its own, and together they mislead.
Endpoint and retention baseline (Book 3 Ch 10 PR-2, with WP3 values):
| # | Control | Setting or action | Owner |
|---|---|---|---|
| 1 | Pin sessions to the covered organisation | forceLoginMethod, forceLoginOrgUUID | Identity engineering |
| 2 | Shorten local transcript retention | cleanupPeriodDays (WP3: 14; Book 3’s Bank A: 7) | Security engineering |
| 3 | Bring transcripts into endpoint scope | Classify ~/.claude/ as confidential; endpoint DLP rule; full-disk encryption check; exclude from backup and sync paths into lower-trust storage | Endpoint security |
| 4 | Block feedback exfiltration | DISABLE_FEEDBACK_COMMAND=1 in managed env (needed where ZDR is not enabled; ZDR disables the commands at the backend, per Book 3) | Security engineering |
| 5 | Disable non-essential traffic | CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1 | Security engineering |
| 6 | Decide the WebFetch preflight | Allow api.anthropic.com at the proxy, or skipWebFetchPreflight plus WebFetch rules | Network + security |
| 7 | Name the workstation in the GDPR Article 30 record of processing | Update the record | DPO |
| 8 | Record ZDR carve-outs | DPIA and records schedule | DPO |
| 9 | Store ZDR enablement evidence per organisation | Third-party register file | Risk / vendor management |
| 10 | Agree the position on prompt content in the SIEM | Works-council agreement and DPIA before the stream goes live; prompt content in a SIEM is employee monitoring | DPO + HR + SOC |
Presence-based flags (Book 3 Ch 8 §7). The DISABLE_* variables act on presence. DISABLE_TELEMETRY=0 disables telemetry. A compliance script that sets “0” to mean “on” will be wrong [FACT-CHECK]. Verify the merged env block with /status, and confirm the result with the retention_sweep telemetry event (WP3 §9.4), which shows whether machines apply the managed retention period. Legal treatment of these records is on the regulatory map.
Step 9 — Telemetry, detections and the evidence pack
Configure the export (per WP3 §10, 10 Nov 2026)
Claude Code exports OpenTelemetry metrics and events (as OTel logs); traces are in beta. Export is off until configured, so monitoring is a policy decision. Two properties make the managed configuration trustworthy:
- From 2.1.282, OTel exporter variables in a repository’s settings files are ignored, so a repository cannot turn telemetry on, redirect it or capture content.
- When an OTLP variable is set in managed settings, conflicting developer-set variables are removed at startup.
| Transport | Use where | Caution |
|---|---|---|
Local agent receiver on 127.0.0.1:4317 | Single-user hosts, build agents | Bind the receiver to loopback. Datadog’s Claude example shows 0.0.0.0; Datadog’s own OTLP page says 0.0.0.0 is used for convenience. OTLP log ingestion is off by default (Agent 7.48.0+) |
| Direct to intake | Hosts without an agent | Needs a distributed API key |
| Central collector | Multi-session hosts; anywhere credentials should stay server-side | Loopback is per host, not per user, and an unauthenticated receiver lets any user forge another’s telemetry |
What arrives.
- Metrics (
claude_code.prefix):session.count,active_time.total,cost.usage,token.usage,lines_of_code.count,commit.count,pull_request.count,code_edit_tool.decision. - Events:
user_prompt,api_request,api_error,tool_resultandtool_decision, linked byprompt.id. - Security-relevant events:
permission_mode_changed,auth,mcp_server_connection,safety_event(2.1.307+),managed_settings_resolved(2.1.274+) andretention_sweep. tool_decisioncarriesdecisionofacceptorrejectand asourcesuch asconfig,hookoruser_reject. A filter ondecision=denymatches nothing.service.nameisclaude-codefor the terminal andclaude-code-desktopfor the desktop app. Filters need both.
Identity depends on the route. user.email, user.account_uuid and organization.id appear only on Claude-account sessions. On API-key, Bedrock, Google or Foundry routes only user.id (a random installation ID) and session.id are populated. Attach identity there with OTEL_RESOURCE_ATTRIBUTES set by a launch wrapper.
Content is off by default. Content is controlled by OTEL_LOG_USER_PROMPTS, OTEL_LOG_ASSISTANT_RESPONSES, OTEL_LOG_TOOL_DETAILS and OTEL_LOG_TOOL_CONTENT. Leave prompt and response content off and record that choice. Enable OTEL_LOG_TOOL_DETAILS (command strings, MCP server and tool names) only into a store approved for source-level content.
Detection rules
These are WP3 §10.3 monitors (OTel) and Book 3 Ch 8 PR-4 rules (hooks to SIEM). All are design proposals.
| Detection | Signal | Severity / routing | Threat | Source |
|---|---|---|---|---|
| Telemetry gap (build first) | Host agent sees a claude process; no claude-code telemetry from that host | High | T8: policy removed, export blocked, client replaced | WP3 |
| Policy source drift | managed_settings_resolved with managed_settings.sources not the expected source | High | Device policy displaced (Step 2) | WP3 |
| ConfigChange from non-policy source | ConfigChange event with source ≠ policy_settings | High; Tier 2 immediately | T8 | Book 3 |
| Mode escalation | permission_mode_changed to bypassPermissions outside the CI allow-list | High | T3, T8 | WP3 |
| Unauthorised MCP attempt | PreToolUse deny on mcp__.* | Tier 2 | T5 | Book 3 |
| Sensitive-file attempt | PreToolUse deny on the sensitive-file guard | SOC, with engineer identity and project | T4 | Book 3 |
| Bash blocklist hit | PreToolUse deny on Bash | Self-service triage; Tier 2 on a second hit by the same engineer within 24 h | T1, T3 | Book 3 |
| Sandbox unavailable / excluded command | Session reports sandbox unavailable, or PostToolUse shows a command in excludedCommands | Tier 2 | Runtime gap | Book 3 |
| Rejection spike | tool_decision decision=reject, or safety_event category managed_policy/permission_rule, above a per-user baseline | Medium | T1 or probing | WP3 |
| Unknown organisation | organization.id not the firm’s, or user.email outside the domain (subscription route only) | High | T6 | WP3 |
| CI privilege drift | tool_result from an edit or shell tool in a read-only pipeline profile | High | T7 | WP3 |
| Cost anomaly / API error surge | claude_code.cost.usage per team or pipeline; api_error rate | Medium | Runaway loops; misconfiguration | WP3 |
The telemetry-gap monitor is the one that still works after everything else has been switched off, because it compares what the tool reports with what the host reports. The client emitting telemetry runs as the user, so the user can always fabricate it. Host process telemetry (EDR, or the kernel audit subsystem on Linux) is the independent record, and it wins when the two disagree. The vendor emits the raw event stream only; baselining, correlation and alerting are the backend’s job. Write sequence detections as well, for example many file reads followed by a rejected network attempt.
False positives are fixed by policy, not by tickets (Book 3 Ch 8 PR-4). Triage to a 24-hour objective for the first cohort and 48 hours at general availability. Every false positive lands as a policy change in the next tier document or fragment, through change advisory. Never grant a per-engineer exception. Book 3 reports that its composite cohort’s false positives fell to near zero by week three on that rule. In the same composite, a curl to the internal artefact repository from a three-year-old build script took 18 hours to resolve and was formalised in the cohort fragment.
Evidence pack (WP3 §11; Book 3 App B §8)
| Evidence | Proves | Retain |
|---|---|---|
| Version history of the managed policy and hook bundle, with change records | Control design and change control (policy change is a control change) | Firm’s evidence horizon |
| Device-management compliance reports (policy present, version floor, WSL2 attestation) | Deployment | Per cohort gate and annually |
managed_settings_resolved events, monitor history, detection outcomes | Operating effectiveness | As above |
| Compliance API / audit-log export (Enterprise only; not available for Foundry per WP3), including changes to server-managed settings | Administrative record | As above |
| Synthetic-test results per cohort gate (below) | Controls fire end to end | Per gate |
Route events into the audit evidence spine. Claude-related incidents follow incident response.
Step 10 — The regulated CI invocation profile
The interactive profile cannot run on build agents, because the login keys block workload credentials. Non-interactive use is also where the agent becomes an unattended actor holding pipeline privileges (T7).
Documented behaviours that set the profile (per WP3 §8).
claude -pruns a project’s.claude/settings.jsonhooks and connects its.mcp.jsonservers, even in an untrusted folder, without a trust dialog. A pull request that adds a hook is asking the pipeline to run a command.--allowedToolspre-approves; it does not restrict. Use--toolsto restrict built-in tools.--toolsdoes not affect MCP tools, so add--disallowedTools "mcp__*".- From 2.1.302, runs with no mode start in Manual mode, where calls that need approval are denied.
dontAskmakes the denial explicit.
Profile.
-
Where it runs. Use self-hosted scale-set agents built from a custom image with the pinned client and the CI policy, torn down after each job, with egress restricted on the subnet. Container jobs on those agents are stronger (from agent 5.279.0 the host Docker socket is not mounted by default). Network restriction comes from the subnet, not the container. Avoid Microsoft-hosted agents for this, because everything would then come from the pipeline definition, which a pull request can change.
-
Policy in the image, not the repository. Bake a CI
managed-settings.jsoninto the image that sets:allowManagedPermissionRulesOnly, so--allowedToolsand repository rules are ignored;allowManagedHooksOnly, so repository hooks do not run;- an empty
managed-mcp.json, so repository MCP servers do not load; allowedProvidersset to the pipeline’s provider;- and it omits the two login keys.
Require reviewer approval for changes to pipeline definitions and
.claude/. -
Split the pipeline. No deployment-capable credential in any job that runs an agentic step on untrusted input. The unprivileged agentic stage produces artefacts. A non-agentic stage behind a human or deterministic gate consumes them, and treats them as attacker-influenced text. See release engineering.
-
Credentials. Use workload identity (Foundry with Entra ID, where there is no key to store), or a secret-store-linked variable group.
-
Invocation. Use
claude -pwith--tools(a read-only set such asRead,Grep,Globfor review),--disallowedTools "mcp__*",--permission-mode dontAskand--output-format json. -
Evidence and fail-fast (per Book 3 Ch 9 §5.3, Aug 2026). Archive
session_idandtotal_cost_usdfrom the JSON output for every run. Hard-fail the pipeline if thesystem/initevent has a non-emptymcp_server_errorsorplugin_errorsarray, because otherwise a control is silently absent. Book 3 also recommends--bare(no auto-discovery of hooks, plugins, MCP servers or memory files, and no keychain OAuth) [FACT-CHECK: whether--barealso skips managed hooks; if it does, it conflicts with a managed evidence hook in the image]. -
Telemetry mandatory, with pipeline and project resource attributes.
-
No bypass mode.
dontAskwith managed allow rules gives a fixed envelope. Mandatory checks go inPreToolUsehooks, never in an SDKcanUseToolcallback, because auto-approved tools never reach the callback (Book 3 Ch 9). -
Human review for effects. Code changes arrive as a pull request and branch policy enforces review.
Source difference. Book 3 Ch 9’s reference invocation scopes the run with
--allowedToolsanddontAsk. WP3’s image policy setsallowManagedPermissionRulesOnly, which makes--allowedToolsignored. Under WP3’s design, the allowed set belongs in the image’s managed rules and restriction comes from--tools. This page follows WP3. Use Book 3’s evidence and fail-fast items on top.
IDE extensions and CLAUDE.md
IDE extensions (Book 3 App B §7, May 2026). The VS Code and JetBrains extensions read the same managed settings and run the same hook bundle as the CLI. PreToolUse and ConfigChange block IDE-initiated actions on the same code path. The firm controls the install path, not the extension binary.
- VS Code: publish the extension through Intune or an internal gallery, version-pinned to the CLI release. Block public-marketplace installs with VS Code enterprise policy:
extensions.allowed,extensions.autoUpdate: falseandextensions.gallery.serviceUrlpointing at the internal gallery. - JetBrains: publish through an internal plugin repository and set
idea.plugins.host. Block the public marketplace withidea.plugins.allow-from-repo-only=true.
[FACT-CHECK: all VS Code and JetBrains policy names, and inheritance of managed settings by the extensions, as of Nov 2026.]
Acceptance check: /status, /permissions and /mcp run from the IDE panel must match the CLI output. Any divergence is a deployment defect.
CLAUDE.md as labelled guidance (Book 3 Ch 8 PR-5). Every in-scope repository carries a root CLAUDE.md, explicitly marked guidance, not control. A pre-commit hook validates its mandatory sections:
- project identity (repository, owning team, contact, sensitivity class);
- team-specific approved Bash patterns above the floor (usually none) and sensitive-file patterns that feed the managed hook;
- MCP servers in scope, with broker IDs;
- risk tier and critical-or-important-function (CIF) flag, which decide the tier document and whether
disableWorkflowsapplies; - review cadence: quarterly for higher tiers, six-monthly for the lowest, with a named reviewer.
A SessionStart hook records which context files loaded. That makes the guidance auditable even though it is not enforceable. A weekly governance scan flags absent or stale files. Anything that must bind goes in managed settings or a hook.
Rollout: cohorts, gates and exceptions
Phases (WP3 §12.2; proposal and estimated durations).
| Phase | Weeks | Content | Exit criteria |
|---|---|---|---|
| 0 Decide | 1–2 | Per use case, the route; then hosting option, repository tiers, a single managed source, the auto-mode position, the acceptable-use policy and the register entry | Baseline and tier map signed off |
| 1 Pilot | 3–6 | About 10 developers on Windows with WSL2, plus one Linux pipeline; registry policy with WSL inheritance; telemetry path | Telemetry from every pilot session; /status shows the expected source on every machine |
| 2 Harden | 6–10 | Tune rules from real use; sandbox on without unsandboxed retry; telemetry-gap, mode-escalation and source-drift monitors; CI image profile | Two weeks without monitor noise; a tamper test is caught |
| 3 Scale | 10–16 | Rings across teams, virtual desktops and Linux; contractor pattern; team budgets | Every surface covered; evidence pack produced |
| 4 Operate | Ongoing | Quarterly policy review against the documentation; version floor raised; MCP allow-list board; injection exercises | Recurring review records |
Book 3’s composite Bank A ran faster (Ch 8 §8):
- cohort 1 was 40 senior engineers from the team accountable for the previous incident, with the full package in week 1 and the first fixes by week 3;
- cohort 2 was 60 platform engineers, then roughly doubling: 400 engineers by week 8, 900 by week 12 and the full 12,000-seat estate by week 24.
Book 3 Ch 8 PR-1 adds a cadence for general availability: weekly hook-volume review for the first quarter, quarterly after that.
Use the pilot’s rejection and prompt counts to set strictness from data. Too strict, and developers route around the tool. Too loose, and the policy is decoration.
Version cadence (WP3 §6.1).
- Package a pinned version. WinGet
Anthropic.ClaudeCodedoes not self-update. - Use
autoUpdatesChannel: "stable", which runs about a week behind latest, orDISABLE_AUTOUPDATER/DISABLE_UPDATESwith an internal ring. - Bound what may start with
requiredMinimumVersionandrequiredMaximumVersion. - Several controls on this page exist only above a specific build, so the version floor is itself a control.
Cohort-gate verification (Book 3 App B §8; run at commissioning, at every gate and annually as an IT general control).
| # | Test | Pass condition |
|---|---|---|
| 1 | /status | Managed settings loaded from the expected source (WP3 Setting sources line); version at or above the floor; route matches the cohort |
| 2 | /permissions | Only managed rules; bypass disabled; no rule sourced from user or project scope |
| 3 | /mcp | Visible servers equal the allow-list minus denies |
| 4 | Synthetic Bash block (e.g. a harmless rm -rf on a scratch path) | Exit 2 from the Bash guard; SIEM record at high severity within 60 seconds |
| 5 | Synthetic sensitive read (.env) | Read deny fires; SIEM or OTel record arrives |
| 6 | Synthetic MCP call to an unregistered server | Registry check exits 2; record arrives |
| 7 | Synthetic prompt | UserPromptSubmit record carries session, working directory, host metadata, redacted body |
| 8 | Tamper: add an allow to ~/.claude/settings.json | ConfigChange blocks; high-severity record with source ≠ policy_settings |
| 9 | Device compliance | 100% of the cohort on the baseline; WSL2 attestation compliant on every Windows device |
| 10 | Sandbox | /status shows enabled and fail-if-unavailable; bwrap --version; AppArmor profile loaded on Ubuntu 24.04+ |
| 11 | Source drift (added by this page from WP3 §5.1; not in App B) | Saving a test key in a non-production console organisation is visible in managed_settings_resolved |
Exceptions. Route every exception and baseline change through the change process (Book 3’s Virtual CAB). Each needs a named owner, a stated cohort scope and an expiry date. Book 3 warns that a managed-settings diff which grows monotonically, with no compensating denies, is drift that nobody can defend in audit.
Ownership
WP3 §11 names four owners (security engineering, platform, application security, risk). This page adds identity engineering, the SOC, the DPO, internal audit and the developer from the Book 3 chapters cited above.
| Role | Owns |
|---|---|
| Security engineering | Policy baseline and tier documents; hook logic; detections content; quarterly re-check against the documentation |
| Platform engineering | Packaging, version rings, delivery channels (Intune, configuration management, images), telemetry plumbing, developer experience |
| Identity engineering | Organisation pinning, SSO/SCIM, workload federation, credential precedence |
| Application security | Repository tiering, review gates, the CLAUDE.md standard, the CI split |
| SOC | Detection response, false-positive triage SLOs, telemetry-gap follow-up |
| Data protection officer | Article 30 entry for the workstation, DPIA, the position on prompt content in telemetry |
| Risk and vendor management | ICT third-party register entry per route; materiality; the record of accepted residual risks (native Windows, processWrapper), which the CISO signs per Book 3 Ch 12 |
| Internal audit | Annual cohort-gate re-run as an IT general control; evidence pack review |
| Developer or pipeline owner | Accountable for what is committed and deployed. Agent output passes the same review and branch protection as human code, and the agent never becomes an unreviewed committer (WP3 §11) |
Per WP3 §11, Claude Code should pass through existing frameworks as an ICT third-party service and an internal tool. That means a register entry per route (Anthropic as provider on every route, including Foundry), an AI inventory entry with an accountable owner, and a processing agreement and records of processing per route. Article-level mapping is on the regulatory map and the control map.
Failure modes and recovery
| Failure | How to recognise it | Recovery |
|---|---|---|
| Baseline shipped without lock flags | /permissions shows rules sourced from user files; developer-added MCP servers visible in /mcp | Set all allowManaged*Only flags and the sideload locks; re-sample weekly for a quarter |
| Device policy silently displaced by a console key | Source-drift monitor; /status names the server source | Clear the console, or adopt managedSourcesBehavior: "merge" deliberately |
| WSL running under a user-writable file | WSL /status names /etc/claude-code; no wslInheritsWindowsSettings | Set inheritance in HKLM; remove reliance on the in-distribution file |
| Invalid JSON in a managed file | Claude Code fails to start fleet-wide after a release | Schema-validate in the pipeline; roll back the document; WP3 notes the published schema can lag the CLI |
| Enforcement wired as an HTTP hook | A gateway timeout lets through the action the hook was written to deny | Convert every blocking decision to a command hook |
| Hooks emit, nobody watches | SIEM ingests Claude events with no analytics rules referencing them | One detection per hook event; review volumes weekly at first |
| Sandbox silently absent | Sandbox-unavailable detection; /status; Ubuntu 24.04 without the AppArmor profile | failIfUnavailable: true; fix the image |
| Native-Windows sidestep | Claude process with no WSL2 attestation; os.type and wsl.version in telemetry | Block at device compliance, or record as an exception with expiry |
availableModels without enforceAvailableModels | Usage registry shows an unapproved model resolved via “Default” | Add the flag; pin full IDs; reconcile on model governance |
Telemetry receiver on 0.0.0.0 or shared loopback | Telemetry from unexpected senders; multi-session hosts | Bind to loopback; central authenticating collector on shared hosts |
| Guidance counted as control | RCSA cites CLAUDE.md or skills as preventive | Re-sort into the two columns; move what can move into settings or hooks |
| Permissions drift across cohorts | Managed diff only ever grows | Change process with owner, scope and expiry per exception |
| Pipeline runs repository hooks or MCP | system/init lists unexpected servers; repository .claude/ changed in a pull request | CI policy in the image; empty managed-mcp.json; reviewer gate on .claude/ |
Acceptance checks
- One managed source per surface;
/statusconfirms it on Windows, WSL2, Linux, macOS and CI; console managed settings empty or deliberately merged. - Windows policy at
HKLM\SOFTWARE\Policies\ClaudeCode; WSL inherits it; WSL1 disabled. - Login method, organisation and provider pinned by device policy; no API keys on endpoints.
- Bypass mode disabled; permission rules, hooks and MCP servers locked to the managed set; sideload flags closed.
- Permission rules meet the authoring standard: no argument-constraining allows, no environment runners, no
Write/Globpath rules. -
availableModelswithenforceAvailableModelsand full model IDs. - Auto mode, workflows and sandbox mode positions recorded per tier.
- Every blocking hook is a
commandhook; the bundle includesConfigChangeandPreCompact; HTTP hook URLs bounded. - Sandbox on with
failIfUnavailableand no unsandboxed retry on Linux, WSL2 and macOS; prerequisites verified; domain list justified entry by entry. - Native Windows either blocked or covered by a recorded, expiring exception with application control and the
processWrapperresidual accepted. - Telemetry on by policy; receiver on loopback or a central collector; content variables off unless approved.
- Telemetry-gap, source-drift, mode-escalation, ConfigChange and cost detections active; a tamper test detected.
-
cleanupPeriodDaysset; feedback commands blocked; workstation named in the Article 30 record; DPIA covers carve-outs and SIEM content. - CI policy in the image; agentic stage unprivileged; privileged stage gated; init-event errors fail the job.
- Cohort-gate tests 1–11 pass and are filed in the evidence pack.
Source conflicts recorded on this page
| Topic | Book 3 says | WP3 / later source says | This page follows |
|---|---|---|---|
| Windows registry path | App B: HKLM\SOFTWARE\Anthropic\ClaudeCode | WP3 and Ch 8: HKLM\SOFTWARE\Policies\ClaudeCode | WP3 (App B error noted for manuscript correction) |
| Source combination | App B: “registry takes precedence if both present”; Ch 8 flags dual delivery as unconfirmed | WP3: first source delivering any key wins; others ignored silently; merge only by managedSourcesBehavior | WP3 |
| WSL policy | App B: /etc/claude-code inside WSL2 governs | WP3: user-writable on WSL; use wslInheritsWindowsSettings | WP3 |
| MCP allow-list identity | App B: serverName entries | WP3, Ch 8 PR-2: name entries are not a security control; use serverUrl or command | WP3 (App B noted for correction) |
Write path deny rules | App B uses them | Ch 8: never consulted | Ch 8 |
| Hook count | App B: six | Ch 8: seven (adds PreCompact) | Ch 8 |
| Vendor telemetry | App B: disable; evidence through HTTP hooks | WP3: OTel export by policy to the firm’s backend | Both, as layers |
| Native Windows | Book 3: WSL2 only | WP3: WSL2 default, native allowed under stricter variant | Tier-dependent decision |
forceLoginMethod value | Ch 8 PR-2: "oauth" | WP3, App B: "claudeai" | WP3 |
| Model list | App B: aliases | Ch 8: full IDs + enforceAvailableModels | Ch 8 |
disableAutoMode | App B: top-level, disabled | WP3: placement inconsistent in docs; left out | WP3 (decision per tier) |
| CI tool scoping | Ch 9: --allowedTools + dontAsk | WP3: --tools restricts; image lock ignores --allowedTools | WP3 |
| Version floor | App B: v2.1.130+ (May 2026) | WP3: 2.1.302 (Nov 2026) | WP3 |
Provenance and refresh
The primary source is Research Paper 3, especially:
Hooks, lock flags beyond the base three, the authoring standard, IDE policy, rollout gates and the endpoint retention baseline come from Book 3 Chapters 5, 6, 8, 9, 10 and 12 and Appendix B. These are dated August and May 2026 and were not re-verified.
Re-check procedure (WP3 §13), at every Claude Code release that touches settings and at least quarterly:
- Open the Claude Code settings reference, the managed-settings page, the permissions, sandboxing, hooks and monitoring pages, and the changelog from the firm’s current floor forward. WP3’s references give the pages, for example
code.claude.com/docs/en/managed-settingsandcode.claude.com/docs/en/settings-reference. - Confirm each key in the base and overlay documents, its scope and its minimum version. Clear or keep each [FACT-CHECK] marker on this page.
- Run
claude doctorand/statuson one machine per surface and compare theSetting sourcesline with the intended source. - Validate the policy documents against the published JSON schema, remembering that it can lag the CLI.
- Re-run cohort-gate tests 4–8 and 11.
Source material
- Research Paper 3, Securing Claude Code in the Enterprise (version 1.0, November 2026; vendor facts verified against documentation on 10 November 2026) — §3 threat model and control philosophy; §4 identity and tenancy; §5 managed settings, baseline policy, MCP and hooks, sandboxing; §6 Windows estate; §7 Linux and WSL2; §8 CI/CD; §9 network and data; §10 monitoring; §11 governance mapping; §12 roadmap and checklist; §13 limitations
- Book 3 (Deploying Claude Safely), Chapter 8, Claude Code at the Workstation (Draft 2, August 2026) — guidance versus control, lock flags, permission-rule authoring, auto mode and dynamic workflows, the seven required hooks, hook semantics, sandbox defaults, managed env block, cohort rollout, anti-patterns, PR-1 to PR-5
- Book 3, Appendix B, Claude Code Enterprise Settings Baseline (Draft 1, May 2026) — settings hierarchy, per-OS deployment, reference managed-settings.json, lockdown field matrix, six-hook bundle, IDE extension policy, cohort-gate verification checklist
- Book 3, Chapter 5, Identity and Access (§4.2 credential precedence; PR-3 configuration starting points)
- Book 3, Chapter 6, The LLM Gateway and Policy Decision Point (§4.3 egress, proxy and mutual TLS; §5.2 the Claude apps gateway)
- Book 3, Chapter 9, The Anthropic API and Agent SDK (§5.3 permission pipeline and regulated CI invocation; PR item 8)
- Book 3, Chapter 10, Data Classification, Retention and DLP (§5.3 what stays on the endpoint; §9 anti-patterns; PR-2 endpoint and retention baseline)
- Book 3, Chapter 12, The Landing Zone Tied Together (§4.9 processWrapper; §6.1 named exceptions)
Related research
Related guidance
-
Identity, Secrets and Configuration for Agent WorkloadsGive every actor one owned identity, size its authority for the worst case, separate runtime from deployment, federate instead of holding keys, refuse impersonation and silent fallback, govern configuration by class, and audit the estate until flagged identities decline. -
Govern MCP Connectors Through a BrokerAdmit, tier, pin and enforce every MCP server through one registry and two enforcement points, keep tokens audience-bound, govern A2A delegation through its own registry and gateway, and expose client-facing agent channels only through the same policy layer. -
Design and Operate the Model GatewayBuild the model gateway as the governed edge for every model call: per-client identity, per-request highest-class routing, tokenisation, pinned models, a conformant wire contract, a correlated evidence record, a tested concentration answer, and day-two cost, latency and reliability operations across two estates and three meters. -
Model Governance: Usage Registry and Upgrade LifecycleGovern models at the grain regulators ask about: a catalogue for what exists, an 18-field usage registry for what is used, risk classified per usage, a registry the policy decision point reads by usage_id, pinned model IDs, and a four-phase upgrade lifecycle from Day −14 to Day +90 with numeric rollback thresholds. -
The Audit Spine and the Evidence RecordHow to capture, join, protect, retain and prove per-action evidence: the AES v0.1.0 record contract, three capture points and one correlation ID, tiered immutable storage, retention and legal hold, replay rehearsal, the route-approval evidence gate, and the Claude-specific ways evidence goes missing. -
Route Regulatory Questions to Obligations and EvidenceA dated, article-level reference that routes AI design questions to the EU AI Act, DORA and its RTS, GDPR and sectoral rules, and turns each obligation into a control, an owner and evidence: change records under RTS 2024/1774 Art 17, the 4 h / 72 h / one-month incident clocks, the CIF hinge and its five artefacts, the three-count Register of Information reconciliation, Art 14(4) oversight controls, the Art 26(5) discharge, the FRIA gate, Art 49 and Art 50, SCHUFA-grade review and supplier controls. -
Data Classes, Processing Lanes and TokenisationClassify every model request by its data, route it only to a processing lane the class permits, keep derived artefacts inside their source class, and treat retention, roles and tokenisation as recorded, testable decisions. -
Change Governance for Agent-Enabled DeliveryRoute agent-speed change by risk without losing the approver: control values that always reach a person, a routing gate that reads the right signals, autonomy earned per change family, a Virtual CAB that prepares a complete dossier, and three bodies with defined escalation. -
Release Engineering for Agent-Written ChangeMove agent-speed change into production through five evidence-emitting stations: one change type per change, a reversal decided at authoring, a valid Deployer Manifest, a gateway that cannot be bypassed, hard health gates and at-most-once rollback. -
The Agent-Speed SDLCA committed artefact chain, governed context, trusted tests and eight SDLC controls that let coding agents work quickly while intent, review, identity and evidence stay connected. -
Respond to Agent IncidentsSort an agent failure into one of four incident shapes, suspend it in three verified layers, keep humans on every classification and disclosure decision, route one playbook to every authority that needs a cover sheet, and close each incident with a named control change. -
Classify Use Cases into Risk TiersThe T0–T4 use-case taxonomy as a working decision reference: the prohibited-use gate, four intake questions, data and action boundaries per tier, the twelve-area control matrix, retention and payload rules, runtime enforcement, approval gates, regulatory routing and re-tiering. -
Build a Unified Control MapJoin the firm's AI and technology controls in one traceable operating view: rows are operating concerns, columns are frameworks read at their own altitude, every cell points to live evidence, and existing ITIL, COBIT and CIS artefacts are extended to agents with a five-question test instead of a parallel AI governance track.