Case Study
How Wix scaled Al-native work to 5,000 employees with Willow
Read More
Adir Ounger
Blog

Your AI agents are talking. OTLP Router decides who gets to listen.

Adir Ounger
00 min
November 17, 2026

OTLP Router is an open-source OpenTelemetry router for AI agents, released under Apache-2.0. Point Claude Code, Codex, Gemini CLI and GitHub Copilot at one endpoint, and it copies every payload to as many destinations as you configure, such as Datadog, Grafana, Splunk, your own collector, or Willow. Before each copy leaves, the router removes what that destination must not see.

Claude Code, Codex, Gemini CLI and GitHub Copilot all speak OpenTelemetry. Turn it on and you get token counts, cost, every tool call and, if you are not careful, the full text of every prompt your engineers type. Including the one with an AWS key pasted in "just for a sec".

Then the requests start coming in.

Four stakeholders, four versions of the truth

WhoThe ask
Platform"Send it to Datadog."
Security"Send it to Splunk. Especially the prompts."
Legal, overhearing the word "prompts""Absolutely not."
Finance"Who spent $4,000 on tokens last Tuesday?"

Every agent exports to exactly one endpoint. You have four stakeholders who want four different versions of the truth. That is the gap OTLP Router fills, and it is the reason Willow built it and open sourced it.

TL;DR

  • What it is: one OTLP ingress for every AI agent, with a copy of each payload sent to every destination you configure.
  • What makes it different: filters are set per destination, by meaning, not by attribute name. You choose Send or Remove for prompts, responses, tool arguments, tool results and cost. The router finds them under each agent's own names.
  • How it fails: every destination has its own queue. One destination failing does not hold up the others.
  • How you run it: one docker run command, or a Helm chart for Kubernetes.
  • License: Apache-2.0. It works with or without Willow.

How OTLP Router works

Point every agent at the router. The router copies each payload to every destination, and applies that destination's filters to its own copy before sending.

One endpoint in, a filtered copy out for every destination

Claude Code
Codex
Gemini CLI
Copilot
OTLP Routercopy, filter, send
DatadogNo prompts, emails hashed
SplunkEverything, secrets redacted
GrafanaClaude Code and Codex only
WillowNo prompts

That is an example configuration, and it shows the point. Security gets its prompts. Legal stops worrying about Datadog. Finance finds out who spent the four grand. (It was a while true loop. It is always a while true loop.)

The ingress accepts OTLP over gRPC on :4317 and HTTP on :4318, protobuf or JSON, with gzip, for traces, metrics and logs. Each destination (the project calls them targets) gets its own copy, its own filters and its own retry queue, so a slow or failing vendor never holds up the others.

Filters by meaning, not by attribute name

This is the part that saves you from a YAML archaeology project.

Every agent names the same data differently. Codex puts tool results in output. Gemini CLI puts tool arguments in function_args. Copilot follows the OpenTelemetry GenAI conventions. A filter that hunts for key names has to know every agent's vocabulary, and has to be updated when an agent changes it.

OTLP Router takes categories instead. The drop_known rule removes each category using the names of the agent that sent the record, so a key like output is only removed from Codex telemetry.

yaml
filters:
  - type: drop_known
    categories: [prompts, responses, tool_results]

What each category removes

CategoryWhat it removes
promptsPrompt text. The prompt events stay, so prompts can still be counted.
system_promptsThe instructions an agent or SDK gives the model.
responsesModel response text.
tool_argumentsWhat the agent passed to tools (commands, file paths). Tool names, decisions and outcomes stay.
tool_resultsWhat tools returned (command output, file contents). Success, errors and durations stay.
costSpend in dollars, for agents that report it. Token counts stay.
noiseHigh-volume events, such as Codex's per-chunk stream events. The final one, with tokens, stays.
identityEmails, user and account ids, host names. Also usable with hash_known.

Notice what each row keeps. Removing content does not mean losing the signal. Prompts disappear but prompt counts stay. Tool results disappear but success, errors and durations stay. Cost can go to the destination that needs it, while token counts remain everywhere.

