Policies
Bundle guardrails with the ceilings an agent runs under — autonomy, actions per beat, tool calls per beat and approval requirements — and attach the result to an agent, or to a group to guard its members' queries
A policy bundles the guardrails it carries with the ceilings it sets. Attached to an agent, all of it governs that agent's beats. Attached to a group, its guardrails on questions and answers govern the queries of the group's members, and its ceilings do not — see A policy on a group. Admin → Policies is where policies are written. Open it with the Admin control in the top navigation bar, then choose Policies under Governance in the Admin sidebar.
Policies, Guardrails and Egress Allowlists are one plane: View policies, guardrails and egress opens all three read-only, and Manage policies, guardrails and egress changes them. Platform Admin holds both. Manage is also required to attach governance to an agent or a group, even though attaching happens on the Team pane or the group — without that rule, anyone with Write access to a project could strip every control off its agents.

Each row summarises what the policy actually constrains, rather than leaving it to be inferred.
Everything a policy sets is a ceiling
This is the single most important property of the model. A policy never grants anything. Every clause is an upper bound, and composing two policies takes the tighter of each:
- Numeric ceilings take the minimum.
- Autonomy can only move an agent down the list.
- Approval requirements are unioned — if either policy requires approval, approval is required.
- A host must be admitted by every egress allowlist in force.
- Guardrails are added together.
Attaching a second policy can therefore only narrow what an agent may do, never widen it. That is what makes it safe to hand an agent a broad policy and a narrow one at the same time.
What a policy carries
Guardrails
Any number of guardrails, up to 100. Every guardrail a policy carries is added to whatever else governs the subject.
Only Active guardrails take part. A draft can be listed in a policy and attached with it, and it checks nothing — the picker shows each guardrail's status badge so you can see that before you save.
An egress allowlist
At most one, or None. It names the hosts the agent's tools are allowed to reach. Because a host must be admitted by every allowlist in force, adding one to a second policy can only narrow the reach.
A Link domain guardrail has no hosts of its own and reads whatever allowlist is in force, so a policy that carries one must name an allowlist as well. Saving an Active policy that carries a Link domain guardrail and names none is refused — without an allowlist to compare against, that guardrail cannot be evaluated at all.
Ceilings
| Ceiling | What it bounds |
|---|---|
| Maximum autonomy | How much a beat may do on its own — Manual or Full. |
| Actions per beat | How many actions one beat may take. 1 to 20. |
| Tool calls per beat | How many tool calls one beat may make. 1 to 20. |
| Require approval for | Read-only tools, Tools that change something, or both. |
Every ceiling bounds an agent's beat, so it governs only the agents the policy is attached to — never the members of a group that carries it.
Leave a ceiling blank and this policy sets none there. Blank is not zero — zero is a value the server refuses, and it would read like the tightest possible setting rather than the refusal it is.
There is no separate approval control on an agent. An approval requirement is a policy clause, so it is something a policy brings rather than a fourth thing to attach.
Status
A policy is Draft or Active. Only an Active policy is in force; a draft can be attached and listed and governs nothing. The page states the count under the list when any policy on it is still a draft.
Create a policy
Select New policy, or, from anywhere on the Admin plane, Create → Policy at the right of the top header. The editor opens as a sheet on the right. The Create menu shows this entry only to holders of Manage policies, guardrails and egress.
Give it a Name and a Description. Name it after the population it governs — "Customer-facing agents" — rather than after the controls inside it, which will change.
Choose the Guardrails it carries. The picker is searchable and shows each guardrail's kind and status.
Choose an Egress allowlist, or leave it on None.
Set the Ceilings you want to impose, and leave the rest blank.

