← All guides · Published November 14, 2026 · Reviewed November 14, 2026 · By the Ingenious AI team · 6 min read

What Is the AgentGate Policy Export and When Do You Need It?

The short answer: it is the Team-tier export that compiles your AgentBlock policy into an agent-policy.json in AgentGate's format — the fleet's agent-governance sibling. The point is portability of decisions: the per-agent posture you built for your website — who is blocked, who is allowed, under what evidence — becomes a machine-readable policy other enforcement points can consume, instead of a website-only artifact that a second team re-derives, differently, elsewhere.

Build my block kit — free · Test a policy in the simulator first

What is the AgentGate policy export?

a Team-tier AgentBlock generator output that compiles a site policy into agent-policy.json in AgentGate's format, carrying the policy's agent decisions in a portable, machine-readable form for agent-governance enforcement beyond the website itself.

Decisions are worth more than artifacts

The expensive part of crawler policy was never generating a Worker; it was the decisions — the graded evidence, the per-agent calls, the recorded exceptions. Artifacts are cheap regenerations of those decisions for particular layers. An organisation that lets the decisions live only inside one website artifact has trapped its most valuable layer in its most disposable one, and will pay for the same judgement again at every new surface: an app, an API, a partner integration, an agent it fields itself.

The export exists to untrap them. One policy, compiled to the governance format, means the website's posture and the organisation's agent posture can be the same posture — reviewed once, evidenced once, changed in one place.

What travels in the file

The export is generated from the policy record by the same generator that builds the Worker, plugin, snippet, robots and evidence outputs — one source, many targets, which is the architectural point. The agent decisions travel in AgentGate's policy schema rather than in a website-specific rule syntax, so the consuming system reads decisions (this agent, this verdict, under this policy) instead of scraping a JavaScript file for substrings.

Because it is a compilation, the export never becomes a second source of truth to maintain. Change a decision in the builder and the next export carries it; the file in a downstream system is a snapshot, dated like every other artifact the policy produces.

Who actually needs it

Three profiles recur. Organisations running their own agents, which need AgentGate-style governance for outbound agent behaviour and want the inbound crawler posture and the outbound agent posture reconciled in one policy conversation. Agencies and platforms enforcing at multiple points — websites plus an API gateway, say — where per-point rule sets would drift. And diligence-driven owners who want the policy in a portable, inspectable format that outlives any single vendor tool, theirs included.

Single-site owners on one stack do not need it, and the tiering reflects that: the export sits on Team beside the classify API and bulk verification — the programmatic, multi-point tier — rather than being upsold to a bakery with one WordPress site.

Keeping two systems honest

Portability has a failure mode: two systems enforcing copies of a policy, edited independently, diverging in the dark. The discipline that prevents it is the same as every other layer in this series — one source of truth, dated snapshots, verification. The policy is authored in AgentBlock's builder; the export is generated, never hand-edited downstream; and a change that originates on the AgentGate side is a proposal to bring back to the source, not a local edit.

With that discipline, the export closes the fleet's loop neatly: the website refuses the agents the organisation refuses, the organisation's own agents operate under the governance its website decisions imply, and an auditor can read both from one policy record.

Five actions to take today

  1. Author decisions in one place. The builder is the source of truth; the export is a compilation, never a second policy to maintain.
  2. Export on change, with the date. Downstream systems should always be able to say which policy snapshot they enforce.
  3. Never hand-edit the exported file. A needed change goes back into the policy and out again through the generator.
  4. Match the tier to the need. Multi-point enforcement, own-agent governance or portability diligence justify Team; a single site does not need the export.
  5. Reconcile postures deliberately. If your outbound agent policy and inbound crawler policy differ, record why — the export makes the comparison possible.

Worked example: one posture, two enforcement points

LoopLedger, the fictional bookkeeping SaaS from the per-agent guide, grew into a second surface: a public API its integration partners' agents call. The partners' question — 'which agents do you permit, and under what policy?' — was the website question wearing a different hat, and the engineering team's first instinct was a second, API-specific rule set written from scratch.

Instead, the website policy was exported as agent-policy.json and adopted as the API's starting posture: same blocked training and scraping names at the gateway, same retrieval allowances for the partners' named agents, same evidence file backing both. The divergence review took one meeting and produced two recorded exceptions, each with its reason.

When the database next moved, one regeneration refreshed both surfaces' snapshots in the same week — the two-point estate behaving, for maintenance purposes, like the single policy it actually is.

Frequently asked questions

What is AgentGate?

AgentGate is the Ingenious AI fleet's agent-governance platform — the sibling concerned with governing agents themselves. AgentBlock's Team export compiles a website crawler policy into AgentGate's agent-policy.json format so the decisions can be consumed by that governance layer.

Is the export a different policy from my kit?

No — it is the same policy, compiled to a different target by the same generator that produces the Worker, plugin, snippet, robots and evidence outputs. One source of truth, several artifacts; the export is a dated snapshot like the rest.

Who should not bother with the export?

Single-stack, single-site owners. If your website is your only enforcement point, the Worker or plugin is your artifact and the export solves a problem you do not have. It earns its tier when a second enforcement point, your own agents, or portability diligence enters the picture.

Can I edit the exported JSON to fine-tune it?

You can, and you should not — a hand-edited export silently forks the policy. Bring the change back to the builder, regenerate, and re-export; the five minutes is what keeps two systems telling one truth.

Does the export include the evidence grades?

The export carries the policy's decisions in AgentGate's schema. The grades and sources behind the decisions remain in the AgentBlock database and policy record, which is the reference the export's consumers can be pointed to — decisions travel, provenance stays addressable.

Build my block kit — free · Browse the agent database

Related guides

HONEST SCOPE: this policy blocks KNOWN agent user-agents and behaviors listed below. Sophisticated spoofing can bypass any user-agent block (e.g. an agent sending a stock browser UA, or rotating residential IPs). This is a control, not a guarantee.
← Back