Agent Identifiers Explained: the vendor/agent Format
Published November 14, 2026 · Reviewed November 2026 · By the Ingenious AI team
The short answer
An agent identifier is the name a rule in an agent-policy.json file speaks to, written in vendor/agent form: openai/agent, meta/muse, xai/grok, google/gemini-agent, anthropic/claude-agent, perplexity/agent — plus generic/*, the catch-all. The v0.1 registry lists those seven and is explicitly non-exhaustive: an identifier nobody has registered yet earns a validator warning, never an error.
What is an agent identifier?
It is how a policy addresses an agent the way an invitation addresses a guest: by a name both sides recognise. The vendor half names the organisation operating the agent; the agent half names the product. An agent evaluating your policy looks for the rule carrying its own identifier, the way the store sample's shopping rule carries openai/agent. Identifiers are advisory, not credentials — the spec's scope section is clear that v0.1 does no authentication of anyone, and identifiers are not API keys. They name who a rule is for; they do not prove who is asking.
The registry, and why it stays open
The seven registry entries cover the major operated web agents the spec's authors could name in October 2026, plus the catch-all. The registry's most important property is what it refuses to do: close. New agents appear constantly, and a format that errored on every unlisted name would punish owners for the ecosystem's growth and punish new agents for existing. So the validator's contract is asymmetric — a duplicate identifier in your file is a conformance error, because that is your mistake; an unknown identifier is a warning, because that may be nobody's mistake at all. Warnings vs errors unpacks the philosophy; the practical upshot is that you may write a rule for an agent launched last week, in the same vendor/agent shape, and the file conforms.
Naming rules for owners
Three habits keep identifiers useful. Copy the registry spelling exactly for known agents — anthropic/claude-agent, not a plausible variant — because the agent looking for its rule matches the identifier as written. Use the catch-all deliberately: generic/* is itself an identifier, matching any agent not named elsewhere, and it is the only wildcard v0.1 defines; there is no per-vendor wildcard syntax. One identifier, one rule: duplicates are invalid, full stop, as the rules guide covers. When you cannot find an agent in the registry, the fallback is not guesswork but layering — your default_policy and catch-all already answer every agent you cannot name.
Identifiers versus user-agent strings
Owners arriving from robots.txt often expect the identifier to behave like a user-agent token. The resemblance is real — both name a class of software — but the differences matter. Identifiers live in a policy about actions and terms, not paths. They are matched against the agent's self-knowledge — which product it is — rather than parsed from request headers by your server, because the policy is read by the agent, not enforced by your stack. And where robots.txt tokens are whatever each crawler happens to send, identifiers follow one documented shape with a published registry, which is what makes statements like "the rule for perplexity/agent" unambiguous between strangers. The full comparison is in agent policy vs robots.txt.
Identifiers also do quiet diplomatic work that is easy to miss. When an operator sees their agent named in your file — spelled correctly, given a considered rule — they learn the relationship is being managed by someone who knows they exist. When they find their agent handled only by a catch-all, they learn the opposite, fairly or not. For the handful of agents your site actually cares about, that signal is worth the five minutes a named rule costs; it converts your policy from a fence into an introduction. Several of the relationships described across these guides began exactly there: an operator who wrote in because the file showed their agent had been thought about, by name, in advance.
Worked example: a design studio names four agents and plans for the fifth
Fictional example. Atelier Nord, a fictional design studio showcasing 90 case studies, names 4 identifiers in its policy: three registry agents get read and quote free at 30 requests per minute, and one agent known for aggressive portfolio scraping gets no with crawl-full-site disallowed. The studio's real foresight sits in the other two layers: a generic/* rule at conditional, 10 per minute, and a conditional default. When a new agent launched the following spring and its operator emailed asking which rule applied, the answer took one line — the catch-all covers you until we write you a rule of your own, which the studio did that week, at yes for reading, becoming the policy's fifth rule.
Working with identifiers in five steps
- Copy registry spellings. For known agents, use the exact vendor/agent strings from the v0.1 registry.
- Keep identifiers unique. One rule per identifier — duplicates invalidate the document.
- Add the catch-all. A
generic/*rule gives every unnamed agent an explicit answer. - Trust the layering. Agents you cannot name are already answered by the catch-all and the default.
- Accept unknown-name warnings. A warning on a new agent's identifier is the registry staying open, not your file failing.
Keep reading
The generic/* Rule: Your Policy's Catch-All, Explained · The signature Field in agent-policy.json: Why It Is null · What Is an Agent Access Policy (v0.1)? · Spec samples · Conformance · Pricing · All guides
Frequently asked questions
What identifiers does the v0.1 registry list?
Six named agents — openai/agent, meta/muse, xai/grok, google/gemini-agent, anthropic/claude-agent, and perplexity/agent — plus generic/*, the catch-all for any agent not named elsewhere. The registry is explicitly non-exhaustive and advisory.
What if the agent I care about is not in the registry?
Write its rule anyway, in vendor/agent form. An unknown identifier earns a validator warning, never an error, precisely so new agents can be addressed before any registry catches up. Your file still conforms, and the agent it names can still find its rule.
Does an identifier prove an agent's identity?
No. v0.1 does no authentication — of agents or of publishers. The identifier names who a rule is for; it is not a credential and proves nothing about who is making any given request. Authentication is listed in the spec among the things v0.1 deliberately does not cover.
Can I use wildcards for a whole vendor's agents?
No — generic/* is the only wildcard the format defines, and it matches agents not named elsewhere, across all vendors. There is no vendor-level wildcard syntax in v0.1. If you want to address several of one vendor's agents, write one rule per identifier.
What happens with two rules for one identifier?
The document is invalid. Conformance rule 4 makes duplicate identifiers an error because the spec defines no first-match-wins: an agent facing two rules addressed to it has no principled way to choose. Merge the intent into a single rule.
Generate a policy — free · Validate a policy · What an agent access policy is