For anything the categories do not cover, filters run in order, on that destination's copy only:

Filter rules, in the order they run

RuleWhat it does
drop_knownDrops a kind of data under each agent's own names.
hash_knownHashes a kind of data (identity) under each agent's own names, with a salt.
drop_log_eventsDrops log records whose event name matches, for example *user_prompt.
drop_attributesRemoves attributes by key glob, on resources, records or both.
mask_attributesReplaces values with [REDACTED].
hash_attributesReplaces values with a salted SHA-256, so you can still group by them.
redactRegex replace in log bodies and string attributes: patterns, named secrets, or builtins for all.
drop_spansDrops spans by name.
drop_metricsDrops metrics by name.

Emails and user ids can be hashed instead of removed, so you can still group by user without exposing who they are. API keys, JWTs and tokens get redacted wherever they show up. The built-in secret formats are:

built-in secret formats
aws_access_key        bearer_token       jwt
openai_anthropic_key  google_api_key     github_token
gitlab_token          slack_token        stripe_key
private_key

Telemetry from an agent the router has no profile for gets OpenTelemetry's standard names plus common ones, and its *user_prompt events are dropped whole.

No guessing: preview filters on real payloads

In the web UI, each category is Send or Remove. User identity is Send, Hash or Remove. Each secret format, with its regular expression shown, is Send or Redact. You can add your own patterns, and Custom rules run after these choices.

Two things take the guesswork out:

  • What it removes. Each destination shows exactly which events, attributes and metrics it removes, per agent.
  • Preview. The preview runs that destination's filters on the latest real payload. No more deploying YAML and then squinting at Datadog wondering why user.email is still there.

The router keeps the last few payloads per signal in memory for this preview. They can contain prompts, are shown only to the admin, and are never written to disk.

Why not just use the OpenTelemetry Collector?

You can. A routing connector with action: copy, one pipeline per destination, and redaction and transform processors will do the job. Willow did it that way at first. By the fourth destination the YAML looked like a Jenga tower, and one wrong indent sent the prompts straight to Datadog.

The Collector is a general toolkit. OTLP Router does one job: agent telemetry to several places, each with its own privacy rules. They also work well together. Send to the router, and let the router forward to your Collector.

OTLP Router vs the alternatives

 OTLP RouterOTel Collector / AlloyVectorCribl / Bindplane
Open sourceYesYesYesPartly or no
Remove prompts across every agent's namingYesNoNoBuild your own
Preview filters on real payloadsYesNoNoYes
Knows Claude Code, Codex, Gemini and othersYesNoNoNo
Config without YAMLYesNoNoYes
Sampling, heavy transforms, 100+ exportersNo, use the CollectorYesYesYes

The last row is there on purpose. If you need tail sampling, OTLP Router is not your tool. Put it in front of one that is.

Run it in five minutes

With Docker, no config file is needed:

bash
docker run -d --name otlp-router -p 4317:4317 -p 4318:4318 -p 8080:8080 \
  -e OTLP_ROUTER_ADMIN_PASSWORD=change-me \
  -e OTLP_ROUTER_SESSION_SECRET="$(openssl rand -hex 32)" \
  -v otlp-router:/data \
  ghcr.io/withwillowai/otlp-router

Open http://localhost:8080, sign in as admin, and create an ingest token on the Tokens page. Until one exists, the router rejects everything. Secure by default, annoying by design. Targets and tokens are kept in the otlp-router volume, so they survive restarts and upgrades.

Then point your agents at it.

Claude Code (shell profile, or the env block of managed-settings.json):

bash
export CLAUDE_CODE_ENABLE_TELEMETRY=1
export OTEL_METRICS_EXPORTER=otlp OTEL_LOGS_EXPORTER=otlp
export OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
export OTEL_EXPORTER_OTLP_ENDPOINT=https://otel.acme.internal
export OTEL_EXPORTER_OTLP_HEADERS="Authorization=Bearer otr_your_token"

