Oklahomaautoquotes
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, covering the safety profile. The description adds value beyond annotations by disclosing the authentication requirement (buyer key) and enumerating the return contents, which is especially useful since there is no output schema. It does not mention failure behavior, but given the strong annotation coverage, this is a minor gap.
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?
Two sentences with no filler; the field enumeration is dense but purposeful. The purpose is front-loaded with the resource and the returned data. The passive 'For a registered agency: its...' construction is slightly awkward but does not cost clarity.
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 single-parameter, read-only tool with no output schema, the description compensates well by enumerating the return fields and stating the required credential. It does not specify the response format or error cases, but the combination of full schema coverage, safety annotations, and the detailed field list makes this largely complete for an agent to call 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?
Schema description coverage is 100% — the schema already describes buyer_key as 'Issued to the licensed contact at confirmation.' The description's phrase 'Requires the buyer key issued at confirmation' largely restates the schema rather than adding new meaning. No additional format, lookup, or sourcing details are provided, so the baseline of 3 applies.
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 identifies the resource (a registered agency) and enumerates the exact data returned: states, rail, terms, founding period, queued/delivered counts, credit balance, and licence verification status. However, there is no explicit verb like 'get' or 'retrieve' — the fragment 'For a registered agency: its...' implies retrieval rather than stating it — and it does not explicitly differentiate from sibling 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 gives one concrete prerequisite — 'Requires the buyer key issued at confirmation' — which tells the agent what credential is needed to invoke the tool. However, it does not state when to prefer this tool over check_eligibility or data_use_terms, nor when not to use it, so the usage context 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.
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 declare the tool read-only, idempotent, and non-destructive. The description adds useful behavioral context: no personal details are collected, and the tool returns licensing scope, permitted actions, and agent counts. There is no contradiction with 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?
Two sentences with no filler. The purpose and ordering come first, followed by a concise summary of the return values. Every sentence earns its place.
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 two-parameter read-only tool, the description covers invocation order, output contents, and the absence of personal-data collection. It slightly underspecifies whether an omitted state returns all states versus a single state, but the schema's optional state parameter makes this inferable.
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's format and product's enum/default, so the description does not need to repeat them. At 50% schema description coverage, the description does not compensate for the undocumented product parameter, but product is fully constrained to 'auto' with a default, limiting practical risk.
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 ('check') and resource (whether quotes can be returned for a state), and clarifies it happens before any personal details are collected. It also names the key output, making the tool's role unmistakable and distinct from quote-fetching siblings.
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 explicitly says 'Call this first,' so an agent knows this is the entry point. It also explains the prerequisite timing (before personal details are collected), though it does not name alternative sibling tools or provide when-not-to-use guidance.
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, destructiveHint=false, so the safety profile is covered. The description adds context that the tool returns machine-readable information to evaluate an exchange before committing, which is useful but does not disclose details such as response format or any external data dependencies. No contradiction exists.
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 sentence that packs in all key aspects: data recipients, purposes, retention, revocation, consent wording, and the evaluative purpose. It is front-loaded with the core question ('What happens to anything you send us') and avoids redundancy with annotations or schema.
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 zero parameters, no output schema, and annotations covering safety, the description is complete for the agent's invocation purposes. The only minor gap is that it does not specify the exact return format or field names, but with no output schema and a natural-language description, this is acceptable. The tool's role in pre-contact consent evaluation is fully conveyed.
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 0 parameters, and schema coverage is 100% because the schema is empty. The description fully context matters because there are no parameters to document, and it clearly communicates the tool returns data-use information, which is the primary semantic needed for 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 description uses a specific verb ('evaluate the exchange') and resource (data use terms and consent wording) and clearly enumerates the content: recipients, purposes, retention, revocation, and consent wording. It distinguishes itself from siblings by explicitly mentioning request_agent_contact, making its purpose unmistakable.
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 says to use this tool when needing to know data handling terms and consent wording before presenting request_agent_contact. It implies the prerequisite use case (before making an exchange) but does not explicitly contrast with all sibling tools; however, the explicit reference to a sibling provides near-complete usage guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_quotesGet indicative quotesBRead-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?
Annotation Contradiction: readOnlyHint=true indicates the tool does not modify state, but the description says 'the request is still registered and a quote_id returned so licensed agents can quote it,' which implies a persistent side effect. This directly contradicts the read-only annotation and is a serious inconsistency for an agent relying on the tool's safety profile.
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 four sentences, front-loaded with the main purpose, and every sentence adds useful information: what it returns, what it does not require, unlicensed fallback behavior, and server behavior on missing facts. There is no repetition or fluff.
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 purpose, PII exclusions, unlicensed fallback, and missing-facts behavior. However, there is no output schema, and the successful licensed-path response format is only described as 'prices' without details. With 10 parameters and a contradictory read-only annotation, the description is not fully sufficient for an agent to confidently predict all invocation outcomes.
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%, and the description does not compensate. It explains that only rating facts are needed and lists excluded PII, but it does not clarify the meaning of fields like annual_mileage, violations_3yr, years_licensed, prior_continuous, or vehicle_make_model beyond their names. The 'server asks for exactly what it needs' note reduces some upfront burden, but the description still leaves most parameter semantics unexplained.
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's verb and resource: 'Return indicative auto insurance prices from multiple carriers.' It also clarifies the licensing boundary and the fallback of returning a quote_id, which distinguishes this from simple quote retrieval. This is specific enough for an agent to understand what the tool does and how it differs from sibling tools like request_agent_contact.
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 context: use this for indicative prices using only rating facts, with no PII required. It also explains the behavior when the entity is not licensed. However, it does not explicitly name sibling alternatives or state when not to use this tool, so the agent must infer the boundary from context.
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?
Even with readOnlyHint=true and destructiveHint=false already present, the description adds substantial behavioral detail: de-identification guarantees, explicit PII exclusions, a 402 behavior when unpaid, pricing by record, and the existence of a sample/schema endpoint. This gives the agent a realistic model of what will happen before calling the tool.
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 long but information-dense, covering dataset contents, PII exclusions, filtering, payment, failure behavior, and a sample endpoint in a logical order. Every sentence contributes useful guidance, though some phrasing such as 'people and their AI assistants made here' could be trimmed without losing meaning.
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 no output schema, the description covers what an agent needs: data contents, privacy safeguards, filtering, payment methods, and the no-payment response. It does not spell out the exact response shape or date formats, but it points to /data.json for the schema and sample, which fills the remaining 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 description coverage is only 36%, so the description must compensate. It does so by enumerating the filter parameters (state, since, until, door, vendor) and pagination parameters (limit, offset), and by mapping payment methods to the relevant parameters (buyer_key, x402, MPP, AP2). It does not specify date formats or door/vendor value constraints, but it adds meaning well beyond the bare schema names.
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 it exposes the de-identified demand dataset of auto insurance requests, with a specific list of fields and outcomes. It is distinct from siblings like pull_requests or get_quotes because it positions this as the purchasable market dataset. The title and verb 'Buy' plus 'the demand dataset' make the resource unmistakable.
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 operational context: filter by state/since/until/door/vendor, paginate with limit/offset, and pay via buyer key, x402, MPP, or AP2. It also explains that without payment the tool returns a 402 with price and preview count, so an agent knows how to handle the no-payment case. It does not explicitly name alternative sibling tools or say when not to use them, so it stops short of a 5.
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?
Beyond the minimal annotations, the description discloses queue-draining/consumptive behavior, the x402 payment requirement with status 402 and accepts[], and the scope-projection guarantee ("never wider"). It also states the auth prerequisite ("Requires your buyer key"), all of which are behavioral traits not visible from annotations alone.
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 three sentences with no filler: the core action is front-loaded, followed by the requirement, the payment caveat, and the security scope note. Every sentence contributes distinct 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?
It covers what the tool does, auth requirements, payment behavior, and scope projection, which is substantial for a tool without an output schema. The return payload shape is not explicitly described, but "drain the queue of pool records" strongly implies the records are returned. This leaves only a small 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?
The schema already documents 75% of the parameters (mandate, payment, credential), and the description only adds that buyer_key is required. The payment-flow explanation gives context but does not map parameters to payload fields or add meaningful semantics beyond what the schema descriptions provide. This matches the baseline for high schema coverage.
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 "drain" acting on "the queue of pool records routed to you," making both the operation and resource unmistakable. The title "Pull routed records (buyers)" reinforces this and sets it apart from sibling tools like agency_status and market_data.
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 context: it is for buyers pulling records routed to them, and it states the buyer_key prerequisite and the condition for metered buyers receiving a payment requirement. It does not explicitly name alternatives or say when not to use the tool, so it stops short of a 5.
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 adds meaningful behavioral context beyond the annotations: the licensed contact must confirm via emailed link, nothing is delivered before confirmation, and billing shifts from a free founding period to prepaid credits. It also points to /join for terms. No contradiction with the readOnly/idempotent/destructive hints.
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 purpose is front-loaded and the sentences cover the workflow, required fields, confirmation, and funding—no filler. It is a little long, but each sentence adds operational value.
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 an 11-parameter registration tool with no output schema, the description covers prerequisites, required inputs, confirmation behavior, and next-step terms, which is strong. It still leaves some conditional wiring (e.g., webhook URL when webhook delivery is chosen) and the immediate response format unspecified.
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 64% schema coverage, the description compensates by naming the required data: agency name, NPN, NPN state, appointed states, contact name/email/mobile, and lead-delivery method. It also attaches meaning to the email parameter (confirmation link) but leaves conditional details like webhook_url and verify_token mostly to the schema.
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 opens by naming the exact action ('register the agency') and its purpose ('to receive consented consumer requests in its states'), so an agent knows what the tool accomplishes. The title repeats the resource ('insurance agency as a buyer') but the description goes further and differentiates this from sibling tools like request_agent_contact or agency_status.
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 the intended caller/context: an AI working for a licensed insurance agency, and it makes clear the registration prerequisite (licensed contact must confirm by email). It does not explicitly contrast with sibling tools or state when not to use it, so routing is mostly left to the agent's judgment.
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?
The description adds meaningful behavior beyond annotations: up to 4 licensed agents receive request and contact details, sell_identity extends sharing to marketing partners, nothing leaves without consent, delivery/refusal is receipted, and POST /forget revokes. This is useful privacy and side-effect context. There is no contradiction with the 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 dense but efficient: purpose in the first sentence, prerequisites and consent mechanics in the second, and recipient/revocation behavior in the third. The repetition of the consent requirement is acceptable given the sensitivity of the operation. It errs slightly on length, but each clause contributes value.
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 complex tool with no output schema, the description covers consent flow, scoping, recipient limits, receipting, and revocation. The main gaps are the absence of a return-payload description and lack of detail on optional contact-channel parameters. Still, the agent has enough to select and invoke the 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?
Schema description coverage is low (44%), so the description compensates by explaining consent modes ('granted by the human, presented by you, or confirmed... at the consent URL'), the provenance of quote_id, and the meaning of the scope enum. It does not describe optional fields like best_time, email_address, or preferred_channel, but the required fields are well covered.
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 opens with a specific outcome: 'Connect the consumer with licensed insurance agents who can quote firm and bind.' It also identifies the required source of the quote_id ('from get_quotes'), which helps distinguish this tool from siblings like get_quotes or register_agency. The title reinforces the consent requirement without ambiguity.
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 states prerequisites: quote_id, full_name, phone_number, and explicit consent. It also explains scope behavior for contact_consumer versus sell_identity, giving the agent actionable routing guidance. It does not explicitly name an alternative tool to use instead, but the dependency on get_quotes and the consent condition provide adequate usage context.
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 distinct part of the workflow: eligibility, quoting, consent, agency registration, status, queue draining, and market data. There is no meaningful overlap, and descriptions clearly separate consumer-facing from agency-facing operations.
Most tools follow a verb_noun pattern like check_eligibility, get_quotes, register_agency, and pull_requests. A few are noun phrases such as agency_status, market_data, and data_use_terms, but all are lowercase snake_case and predictable.
Eight tools fit the server's scope well: the consumer quote/contact flow, agency lead handling, terms disclosure, and market data each have dedicated tools. None feel redundant, and the count is neither thin nor bloated.
The core lifecycle is well covered: check eligibility, get quotes, request agent contact, register an agency, check agency status, and pull requests. Minor gaps exist around explicit revocation/forget and agency updating, though these are hinted at in descriptions.