Skip to main content
This is draft 0.1 of the registry. A later draft can break it until 1.0. The registry server defines its types and its tools in registry/src/schema.ts, and the schema reference shows them from section R1. This page gives the rules. The tools of each seller are in the specification.

1. Overview

A buying agent calls the registry before it sends anything to a seller. The registry answers three questions, and it needs no customer data to answer them:
  • Who sells here? search_distributors returns the sellers that speak AIP in a country, for a line.
  • Can this seller sell here? verify_licence checks a seller, or the insurer behind an offer, in the public registers. It works for a seller that the registry does not list.
  • Which rules apply here? get_country_rules returns the rules of a country for the AIP skill.
Each seller runs its own MCP server with the tools of the specification. The registry is the global search, and the server of each seller is the one-to-one. The registry does not price, it does not check the underwriting scope of a product, and it does not copy what a server publishes. Those stay on the seller’s server.

1.1 Roles

  • Operator. The organisation that runs the registry. It follows the rules on this page, and section 1.2 says who it is.
  • Agent. The AI agent that acts for the customer. It calls the registry, then the seller.
  • Seller. A distributor: the company that runs an MCP server with the AIP tools and sells the product.
  • Provider. The insurer that carries the risk. It can be the seller itself.
  • Register. A public list of licensed insurers or intermediaries, kept by a regulator or for one. The registry reads it and never replaces it.

1.2 Who runs the registry

A regulator decides who holds a licence, and the operator reads that decision in the public register. The operator adds no judgement of its own. Each seller goes through the same steps, and each answer names the register entry it rests on. This keeps the operator independent of the sellers. The operator changes in three stages:
  1. Draft 0.1. The AIP maintainers run a test registry, with fictional register entries. They take the requests to be listed, and answer them.
  2. An independent body. A body with a public charter runs the registry. Insurers, distributors, makers of AI agents and consumer groups can be members, and regulators can be members or observers. No member decides a listing, because the rules on this page decide.
  3. The regulators. Each regulator can take over its country. It opens its register through an API, owns the rules file of its country in the skill, and can run the part of the registry for its country.
The rules files of the skill take the same path, from the AIP maintainers to the regulator of each country.

2. Conventions

The conventions of the specification apply. A subdivision is an ISO 3166-2 code, such as US-TX. A domain is a lower-case host name with no scheme and no path, such as pets.example.com.

2.1 Network reads

Anyone can give the registry an address: a seller that asks to be listed, or an AI agent that gives a domain to verify_licence. Each read that the registry makes of an address of a seller, its aip.json and the mcp_url that it gives included, follows these rules:
  • The registry MUST read only HTTPS on port 443, on a host whose addresses are all public. It MUST check the addresses on each connection, so that a DNS answer that changes after a check cannot send it to a private network.
  • It MUST NOT follow a redirect to another host, and it MUST limit the time and the size of each read.
  • It MUST NOT put the body of a response or the text of a network error in a result, or in an answer to a seller.

3. Discovery

The AIP skill gives the address of the registry. The registry declares its extension under capabilities.extensions["org.agenticinsuranceprotocol/registry"] in its MCP server/discover response. The value is a RegistrySettings object: the version, the countries where the registry checks licences, the countries that have rules, every register it reads, and the page where the operator publishes its method. The registry SHOULD also serve the AIP skill through the MCP Skills extension. An agent whose host loads skills over MCP then gets the whole skill from the registry. get_country_rules serves the same country files to every other agent.

4. Tools

