the short answer
Install a policy client on every developer machine that hooks each coding agent. An admin defines policies once, every enrolled machine pulls them, and each gated tool call is checked before it runs. Device management tools like Jamf and Intune manage the laptop and its files. Agent policy manages the actions an agent takes with the developer’s credentials, across Claude Code, Codex, Cursor and other harnesses, and records every decision.
- Unit managed
- The agent tool call (shell command, file write, API call), not only the device
- Enforced where
- On the developer machine, at the agent’s hook layer, before the call runs
- Managed from
- A central console that deploys versioned policies to enrolled machines
- Decisions
deny(block),instruct(continue with guidance) orallow, each recorded- Does not replace
- IAM least privilege, device management, code review or CI controls
Why Device Management Alone Does Not Cover It
Companies already know how to manage laptops. Jamf, Intune and Kandji push configuration profiles, install software and enforce disk encryption. What they cannot see is what happens inside an AI coding agent session: the agent reads a repository, decides to run terraform apply or aws route53 change-resource-record-sets, and executes it with whatever credentials the developer has loaded. Nothing in device management evaluates that decision.
The missing layer is a fleet-wide policy that is pushed centrally, like a device profile, but evaluated per agent action, like a firewall rule. It answers a common question from infrastructure leads: what tool calls are our engineers’ agents actually making?
Device Management Versus Agent Policy
The two are complementary. Device management is a good way to install and keep the policy client present on every machine; deploying with Jamf or Intune covers that. The agent layer is what actually reads rm -rf, kubectl delete or a Python script calling boto3 and decides.
| Question | Device management (Jamf, Intune, Kandji) | Agent policy |
|---|---|---|
| What is managed | The machine: OS settings, apps, certificates, disk encryption | The agent: which tool calls it may make, under which conditions |
| When it acts | At install, check-in and compliance evaluation | Before every gated agent tool call, in the hook path |
| What it can stop | An app from installing, a setting from changing | terraform destroy, a DNS record deletion, a .env read, a push to main |
| What it records | Device inventory and compliance state | Agent sessions, tool calls and policy decisions, per machine |
| Granularity | Device group | Machine (central deployments), repository (project-scope policy files), persona (managed deployments) |
| How they combine | Delivers and keeps the agent-policy client installed | Enforces what the agent does once it runs |
The Five Parts of a Working Setup
- A local enforcement point. A hook in each agent harness hands every gated event to a local evaluator before the agent proceeds. In Failproof this is the
failproofaiCLI plus thefailproofaiddaemon thatfailproofai configinstalls. - Policies as code. Rules written in JavaScript or TypeScript, versioned, testable, and evaluated the same way across harnesses. See policy-as-code.
- Central deployment. Admins publish policy versions and deploy them to enrolled machines, first in observe mode, then enforce. See the rollout guide.
- Scoping. Repository rules live in project-scope policy files; central deployments target machines; managed deployments add persona assignment, such as stricter rules for on-call engineers. See different rules per team.
- Telemetry. Sessions and decisions from every machine in one place, so an incident can be traced to a session and a machine. See what agents did.
What Happens on One Tool Call
Deterministic policies evaluate on the machine, so a decision does not wait on a network round trip; our engineering write-up measured the daemon path at about 0.7 ms p50. The central side deploys policies and receives telemetry. The exception is optional Jev review, which makes one model request per reviewed call.
PreToolUse (or its native equivalent) to the local evaluator.deny blocks with a reason, instruct lets it continue with guidance, allow continues.What Agent Policy Is Not
- Not a sandbox. A sandbox limits what a process can touch. A policy decides whether a specific action is allowed. Most teams want both; see hooks vs sandbox vs managed settings.
- Not a replacement for IAM. If a developer’s SSO session can delete production DNS, a policy lowers the chance an agent does it, and IAM decides whether it is possible at all.
- Not a ban on agents or a mandated toolchain. The point is to let developers keep their IDE, terminal and harness of choice while the same rules apply to all of them.
- Not complete on every harness for every event. Pre-tool blocking is verified on all twelve harnesses Failproof supports; stop, prompt and post-tool gates vary, and on Hermes an
instructdoes not stop the call. See one policy across agents.
How to Check a Vendor’s Claim
- Ask an agent to run a blocked command directly, then through a shell script it writes itself. Both should be denied, or the vendor should tell you which one is not covered.
- Stop the local evaluator and retry. The call should fail closed with a visible reason, not silently run.
- Ask the agent to disable or pause the policy client. It should be refused.
- Find the blocked call in the console, attributed to the right machine, policy and session.
FAQ
Is this the same as Claude Code managed settings?
No. Managed settings configure one harness (permissions, allowed hooks, model access). An agent policy layer evaluates actions across harnesses with code you can test, and records the decisions. Managed settings are a useful input; see are managed settings enough.
Does it send my code to a vendor?
Policies evaluate locally. Connecting a machine to Failproof AI Cloud sends session transcripts by default so traces and audits work; --no-transcripts keeps prompts, file contents and terminal input on the machine while still reporting policy decisions, and also keeps Cloud Jev off. A machine set up with no Cloud key enforces locally and sends nothing to Cloud; the CLI’s separate anonymous usage telemetry is turned off with FAILPROOFAI_TELEMETRY_DISABLED=1.
Which agents does it cover?
Failproof hooks twelve harnesses: Claude Code, Codex, GitHub Copilot CLI, Cursor, OpenCode, Pi, Factory Droid, Devin CLI, Antigravity CLI, Goose, Hermes and OpenClaw. Blocking before a tool call is verified on all twelve. Gemini CLI is not among them.
Where does the code live?
The failproofai CLI and policy packs are published on GitHub under an MIT + Commons Clause license: free for internal use, with commercial resale needing an agreement. Fleet deployment, telemetry and alerting are Failproof AI Cloud.
Sources
Checked against the sources below on October 21, 2026. Harness settings, hook capabilities and cloud features change between versions.
- Failproof AI docs: Policies overview
- Failproof AI docs: Agent harnesses and enforcement capability
- Failproof AI docs: Deploy a policy
- Failproof AI docs: Settings and security
- Failproof AI docs: Custom policies (policy SDK)
- GitHub: FailproofAI/failproofai (open source CLI, policies and daemon)
- Failproof AI: How we made agent enforcement sub-millisecond
- OWASP: LLM06:2025 Excessive Agency