Exploring Claude Managed-Settings: an Enterprise Setup Guide

If you're an IT or security lead rolling out Claude Code across managed developer laptops, you’re probably wondering: where does managed-settings.json go, what should it contain, and how do you push it through Jamf, Kandji, Intune, or GPO? Additionally, many enterprise teams are also finding that a laptop-level file solves the first enforcement problem, but not the broader governance problem across AI agents, MCP servers, and shadow AI usage.
Luckily, Claude managed-settings give administrators a way to enforce Claude Code policy at the machine level. Used well, they help standardize authentication, restrict risky permission bypasses, control MCP usage, and prevent local project settings from weakening enterprise policy.
In this guide, we’ll cover the configuration, policy set up, deployment paths, and verification steps needed for an endpoint baseline, then explain where broader governance across agents and connected tools adds value.
Key Takeaways
- Claude Code managed settings enforce administrator-controlled policy above user, project, and command-line configuration.
- "managed-settings.json" should be deployed to the system-level directory instead of the user settings directory, in those cases when IT needs enterprise enforcement.
- Controls like "disableBypassPermissionsMode", "allowManagedHooksOnly", and "allowManagedPermissionRulesOnly" reduce local override risk.
- MDM deployment works as a first enforcement layer, but static files do not provide real-time visibility, approval workflows, or a live audit trail.
- If file-based governance becomes operationally heavy, you can use Willow to deploy a baseline "managed-settings.json" and easily evaluate a tenant-wide policy model.
Understanding Claude Code Managed Settings
Claude Code managed settings are administrator-controlled policies that take precedence over ordinary user and project configuration. Anthropic supports endpoint-managed delivery through system files and operating-system policies, as well as server-managed settings for eligible organizations.
For enterprise use, managed settings are especially important since they sit at the highest configuration scope. A developer can change their user preferences, a repo can include project settings, and a CLI flag can affect runtime behavior, but managed policy is designed to enforce organization-controlled decisions.
Some good resources to start with here include:
- The Claude Code settings documentation that explains configuration scope and precedence.
- The Claude Code admin setup, which covers organization deployment.
The Configuration Precedence Hierarchy
Claude Code configuration uses precedence, which can come in handy when an engineer says, "I set that in my project file, but it isn't working." In enterprise deployments, that usually means a higher-level policy is overriding the local value.
The typical hierarchy here is:
- Managed settings: administrator-controlled policy, typically deployed by MDM or written to a system-level location.
- Command-line flags: runtime options passed when launching Claude Code, unless blocked or overridden by managed settings.
- Local project settings: machine-local project configuration, useful for developer preferences that should not be committed.
- Project settings: repository-level settings shared with the team.
- Global user settings: user-level preferences for Claude Code on the local machine.
Core Controls and Enforcement Capabilities
We recommend starting with the controls for authentication, permission bypass, hooks, file access, and approved MCP servers.
Arguably the most important controls to evaluate first are:
- "disableBypassPermissionsMode", which prevents use of broad permission bypass behavior.
- "allowManagedHooksOnly", which limits hook configuration to managed policy.
- "allowManagedPermissionRulesOnly", which prevents local permission rules from expanding access beyond policy.
- "dangerously-skip-permissions", which should be treated as a high-risk bypass pattern in enterprise environments.
The naming scheme is blunt for a reason. If a developer can launch Claude Code with broad bypass permissions on a laptop that has source code, .env files, cloud credentials, and production scripts, local convenience can override enterprise access control.
Two other areas to review are model configuration and network tools. Consider which models and authentication methods your organization permits, and whether developers need access to WebFetch, WebSearch, or shell commands such as "curl", "wget", and "nc". Additionally, review shell access alongside built-in tools when defining restrictions on external connections.
Restricting Shell Commands and File Access
Shell access and file access are the first places we look when reviewing Claude managed settings for developer endpoints. Claude Code is valuable because it can inspect code, run commands, and assist with real work, but those same capabilities need least privilege boundaries.
A baseline policy should restrict access to sensitive files and risky commands. For example, .env, .pem, .kube/config, SSH keys, and cloud credential files should not be available to an AI coding agent by default.
Locking Down MCP Servers and Authentication
MCP creates a second policy surface. Once Claude Code can connect to external tools through Model Context Protocol servers, the question shifts from "Can it read this repo?" to "Can it act inside Jira, GitHub, Slack, cloud consoles, or internal systems?"
Managed settings help by standardizing which MCP servers are allowed and how authentication happens. The authentication controls worth evaluating early are:
- "forceLoginMethod", to require the approved login method.
- "forceLoginOrgUUID", to bind usage to the correct organization.
- SSO enforcement through the enterprise IdP.
- MCP restrictions that prevent unmanaged local server connections.
MCP governance needs the same discipline. A local MCP server can be harmless, but it can also create a path from a coding assistant into internal tools. The policy should define which servers are approved, which capabilities they expose, and which identities they use.
Tip: For connected business tools, MCP gateway security can add controls over governed tool access and actions.
Creating Your Claude Code Policy
What Is a Claude Code Policy?
A Claude Code policy is a set of managed settings that govern how Claude Code behaves on a machine: which tools it can use, which commands it can run, which MCP servers it can reach, and more. It is defined in a "managed-settings" file and enforced at the system level, pushed through your MDM. The key word here is managed, as unlike local settings, a developer cannot edit it away or skip it.
So, for any team rolling Claude Code out past a handful of engineers, this file is the difference between governed adoption and hoping for the best.
Managed Settings vs Local Settings
Local settings live in the developer's home directory. Anyone can edit them, delete them, or bypass them with a single flag. They are a suggestion.
Managed settings are how you set your policy. They are pushed through your MDM (Jamf, Intune, or your tool of choice), enforced on every session, and a developer cannot override them. In short, this is how you say yes to Claude Code without betting your codebase on the honor system.
What You Can Control With Claude Code Managed Settings
The "managed-settings" spec is broad. The main controls are:
- Bash commands. Allow, ask, or block per command. Stop "curl", "wget", "sudo", "git push", "scp", and "rsync" before they run.
- MCP servers. Managed servers only, or none at all. You won’t get a developer wiring an unreviewed server into your repo.
- Model configuration. Force Claude.ai account login, block raw API keys at startup, and set the models you allow.
- Hooks. Disable hooks entirely or scope exactly which ones can fire.
- Secrets and files. Block reading ".env, secrets/**", SSH keys, AWS credentials, and service-account files.
- Network tools. Block WebFetch, WebSearch, "curl", "wget", and "nc" for air-gapped sessions.
- Bypass mode. Disable "--dangerously-skip-permissions" so no one steps around your policy.
This right here is what provides real coverage. It is also exactly why teams stall: a blank file with this much surface area is intimidating, and while the docs tell you what each setting does, they don’t offer recommendations on what you should set.
Why Teams Stall, and How to Skip It
The typical pattern we see across rollouts is this: the "managed-settings" file is powerful but vague, so the policy ends up half-written, copied blind from a gist, or never written at all. So, the teams who need governance the most also usually happen to be the ones staring at a blank JSON file on a Friday afternoon.
The solution here is not having more thorough documentation, though that’s a great starting point. Instead, we suggest that you begin from a hardened baseline a real security team would ship, and only then adjust.
Writing Your Claude Code Policy With Policy Ranger
Policy Ranger is a free Claude Code policy builder. Simply pick a baseline, tune the rules in a visual editor, and export the file your MDM can then push. No hand-written JSON or signup is needed, either.
It is built on Anthropic's published "managed-settings" spec, with defaults drawn from real Claude Code rollouts at companies governing AI in production, including Wix, Innovid, and Riskified. This means that rather than starting from zero, you begin from a policy that already reflects how careful teams deploy.
Picking a baseline by risk level
Start from the Policy Ranger tier closest to your needs, then make it yours:
- Minimal: Light guardrails, zero workflow friction.
- Standard: The recommended baseline for most teams.
- Strict: Hardened for security-conscious organizations.
- Lockdown: Maximum restriction (read-only and agent-free).
Deploying Managed Settings via MDM
File-based managed settings are a good first move because they let IT enforce Claude Code policy with tools already used for endpoint management. Jamf, Kandji, Intune, and GPO can place the same "managed-settings.json" on every managed device, which is infinitely better than asking developers to configure each policy manually.
The notable catch here is rollout timing. Jamf and Kandji policies can wait for check-in, Intune can lag until device sync, and GPO depends on domain connectivity and refresh timing. That delay could be detrimental when a new MCP server needs approval or a risky permission rule needs to be blocked quickly.
We therefore recommend deploying the policy through existing endpoint tooling: Jamf or Kandji for macOS, Intune or Group Policy for Windows, and configuration management for Linux. Additionally, make sure to test delivery timing and effective policy on pilot devices before expanding the rollout.
Here is what a safe rollout sequence looks like:
- Create a baseline "managed-settings.json" in source control.
- Test the policy on one device per operating system.
- Confirm the file lands in the system-level path instead of the user settings path.
- Run "/status" inside Claude Code and "claude doctor".
- Deploy to a pilot developer group.
- Expand once blocked commands, allowed MCP servers, and SSO behavior match expectations.
This gives IT a controlled path without interrupting engineering teams that already rely on Claude Code for code review, test generation, documentation, and debugging.
Specifying macOS, Linux, and Windows File Paths
The most common implementation mistake we often see is placing the managed settings file in a user directory. That may affect one user, but it doesn't create a reliable enterprise policy.
Instead, make sure to use the system-level path for each operating system as outlined in the table below.
| Operating System | Managed Settings Location | Deployment Mechanism |
|---|---|---|
| macOS | "/Library/Application Support/ClaudeCode/managed-settings.json" | Jamf, Kandji, Intune, or configuration profile using com.anthropic.claudecode where applicable. |
| Linux and WSL | "/etc/claude-code/managed-settings.json" | Endpoint management, configuration management, or root-owned file deployment. WSL policy inheritance depends on configuration. |
| Windows | "C:\Program Files\ClaudeCode\managed-settings.json" | Intune, GPO, or endpoint management. |
| Windows policy registry | "HKLM\SOFTWARE\Policies\ClaudeCode" | GPO or registry policy deployment. The policy JSON is stored in a "Settings" value. |
A few extra details are worth mentioning here:
- Some docs and search results refer to the Windows directory as "C:\Program Files\ClaudeCode/", but make sure to use the path format your Windows deployment tool expects when writing scripts or GPO policies.
- Create the directory before placing the file, and set permissions so standard users can't modify the policy. On macOS and Linux, admin or root ownership matters. On Windows, write access should stay with administrators.
- For macOS fleets, Jamf and Kandji deployments usually package the file or run a script that creates "/Library/Application Support/ClaudeCode/", writes "managed-settings.json", and sets ownership. For Windows, Intune or GPO should place the file or registry policy under machine-level control rather than user profile control.
Verifying the Active Configuration
After deployment, verify the results from a managed developer machine. We urge you not to rely solely on the MDM console showing a successful push, because a file can still land in the wrong directory or fail JSON parsing.
So, make sure to first run "/status" inside Claude Code. A healthy result should show that Claude Code is authenticated to the intended organization and that the managed policy is active.
Tip: Use this check to confirm the user did not authenticate with a personal account when "forceLoginMethod" and "forceLoginOrgUUID" are part of the policy.
Next, run "claude doctor" to check installation health, configuration parsing, and environment issues. If managed settings are missing, the first places to inspect are the file path, file permissions, and JSON syntax.
Here’s a quick verification checklist to get you started:
- The file exists at the system-level path for the operating system.
- Standard users cannot edit or delete the file.
- JSON validates with no trailing commas.
- Running "/status" inside Claude Code shows the expected organization and policy state.
- Attempts to use "dangerously-skip-permissions" fail when "disableBypassPermissionsMode" is enabled.
- Local project settings do not override managed permission rules.
Extending Claude Code Policy Across Agents and Tools
A properly set up agentic control plane can go beyond one client’s configuration to identity, permissions, and audit across agent workflows.
The fact is that Claude Code managed settings establish policies for Claude Code alone. Yet, broader governance also needs to account for other agents, connected business tools, delegated identities, and workflows outside that configuration scope.
| Enterprise Requirement | Claude Code managed settings | Willow |
|---|---|---|
| Claude Code configuration | Enforces supported settings through endpoint-managed or server-managed delivery. | Provides tooling for Claude Code policy alongside broader agent governance. |
| Connected-tool permissions | Controls supported MCP configuration and Claude Code permissions. | Applies identity-linked permissions to governed tool actions. |
| Operational evidence | Requires the relevant configuration, telemetry, and logging setup. | Centralizes governed activity and audit evidence. |
| Organizational coverage | Focuses on Claude Code and supported execution environments. | Governs supported agents and connected tools across teams. |
How Willow Helps You Move Beyond Claude Governance
Effective governance combines enforcement with visibility. Teams need controls that constrain actions and records that explain which agent acted, on whose behalf, against which tool, and under which policy.
Willow is an agentic access platform for enterprise AI governance that can achieve all of the above. We combine identity-linked tool access, action-level permissions, runtime guardrails, discovery, and audit across supported agent workflows, while endpoint policies remain part of that architecture. Our Policy Ranger also provides a focused entry point by helping teams create and export a Claude Code policy.
Businesses like Innovid use Willow to govern and secure developers’ local machines, including exposure to MCP servers and external skills, with Assaf Grimberg, SVP Software Engineering, crediting the platform with improving access control and reducing risk.
Putting All-Around Visibility in Place of Static Enforcement
Static enforcement is no doubt useful. It blocks known risky behavior, gives IT a baseline, and helps reduce shadow AI shenanigans when developers are already busy installing AI coding tools.
But it is well-implemented visibility that turns a policy into true governance. After all, a static file can rarely answer the questions CISOs tend to ask as they see Claude Code adoption climbing exponentially:
- Which agents accessed which tools this week?
- Which MCP server introduced a new capability?
- Which identity approved a sensitive workflow?
- Which team created a vibe-coded app that now touches internal data?
- Which activity should flow into the SIEM for investigation or retention?
And while an MDM console can report that a configuration profile or file deployment succeeded, that telemetry doesn't show which agent called which tool, which MCP server exposed a new action, or which workflow touched sensitive data.
So, start with a validated Claude Code policy, deploy it through the appropriate management channel, and verify the effective controls on pilot devices. Then, extend governance to the agents, identities, and connected tools outside that policy’s scope to ensure a safe working environment that’s still productive.
Need a bit of help to get you started? Try Willow for free to explore governed agent access, and review enterprise plans for granular identity integration, action-level permissions, and runtime guardrails.
Frequently Asked Questions
Can developers with local administrator access change the policy?
File ownership typically protects a policy from standard users. Developers with administrator or root access may be able to change endpoint controls though, so make sure to assess local privileges and device-management protections as part of deployment.
Does the Windows policy automatically cover Claude Code running in WSL?
We recommend not assuming that it does. Claude Code documents both Linux policy paths for WSL and configurable Windows-policy inheritance, so verify which source applies inside the WSL environment.
Will the same managed settings reach CI jobs?
Delivery ultimately depends on the runner, authentication method, and execution environment. Verify whether the job receives server-managed settings or needs an endpoint-managed policy in its runner image.
Is Policy Ranger free to use?
Yes. With Policy Ranger, you get unlimited policies, every tier, and every export format. No signup to build or export is needed either.
Can developers override a managed-settings policy?
No. Managed settings are enforced at the system level through your MDM. That is what separates managed settings from local settings.
What can I export from Policy Ranger?
"managed-settings.json" for Linux and file-based deployment, ".mobileconfig" for macOS MDM, and ".reg" for the Windows Registry.
Is Policy Ranger an official Anthropic product?
No. Policy Ranger is built by Willow on Anthropic's published Claude Code "managed-settings" spec.
Background Agents in the Enterprise
Most teams can spin up an agent. Few can deploy one their security team signs off on. Here's the framework that does both.
FAQS
Everything you need to get your Basecamp running.
Your agents are already in the wild.
Give them a Basecamp. Go from AI chaos to AI work, in minutes.