Every registry tool is read-only and needs no session, so the registry never learns who the customer is. The params describe a market or a company, never a person. A registry tool MUST refuse a call whose params do not match its input schema, a param that this draft does not define included, and keep nothing of the call. The refusal is an MCP tool result with isError: true and the reason as text. search_distributors takes a country, and optionally a subdivision, a line, an insured family and a minimum conformance level. It returns ListedDistributor objects: the legal and trading names, the domain, the MCP endpoint, the roles, the conformance level, the lines, the countries, the insured families, the complaints page, and a licence check for the market of the search.
  • Each result MUST match every param of the search.
  • The registry MUST return every listed seller that matches, across the pages.
  • For a country where it lists no seller, the registry returns country_not_covered. An agent then does not read an empty list as “no seller exists”.
  • The order carries no meaning. The registry MUST NOT rank a seller for a payment or for any commercial link, and it SHOULD shuffle the order for each new search. An agent MUST NOT show the order to the customer as a ranking.
The licence_check of each seller is a whole VerifyLicenceResult: the check that verify_licence gives for the seller’s domain, in the country, the subdivision and the line of the search. Its verdict is licensed, because a search returns only licensed sellers, and it MUST rest on reads made at most seven days before it. An agent MAY rely on it in place of its own verify_licence call when it is at most seven days old and the agent sends the answers to the mcp_url of the listing. The agent keeps it with the record of the sale, as any check. A seller found anywhere else needs verify_licence. The address of a server is the only proof of its domain. An AI agent MAY rely on a listing, or on a verify_licence result for a domain, only when it knows the address of the server that receives the answers, and that address is on that domain. It knows the address when it called the mcp_url itself, or when its host gives the address of each server that it connected, for example in its instructions or its configuration. The domain that the server gives in get_distributor MUST then be that domain. When it is not, the AI agent MUST NOT send the customer’s answers to that server. When the AI agent does not know the address of the server, it cannot tie the server to a domain. It MUST then treat the licence as unknown, tell the customer why, and send no answers to that server. The domain that a server gives about itself never proves its domain. Many hosts connect MCP servers before the conversation and do not show their address: see the open points of the specification.

6. Licence check

verify_licence answers one question: can this party sell, or carry the risk, for a customer in this country, subdivision and line? It MUST work for a seller that the registry does not list. An agent can find a seller anywhere on the web, and the check matters most then.

6.1 What the agent asks

The params are a VerifyLicenceParams object. Its capacity says what the agent checks.
  • A seller, with the capacity distributor. The agent gives the domain of the server or the website that will receive the customer’s answers. It can add the register entry and the legal name that the seller shows, for example in the legal notice of its website. A register number alone does not prove who runs a website, so a seller check always names the domain.
  • A provider, with the capacity provider, for example the insurer in Product.provider or Offer.provider. The agent gives its domain, a register entry, or both. Only a provider role counts.
Both give the customer’s country and, when the agent knows it, the line. Where a licence applies per subdivision, the subdivision is REQUIRED. In draft 0.1 that is the United States, where each state grants its own licences.

6.2 What the registry reads

The result lists every register entry that the registry read for the party, as LicenceCheck objects, and that includes the entries that are not active. Each entry gives the register and the identifier, the role, the categories, the subdivisions, the countries of an EU passport, the name in the register, the time of the read, how the registry read it, and the public page where anyone can check it. register_status keeps the status in the words of the register, for example “Authorised” or “Inscrit”. When the params give a domain, the registry SHOULD read get_distributor on the MCP server of the domain, through its aip.json, under the rules of network reads. For a listed server, it uses the licences that it keeps and the mcp_url that it already checked, and makes no new read. It reads each licence that the server claims in the register, with the domain link claimed. A claimed identifier that the register does not have gives not_licensed with the reason no_entry.

6.3 Domains

Any domain can claim any register entry, for example in the get_distributor result of its MCP server. That proves control of the domain and nothing more. DomainLink says how the registry tied the domain to the entries:

6.4 Verdict

The registry tests each entry in this order: the country (or an EU passport into it), the subdivision, the line, the role for a provider, then the status. An entry that passes the five tests covers the question. Each verdict comes with a message in plain words that the agent can pass to the customer. A verdict MUST rest only on reads made at most seven days before it (MAX_READ_AGE_DAYS). The registry SHOULD read the register again for each call when the register has an API or a web page.

6.5 What the agent does

