AI Agent Allowlist
Home Page-Types Database Agent Guardrails 2026 Incidents API Docs Pricing
Why It Matters
2026 Agent Incidents Category Targeting Database Refreshes Contact Customer Login
Download Free Sample
Setup guide — for database licensees

Running the Full Method, locally

Every database license ships three things: the page-type database, the 40-rule Egress Rules Library, and the High-Value Host List. Used together, in a fixed order, they answer one question deterministically: may this agent open this URL? This page is the complete local setup: the evaluation order, a reference implementation you can lift into your proxy, the file schemas, and worked examples you can verify against the live API — which runs exactly the same order on every request.

The evaluation order

Four steps, always all of them, always in this order

The Full Method is one function: URL and method in, verdict out. No step is optional and no step is a fallback you add later — each catches what the previous one cannot see, and the order is what makes the result deterministic.

High-Value Host List

Is the destination host one of the ~60 entries that are sensitive by identity — cloud consoles, secrets managers, admin planes? Exact hostnames and wildcard patterns (*.console.aws.amazon.com). A hard deny here ends evaluation; a flag is remembered and carried along.

deny wins outright · flag defers to steps 2–3

Verified page-type URLs

Does the URL exactly match one of the domain’s verified page-type URLs from the database? A match on a write surface (login, signup, checkout, upload, post_create…) is a deny; a match on a read surface (documentation, pricing, blog…) is an allow. Normalize both sides the same way: strip scheme, www., and trailing slash.

the precision layer — verified URLs, per domain

The 40 URL-pattern rules

Does the URL’s path and query match any rule in the Egress Rules Library? These fire on any domain — classified or not — and are method-aware, which matters for legacy software where writes travel as GETs. This is the layer that covers the web’s long tail.

structure over identity — works on domains nobody classified

Defaults

Nothing matched? A carried host-list flag surfaces now. Otherwise: read methods (GET, HEAD) allow; write methods (POST, PUT, DELETE…) deny — an agent has no business writing to a URL no layer can name.

unmatched reads pass · unmatched writes are denied
  One rule of thumb covers the whole page: never enforce a subset. Page types without the pattern rules miss unclassified domains; pattern rules without page types miss verified per-domain surfaces; both without the host list miss destinations that are dangerous regardless of URL shape. The layers are designed as one method — the API never evaluates fewer than all of them, and neither should your proxy.
Reference implementation

The whole method in ~50 lines

This mirrors the evaluation the API runs, line for line. Load the three files at startup, call evaluate(url, method) from your egress hook, enforce the verdict, log the match.

# startup: load the three deliverables
rules = [json.loads(l) for l in open("page_type_rules.jsonl") if l.strip()]
for r in rules: r["rx"] = re.compile(r["url_regex"], re.I)
hosts = list(csv.DictReader(open("high_value_hosts.csv")))
db = load_page_types() # domain -> {page_type: verified_url}; CSV, Parquet, or your store
DENY_TYPES = {"login","signup","password_reset","cart","checkout","upload","post_create","comment","subscribe"}

def evaluate(url, method="GET"):
    host, pathq = split_host_pathq(url); dom = base_domain(host)
    # 1. host list: hard deny ends it; flag is carried
    flag = None
    for h in hosts:
        if host_matches(host, h["host_pattern"]):
            if h["default_verdict"] == "deny": return "deny", ("high_value_hosts", h)
            flag = h; break
    # 2. verified page-type URLs for this domain (normalize both sides)
    for ptype, purl in db.get(dom, {}).items():
        if norm(purl) == norm(url):
            return ("deny" if ptype in DENY_TYPES else "allow"), ("page_type_db", ptype)
    # 3. the 40 pattern rules, on path+query (any domain)
    for r in rules:
        if r["rx"].search(pathq): return r["default_verdict"], ("rules", r["id"])
    # 4. defaults: carried flag, then read/write split
    if flag: return "flag", ("high_value_hosts", flag)
    return ("allow" if method in ("GET","HEAD") else "deny"), ("default", method)

Three practical notes. Subdomains: when the full host has no database row, fall back to its base domain (chat.openai.com → openai.com) — the API does the same. Performance: the database is a hash lookup and the 40 regexes evaluate in microseconds; the whole method adds no meaningful latency to an egress hook. Logging: keep the matched layer and id with every verdict — your audit trail then explains every denial by itself.

What ships in the license

The three deliverables and their schemas

DeliverableFormatFields
Page-type database CSV / Parquet: domain, language, page_types page_types is type=url;type=url;… — only verified pages appear; an absent type is a verified negative. 40M+ domains, 28 possible types per domain.
Egress Rules Library page_type_rules.jsonl — one rule per line id, page_type, group, url_regex, write_methods, default_verdict, note. 40 rules across identity, transaction, content-write, infrastructure, and admin groups.
High-Value Host List high_value_hosts.csv host_pattern (exact or *.wildcard), category, page_type, default_verdict (deny or flag), note. ~60 curated entries, reviewed by hand.

One example rule, verbatim, so you know what to expect: {"id":"login","group":"identity","url_regex":"(^|/)(login|log-in|signin|sign-in|…)(/|\?|$)","write_methods":["POST"],"default_verdict":"deny"}

Worked examples

Six URLs through the Full Method

Run these through your implementation; every row is verifiable against the live API with the same URL, and your local answers should match exactly.

URL (method)VerdictDeciding layer
https://huggingface.co/docs (GET)allowpage_type_db · verified documentation URL
https://huggingface.co/new-dataset (GET)denypage_type_db · verified upload URL
https://anywiki.example/wiki.cgi?action=edit&id=X (GET)denyrules · wiki_edit — fires although the domain has no database row
https://console.aws.amazon.com/ec2 (GET)denyhigh_value_hosts · identity, ends evaluation at step 1
https://smallblog.example/posts/hello (GET)allowdefault · unmatched read passes
https://smallblog.example/x/handler (POST)denydefault · unmatched write is denied
  Parity with the API: the hosted API runs this exact order on every request — there is no reduced mode. That makes it your free conformance suite: send any URL to /api/check?url=… and compare verdict and matched with your local result. A handful of golden URLs in your CI keeps the local implementation honest as you refresh data.
Go deeper

The layers, in detail

The Full Method, on your infrastructure

Database licenses ship all three deliverables with quarterly or daily-refresh options — run the complete evaluation locally with zero per-request calls.

See Database Licenses