Never answer your agent twice.
When an agent hits a decision its playbook does not cover, it asks the owner on Slack. Approve the answer once and every agent has it from then on.
Claude Code 
Codex 
Cursor 
GitHub Copilot 
VS Code 
Gemini What the playbook misses reaches a person.
PolicyLayer holds your company’s authorised playbooks; agents reach them over MCP. Uncovered decisions route to their owner in Slack. The answer resolves the case and, once approved, becomes policy for every agent.
The question goes to Customer Operations. The agent keeps working.
Seven rules. Half as many cases needed a person.
Across more than 50 real support cases, repeated human decisions became seven approved rules. These are results from the next 20 cases.
Half as many interruptions after seven approved rules.
The same people stopped being interrupted.
Approved from real decisions, not written up front.
Agents can ask. Only people can decide.
Until a reusable rule is approved, the answer grants no authority anywhere else.
A named person approves, edits or rejects the exact rule before it reaches another agent.
If PolicyLayer is unavailable, agents gain no new authority and fall back to the last signed playbook.
Every rule, its owner, and who signed it.
One MCP surface. Four small tools.
Keep your model, framework and tools. PolicyLayer handles only the words and rules that govern what the agent may decide.
Load the latest signed company playbook.
Route an uncovered decision to its owner.
Return the answer, owner and context.
Turn a decision into a rule proposal.
Paste the endpoint into your MCP config. That is the whole integration.
Your model, framework and every existing tool stay exactly as they are.
Start with one agent. Add the fleet when the playbook has earned it.
Your company already knows the answers.
Runbooks, policy docs, or the rules buried in your system prompts: PolicyLayer turns them into proposed rules, each routed to its owner to sign.
Agents keep working exactly as they do today. PolicyLayer watches the decisions being made and surfaces the repeated ones worth turning into rules.
One authority layer. Different agent workflows.
Refunds, fee waivers and policy exceptions become reusable after the right person approves them.
See the decision loop →Claude Code, Codex and Cursor start from the same approved rules without files drifting apart.
Explore coding agents →Route uncovered decisions to owners while long-running agents keep working on everything else.
Explore managed agents →The four things people ask.
Nothing waits on a human. The question returns a case reference straight away, the case parks and the agent carries on with everything else. Answers wait in a queue it collects in any later session. While a question is open no new authority is granted, so silence is never read as permission.
A file is per repository and per machine, and it drifts the moment someone edits their copy. The playbook is one signed version with an owner on every rule, so Claude Code, Codex and Cursor read the same current rules without anyone syncing anything.
The playbook you import and the questions your agents ask. Not your repository, not your customer records, not the tools your agents call. The playbook is yours and exports on demand.
Scope. An answer resolves the case it was asked about and nothing else. Turning it into a rule is a separate decision by the person who owns it, and the rule carries their name, its scope and the date it took effect. Draft rules are checked against the approved playbook, so a contradiction reaches a human instead of quietly winning.