The agent MUST check the seller before it sends any of the customer’s answers, with verify_licence or with the licence check of a search, for the domain of the address of the server that receives the answers (see Search). It MUST check the provider of an offer before it applies, when the provider is not the seller. The AIP skill checks the provider earlier, when list_products names it, so that the customer does not answer questions for an insurer that fails the check. It MUST keep each result that it relies on with the record of the sale, and SHOULD give the customer a copy. The result repeats the params of the call, so it is a complete record on its own.

7. Country rules

get_country_rules returns the rules files of the AIP skill for a country. The file of the country comes first. The file of the subdivision and the file of the line follow, when they exist. The agent MUST follow every file of the result. For a country with no file, the registry returns country_not_covered. Each file is Markdown with a YAML front matter:
  • owner is the AIP maintainers, until a regulator takes the file over.
  • status is draft, or endorsed when a regulator endorsed this version. An endorsed file names the regulator in endorsed_by.
  • reviewed_at is the date of the last legal review. The key is absent when no review happened.
  • language is the language of the text, as a BCP 47 tag.
  • effective_from is the first day the version applies. A version that follows a change in the law can be published before that day.
  • A file of a subdivision or of a line adds subdivision or line. In the skill, the file of a country is countries/<code>/country.md, the file of a subdivision is in states/, and the file of a line is in lines/.
  • sources lists the legal texts that the file rests on.
A RulesFile gives the same values, the whole file in content, its public address, and its URI in the skill that the registry serves over MCP. The text MUST be the same as the file of the same version in the skill. When the registry does not answer, the agent uses the copy in its installed skill, and SHOULD tell the customer which version it used. A regulator that takes over the rules of its country changes one file. Each agent that loads the rules from the registry gets the change on its next call.

8. Listing

A seller that runs an MCP server with the AIP tools asks to be listed at the listing_url of the registry. The test registry takes the requests on the submission form of this site. The form runs steps 2, 3 and 5 of section 8.1 before it sends a request, under the rules of network reads, and takes the name, the countries, the roles and the licences from get_distributor.

8.1 Ask to be listed

The seller gives its website, or the address of its MCP server or of its aip.json, and an email address for the answer. The registry reads the rest from the aip.json and from get_distributor. The operator follows these steps:
  1. The seller asks. The operator finds the domain: the host of the website or of the aip.json, or the domain that get_distributor returns on the MCP server.
  2. The registry reads https://{domain}/.well-known/aip.json, the seller’s AipDocument. Its domain MUST be the domain. The document comes from that host, so it proves that the seller controls the domain.
  3. It calls get_distributor on the MCP server that the document names in mcp_url. The domain of the result MUST be the domain.
  4. It checks each licence of the result in the public register of its country, as verify_licence does. It also confirms with the holder of each entry that the domain is theirs: the register gives the domain, or the operator asks the holder through contact details that the register or the regulator gives.
  5. It checks that the server has every tool of the level it declares, and that the results of the level 1 tools match the schema.
  6. It lists the server, and answers the seller.
The operator runs the steps after the request, with a person or a program. Some registers need an agreement or a person to read them.

8.2 Answer

Each answer names each step that did not pass. For a licence, it names the register entry and the date of the read.

8.3 Rules for the operator

  • The operator MUST answer each request, as section 8.2 says.
  • The operator MUST apply the same steps to each seller. It MUST NOT list, refuse or delay a seller for a commercial reason.
  • The operator reads the register, and adds no judgement of its own. A seller that disagrees with a register entry goes to the regulator. A seller MAY ask again at any time.
  • Each read of the listing follows the rules of network reads. The registry shows the seller a reason for each step.
  • The registry MUST list a server only when steps 2, 3 and 5 pass, and step 4 passes for at least one licence. A server that lacks one tool of its level MUST NOT be listed.
  • The registry MUST NOT list a server that claims a licence whose status is not_found or name_mismatch. It MUST NOT link a register entry to a second domain unless the holder of the entry confirms the second domain too.
  • A listed server appears in a search for a country only while its verdict there is licensed.
  • The registry MUST check each listed server again at least every seven days (RECHECK_DAYS), and when the seller or a regulator asks. It SHOULD also check again when anyone reports a problem.
  • When a licence stops being active, the registry MUST remove what that licence covered from the listing before it answers another search.
  • When aip.json or the MCP server goes away, or the server fails step 5, the registry MUST remove the listing.
  • The registry keeps the fields of ListedDistributor and the licences. It MUST NOT copy the products, the underwriting scopes, the prices or the documents of a server.