Codex (~/.codex/config.toml):

toml
[otel]
log_user_prompt = false
exporter = { otlp-http = { endpoint = "https://otel.acme.internal/v1/logs", protocol = "binary", headers = { "Authorization" = "Bearer otr_your_token" } } }

Gemini CLI (~/.gemini/settings.json), plus OTEL_EXPORTER_OTLP_HEADERS for the token:

json
{ "telemetry": { "enabled": true, "target": "local", "otlpEndpoint": "https://otel.acme.internal", "otlpProtocol": "http" } }

Anything else that exports with an OpenTelemetry SDK, such as the Claude Agent SDK or your own agents, reads the standard OTEL_EXPORTER_OTLP_ENDPOINT and OTEL_EXPORTER_OTLP_HEADERS variables. The router recognises Claude Code, Codex, Gemini CLI, Qwen Code and GitHub Copilot from service.name, and the UI's Agents page gives copy-paste setup for each, with your ingress URL and token filled in.

Last step: add a destination, set prompts to Remove, and you are done before your coffee gets cold.

On Kubernetes, use the Helm chart:

bash
helm install otlp-router oci://ghcr.io/withwillowai/charts/otlp-router \
  --namespace observability --create-namespace

Ingest tokens you can rotate without an outage

Agents send Authorization: Bearer <token>, over HTTP or as gRPC metadata. You manage tokens on the Tokens page:

  • Create. Name a token after the agents that use it, such as "Engineering laptops" or "CI". The token (otr_...) is shown once. The router stores only its SHA-256 hash.
  • Rotate. Issues a new token with the same name. The old one keeps working for a grace period you pick (none, 1 hour, 24 hours or 7 days) while you roll the new one out, then stops.
  • Revoke. Stops a token immediately.

The page shows when each token was last used, and /metrics counts rejected requests in otlp_router_ingest_unauthorized_total, so you can see when the old token has gone quiet.

Operating it

  • Live page. Shows every request agents sent: when, which agent, user, device and token, and what each destination did with it (sent, filtered, retrying, or failed with the error), plus rejected requests. Each replica keeps its last 1,000 requests in memory. No database is needed. Set disableLive: true to hide the page and keep nothing.
  • Stores. configmap for Kubernetes, where every replica polls the ConfigMap so edits apply everywhere in seconds. file for Docker or a VM with a volume. memory for development.
  • GitOps. Set readOnly: true to manage targets and tokens only through config. The UI then shows them but cannot change them.
  • Secrets. Header values, tokens and salts can be ${env:NAME} references, resolved inside the router, so the secret lives in a Kubernetes Secret or environment variable and never in the stored target list.

Security model

  • The UI and API need the admin login. Sessions are HTTP-only, SameSite=Strict cookies, and failed logins are rate limited.
  • Ingest always requires a token unless you explicitly allow unauthenticated ingest. With no tokens, everything is rejected rather than accepted, so revoking the last token never opens the router up.
  • Expose the UI only on an internal network. The Helm chart has separate ingresses for OTLP and the UI.
  • The Live page keeps request details only, never the telemetry itself.
  • /metrics (Prometheus) is unauthenticated and exposes counters and target ids only.

Why open source

Willow builds governance and analytics for AI agents. A tool that decides where your company's prompts end up should not be a black box, so OTLP Router is about five thousand lines of Go that you can read yourself. It works with or without Willow.

Star it, break it, send PRs: github.com/withwillowai/otlp-router

Your agents are going to keep talking. You might as well decide who is listening.

FAQ

What is OTLP Router?

OTLP Router is an open-source OpenTelemetry router for AI agents. It gives every agent one endpoint to export to, copies each payload to every destination you configure, and removes what each destination must not see before sending. It is licensed under Apache-2.0.

Which AI agents does OTLP Router support?

