Nevadaautoquotes
Server Details
Indicative US auto insurance prices for agents: rating facts only, no PII, consented path to agents.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP
- URL
Available Tools
8 toolsagency_statusAgency status (buyers)ARead-onlyIdempotentInspect
For a registered agency: its states, rail, terms, founding period, queued and delivered counts, credit balance, and whether the licence was verified. Requires the buyer key issued at confirmation.
| Name | Required | Description | Default |
|---|---|---|---|
| buyer_key | Yes | Issued to the licensed contact at confirmation |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the agent knows this is a safe read. The description adds useful behavioral context by requiring the buyer key and scoping the operation to registered agencies. It also enumerates the returned fields, which is the main expected behavior of a status endpoint.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences: the first lists the payload, the second gives the required credential. Every clause earns its place and the key requirement is front-loaded near the field list.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-parameter tool with no output schema, the description carries the burden of explaining what the agent receives, and it does so with an explicit field list. It does not cover error behavior, empty states, or exact value formats, but those are minor for a simple status read with strong annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The sole parameter buyer_key is fully documented in the schema as 'Issued to the licensed contact at confirmation,' and the description restates this same detail. Since schema coverage is 100% and the description adds no new format, source, or validation information, it meets the baseline but does not exceed it.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description identifies a clear resource (a registered agency) and enumerates the specific data it returns: states, rail, terms, founding period, queued/delivered counts, credit balance, and verification status. The title 'Agency status (buyers)' plus the buyer_key requirement helps separate it from registration or eligibility siblings. It lacks an explicit imperative verb like 'get' or 'retrieve,' but the intent is unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It states a clear precondition: the agency must be registered and the caller must hold the buyer key issued at confirmation. This implies it is used after registration rather than during eligibility checks or initial registration. It does not name alternatives such as status_dashboard, so exclusion guidance is absent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
check_eligibilityCheck eligibilityARead-onlyIdempotentInspect
Check whether we can return quotes for a state before any personal details are collected. Call this first. Returns the states we are licensed in, what we can do in each, and how many licensed agents can take a request there.
| Name | Required | Description | Default |
|---|---|---|---|
| state | No | Two-letter US state code, e.g. NV | |
| product | Yes | auto |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover safety (read-only, idempotent, non-destructive), and the description adds useful behavioral detail: it returns licensed states, per-state capabilities, and agent counts. No contradictions or hidden side effects are implied.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three tight sentences: purpose, when to call, and return contents. No filler, front-loaded, and every clause contributes information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only eligibility check with supportive annotations and a minimal schema, the description covers purpose, timing, and output. A minor gap is that optional state semantics are not spelled out, but the schema signal partly covers this.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema documents state and product partially; the description references state but does not clarify what happens when state is omitted or how product affects the response. Product is self-explanatory via its enum/default, but the optional-state behavior is left implicit.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('Check whether we can return quotes') and a clear resource (state eligibility), and distinguishes itself from quote-gathering tools by noting it runs before personal details are collected. Also describes concrete outputs: licensed states, allowed actions, and agent counts.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says 'Call this first,' giving clear workflow placement as a preflight check. It does not name sibling alternatives or state when not to use it, but the timing and purpose are unambiguous.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
data_use_termsData use terms and consent wordingARead-onlyIdempotentInspect
What happens to anything you send us: who receives it, for what purpose, how long it is kept, how your human revokes it, and the exact consent wording to present before request_agent_contact. Machine readable so you can evaluate the exchange before making it.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful context about the machine-readable output and the consent-evaluation purpose, but it does not disclose return format details; that is acceptable given the annotations carry most of the burden.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single dense sentence that front-loads the resource, then efficiently enumerates the content list with a colon and commas. Every phrase adds information, and no space is wasted.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter informational lookup with annotations covering safety, the description tells an agent what it will receive and when to call it. It stops short of specifying the exact response shape, but 'machine readable' plus the enumerated categories is sufficient for this tool's simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters and 100% schema coverage, so there is nothing for the description to add. Per the baseline for 0-parameter tools, this is correct.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific resource ('anything you send us') and enumerates the exact content categories the tool returns: recipients, purpose, retention, revocation, and consent wording. It also distinguishes itself from siblings by explicitly tying its output to request_agent_contact, so an agent can tell it apart from the other data-lookup tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly signals when to use it: before request_agent_contact, to prepare consent wording and evaluate the data exchange. It does not explicitly name alternatives or state when not to use it, but the targeted reference to a sibling tool gives clear contextual routing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_quotesGet indicative quotesARead-onlyInspect
Return indicative auto insurance prices from multiple carriers, where this entity is licensed to show them. Takes rating facts only — no name, phone, email, SSN or licence number is required for an indicative price. Where we are not licensed to show prices, the request is still registered and a quote_id returned so licensed agents can quote it. If facts are missing the server asks for exactly what it needs and nothing more.
| Name | Required | Description | Default |
|---|---|---|---|
| state | No | Optional; derived from the ZIP when absent | |
| coverage | Yes | ||
| garaging_zip | Yes | Five-digit ZIP where the vehicle is kept | |
| vehicle_year | Yes | ||
| date_of_birth | Yes | ||
| annual_mileage | No | ||
| violations_3yr | No | ||
| years_licensed | No | ||
| prior_continuous | No | ||
| vehicle_make_model | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the readOnlyHint annotation, the description adds meaningful behavior: no PII is collected for indicative pricing, unlicensed requests are still registered and yield a quote_id, and the server asks for only the missing facts. These are non-obvious behaviors an agent needs to know and are not present in the schema or annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is reasonably concise and front-loaded with the core purpose. All four sentences carry useful information, though the unlicensed-agent explanation could be tightened slightly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 10 parameters, 20% schema coverage, and no output schema, the description is not fully complete. It does mention the key quote_id outcome and the licensing caveat, but it leaves many parameter meanings and the overall response shape unspecified. It is adequate but has clear gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 20%, so the description must compensate for undocumented parameters. It groups inputs as 'rating facts only' and clarifies that PII is not needed, but it does not explain most parameters such as annual_mileage, violations_3yr, years_licensed, or prior_continuous. The server-asks-for-missing-facts note does not help an agent supply correct values up front.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns indicative auto insurance prices from multiple carriers, with a licensing condition. This is a specific verb+resource, but it does not explicitly differentiate from siblings like market_data or check_eligibility, so it misses the highest bar.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear usage context: it takes rating facts only, does not require PII, and handles unlicensed situations by returning a quote_id for licensed agents. However, it does not name alternative tools or state when not to use this one, so exclusion guidance is implied rather than explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
market_dataBuy de-identified demand records (the dataset)ARead-onlyInspect
The demand dataset: every auto insurance request people and their AI assistants made here, de-identified (age band, ZIP3, vehicle, coverage, mileage band, record, prices shown, the door and the AI vendor that asked, and the outcome: consented, verified, delivered, withdrawn). Never a name, phone, email, date of birth or five-digit ZIP. Filter by state, since, until, door, vendor; limit and offset. Priced per record with a minimum per pull; pay with a prepaid buyer key, x402, MPP or AP2. Without payment the result is a 402 with the price and a preview count. A free sample and the schema are at /data.json.
| Name | Required | Description | Default |
|---|---|---|---|
| door | No | ||
| limit | No | ||
| since | No | ||
| state | No | ||
| until | No | ||
| offset | No | ||
| vendor | No | ||
| mandate | No | AP2 Payment Mandate | |
| payment | No | x402 X-PAYMENT payload | |
| buyer_key | No | A prepaid buyer key | |
| credential | No | MPP credential |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds substantial behavioral detail beyond annotations: it explains the de-identification guarantees, pricing model, minimum per pull, accepted payment methods, and the 402 response with a price and preview count when no payment is provided. This is exactly the kind of non-obvious behavior an agent needs to know.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is dense but every sentence adds value: dataset contents, privacy guarantees, filtering, pricing, payment, failure response, and a link to the sample/schema. The most important information is front-loaded, and there is no redundant filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 11 parameters, no output schema, and payment-related behavior, the description covers the critical invocation details: what data is returned, how to paginate, how to pay, what happens without payment, and where to find the full schema and sample. Nothing essential is missing for a competent agent to call this tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With schema description coverage at only 36%, the description compensates by mapping filter dimensions (state, since, until, door, vendor, limit, offset) and payment mechanisms (buyer_key, x402, MPP, AP2) to parameter groups. It does not spell out date formats or allowed values, but it gives enough semantic grounding for correct invocation.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The title and description clearly identify the resource as 'de-identified demand records' and the operation as purchasing/retrieving that dataset. The description specifies exactly what the dataset contains and how it is filtered, distinguishing it from sibling tools like get_quotes or pull_requests.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use this tool: when the agent needs de-identified auto-insurance demand records, with filtering by state/date/door/vendor and payment. It does not explicitly name alternative tools or state when not to use it, but the usage context is unmistakable.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
pull_requestsPull routed records (buyers)AInspect
Drain the queue of pool records routed to you. Requires your buyer key. Metered buyers receive an x402 payment requirement (status 402, accepts[]) until a payment is supplied. Records are projected to the scope the consumer granted — never wider.
| Name | Required | Description | Default |
|---|---|---|---|
| mandate | No | AP2 Payment Mandate | |
| payment | No | x402 X-PAYMENT payload | |
| buyer_key | Yes | ||
| credential | No | MPP credential (the base64url JSON that would follow "Authorization: Payment") |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds substantial behavior beyond the annotations: it requires a buyer key, explains the x402 payment flow with status 402 and accepts[], and commits to scope projection. These are context-rich disclosures about authentication, payment gating, and data visibility. No contradiction with readOnlyHint=false or destructiveHint=false is present.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded: the core action appears first, followed by prerequisites, payment behavior, and a data-scope guarantee. Every sentence carries distinct information, and there is no filler or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the main workflow: auth, payment prompting, and scope projection. However, there is no output schema, and the description does not describe the success response shape or behavior for an empty queue. Since the agent must handle the response, this is a moderate completeness gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema descriptions cover mandate, payment, and credential, but buyer_key has no schema description. The tool description compensates by stating "Requires your buyer key," giving the required parameter clear meaning. It also ties the payment flow to the payment/credential parameters. The mandate parameter still relies solely on its schema description, preventing a perfect score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb and resource: "Drain the queue of pool records routed to you." This clearly distinguishes pull_requests from sibling tools like register_agency or market_data by emphasizing buyer-routed pool records. The title and description together make the tool's function unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use the tool: when you have pool records routed to you and possess a buyer key. It also describes the metered-payment condition. However, it never explicitly contrasts this tool with alternatives or states when not to use it, so guidance is more implied than directive.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
register_agencyRegister an insurance agency as a buyerAInspect
For an AI working for a licensed insurance agency: register the agency to receive consented consumer requests in its states. Needs the agency name, the producer NPN (National Producer Number) and its state, the states it is appointed in, the licensed contact's name, email and mobile, and how leads should arrive (email, webhook, or pull by key). The licensed contact confirms by a link sent to their email; nothing is delivered before that. The first agencies in a state receive leads free for a founding period, then prepaid credits by card. Read /join for the terms.
| Name | Required | Description | Default |
|---|---|---|---|
| npn | Yes | NPN (National Producer Number). Your NPN is on your licence and at nipr.com. Digits only. | |
| rail | No | How leads arrive: email, an https webhook (HMAC-signed), or pull by key over MCP/REST | |
| states | No | Two-letter states the agency is appointed in; defaults to npn_state | |
| website | No | ||
| npn_state | Yes | Two-letter state that issued the licence | |
| agency_name | Yes | ||
| webhook_url | No | ||
| contact_name | Yes | The licensed contact, who confirms by email | |
| verify_token | No | Optional: from POST /v1/verify/check after the contact enters the code texted to them | |
| contact_email | Yes | ||
| contact_phone | Yes | US mobile |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses important behavioral traits beyond annotations: the licensed contact must confirm via an emailed link, nothing is delivered before confirmation, and the first agencies in a state receive free leads for a founding period. The annotations already indicate a mutating, non-idempotent operation, and the description complements them with activation and billing context. It does not explicitly state that registration is irreversible or that duplicate NPNs may be rejected, but it is reasonably transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single dense paragraph with a clear logical flow: purpose, required data, confirmation behavior, and billing terms. It front-loads the core registration concept and audience, then moves through the required fields and delivery options. It is slightly long but every sentence earns its place because there is no structured field-level documentation for several parameters.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 11 parameters, 6 required, no output schema, and a mutating non-idempotent operation, the description covers the registration flow, prerequisites, delivery modes, confirmation step, and billing. It does not fully document the optional website and webhook_url parameters, nor does it explain pull-by-key mechanics. The reference to /join for terms is helpful. An agent could likely call this tool correctly but might need to ask about webhook URL and pull-by-key details.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 64%, so some parameters are already documented in the schema (npn, contact_name, contact_phone, states, verify_token). The description adds meaning by grouping the required fields and explaining the delivery options and confirmation step. However, several parameters like website and webhook_url have no schema descriptions and are not fully explained in the description either; the description says 'how leads should arrive (email, webhook, or pull by key)' but does not clarify the relationship between verify_token, webhook_url, and pull mode. It does not sufficiently compensate for the undocumented parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The title and description clearly state the verb ('register') and resource ('an insurance agency as a buyer'), and specify what the registration enables: receiving consented consumer requests in its states. The description also includes the audience ('for an AI working for a licensed insurance agency'), which helps distinguish this from other agency-facing tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains the registration flow and prerequisites implicitly: the agency must be licensed, have a producer NPN, be appointed in states, and provide a licensed contact who confirms by email. It does not explicitly name sibling alternatives or when to use them, but it does point to '/join' for terms, which is additional guidance. A clear when-to-use statement is missing, but the context is strongly implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
request_agent_contactConnect with licensed agents (consent required)AInspect
Connect the consumer with licensed insurance agents who can quote firm and bind. Needs the quote_id from get_quotes, the consumer's name and phone, and the consumer's explicit consent to be contacted — granted by the human, presented by you, or confirmed by the human directly at the consent URL the elicitation returns. Under scope contact_consumer up to 4 licensed agents receive the request and contact details; sell_identity additionally permits sharing with marketing partners. Nothing leaves without the consent. Every delivery and refusal is receipted, and POST /forget revokes.
| Name | Required | Description | Default |
|---|---|---|---|
| consent | Yes | ||
| quote_id | Yes | From get_quotes | |
| best_time | No | ||
| full_name | Yes | ||
| phone_number | Yes | US mobile or landline | |
| verify_token | No | Optional. From POST /v1/verify/check after the consumer enters the code texted to them. A verified number sells at the verified price and is contacted first. | |
| email_address | No | ||
| street_address | No | Optional. Lets a licensed agent answer firm. | |
| preferred_channel | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only provide generic hints, but the description discloses meaningful behavior: nothing leaves without consent, up to 4 agents receive contacts under default scope, marketing partners are possible under sell_identity, deliveries/refusals are receipted, and POST /forget revokes. This goes well beyond the structured fields and gives the agent important side-effect awareness.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is dense but every sentence adds value: purpose, prerequisites, scope behavior, consent boundary, and lifecycle/revocation. It is front-loaded with the core action and does not repeat schema field names mechanically.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 9-parameter tool with nested consent and no output schema, the description covers the most important operational context: prerequisites, consent, scope, receipts, and revocation. It does not elaborate on optional contact fields or the exact response shape, but the supplied context is sufficient for safe invocation in most agent flows.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 44%, so the description must compensate. It explains quote_id, name, phone, and consent, but leaves parameters like best_time, email_address, and preferred_channel without additional meaning in the description or schema. The consent object is clarified well, but several parameters remain undocumented.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb and resource: "Connect the consumer with licensed insurance agents who can quote firm and bind." It clearly separates this tool from siblings by anchoring it to quotable/bindable agent contact and explicitly requiring consent. The title reinforces the consent requirement without relying on it.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description names the required prerequisite (quote_id from get_quotes), the required consumer approvals, and how consent can be obtained. It explains the two scope variants and their different sharing targets, but does not explicitly name sibling tools to exclude or state when not to use this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
8 tool updates
- First observed
agency_status - First observed
check_eligibility - First observed
data_use_terms - First observed
get_quotes - First observed
market_data - First observed
pull_requests - First observed
register_agency - First observed
request_agent_contact
Frequently Asked Questions
Claiming proves that you control a remote MCP connector. It does not move, proxy, or interrupt the server.
Open the connector listing, choose Claim ownership, and sign in to Glama.
Complete one verification method:
GitHub identity — fastest for official registry listings. For a namespace such as
io.github.alice/server, link the matching GitHub user, then choose Claim with GitHub. An organization namespace such asio.github.acme/serveralso needs that organization to have installed the Glama AI GitHub App and approved its permissions, because GitHub discloses organization membership only to apps it has installed. Use HTTP or DNS when it has not.HTTP challenge — works when you can deploy a public file. Generate a token, publish the exact JSON Glama shows at
/.well-known/glama.jsonon the same origin as the connector, then choose Check HTTP challenge.DNS challenge — works when you control DNS but cannot change the server. Generate a token, create the exact TXT record Glama shows, wait for it to propagate, then choose Check DNS challenge.
After verification, Glama sends a confirmation email and gives you access to listing details, thumbnails, health checks, and analytics. Keep the HTTP file or DNS record in place: Glama periodically checks it and ownership remains verified while the token is discoverable.
The HTTP ownership file has this structure:
{
"$schema": "https://glama.ai/mcp/schemas/connector.json",
"claim": "glama_claim_..."
}Claim tokens are opaque, stable, and bound to the signed-in Glama account. They contain no email address or other personal information. If Glama can no longer discover a verified HTTP or DNS token, it starts a seven-day grace period before removing claim-based access. Restore the same token during that period to keep ownership verified. Never publish an email address, Glama session token, GitHub token, or connector credential as ownership proof.
If verification fails, confirm that you copied the current token exactly. The HTTP file must be public, return valid JSON with a successful HTTP response, and stay on the connector's origin. DNS changes may need more time to propagate. A claim cannot transfer to a different origin or hostname: if the connector target changes, Glama starts the grace period and the new target must be claimed separately after the previous claim is released.
For a connector linked to the official MCP Registry, registry updates continue to replace its name, description, and URL by default. After claiming, open Manage connector and enable Use Glama listing details as the source of truth if edits made on Glama should be preserved. Categories and thumbnails are always managed on Glama; registry linkage and technical connection settings continue to sync.
Control your server's listing on Glama, including description and metadata
Access analytics and receive server usage reports
Get monitoring and health status updates for your server
Feature your server to boost visibility and reach more users
To improve your MCP server's ranking:
Claim ownership of the server listing
Complete the server profile with an accurate description and thumbnail
Provide a test profile so Glama can connect to and evaluate the server
Keep tool definitions clear and complete to earn a high Tool Definition Quality Score (TDQS)
Route real usage through the Glama Gateway; more recorded successful server uses also improve the ranking
For users:
Full audit trail – every tool call is logged with inputs and outputs for compliance and debugging
Granular tool control – enable or disable individual tools per connector to limit what your AI agents can do
Centralized credential management – store and rotate API keys and OAuth tokens in one place
Change alerts – get notified when a connector changes its schema, adds or removes tools, or updates tool definitions, so nothing breaks silently
For server owners:
Proven adoption – public usage metrics on your listing show real-world traction and build trust with prospective users
Tool-level analytics – see which tools are being used most, helping you prioritize development and documentation
Direct user feedback – users can report issues and suggest improvements through the listing, giving you a channel you would not have otherwise
The connector status is unhealthy when Glama is unable to successfully connect to the server. This can happen for several reasons:
The server is experiencing an outage
The URL of the server is wrong
Credentials required to access the server are missing or invalid
If you are the owner of this MCP connector and would like to make modifications to the listing, including providing test credentials for accessing the server, please contact support@glama.ai.
Discussions
No comments yet. Be the first to start the discussion!
Related MCP Connectors
Indicative US auto insurance prices for agents: rating facts only, no PII, consented path to agents.
81Indicative US auto insurance prices for agents: rating facts only, no PII, consented path to agents.
81Indicative US auto insurance prices for agents: rating facts only, no PII, consented path to agents.
81Indicative US auto insurance prices for agents: rating facts only, no PII, consented path to agents.
81
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceEnables AI agents to get real home & auto insurance quotes and start binding through a network of licensed independent agencies.Apache 2.0
- FlicenseNot gradedqualityNot gradedmaintenanceProvides tools for motor insurance quoting, including vehicle lookups, postcode risk assessments, and premium calculations. It enables users to generate and compare car insurance quotes through natural language interactions.-
- AlicenseAqualityCmaintenanceReal US & Canada dental price data for AI assistants: average costs by procedure, state and city, insurance acceptance, and cheapest-state lookups — backed by open datasets (CC BY 4.0, permanent DOIs).465MIT
- AlicenseAqualityCmaintenanceAgentShare delivers structured product search and pricing signals for AI agents over REST and MCP (Streamable HTTP). Responses include freshness & coverage metadata so agents can reason about data recency. API keys secure billed endpoints; public discovery at /agent.json and /mcp.json. Currently integrates connected marketplaces and affiliate feeds – roadmap expands to global e-commerce (AliExpre41MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.
TDQS
Each tool targets a clearly distinct operation: eligibility preflight, quote generation, consumer contact, agency registration/status, queue draining, market data, and terms. Potential proximity between check_eligibility and get_quotes is resolved by explicit sequencing and different outputs.
Most tools follow a verb_noun pattern such as check_eligibility, get_quotes, register_agency, pull_requests, and request_agent_contact. However, agency_status, market_data, and data_use_terms are noun-style resource names, creating a noticeable but still readable mix.
Eight tools is well within the ideal range for a domain-focused server. Each tool serves a distinct function across quoting, consent, agency operations, queue handling, and data access, with no obvious redundancy.
Core workflows are well covered: eligibility, indicative quotes, consumer-agent connection, agency onboarding/status, lead queue draining, and market data purchase. Minor gaps remain, such as no tool to update or remove an agency, and no tool to inspect an individual consumer request or consent status; revocation is only mentioned as an external POST endpoint.