Free plan

← All guides

Agent Policy for SaaS and API Products

Published November 14, 2026 · Reviewed November 2026 · By the Ingenious AI team

The short answer

A SaaS product's agent policy revolves around one verb: api-call. Your documentation and marketing pages want readers; your product API wants authenticated customers and named partners — nobody else. The SaaS pattern therefore publishes a split personality in one file: generous reading rules for the public surfaces, api-call disallowed for the world, and named partner rules where api-call is permitted under the credentials those partners already hold. The authentication guide explains why the file declares and the gateway verifies.

Generate your policy — free · Validate an existing one

What does a SaaS policy need to decide?

Three boundaries. Content: docs, guides, changelogs, and status pages are your agent-readable shop window — the material support agents and developer agents use to answer questions about your product. Product surface: the application itself, where submit-form and api-call act on customer data and must never be public grants. Partner surface: the integrations — the small set of agents whose api-call access is a designed feature, governed by contract and keys, and recorded in the policy as named rules. Most SaaS policy errors come from blurring the three; the pattern below keeps them in separate rules with separate verbs.

The public layer: docs that agents can actually use

Grant the reading verbs broadly over your public presence — an allow default or a generous catch-all — with two SaaS-specific refinements. First, mind the status page: agents answering "is it down?" for your customers are support deflection you did not have to build; read on status content is nearly free value. Second, write data-use terms that fit developer content: documentation may be quoted with attribution (your docs being cited inside agent answers is your product being recommended), while customer data — which agents should never reach through public surfaces at all — is refused in terms as well as in architecture. The public layer's pace can be your most generous; docs are cacheable in a way APIs are not.

The product layer: refusal as a feature

For the world at large, api-call and submit-form sit in disallowed lists — not from hostility but from category: unauthenticated state-change is not a public offer in any SaaS business. Stating the refusal in the policy has a practical benefit beyond tidiness: partner and security conversations start from an accurate map. When a customer's security review asks how agents interact with your product, the file is a quotable answer — the public grant is reading; everything else is named, credentialed, and contractual. That answer, fetchable in one request, is worth more in procurement cycles than any slide deck — a dynamic B2B SaaS owners consistently underestimate until a buyer's agent fetches the file during evaluation.

The partner layer: named rules over issued keys

Each integration partner gets a rule: api-call permitted, pace set to the integration's real shape, data-use terms referencing the governing agreement and the credential regime. The rule never contains keys or secrets — it is a public document — but it records the arrangement's outline where the partner's own agent will read it. Retire rules as integrations retire; a partner list that only grows becomes a map of relationships that no longer exist, and the quarterly review in the cadence guide is where SaaS partner rules earn their audit. Products with dozens of integrations graduate to managing this layer as a register — the pattern in the multi-site guide, applied to rules instead of domains.

SaaS owners should also expect the policy to leak, productively, into their sales motion. Once the file exists, it gets attached to security questionnaires, quoted in procurement threads, and screenshotted into evaluation decks — usually by your own champions inside the buying organisation, who find in it the one artefact that answers the agent question without booking a call. That afterlife argues for maintaining the file with the care usually reserved for the pricing page: current dates, precise verbs, no stale partner rules advertising integrations that churned two quarters ago. The document will represent the product in rooms the product team never enters; dress it accordingly.

Worked example: a project tool's three-layer file

Fictional example. Kanbanly, a fictional project-management SaaS with 31,000 workspaces, publishes 7 rules in three layers. Public: catch-all granting reading verbs at 45 requests per minute, attribution in the terms. Product: api-call and submit-form disallowed in every public-facing rule, restated in the notice. Partner: 5 named integration rules permitting api-call at paces from 60 to 240 per minute, each with agreement-referencing data terms. The year's evidence: support tickets tagged "agent access" fell by half once the file answered the questions publicly; one enterprise evaluation cited the policy URL in its security appendix unprompted; and 2 retired integrations were caught at quarterly review still holding live rules — removed in the same pass, the audit working as designed.

The SaaS policy checklist

  1. Layer the file. Public reading, product refusal, partner grants — separate rules, separate verbs, no blur.
  2. Open the docs. Reading verbs generous over documentation, guides, and status — with attribution terms.
  3. Refuse state-change publicly. api-call and submit-form disallowed for the world, in every public rule.
  4. Record partners precisely. Named rules with real paces and agreement-referencing terms; credentials never in the file.
  5. Audit partner rules quarterly. Integrations retire; their rules retire in the same pass.

Keep reading

Agent Policy for Travel and Booking Sites · Agent Policy for Healthcare Sites · How to Tell AI Agents What They May Do · Spec samples · Conformance · Pricing · All guides

Frequently asked questions

Should documentation be behind the same refusals as the API?

No — conflating them is the common SaaS error. Documentation is marketing and support: agent-readable docs answer your customers' questions inside their own tools. The API is operations: authenticated, metered, contractual. The policy's job is to state both postures in one file without confusing them, which the layered pattern does.

Can the policy express our API rate limits?

It can declare them — rate_limit is a per-rule requests-per-minute statement — but declaration is not enforcement. Your gateway throttles; the policy publishes the number so partners can plan and so breaches are breaches of a stated term. Keep declared numbers at or inside enforced ones, as the authentication guide advises.

What about agents our own customers build on our API?

They are customers first: their access runs through your ordinary developer programme — keys, quotas, terms of service. The policy's role is discovery and posture: a customer evaluating whether agents may use your product finds the answer, and the api-call shape, in one fetch — then joins the programme like any developer.

Does an agent policy help in enterprise security reviews?

Owners report that it does, for a simple reason: the review's agent questions — what may agents do, where, under whose credentials — have a single fetchable, dated, standards-shaped answer. It does not replace your security documentation; it gives reviewers the public boundary statement those documents usually lack.

We have no partner integrations. Is a policy still useful?

Yes — the two-layer version (public reading, product refusal) is the policy most SaaS products need today. It answers customers' agents, buyers' diligence, and your own support queue from one file, and it leaves the partner layer as an empty, ready structure for the day the first integration is signed.

Generate a policy — free · Validate a policy · What an agent access policy is

← Back