It recognises Claude Code, Codex, Gemini CLI, Qwen Code and GitHub Copilot from service.name. Anything that exports with an OpenTelemetry SDK, including the Claude Agent SDK and custom agents, can send to it using the standard OTEL_EXPORTER_OTLP_ENDPOINT and OTEL_EXPORTER_OTLP_HEADERS variables.

How do I keep prompts out of Datadog?

Set prompts to Remove on the Datadog destination, which applies the drop_known rule with the prompts category. The router removes prompt text under each agent's own attribute names. The prompt events stay, so you can still count prompts.

Does OTLP Router replace the OpenTelemetry Collector?

No. The Collector is a general toolkit with sampling, heavy transforms and 100+ exporters. OTLP Router does one job: agent telemetry to several destinations, each with its own privacy rules. You can send to the router and let it forward to your Collector.

What happens if one destination is down?

Only that destination's queue backs up. Each destination has its own copy, filters and retry queue, so a slow or failing vendor never holds up the others.

Is OTLP Router secure by default?

Yes. Until you create an ingest token, the router rejects all telemetry. Tokens are stored as SHA-256 hashes, the UI needs an admin login, and revoking the last token never opens the router up.

Do I need Willow to use it?

No. OTLP Router works with or without Willow. Willow is one of the destinations you can send to.

Sources

Blog

AI Agent Monitoring: How to Get Full Visibility Into What Agents Do in Production

Adir Ounger
00 min
July 23, 2026

Why Standard Monitoring Falls Short for AI Agents

Traditional observability tools were built for services, not agents. They track uptime, latency, and error rates – useful, but not the right questions when an agent has access to production systems.

What specific actions did this agent take in Jira? Which files did it read in GitHub? Did it touch data it wasn't supposed to? When did it last run, and who authorized it?

Those questions require a different kind of monitoring — one built around identity and action, not infrastructure health.

The Visibility Gap Most Teams Don't See Coming

The harder problem isn't monitoring the agents IT already knows about. It's the ones it doesn't.

Employees are spinning up agents and MCP connections without IT approval. A developer connects a Cursor agent to the company GitHub. A marketing manager builds a vibe-coded automation that touches Gmail and Attio. None of it goes through procurement. None of it appears in your SIEM.

Shadow AI is already in production. By the time a compliance audit surfaces it, that access has often been running for months.

What Full Visibility Actually Requires

Genuine AI agent monitoring has four components. Most organizations have one or two. Getting all four is what separates reactive incident response from proactive governance.

1. Agent Identity

You can't monitor what you can't identify. Every agent needs a real identity tied to your company directory – not a shared service account, not a hardcoded API key, not a generic credential that three people use interchangeably.

Agent identity should flow through your existing identity provider. If you're running Okta, Entra ID, or JumpCloud, agents should authenticate through the same OIDC, OAuth2, SAML, or JWT flows your human employees use. That way, every action an agent takes is attributed to a specific identity with a known owner.

Without this, your audit trail is essentially useless. You'll see that something accessed Jira at 2am. You won't know what, why, or whether it was authorized.

2. Action-Level Logging

Access-level logging tells you an agent connected to a tool. Action-level logging tells you what it actually did there.

The difference matters. An agent with read access to GitHub is very different from one with write access to the main branch. An agent that can view Jira tickets is very different from one that can close, reassign, or delete them.

Effective monitoring captures every MCP call, every tool invocation, and every specific action – not just the connection event. That's what makes an audit trail useful during an incident or a compliance review.

3. Shadow AI Discovery

Monitoring only the agents you've sanctioned leaves a significant blind spot. You need a way to surface agents that employees brought in without IT approval the moment they appear – not weeks later.

That means passive discovery at the network or identity layer, not periodic scans. When a new agent checks in or a new MCP connection appears, it should be visible immediately, with enough context to make a governance decision: allow, restrict, or block.

4. Credential Lifecycle Management

Monitoring doesn't end when an agent stops running. If the employee who owned an agent leaves the company, their credentials shouldn't keep working.