9. Data sources

The registry reads public registers. It MUST read a register only through an access that the terms of the register allow, and under an agreement when the terms ask for one. This table gives what we found on the official pages on 24 October 2026. “Not verified” marks each fact that no official page confirmed.

9.1 At launch

With no agreement, a first registry can check:
  • the insurers of France, from REGAFI, after the ACPR confirms in writing that the registry may reuse the data;
  • the insurers of the EEA, including those that sell in France on a passport, from the EIOPA register;
  • the agents and agencies of Texas, from the open data of the Texas Department of Insurance;
  • the legal identity of a company in any country, from GLEIF. The LEI and the SIREN join GLEIF to REGAFI, EIOPA and ORIAS.
The intermediaries of the three countries need an agreement: NIPR for the United States, the FCA for the United Kingdom, and ORIAS for France. The insurers of the United States need one with the NAIC. NIPR also asks for a “permissible purpose” under the Fair Credit Reporting Act, and we have not verified that a registry qualifies. Until these agreements exist, verify_licence returns unknown with the reason country_not_covered for what the registry cannot read. The FCA’s “re-sale use” licence names the use of the registry: to help users find out if a firm is regulated.

9.2 Domains in the registers

ORIAS, the EIOPA register and the NAIC show the website of an entry. The FCA Register can show one, and we have not verified that its API returns it. NIPR and the Texas data show none. When a register gives the website, the registry can tie a domain to the entry with the link register. The firm declares its website to the register itself, so another firm cannot add its own domain to the entry. In the other cases, the operator confirms the domain with the holder of the entry.

9.3 Status labels

The registry maps the labels of each register to a LicenceStatus, and keeps the label in register_status:

10. Trust and privacy

  • Every result says where its data comes from and when the registry read it: the register, the access (API, file or web page), the date of the data in the source, the time of the read, and the public page of the entry.
  • The registry never receives customer data. Its tools need no session, and their params describe a market or a company. Check RG8 tests the params of each tool against a closed list of fields.
  • The registry SHOULD keep each verify_licence result under its check_id for at least five years, so that it can confirm later what it said.
  • Draft 0.1 does not sign results, so an agent cannot yet prove alone what the registry said. See the open points.

11. Errors

A registry tool returns its result in structuredContent, and the same JSON as text in content, as the specification says. It returns an error in an MCP tool result with isError: true, as a RegistryError in structuredContent.error, and the same JSON as text in content.

12. Worked example

These calls go with the pet insurance flow. The rules, the search and the seller checks come before it, and the insurer check comes before the application. All companies are fictional.

Load the rules of the country

get_country_rules Alice lives in France and wants to insure her cat. The agent first loads the rules of France. The file is the one of the AIP skill, unchanged, with its version, its owner, its status and its hash.
spec/examples/registry-01-get_country_rules.params.json
spec/examples/registry-02-get_country_rules.result.json

Find the sellers

search_distributors The agent asks the registry for the sellers of pet insurance in France that can at least quote. The registry returns Example Pets, with a licence check for this market that it made overnight. The check is less than seven days old, so the agent can rely on it and keep it with the record of the sale.
spec/examples/registry-03-search_distributors.params.json
spec/examples/registry-04-search_distributors.result.json

Check a seller that the customer names

