Agent Access Policy Examples: Allow, Approve and Deny Rules for Real Sites
Published November 13, 2026 · Reviewed November 2026 · By the Ingenious AI team
The short answer
Every rule in an agent-policy.json file resolves to one of three verdicts for an agent: allow (operate on the stated terms), approve (stop and get the owner's agreement first — the spec's conditional), or deny (do not operate). The published AGENT-POLICY v0.1 samples show all three at work: a bank that denies everyone, a blog that allows almost everyone, and a store that lets named agents shop but never check out. Examples drawn from AGENT-POLICY-SPEC.md and the published spec samples, November 2026.
What do allow, approve, and deny mean in a policy?
A policy speaks at two levels, and each level has its own exact values in the file. At the top level, default_policy covers every agent you do not name. Inside agents, each per-agent rule carries its own allowed field. The plain-language verdicts map onto them like this:
| Verdict | default_policy value | Per-agent allowed value | What the agent reads |
|---|---|---|---|
| Allow | allow | yes | You may operate, on the terms this rule states — its permitted actions, rate limit, and data-use terms. |
| Approve | conditional | conditional | Contact the owner first. The spec defines conditional at the default level as "contact the owner first", and the store sample applies the same idea per agent: generic/* may browse and read only after contacting the store, on terms negotiated per agent. |
| Deny | block | no | You may not operate. A denied rule's permitted_actions may be empty, and anything the rule lists as disallowed is explicitly out of bounds. |
One honest limit applies to all three verdicts: a policy is a declaration, not an enforcement mechanism. It states the owner's terms in a form agents can discover and parse; it cannot force an agent that ignores it to stop. If the format itself is new to you, start with what an agent access policy is.
What does one rule look like, field by field?
Take the strongest allow in the samples: the store's rule for openai/agent. Every field the spec requires on a rule is doing a specific job:
| Field | Store sample value | What it decides |
|---|---|---|
identifier | openai/agent | Who the rule speaks to, in vendor/agent form. generic/* is the catch-all for agents not named elsewhere. |
allowed | yes | The verdict itself: yes, no, or conditional. |
permitted_actions | browse, read, search, shop | What this agent may do. Everything else is not granted by this rule. |
disallowed_actions | checkout, submit-form, api-call | What is explicitly out of bounds. An action may never appear in both lists of the same rule — that contradiction makes the document invalid. |
commercial_terms | paid-tier | The business terms: free, paid-tier, or contact. |
rate_limit (optional) | {"requests_per_minute": 60} | A requested politeness cap, in requests per minute. null states no limit. |
data_use_terms (optional) | "Product catalog data may be used for price comparison and shopping assistance only. No resale of catalog data. No model training on product images." | Plain-language constraints on retention, resale, and training use of the site's data. |
Around the rules sit the seven required top-level fields: policy_version ("0.1"), site, owner (a name and a contact), default_policy, agents, last_updated, and signature — which in v0.1 is null, an unsigned placeholder validators must accept.
How do the bank, blog, and store samples compare?
The three published samples are fictional, and each is built from the same fields — what changes is only the decisions. Together they mark the ends and the middle of the dial:
| Sample | Default | Rules | The decision in one line |
|---|---|---|---|
| Bank — block all (Meridian Trust Bank, fictional) | block | Empty agents list | Deny everyone. When the default says everything, per-agent rules are optional — the notice restates that no AI agent may access the banking site in any capacity. |
| Blog — open with attribution (Signal & Static, fictional) | allow | One rule: xai/grok set to no, with browse, read, search, summarize, quote, download, and crawl-full-site all disallowed | Allow the unnamed majority by default, deny one named agent completely. The blog's notice welcomes agents that attribute and link back, and refuses bulk scrapers that copy full articles. |
| Store — shopping agents (Brightline Goods, fictional) | conditional | Three rules: openai/agent yes on a paid tier at 60 requests per minute; perplexity/agent yes, free at 30 per minute, quotes must link back; generic/* conditional at 10 per minute | Approve-first for strangers, allow for named agents — and deny checkout, form submission, and API calls to all three rules alike. |
Read the full JSON of all three on the samples page. Notice what none of them does: none mixes verdicts inside a single rule. Each rule gives one agent one answer, with the permitted and disallowed lists kept strictly apart.
Worked example: a kitchenware store with six decisions
Example — fictional, written for this guide. The Copper Pantry is a fictional kitchenware store. Its owner starts from the store sample above — a conditional default and a named shopping-agent rule — and writes down six decisions, one per area of the site, before encoding any of them:
| Area | Verdict | How the decision is expressed |
|---|---|---|
| Product pages | Allow | browse, read, and search sit in the shopping rule's permitted_actions, as in the store sample. |
| Cart | Allow | shop is permitted, so the agent may compare pans and place the chosen one in the cart. |
| Checkout | Approve | checkout is kept out of permitted_actions. The agent's answer at the till is conditional: stop, and get an explicit go-ahead before any purchase is completed. |
| Account pages | Deny | Nothing on an account page is granted to the agent; submit-form — the action account changes would need — is in disallowed_actions, exactly as the store sample has it. |
| Admin | Deny | No rule permits anything in the admin area, and the conditional default means an unnamed agent has no standing there either. |
| Bulk catalogue scrape | Deny | crawl-full-site is listed in disallowed_actions — the store sample does exactly this on its generic/* rule — while ordinary product reading stays allowed at the rule's rate limit. |
Now watch the approve row fire. A shopping agent is helping a customer replace a saucepan: it reads the Copper Pantry's product pages, compares sizes and prices, and puts the chosen pan in the cart — all inside its permitted actions. It then moves to pay, and reaches the one step its rule never granted: checkout. That is the approve gate. The agent stops before any money moves, shows its customer the cart it built, and asks for an explicit go-ahead, handing the purchase itself back to the human. One honest caveat, straight from the spec: v0.1 deliberately does not define a real-time negotiation protocol — the policy declares where the boundary is; the pause is what an agent honouring the declaration does at that boundary.
How do you write rules an agent can actually parse?
An agent reading your file is doing something simple: fetch one JSON document, find the rule whose identifier matches it (or fall back to the default and the generic/* catch-all), and read off the verdict and the two action lists. Rules stay parseable when they respect how the file is read:
One agent, one rule. Duplicate identifiers are an error — the spec defines no first-match-wins, so a second rule for the same agent does not override the first; it invalidates the document. Never contradict yourself inside a rule: an action in both permitted_actions and disallowed_actions leaves the agent with no readable answer, and conformance rule 3 makes the document invalid for it. Use the suggested vocabulary where it fits — browse, read, search, summarize, quote, shop, checkout, book, submit-form, download, api-call, crawl-full-site — because agents already know those words. The vocabulary is non-exhaustive: a name outside it earns a validator warning, not an error, and the same applies to agent identifiers outside the v0.1 registry. Warnings are how the format grows without breaking the files already published.
The five-step method for making the decisions themselves — default, agents, actions, terms, publish — is its own guide: how to tell AI agents what they may do. And if you came here from robots.txt, agent policy vs robots.txt draws the exact line between paths and actions. The wider Ingenious AI fleet is at getingeniousai.com.
How do you test, publish, and version an example?
An example only becomes a policy when it survives the conformance checks and lands at the one URL agents actually fetch. The publishing checklist:
- Draft it. Start from the sample closest to your decisions and change the decisions, not the format — or build the file with the free generator.
- Validate it. Run the free validator and fix every error it reports: missing required fields, an action in both lists of one rule, a duplicate identifier.
- Publish it. Serve the file at
/.well-known/agent-policy.jsonasapplication/json, reachable without authentication. - Check the live copy. Fetch the published URL the way an agent would and validate what comes back — the file on the server is the policy, not the draft on your disk.
- Version it honestly. Set
policy_versionto the spec version the document follows ("0.1"today) and updatelast_updatedevery time you review the terms.
On versioning, the spec is precise about what readers may assume: policy_version follows a semver-ish "major.minor" shape, validators for v0.1 must reject unknown major versions, and they should warn on unknown minor versions. That is why the version field and the review date are not decoration — they are how an agent knows which rulebook your file was written against, and how fresh the decisions in it are.
Frequently asked questions
What is an example of an agent access policy?
The spec publishes three fictional samples. A bank sets default_policy to block with an empty agents list, so no agent may operate. A blog sets its default to allow and adds one rule switching a single named agent off entirely. A store sets a conditional default and welcomes named shopping agents — one may browse, read, search, and shop on a paid tier, while checkout stays disallowed for every rule in the file.
What is the difference between allow, approve-first, and deny?
They are the plain-language reading of the spec's two value sets. At the top level, default_policy is allow, conditional, or block: conditional means contact the owner first — the approve-first verdict. Inside a per-agent rule, allowed is yes, conditional, or no. Allow and yes let the agent operate on the stated terms; conditional pauses it until the owner has been contacted; block and no refuse it.
Can an agent be allowed to shop but not check out?
Yes — that is exactly the store sample. Its openai/agent rule permits browse, read, search, and shop at up to 60 requests per minute on paid-tier terms, and lists checkout, submit-form, and api-call as disallowed. The agent can fill a cart and compare products, but completing the purchase is outside what the policy permits.
What makes an example policy invalid?
The same things that invalidate any v0.1 document: a missing or mistyped required field, an action listed in both permitted_actions and disallowed_actions of the same rule, or two rules sharing one identifier — the spec defines no first-match-wins, so duplicates are an error. Unknown agent identifiers and unknown action names only earn a validator warning, never an error, because both lists are non-exhaustive.
How do I turn an example into my own policy?
Start from the sample closest to your answer, then change the decisions, not the format: set your default, name the agents you care about, list permitted and disallowed actions per rule, and set commercial terms. AgentGate's free generator builds the file from a short questionnaire and the free validator checks it against the v0.1 conformance rules. Publish the result at /.well-known/agent-policy.json, reachable without authentication, and update last_updated whenever you review it.
Generate a policy — free · Validate a policy · What an agent access policy is