Each ceiling is an upper bound; where two policies both set one, the tighter wins.
Leave Status on Active and select Create policy.
Attach a policy
Writing a policy governs nothing on its own. Attach it to a subject, and which subject you choose decides which traffic it governs:
- An agent — open the agent on the project's Team pane and use its Guardrails tab. Everything the policy carries governs that agent's beats.
- A group — attach it to a native group on the Users page. Part of the policy governs the queries of the people in that group, from the console, a channel, the API, the CLI or MCP; a caller's groups are resolved on every query and narrowed together into one effective set. The next section says which part.
A subject may carry up to 25 policies, plus guardrails and an allowlist attached directly. The agent's Guardrails tab shows an In force panel that asks the server what the current selection actually composes to, and re-asks it on every change. That panel is the only place the whole narrowing is visible before a beat runs — including narrowing you did not intend. The agent's Heartbeat tab says it too, beside each setting a ceiling holds lower.
Saving the Guardrails tab writes only what you changed: the policies, the guardrails, or the allowlist. A policy, guardrail or allowlist another admin attached while your tab was open stays attached. If you both changed the same list, the later save wins that list.
Detaching governance is a widening, and nothing about an empty selection is invalid, so it validates clean. Attachment is gated on the governance permission for exactly that reason: without it, stripping every control off an agent would be an ordinary edit.
A policy on a group
A query asks a question and returns an answer; it calls no tool and runs no beat. So when a policy is attached to a group, only the parts of it that act on a question or an answer govern the group's members:
| Part of the policy | On a group member's query |
|---|---|
| Status | Applies. An Active policy is in force; a Draft one governs nothing. |
| Input and Output guardrails | Apply, alongside the group's own guardrails. |
| Egress allowlist | Applies only as the list a Link domain guardrail compares the answer's links against. |
| Maximum autonomy, Actions per beat, Tool calls per beat | Do not apply. They bound an agent's beat. |
| Require approval for | Does not apply. It holds an agent's tool calls for approval. |
| Tool call guardrails | Do not apply. They inspect what an agent sends to a tool. |
The parts that do not apply on a query do not reach an agent either: an agent's beats are governed by the policies attached to that agent, never by those on a group. To bound what an agent may do, attach the policy to the agent.
Policies that ship with AskRAI
Every tenant is seeded with Baseline safety, a platform policy bundling the shipped deterministic controls: no credential leakage, masked contact details, blocked identifiers and denied words. It carries a Platform badge. The Add agent panel ticks it for every new agent, for someone with the governance permission.

A platform policy is inspectable but not editable — write your own alongside it.
Platform policies are read-only: the server refuses an edit or a delete. Unlike a guardrail, a policy has no duplicate action, so the editor says plainly that it cannot be changed rather than offering a Save that would fail. Write your own alongside it — composing a second policy can only narrow what an agent may do, so adding one never weakens the baseline.
Seeding a tenant changes no traffic. A policy governs a turn only once something attaches it.
Delete a policy
Delete is on the left of the editor footer. Before you can confirm, the dialog reads how many agents and groups attach the policy and states the count, because that number is the whole question — deleting a policy nothing uses is housekeeping, and deleting one that governs a live team is not. If that lookup fails, the dialog says so rather than showing a reassuring zero.
Deleting is permanent, and the policy stops governing everything it is attached to.
A policy that constrains nothing
A policy with no guardrails and no ceiling is legal, and the list flags it: "This policy carries no guardrails and sets no ceiling — attaching it changes nothing." It is worth writing one deliberately as a placeholder, but it is more often a policy someone emptied without noticing.
Field reference
| Field | Notes |
|---|---|
| Name | Required. Up to 120 characters. |
| Description | Optional. Up to 500 characters. |
| Guardrails | Up to 100. Only Active guardrails take part. |
| Egress allowlist | At most one, or None. |
| Maximum autonomy | Manual, Full, or no ceiling. A policy set to Suggest before it was withdrawn shows and holds as Full. |
| Actions per beat | Whole number, 1 to 20, or blank for no ceiling. |
| Tool calls per beat | Whole number, 1 to 20, or blank for no ceiling. |
| Require approval for | Read-only tools and/or Tools that change something. |
| Status | Draft or Active. Only Active is in force. |
Related pages
Guardrails
Author the individual checks a policy bundles.
Team
Attach a policy to an agent and read what it composes to.
Governance concept
How governance and the audit trail fit together.
Interactions
What a beat is, and what the per-beat ceilings bound.
Egress Allowlists
Write the host list a policy carries.
Agent Templates
Author reusable agent configurations, version them, grant them to organizations, save an existing agent as one, and review the agents projects suggest
Guardrails
Author the checks that inspect what reaches an agent, what it says, and what it sends to a tool — their kind, stage, action, and whether they are in force