Guardrails
Inspect every tool call and refuse the ones that break your rules.
In beta. Guardrails are in every workspace. A rule decides nothing until it has coverage and you switch it on, so a workspace without rules is unaffected.
A guardrail is a rule your workspace runs against a tool call. The rule is a script: it reads the call and returns a verdict, and a blocking rule refuses the call when the verdict is no.
Skilder enforces it, not the agent. An agent working under the rules never sees their coverage, script or publish state, so it cannot plan around them. It meets the effect: a refused call and the reason for it.
Two other agents do see guardrails. A contributor's agent can read rules through the manage tool, and an admin's agent can also write and test them: see Author rules from your agent. Every agent can report decisions through analytics, within the calls that member can read: the rule's name, whether it was blocking or observing, and its reason.
A call's path
Only published rules that are switched on and cover the call run. A rule set to Before the call reads the arguments, and one set to After the call reads the result. Before and after the call does both.
A Blocking rule refuses the call when it returns NO_GO, and when it gives no verdict at all. One refusal is enough. An After the call refusal withholds a result the tool already produced. An Observing rule records its verdict and never stops the call.
Before you start
- You have the admin role in this workspace. Contributors and members see every guardrail screen, read-only.
- You know which calls you want to watch. Coverage is expressed in MCP servers, tool names, read or write, and roles.
Create the rule
Go to Guardrails, under Governance in the sidebar, and click New guardrail. Name it after what it protects, pick a language (Python, JavaScript, TypeScript or Bash) and click Create guardrail.
A new rule is switched off, set to Observing, and covers nothing. It decides nothing until you say otherwise.
Write the script
A rule is read-only until you click Edit, which opens a draft.
On the Rule tab, the script reads one JSON object on standard input and prints one back: {"ruling":"GO"} to let the call through, or {"ruling":"NO_GO","reason":"..."} to refuse it. The reason reaches the agent, so write one it can act on.
A TypeScript or JavaScript rule can import the helpers instead of writing the contract by hand. See Script SDK.
The sandbox installs no dependencies in any language. Standard library only.
Say what it covers
On the Coverage tab, either choose Everything in this workspace, or pick Only calls that match conditions and fill in MCP servers, Tool name, Tool kind and Roles. Values inside one condition are alternatives; conditions are combined. Anything left as Any imposes nothing.
The preview lists the tools your choice matches today, using the same evaluator the runtime runs. Coverage is an expression, not a list, so a tool added tomorrow is covered without an edit. When the preview looks right, click Save coverage.

A rule with no coverage cannot be switched on. The Coverage column of the Guardrails list shows each rule's published reach: Not configured, Everything, or how many of the workspace's tools it covers.
Test it
Below the editor on the Rule tab, edit the sample call into one you want to catch and click Run test. While a draft is open, the test runs the draft unless you pick Published under Version. Nothing is recorded, and the tool itself is never called.
The result below comes from the published version of a blocking rule that is switched on.

Publish, then switch it on
The script, the coverage, the mode and the phase are versioned. Your edits sit in a draft until you click Publish, exactly like a skill. The Switch row on The rule card is separate and takes effect at once.
Watch, then promote
Leave the rule Observing while you read what it decides on the rule's Activity tab, and across the workspace in Activity > Guardrails. When the numbers look right, click Make blocking. That is a publish, so it lands in the version history and you can Return to observing the same way.
On a rule's own Activity tab, each outcome figure counts only the calls that rule decided, while Evaluated counts every call it judged. In either feed, the rule that decided a call is set in bold. A note under the figures counts the calls no single rule can be credited with: calls recorded before decisions were credited per rule, and calls whose deciding rule has since been deleted.
Check it worked
A call a blocking rule turned down carries the Refused status in Activity > Call Log. Click the row to see the rules that judged it, the reason for the refusal, and the message the agent received. An observing rule records the same verdict and lets the call through.

Author rules from your agent
An admin's agent can write, test and switch rules through manage. A contributor's agent sees only the rules, never these operations. Publishing stays with you. Ask in plain language and the agent picks the operation.
Create a guardrail on write calls to zendesk that refuses any call deleting a ticket, then test it on a sample call.- Create. A new rule is published at once, switched off, Observing unless you ask otherwise, and covers nothing until you give it coverage.
- Edit. Changes to the script, coverage, mode or phase go into the draft.
managecannot publish: you publish the draft in the app, or on the version card your agent displays when your MCP client renders cards. - Test. The agent runs the published rule or the draft against a sample call. Nothing is recorded and the tool is never called. The run does not check coverage, the switch or the configured phase, so it tells you what the rule would do to a call it covers.
- Switch on or off. This acts on the published rule at once. Switching on is refused while the published version covers nothing.
- Delete. Permanent, with the draft and the version history. Switch the rule off to stop it for a while.
Limits
- Every rule covering one call shares a 3 second budget per phase, observing rules included. A slow observing rule can leave a blocking rule no time, and that rule then refuses the call. A rule that inspects arguments has no reason to run for seconds.
- A blocking rule that fails to produce a verdict refuses the call. An empty script, a crash and a timeout all count.
- Where several rules cover the same call, any refusal wins.
Next
- Read Activity, to see the calls a rule judged alongside everything else agents did.
- Insights, to turn what you observe into better capabilities.