Automatic credential revocation tied to IdP offboarding is what closes this loop. When an employee offboards, every agent and integration they owned should lose access – no manual ticket, no delay, no orphaned credential sitting in a tool for months.

How to Structure AI Agent Monitoring in Practice

Here's a practical framework for getting real visibility into what agents do in production.

Start with inventory. You can't govern what you haven't found. Run a discovery pass to surface every agent and MCP connection in your environment, including the ones that came in without IT approval. This is your baseline.

Assign ownership. Every agent should have a human owner tied to your company directory – the person accountable for what the agent does, and the anchor for automatic revocation when that person leaves.

Define action-level permissions. Don't grant broad tool access. Grant specific actions within specific tools. An agent that needs to read GitHub pull requests doesn't need to merge them. Scoped permissions limit blast radius and make audit logs far easier to interpret.

Log everything at the action level. Every tool call, every MCP invocation, every data access – stored centrally so it's available for compliance reviews, incident investigations, and routine audits.

Set runtime guardrails. Monitoring is reactive by default. Guardrails make it proactive. Define what agents are and aren't allowed to do at runtime – PII access, specific data sources, external endpoints – and enforce those rules automatically, not after the fact.

Automate revocation. Tie credential lifecycle to your IdP. When an employee offboards, access goes with them. No manual cleanup required.

The Case for One Control Plane

The biggest operational mistake enterprises make with AI agent monitoring is building it from separate tools. One for identity. Another for logging. A third for shadow AI detection. A fourth for credential management.

Each tool has its own data model, its own alert format, and its own blind spots. Stitching them together creates gaps – and gaps are where incidents happen.

The more practical approach is a single control plane where every agent checks in. Identity, access, audit logging, shadow AI discovery, and credential revocation all operate from the same policy layer. Security defines policy once. Enforcement happens automatically across every agent, sanctioned or not.

Willow is built on this model. Enterprises connect it to their existing IdP, grant agents scoped action-level permissions to tools like Jira, GitHub, Gmail, and Attio, and get a full audit trail on every agent action and MCP call. Shadow AI surfaces the moment it appears. Credentials revoke automatically when employees leave. Wix, Innovid, Papaya Global, Riskified and many more run it in production.

What to Look for in an AI Agent Monitoring Solution

If you're evaluating options, these are the questions worth asking:

A solution that checks all six is rare. Most cover two or three and leave the rest to your team.

Getting visibility into what AI agents do in production isn't something you can defer. The agents are already there. The access is already granted. The question is whether you have a record of what happened — and the ability to respond when something goes wrong.

Start with identity. Build toward action-level logging. Make revocation automatic. And put it all in one place, not three tools you're hoping will talk to each other.

Learn more at withwillow.ai.

Blog

Claude Managed-Settings: an Enterprise Setup Guide

Adir Ounger
00 min
June 23, 2026

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 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:

  1. Managed settings: administrator-controlled policy, typically deployed by MDM or written to a system-level location.
  2. Command-line flags: runtime options passed when launching Claude Code, unless blocked or overridden by managed settings.
  3. Local project settings: machine-local project configuration, useful for developer preferences that should not be committed.
  4. Project settings: repository-level settings shared with the team.
  5. 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:

  1. Create a baseline "managed-settings.json" in source control.
  2. Test the policy on one device per operating system.
  3. Confirm the file lands in the system-level path instead of the user settings path.
  4. Run "/status" inside Claude Code and "claude doctor".
  5. Deploy to a pilot developer group.
  6. 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 SystemManaged Settings LocationDeployment 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 RequirementClaude Code managed settingsWillow
Claude Code configurationEnforces supported settings through endpoint-managed or server-managed delivery.Provides tooling for Claude Code policy alongside broader agent governance.
Connected-tool permissionsControls supported MCP configuration and Claude Code permissions.Applies identity-linked permissions to governed tool actions.
Operational evidenceRequires the relevant configuration, telemetry, and logging setup.Centralizes governed activity and audit evidence.
Organizational coverageFocuses 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.