verify_licence When Alice names a seller herself, the agent checks it with verify_licence before it sends any answer. It gives the domain that will receive the answers. The registry reads the ORIAS entry again, and the entry gives the website of Example Pets, so the link is register. The verdict is licensed, and the agent keeps the result with the record of the sale.
spec/examples/registry-05-verify_licence.params.licensed.json
spec/examples/registry-06-verify_licence.result.licensed.json

Check a seller found on the web

verify_licence Another site sells pet cover and gives an ORIAS number in its legal notice. ORIAS has no such entry. The verdict is not_licensed, so the agent sends nothing to that site and tells Alice why.
spec/examples/registry-07-verify_licence.params.no_licence.json
spec/examples/registry-08-verify_licence.result.no_licence.json

Load the rules of a state and a line

get_country_rules In another sale, a customer in Texas wants to insure a cat. The agent asks for the rules of the United States, with the state and the line. Texas has no file of its own yet, so the result holds the file of the United States, then the file of pet insurance there. Each file is the file of the skill, unchanged.
spec/examples/registry-13-get_country_rules.params.state_line.json
spec/examples/registry-14-get_country_rules.result.state_line.json

Check a seller whose licence lapsed

verify_licence In the same sale in Texas, a licence applies per state, so the agent gives the state. The operator confirmed the agency’s domain when it listed it. The Texas licence lapsed, and the Oklahoma licence does not cover a customer in Texas. The verdict is not_licensed, and the reason comes from the Texas entry.
spec/examples/registry-09-verify_licence.params.lapsed.json
spec/examples/registry-10-verify_licence.result.lapsed.json

Check the insurer

verify_licence Back in France, before it asks Alice any question, the agent checks Example Mutual, the insurer that list_products names in Product.provider. A provider check can use the register entry from Product.provider alone. The ACPR register shows an active authorisation, so the verdict is licensed.
spec/examples/registry-11-verify_licence.params.provider.json
spec/examples/registry-12-verify_licence.result.provider.json

13. Checks

The repository checks the examples against schema.json, and against the registry rules that a JSON Schema cannot express:
  • RG1 a search returns only listed servers that match every param.
  • RG2 the verdict of a licence check follows from the entries it read and from the domain link.
  • RG3 every entry was read at most seven days before the verdict.
  • RG4 a licence check repeats the params of the call.
  • RG5 a check in a country where licences apply per subdivision gives the subdivision.
  • RG6 the front matter of a rules file matches the file.
  • RG7 the rules start with the file of the country.
  • RG8 the params of the registry tools hold no customer data.
  • RG9 a rules file that the registry serves is the same text as the file of the skill.
  • RG10 the licence check of a listed server in a search checks that server for the market of the search, and its verdict follows from entries read at most seven days before.
The listing steps, the order of the search results and the schedule of the checks are rules about how the operator works. A test of a live registry can check them. The examples cannot.

14. Open points

  1. Signed results. A signature on each verify_licence result would let an agent prove later what the registry said, with no call to the registry. Draft 0.1 leaves signatures out. A later draft can add them, for example with a key that RegistrySettings publishes.
  2. Reading a past check. The registry keeps each result under its check_id, but no tool reads it back yet.
  3. Confirming a domain. The operator confirms the link between a domain and a register entry with its own method. A later draft can define one channel for it, for example a code that the register or the regulator sends to the holder.
  4. Names and categories. How the registry compares a name with the name in a register, and how it maps the categories of a register to lines, is the operator’s method for now. The operator publishes it at policy_url.
  5. US states. The rules files of the US states come later. The US file covers the common points and says that the rules differ by state.
  6. Data agreements. The intermediaries of the United States, the United Kingdom and France need an agreement with NIPR, the FCA and ORIAS. The insurers of the United States need one with the NAIC. See At launch.
  7. Registry address. A test registry runs at registry.agenticinsuranceprotocol.org, with fictional register entries. The skill does not pin it yet, so an agent cannot tell the registry from a copy. A later draft says how the skill pins its address.