BackCrew Housecall Pro MCP Server

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.1.0
Disambiguation4/5
Tools are mostly distinct with clear resource+action separation (jobs, estimates, invoices, leads, customers, materials). Some potential confusion exists between get_schedule and list_events (both relate to scheduling/calendar), and between list_job_line_items and list_invoices line items, but the descriptions differentiate them adequately. list_job_invoices vs list_invoices also has slight overlap but the scoping differs.
Naming Consistency5/5
All 30 tools follow the consistent verb_noun pattern (list_*, get_*), with list_ prefixed collection endpoints and get_ prefixed singular resource fetches. The naming is uniform, predictable, and follows standard REST resource conventions throughout.
Tool Count4/5
30 tools is on the heavier side, but the domain (a field service management platform) genuinely spans many resource types: customers, jobs, estimates, invoices, leads, employees, materials, price book, schedule, tags, and company settings. Each list/get pair earns its place for the breadth of the CRM/job management domain, though it borders on the high end.
Completeness2/5
The entire tool surface is read-only (every single tool is readonly-owner tier). There are no create, update, or delete operations anywhere. This is a severe gap for a job-management platform where agents would realistically need to create customers, schedule jobs, create estimates, or invoice customers. The surface lacks all write capabilities and even some reads like customer contact details or job-specific customer info.
Average 3.3/5 across 30 of 30 tools scored. Lowest: 2.4/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 11 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full behavioral burden. It mentions '[tier: readonly-owner]' suggesting read-only ownership scope, which is somewhat useful, but it doesn't disclose pagination behavior, what the response contains, sorting, or whether results are limited by ownership scope beyond the cryptic tier tag. For a list tool with zero annotations, this is thin.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact at a single sentence plus the HTTP mapping tag. It's front-loaded with the core purpose in the first clause. The '[tier: readonly-owner]' tag is concise but cryptic. No wasted sentences, though the tier notation is somewhat opaque.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema and zero annotation coverage place high demand on the description, which responds with only one sentence. It doesn't describe pagination, response shape, filter behaviors, or access constraints. For a 5-parameter list tool with rich siblings (list_jobs, list_estimates), a competing read tool, and no structured safety annotations, this is materially under-specified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate, but it only says 'optional filters' without explaining any specific parameter (status, customer_id, lead_source_id, page, page_size). None of the filter semantics, value formats, or relationships (e.g., customer_id filters by owning customer) are clarified. The 5 parameters are essentially undocumented by the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose3/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'List prospective-work leads with optional filters' — a clear verb+resource. However, it doesn't differentiate from siblings like list_jobs, list_estimates, or list_invoices, all of which are parallel list tools. 'Maps to GET /leads' is technical detail but not differentiating guidance.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It says 'with optional filters' implying the parameters are all optional, and '[tier: readonly-owner]' hints at access level, but there is no explicit when-to-use guidance versus alternatives. No exclusions or naming of sibling tools for comparison when to prefer a different list.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. The '[tier: readonly-owner]' tag implies the consumer must be an owner with read-only access, but this is vague. It does not disclose pagination behavior, what is returned, whether it returns only estimates owned by the caller, or any rate-limiting or data scoping constraints.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the primary action. The '[tier: readonly-owner]' marker is compact. No wasted words, though the date-range mention that doesn't match the schema adds slight confusion.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness2/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a list tool with 7 parameters and no output schema, the description is thin. It should clarify pagination behavior, sorting semantics, the relationship between parameters, and what the response contains. The mismatch between the 'date range' claim and the absence of date parameters is a notable completeness gap. Sibling get_estimate may handle single-record retrieval but this is not cross-referenced.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 14%, so the description must compensate, but it only names the filter dimensions (customer, employee, status, date range) without mapping them to specific parameter names or clarifying semantics. Notably, the description mentions a date range filter but there is no start_date/end_date parameter in the schema - a mismatch that could confuse an agent. The schema itself has minimal descriptions (only 'status' has an example).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a clear verb+resource: 'List estimates' with the filters it supports (customer, employee, status, date range). It names the endpoint it maps to. However, it does little to differentiate from its sibling list_* tools, though those siblings cover different resources so the purpose is sufficiently distinct.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description lists filter capabilities but provides no context on when to use this tool versus alternatives, no pagination guidance, no mention that get_estimate would be used for a single record, and no guidance on typical usage patterns. The '[tier: readonly-owner]' is the only usage-ish hint.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden of behavioral disclosure. The description states it's a GET mapping and readonly tier, which implies a read operation. However, it doesn't describe what's returned (schedule structure, availability format), whether employee_ids is required for filtering, or any response shape. The readonly nature is only conveyed via the tier note rather than explicit behavior description.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, efficient and front-loaded. The endpoint mapping and tier annotation add useful context without bloat. Could perhaps mention the filter param but the description is appropriately concise for its scope.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read tool with no output schema, the description gives the endpoint and scope but not return format, filtering behavior of employee_ids, or pagination. Given the moderate complexity (read-only schedule retrieval), the description is somewhat sparse but adequate for a straightforward GET operation with two required date params.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 67% (2 of 3 params have descriptions). The description adds 'date range' context which maps to start_date and end_date, and both already have 'ISO 8601 date' descriptions in the schema. The employee_ids parameter's semantics (whom to filter by) is inferable from the name but not described in either schema or description. Baseline 3 is appropriate given moderate schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb (get), resource (technician schedules and availability), and scope (for a date range). It also maps to the underlying endpoint (GET /schedule). However, it doesn't explicitly distinguish from sibling tools like get_appointment or list_job_appointments, though those are clearly different resources, so purpose is clear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No when-to-use guidance is provided. The description doesn't mention when a date range is required, whether employee_ids is optional filtering, or how this relates to appointment/schedule tools as alternatives. The tier marker '[tier: readonly-owner]' hints at permission context but no explicit usage context or exclusions are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions it's a read-only tier operation via the tier label, which is helpful, but it doesn't describe pagination, ordering, whether deleted addresses are included, or what fields are returned. The tier label is partial credit but insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences: one stating purpose and one mapping to the REST endpoint plus tier. Zero wasted words, well front-loaded with the action and resource.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple 1-param resource-listing tool with no output schema and no annotations, the description lacks pagination/ordering behavior and return format. It's adequate but leaves several practical questions unanswered that an agent might need (e.g., how many results, ordering, whether customer must exist).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Only one parameter (customer_id) exists and the description's 'for a customer' implies its role. However, the description doesn't explain the format of customer_id (UUID, numeric ID, etc.) or clarify whether it matches other customer_listing tools. With 0% schema description coverage, the description should add more detail than it does; it names the parameter's role but not its format.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clear verb+resource+scope: 'List all service addresses for a customer.' The purpose is specific and unambiguous. It maps to a REST endpoint which adds concrete grounding, though it doesn't differentiate from get_customer_address beyond the plural/singular distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description tells us it lists all addresses for a customer but offers no guidance on when to use this versus get_customer_address, or when one would prefer this over get_customer. The tier label '[tier: readonly-owner]' hints at permissions but isn't actionable guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of disclosure. It mentions the endpoint mapping (GET /materials) and tier tag '[tier: readonly-owner]', which implies read-only access but doesn't explicitly state the tool is non-destructive, whether pagination defaults exist, or what the return structure looks like. For a read/list tool with zero annotation coverage, moderate disclosure exists but significant gaps remain.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no filler. The endpoint mapping and tier tag are efficiently included. Every sentence earns its place, though the tier tag format is cryptic.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple 4-param list operation with no output schema and no annotations, the description is moderately complete. It covers the core purpose and endpoint, plus category filtering. Gaps: no pagination behavior described, no search semantics for q, no disclosure of what fields are returned. Given the tool's relative simplicity, this is adequate but could add a bit more on parameter behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, meaning the description must compensate for 4 undocumented parameters. The description mentions 'category' which maps to category_id, but the 'q' (search), 'page', and 'page_size' parameters are not explained in the description at all. However, page/page_size are conventional pagination params an agent can infer from naming, and q is a common search token. Some compensation but not complete for all 4 parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'List price book materials, optionally filtered by category' with a clear verb+resource. It maps to GET /materials. It distinguishes from siblings like list_material_categories and list_price_book_services, though not explicitly naming them. The 'optionally filtered by category' adds useful scoping.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit when-to-use guidance, no exclusions, no mention of alternatives. The '[tier: readonly-owner]' tag hints at access requirements but not usage context. The tool identity implies it's the go-to for listing materials, but there's no guidance on when to use it versus list_price_book_services or list_material_categories.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It includes a 'tier: readonly-owner' tag which implies read-only access, but doesn't disclose what fields are returned, whether the employee must exist (error behavior), or any auth/access implications. Some safety signal is present via the tier tag, but it lacks depth.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences with a useful endpoint mapping and tier tag. Every word earns its place with no fluff. Could arguably be more detailed given the low coverage, but the structure is clean and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple single-parameter get-by-ID tool, the description is reasonably adequate. It communicates the purpose, endpoint, and read-only tier. However, with no output schema, no annotations, and 0% param coverage, it could describe what 'full profile details' includes or clarify the response shape to help the agent anticipate results.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and the description provides no parameter-level detail. The single parameter employee_id is described only by its name in the schema. The description adds no meaning about what constitutes a valid employee_id (format, lookup by ID vs other identifier), though the single-param simplicity somewhat mitigates the gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clear verb+resource ('Get full profile details for a single employee'). Distinguishes well from sibling list_employees by specifying it returns full profile details for a single employee. The API endpoint mapping adds clarity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context via 'single employee' vs the list_employees sibling, but doesn't explicitly state when to choose this over other tools or provide exclusions. Context is clear enough to differentiate from list_employees, but no when/when-not guidance is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. The tier tag [tier: readonly-owner] adds useful access-level context. However, it doesn't describe pagination, ordering, or what fields are returned, though the endpoint mapping provides some expectation of a read-only operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, zero waste. The endpoint mapping and tier tag are useful additions packed efficiently. Could arguably merge information more, but it's appropriately brief.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple single-parameter read-only list tool, the description provides the essential targeting info (resource + endpoint + access tier). However, with no output schema and no documentation of return fields or pagination behavior, it's slightly under-specified for a list endpoint.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and there's only one parameter (job_id) which is self-explanatory from the name. The description adds no meaning about the parameter beyond the schema, and with 0% coverage the description should compensate, though job_id is fairly unambiguous.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb (List), the resource (all line items on a job), and maps to a specific REST endpoint (GET /jobs/{id}/line_items). It distinguishes reasonably from siblings like list_job_input_materials and list_job_appointments by being job-line-item-specific, though it doesn't explicitly differentiate from similar list tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives. The tier tag [tier: readonly-owner] hints at access-level usage but doesn't explain context or exclusions. No mention of which jobs it applies to or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. The 'readonly-owner' tier hint and 'Billable services' wording indicate read semantics, which is helpful. However, it doesn't disclose pagination semantics, default page sizes, or whether results are ordered/filtered in any particular way.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with zero waste. Front-loaded with the core purpose, then maps to the endpoint and tier. This is appropriately concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a three-optional-parameter list tool with no output schema, this is reasonably complete given the tier hint covers safety. However, the 0% schema description coverage plus undeclared pagination defaults and no filter explanation leaves gaps an agent would have to discover at runtime.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so description must compensate, and it does not. None of the three parameters (page, page_size, category_id) are explained. The purpose of category_id is inferable from the tool's purpose, but no explicit guidance is given on filter semantics or pagination constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clear verb+resource ('List billable services configured in the price book'). The purpose is specific and distinct from siblings like list_materials or list_price_forms, though it doesn't explicitly differentiate itself from these names.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No when-to-use or when-not-to-use guidance. The tier hint '[tier: readonly-owner]' implies it's a read-only list operation, but there's no mention of pagination behavior, filtering alternatives, or context in which this would be preferred over other list tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description carries the disclosure burden. The ['tier: readonly-owner'] tag hints at read-only, owner-scoped access, and the REST endpoint mapping is helpful. However, it doesn't describe what happens if the customer doesn't exist (404 behavior), pagination, or response structure beyond what the endpoint implies.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, compact and efficient. The endpooint mapping and tier tag add useful metadata. No waste, though the tier tag could arguably belong in annotations rather than description.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter read tool, the description is reasonable but sparse. It lacks explicit behavior on not-found cases, authentication requirements, and doesn't explain what the response contains. Given no output schema and no annotations, more detail could be warranted, though simplicity helps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and there's one required parameter (customer_id) that has no description in the schema and no elaboration in the tool description. The description names the endpoint but doesn't explain the format, constraints, or semantics of customer_id beyond it being an identifier.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description states 'Get a single customer by ID' with a specific verb+resource and maps to an explicit REST endpoint. It distinguishes itself from siblings like 'list_customers' and 'get_customer_address' by focusing on a single customer fetch, though it doesn't explicitly differentiate from get_customer_address beyond the obvious resource.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The '[tier: readonly-owner]' tag implies safe read usage and the operation semantics imply when to fetch a customer by ID. However, there's no explicit when-to-use vs alternatives guidance, no mention of when to prefer list_customers, and no exclusion criteria.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description includes '[tier: readonly-owner]' which signals a read-only operation and ownership constraint. No annotations are provided, so the description carries the burden. It adds the readonly and owner-scope context, which is useful, though it doesn't detail behaviors like pagination, sorting, or what happens with no appointments. The tier marker adds some transparency value beyond the schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is four sentences/short clauses and to the point, front-loading the core purpose and endpoint. The '[tier: readonly-owner]' tag is compact metadata. Minimal waste, though the 'filters' mention creates an expectation of parameter documentation that isn't fulfilled.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter list tool with no output schema and no annotations, the description is reasonably informative: it states scope (per-job or account-wide), the endpoint mapping, and access tier. However, it promises 'filters' without enumerating them, and with 0% schema coverage the job_id parameter and any filter parameters go undocumented. Given the tool's simplicity, this is adequate but leaves the filter behavior under-specified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, and there's only one parameter (job_id: string). The description never mentions the job_id parameter explicitly — it's only implied by 'List appointments for a job.' With 0% coverage, the description should compensate, but it adds no parameter-specific detail about job_id format, whether it's required, or any filter parameters that the 'across the account with filters' clause implies would exist. This is a meaningful gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'List appointments for a job, or across the account with filters' — a clear verb+resource with scope indicated. It maps to GET /jobs/{job_id}/appointments, which confirms the endpoint. However, it doesn't explicitly distinguish from sibling get_appointment (singular vs plural could be inferred but not stated).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description notes it lists for a specific job OR across the account with filters, so an agent knows it can be used in both scopes. However, it doesn't explicitly state when to prefer this over get_appointment (retrieving a single appointment by ID vs listing), and the 'or across the account with filters' is vague — no detail on what filters are available.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, but the '[tier: readonly-owner]' tag in the description discloses a read-only safety profile. This adds modest behavioral context, though it doesn't describe return format, permission requirements beyond owner-level, or error behavior. The tier tag partially compensates for missing annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences total, zero waste. States the action, maps to the endpoint, and tags the safety tier. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-item GET with 2 required parameters and no output schema, the description is reasonably adequate. It identifies the resource and both parameters via the endpoint mapping. However, with no annotations or output schema, it could add what data the returned address contains or any caveats about ownership scoping, leaving some gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description carries full burden. The description names both parameters in the endpoint path (customer_id, address_id) but doesn't add any type, format, or semantic nuance beyond what the raw schema properties (just 'string' with no descriptions) provide. The path mapping helps but doesn't explain what each ID represents or any constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Get a single address for a customer' with specific verb+resource+scope. It maps to a precise endpoint and distinguishes from siblings like list_customer_addresses and get_customer. It doesn't explicitly name the sibling alternative, so not a 5.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage (retrieve one specific address by IDs) but doesn't state when to use this vs list_customer_addresses or get_customer. The context is implied by the mapping to a specific endpoint but no explicit exclusions or alternatives are named.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. The description notes '[tier: readonly-owner]' which hints at access level, but doesn't explain what this means behaviorally. There's no mention of pagination behavior, default page size, rate limits, or what happens when no customers match. For a list tool, the description is thin on behavioral detail beyond 'it lists.'
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, zero waste. It states the core function (list customers), lists the key options (optional search, sorting, pagination), and adds the endpoint mapping for technical grounding. This is appropriately concise and front-loaded with the core purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a list tool with 6 parameters and no output schema, the description is somewhat minimal. It covers the three main operations (search, sort, paginate) but doesn't explain default behaviors (e.g., default sort order, default page size), the expand parameter's effect on response size, or the meaning of 'readonly-owner' tier. Given no output schema and no annotations, the description could do more.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 50%, meaning half the parameters have descriptions in the schema. The description itself mentions search, sorting, and pagination, which loosely maps to q, sort_by/sort_direction, and page/page_size parameters. However, it adds no detail beyond what the schema provides for those parameters, and the undocumented parameters (page, sort_direction) get no additional explanation. The description doesn't compensate for the coverage gap, staying at baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states what the tool does: 'List customers, with optional search, sorting and pagination.' It uses a specific verb (list) plus resource (customers) and mentions the HTTP endpoint mapping. It's clearly distinct from siblings like get_customer (single record) and list_customer_addresses (different resource). However, it doesn't differentiate itself from the other list_* sibling tools beyond naming the resource, but that's inherent to the naming.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions optional search, sorting and pagination, giving some implicit guidance on when these features are used. However, it doesn't explicitly state when to use this vs alternatives (like get_customer for a single record, or list_customer_addresses for addresses). No exclusions or prerequisites (e.g., ownership constraints) are noted. The guidance is adequate but implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It indicates a read-only operation via the tier tag and endpoint (GET), but does not describe the shape of the hierarchy returned, whether it's a flat list or nested tree, pagination behavior, or any ordering characteristics. Minimal disclosure of behavioral traits beyond the endpoint method.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that states the purpose and endpoint reference. It's front-loaded and efficient. The tier tag adds a small amount of access control context. No wasted words, though it could arguably include more information given how short it is.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has no parameters and no output schema, which lowers complexity. However, with no annotations and a no-annotations environment, the description could benefit from noting what the returned hierarchy looks like (e.g., whether categories are nested or flat, what fields are returned). For a simple no-parameter list operation, it's adequate but could be more informative.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so there's nothing for the description to clarify about parameters. The schema coverage is 100% (trivially, as there are no properties). With 0 parameters, the baseline is 4 — the description doesn't need to add parameter context since none exist.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool lists the price book's material category hierarchy, mapping to a well-defined endpoint (GET /material_categories). It has a specific verb+resource and scopes it to 'material categories', which is distinct from the sibling list_materials (which lists materials, not their categories). It doesn't explicitly distinguish from siblings but the resource is clearly different.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit when-to-use or when-not-to-use guidance is given. The description implies usage by identifying the resource and endpoint, but doesn't clarify when to use this over sibling tools like list_materials or list_price_forms. The tier marker [tier: readonly-owner] offers some scoping but no guidance on selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. The '[tier: readonly-owner]' notation hints at read-only access and ownership scoping, which is useful. However, the description does not disclose what the response contains, potential error conditions, or behavior if the appointment doesn't exist, beyond what the endpoint mapping implies.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single efficient sentence that states purpose, mapping, and access tier. Concise and front-loaded with no wasted words. It could arguably be a 5, but the tier annotation appended in brackets is slightly cryptic without elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a simple two-parameter fetch tool with no output schema and no annotations. The description provides the endpoint mapping and tier, which is decent context, but it doesn't mention response shape, error handling, or relationship to related tools like list_job_appointments. For a simple single-resource GET, it's adequate but leaves questions unanswered.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and there are only 2 plain string parameters (job_id, appointment_id) with no descriptions in the schema. The description names both IDs implicitly through the endpoint path, which adds modest value, but it doesn't clarify their format, relationship, or required scope beyond what the endpoint mapping shows. With 0 params, baseline would be 4, but the endpoint mapping provides some of that semantics already.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool fetches details for a single appointment, with a specific verb ('Get') and resource ('details for a single appointment'). It maps to a clear REST endpoint and includes a tier notation ('[tier: readonly-owner]'). However, it doesn't explicitly differentiate itself from its sibling 'list_job_appointments' beyond the implied singular vs. plural distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context (fetching a single appointment via job_id and appointment_id) but does not explicitly state when to use this versus list_job_appointments or other siblings. The 'readonly-owner' tier hint provides some permission context, but there is no when/when-not guidance or naming of alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden. The 'Maps to GET /employees' and '[tier: readonly-owner]' hint at a read-only operation, which is useful safety context. However, it doesn't disclose pagination behavior, default sort order, or what happens with large result sets, which would be valuable for a list endpoint.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence (plus API mapping and tier tag). Every element earns its place. It's appropriately front-loaded with the core purpose first. The tier tag and endpoint mapping add useful context without bloat.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a list tool with 8 parameters, low schema coverage, no output schema, most describing a simple list operation, the description is adequate but thin. It doesn't explain the employee roles fully, pagination semantics, filtering behavior, or the q/role/tags/is_active parameter semantics. It's a minimum-viable description but leaves the agent to guess about key behaviors.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 13% (1 of 8 params described in schema). The description mentions 'optional filters' generically and identifies the domain roles (field techs, office admins), but doesn't explain the 8 parameters or how they interact. It adds minimal value beyond the schema's near-empty parameter descriptions, and doesn't compensate for the low coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'List employees (field techs and office admins), with optional filters' - a specific verb (list) + resource (employees) with field/domain context. It distinguishes nicely from siblings like get_employee (single record vs list). The 'Maps to GET /employees' adds API grounding. It could explicitly differentiate from similar list_* siblings, but the resource name is clear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies this is a list/collection tool via 'optional filters' and the GET mapping, which gives some context. However, it doesn't explicitly state when to use this vs alternatives like list_employees vs get_employee (single lookup), or when pagination is needed. There are no explicit exclusions or 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.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the disclosure burden. It indicates a read-only mapping to GET /events and the tier note, which conveys safety. However, it doesn't disclose pagination behavior, date-range semantics, or what 'scheduling conflicts' entails in the response beyond the listing promise.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single efficient sentence that names the purpose and REST mapping. The tier bracket is compact. No wasted words. Could arguably add more detail, but structural economy is good.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 4 params, 50% schema coverage, no output schema, and no annotations, a richer description would help. The tool is a read-only listing operation, which is relatively simple, but the absence of pagination/date-range explanation and output-format detail leaves the agent under-informed about expected behavior. Adequate but with clear gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 50% — start_date and end_date have 'ISO 8601 date' descriptions, but page and page_size lack descriptions entirely. The tool description adds no per-parameter semantics; it doesn't explain that dates likely filter the event window or how paging relates to results. It maps to the GET endpoint but doesn't clarify parameter behavior beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'List calendar events and scheduling conflicts' — a clear verb+resource pair that distinguishes from siblings like list_jobs or list_estimates. It also maps to a REST endpoint which adds clarity. However, it doesn't emphasize the owner-readonly scoping context beyond the bracketed tier note.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description includes a tier annotation '[tier: readonly-owner]' that implies context for when this can be called, but provides no explicit guidance on when to use this vs alternatives like get_schedule or list_job_appointments. No exclusions or alternative tool mentions are given; usage context is only implied by the 'list events' framing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It does disclose that this is a readonly operation via the '[tier: readonly-owner]' tag, which is useful behavioral context. However, it doesn't disclose pagination behavior, result ordering defaults, or what happens with no filters (returns all invoices). The readonly disclosure adds value but richer behavioral context (e.g., default sort, max page size behavior) is missing.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single compact sentence plus an endpoint mapping and tier tag. It's front-loaded with the core action and conveys useful information efficiently with zero waste. Could arguably be more structured but is appropriately concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a list/filter tool with 6 parameters, no output schema, and no annotations, the description provides a reasonable baseline: it names the resource, the filter types, the endpoint, and the tier. However, with 83% of parameters lacking schema descriptions and no output schema, an agent cannot know expected response shape, pagination semantics, or valid values for sort_by without external knowledge. The description is adequate for simple invocation but insufficient for edge-case usage.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 17% (only 'status' has an inline description), so the description should compensate. The description mentions 'customer and payment status' filters, which partially maps to customer_id and status parameters, but it doesn't clarify the semantics of page, page_size, sort_by, or sort_direction beyond what the schema types suggest. The description adds marginal value for two parameters but leaves the other four under-documented in both schema and description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('List invoices') with a clear resource and specifies the available filters (customer, payment status). It maps to GET /invoices for endpoint reference. However, it doesn't explicitly distinguish itself from sibling tools like list_job_invoices, which could be ambiguous given list_invoices also exists. The verb+resource is clear but sibling differentiation is largely left to the names themselves.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description identifies what filters are available (customer and payment status) and the readonly tier, implying it's safe to use for read-only scenarios. However, it doesn't explicitly state when to prefer this over list_job_invoices (which lists invoices scoped to a job) or get_invoice (single invoice). The 'optional filters' phrasing suggests flexible usage but no explicit when/when-not guidance is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. The tier tag "readonly-owner" is embedded in the description, which helps signal authorization requirements. However, it doesn't describe what happens for a job with no input materials (empty list vs error), pagination behavior, or whether the response includes quantities/prices. For a read-only list operation, this is acceptable but thin.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, each earning its place — the first states the purpose, the second provides the endpoint mapping and tier. No wasted words. Could optionally add usage guidance, but what's present is tight.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a simple filtered-list tool with a single parameter and no output schema. The description covers the purpose and endpoint clearly. Given the tool's low complexity, the description is nearly adequate. However, the tier "readonly-owner" implies ownership scoping that isn't explained, and it doesn't mention what fields or material details are returned. Acceptable for a simple tool but could note the return includes quantities/prices per material.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for documentation. There's only one parameter (job_id), and although the description mentions "on a job", it doesn't explicitly explain that job_id is the identifier of the job whose materials are being listed. With a single obvious parameter, the baseline is somewhat lower, but the description doesn't explicitly map the parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states "List materials consumed on a job" with a specific verb (List), resource (materials), and scope (on a job). It maps to a clear endpoint. However, it doesn't clearly distinguish from siblings like list_materials (which lists all materials globally) — although the job-scoping is implied through the name. The endpoint mapping adds clarity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The tier annotation "readonly-owner" and endpoint mapping provide implicit usage context, but there's no explicit statement about when to use this vs list_materials or list_job_line_items. "Consumed on a job" implies it requires an existing job_id, but no alternative tool is explicitly named or excluded.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. The [tier: readonly-owner] tag communicates that this is a read-only operation owned by the lead's owner, which adds some behavioral context. However, it doesn't disclose return format, error behavior, or authentication beyond the tier hint. The tag provides moderate value but not deep transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, tight sentence plus API mapping and tier tag. Zero wasted words, all content earns its place. The GET /leads/{id} mapping and tier annotation are compact and valuable additions.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple single-parameter read tool with no output schema and no annotations, the description is reasonably informative but could go further. The tier tag, API mapping, and single-parameter schema cover the basics. It would benefit from noting what 'full details' includes (fields returned) given there's no output schema to communicate that.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There's only 1 parameter (lead_id), and schema description coverage is 0%, so the schema provides no semantic meaning beyond the type. The description implies lead_id is what identifies the lead but doesn't elaborate on its format or how to obtain valid IDs. With only one self-evident parameter, the gap is modest.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it gets full details for a single lead, which is a specific verb+resource that distinguishes it from list_leads (which would list leads). However, it doesn't explicitly contrast with siblings beyond the single-vs-list implicit distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The [tier: readonly-owner] tag and 'Get full details' phrasing imply it's for retrieving one lead when you have its ID. It doesn't explicitly say when to use this versus list_leads, though the single vs list contrast is fairly intuitive. No explicit exclusions or alternative recommendations provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden of behavioral disclosure. '[tier: readonly-owner]' signals this is a read-only operation scoped to the owner, which is helpful safety context. However, it doesn't disclose what fields the returned tag contains, whether related data is included, or any error/not-found behavior. The read-only nature is conveyed but minimally.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences with zero waste. Front-loaded with the purpose, followed by the endpoint mapping and tier hint. Every element earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-obvious-parameter read tool with no annotations, the description covers the core: purpose and read-only tier. Given the simplicity (1 param, no output schema requirements to explain), this is reasonably complete. Missing mention of what the response contains, but for a simple tag object this is a minor gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate but doesn't. tag_id is self-explanatory from its name as an identifier, and the description mentions it maps to /tags/{id}, confirming the path-parameter semantic. For a single obvious parameter, this is acceptable baseline, though nothing additional is added beyond what the schema's name implies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clear verb+resource ('Get details for a single tag') that distinguishes from sibling list_tags which retrieves multiple. The mention of the HTTP endpoint adds specificity. However, it doesn't elaborate on what 'details' includes beyond the obvious tag object.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description identifies this as a single-resource retrieval tool, implying it pairs with list_tags (to find IDs). The [tier: readonly-owner] hint signals read-only usage context. No explicit when-to-use vs when-not-to-use or alternative selection guidance is given, but the single-vs-list distinction is implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The '[tier: readonly-owner]' tag conveys an access-level constraint, which is useful behavioral context beyond the schema. However, with no annotations provided, the description carries the transparency burden, and it does not state what happens if the job has no invoices (empty list vs. error), pagination behavior, or response ordering.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with zero waste: the first states the function and the second maps to the endpoint with an access-tier tag. Efficiently organized and front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a simple filtered-list tool with one parameter and no output schema. The description is reasonably complete for the simple use case, though it lacks detail on empty results, ordering, or pagination. The tier tag adds access context. Adequate but with room to describe return behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description carries full burden for the single parameter. However, job_id is a self-explanatory identifier and the description's 'for a specific job' clarifies its role as the job selector. With only one simple parameter, the baseline is acceptable even at 0% coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a clear verb+resource: 'List the invoices generated for a specific job.' It distinguishes from the sibling list_invoices (which lists all invoices) by specifying 'for a specific job.' The endpoint mapping adds precision. Not a 5 because it doesn't explicitly contrast with sibling list_invoices.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The 'for a specific job' phrasing implies the tool requires a job_id context, distinguishing it from a general invoice listing. However, there's no explicit when-to-use vs. alternatives guidance, no mention of list_invoices as the alternative for global access. Some implied usage context but no explicit exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It does add the read-only tier indicator ('tier: readonly-owner') which is useful behavioral context. However, it doesn't describe error behavior, what happens if the estimate doesn't exist, or any authentication/authorization nuances beyond the tier tag.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences that convey the purpose, scope, endpoint mapping, and access tier. Every sentence earns its place with zero filler. Well-structured and immediately readable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-resource read tool with one simple parameter and no output schema, the description is largely sufficient. The tier tag and endpoint mapping provide useful context. The only gap is not explicitly distinguishing from list_estimates or describing the response format, but for a simple getter this is acceptable.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate for the single parameter (estimate_id). The description implies the ID identifies the estimate but doesn't explain how to obtain it (e.g., from list_estimates) or its format. With only one simple param, the gap is minimal but the description could still mention where the ID comes from.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the verb (get) + resource (single estimate) and adds that it includes options. It maps to a specific endpoint (GET /estimates/{id}) for precise understanding. It's distinct from list_estimates, though it doesn't explicitly name the sibling.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies it's for a single estimate (as opposed to list_estimates for collections) but doesn't explicitly state when to use it vs. list_estimates or other alternatives. The singular focus and resource name provide implicit context but no explicit exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. The description states it returns line items and mentions [tier: readonly-owner] which hints at access level/auth requirements. However, it doesn't disclose behaviors like error cases for invalid IDs, response shape, or pagination (if any for line items). The tier note adds modest value but doesn't fully compensate for missing annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact at two sentences, front-loads the core purpose, and adds the API mapping and tier note. It's efficient without being under-specified. The '[tier: readonly-owner]' addition is useful context in a single concise token.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple single-resource GET with one parameter, the description is reasonably complete: it states what it returns (full details plus line items) and the API mapping. However, with no output schema, no annotations, and no description of what 'full details' contains (fields like payment status, due date, totals), an agent has limited insight into the tool's output richness or error behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With only 1 parameter and 0% schema description coverage, the description doesn't elaborate on invoice_id beyond what the schema provides. The schema alone defines it as a required string, and the description doesn't add format expectations (e.g., UUID style, numeric ID). However, with only a single self-explanatory parameter, the gap is minimal — the schema and tool name convey sufficient meaning.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Get full details for a single invoice, including line items' with a specific verb (get), resource (invoice), and scope (full details including line items). It maps to GET /invoices/{id} and distinguishes from siblings like list_invoices (listing vs single) and list_job_invoices (which scopes by job).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage ('get a single invoice') and the sibling set includes list_invoices for listing, which provides natural differentiation. However, there's no explicit statement of when to use this vs alternatives like list_invoices, get_estimate, or get_job. The [tier: readonly-owner] note provides some access context but no explicit when/when-not guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It includes '[tier: readonly-owner]' which signals a read-only operation and ownership scope — helpful security context. However, it doesn't describe the return structure, pagination behavior, or error cases. The tier tag adds value but the details of what 'full details' includes are not fully specified.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, zero waste. The first states purpose with scope, the second gives the REST mapping and tier annotation. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple single-resource GET with one self-explanatory parameter and no output schema, the description is reasonably complete. It notes the tier (readonly-owner) and includes line items and schedule scope. Could mention what happens when job_id is invalid, but for a straightforward fetch the description is adequate for the tool's complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, but there's only one parameter (job_id) which is self-describing. The description says 'for a single job' and maps to GET /jobs/{id}, which implies job_id is the path identifier. The schema provides the parameter name; the description provides minimal additional semantics, but for a single obvious parameter this is adequate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it gets 'full details for a single job, including line items and schedule' — specific verb (get) + resource (job) + scope (full details). It maps to GET /jobs/{id} which disambiguates the single-resource fetch from siblings like list_jobs. It doesn't explicitly differentiate from other get_* tools, but the job resource is clear.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage: fetch full details for a job. The sibling list_jobs vs get_job contrast is implied (list vs single). However, there's no explicit when/when-not guidance or alternatives named for when a user should use a more targeted tool like list_job_line_items instead of get_job for a single fragment.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The '[tier: readonly-owner]' tag signals read-only/ownership scope, providing some behavioral context. With no annotations provided, the description partially carries the transparency burden. However, it doesn't disclose pagination behavior, default sorting, result limits, or whether filters are combinable. The tier tag is useful but limited in detail.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences with zero waste. Front-loaded with the primary action and all key filter dimensions, plus the endpoint and tier context. Every element contributes value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a listing tool with 11 parameters, 45% schema coverage, and no output schema, this is moderately complete. The description captures the filtering dimensions but lacks detail on pagination defaults, result shape, and any permission implications beyond the tier tag. Sibling tools like list_estimates and list_invoices follow similar patterns, so some inference is possible, but the 11-parameter surface area warrants more guidance.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is only 45%, so the description must compensate. It names the filter dimensions (customer, employee, status, date range) which maps to ~5 of the 11 parameters (customer_id, employee_id, work_status, scheduled_* bounds). This helps decode several undocumented params. However, it doesn't clarify page/page_size/sort_by/sort_direction semantics beyond what schema type hints suggest, and the date range mapping is implicit.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
Description states it lists jobs with optional filters (customer, employee, status, date range), clearly distinguishing it as a listing operation. It verb+resource is specific and the endpoint mapping adds clarity. Could benefit from explicitly distinguishing from get_job (single resource retrieval), but sibling differentiation is partially achieved by the plural listing nature.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies it's for listing jobs and mentions the filter options, giving context on when to use it. However, it doesn't explicitly state when NOT to use it (e.g., when you need a single job use get_job, or when you need job line items use list_job_line_items). No exclusions or alternative tool mentions beyond the implicit endpoint mapping.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the behavioral disclosure burden. It does specify read-only nature via the tier tag '[tier: readonly-owner]' and the 'List' verb, which conveys non-destructive behavior. However, it doesn't describe the return format, ordering, pagination, or whether the list is exhaustive. The tier tag provides some confidence about the read-only nature but is somewhat cryptic for an agent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, compact sentence that packs the purpose, examples, endpoint mapping, and tier annotation into roughly 30 words. It's efficient and front-loaded with the core action. No wasted words. The tier tag, while slightly cryptic, is concise. Could arguably be a 5, but the crypticity of the tier annotation and the absence of any additional useful context keeps it at 4.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter, read-only list tool, this description is reasonably complete. The examples ground the resource type, the endpoint mapping aids verification, and the tier tag indicates permissions. No output schema exists, so the description doesn't need to explain return values per the rubric. There's not much more one could meaningfully add for such a simple tool without padding. The main gap is that the tier tag '[tier: readonly-owner]' is somewhat ambiguous about what 'owner' means in terms of access scope.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
This tool has 0 parameters, and schema description coverage is 100% (an empty properties object). With no parameters to document, the description's job is minimal on this dimension. The description correctly notes there are no filters or inputs needed, and the endpoint mapping is provided. A baseline of 4 is appropriate for a zero-parameter tool where nothing further could be added.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('List') and resource ('service/job types configured for the company'), with concrete examples (Termite Inspection, Quarterly Treatment). It maps to GET /job_types, which adds confidence. It doesn't explicitly distinguish from siblings, but the sibling list contains many list_* tools for distinct resources, and this tool's resource is uniquely named 'job_types', so the purpose is clear without confusion.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description includes a tier tag '[tier: readonly-owner]' which implies it's a read-only operation scoped to the owner. It gives the endpoint mapping for reference. However, it doesn't explicitly state when to use this vs alternatives or mention any prerequisites, ordering, or combinations with other tools. The usage context is implied (read-only list operation for job types) but not elaborated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior2/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description carries the full burden. It mentions '[tier: readonly-owner]' which suggests permission/access requirements, and maps to GET (implying non-destructive). However, it doesn't describe pagination, ordering, or response shape for a list operation. Minimal behavioral disclosure beyond the method mapping.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence with examples, endpoint mapping, and tier tag. Efficient and front-loaded with the purpose. Slightly dense with the bracket metadata but no wasted words. Effective for such a simple tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 0-parameter list tool with no output schema, the description is reasonably complete: it states what it returns, gives representative examples of lead sources, and indicates the endpoint. It doesn't describe result limits or sort order, but for a lookup-style tool this is acceptable. Tier tag adds access context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, so there is nothing for a description to document. Per the rubric, 0 params = baseline 4. The description correctly emphasizes the scope (configurable lead source types) which is the only semantic element. A 5 is appropriate given there are no parameters to clarify.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clear verb+resource ('List the configured lead sources'), distinguishes itself from siblings like list_leads by specifying lead source configuration (Google Ads, Referral, Door Hanger). Maps to an explicit endpoint. Not a full 5 as it doesn't explicitly distinguish from list_materials or other list tools beyond examples.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The '[tier: readonly-owner]' tag implies read-only usage scope. No explicit when-to-use or alternatives guidance, but the tool is simple and self-evident (listing configured sources), so context is reasonably implied by the name and examples. No exclusions mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It discloses '[tier: readonly-owner]' which communicates read-only behavior and owner-scoped access. However, it doesn't describe the return shape, whether 'settings' includes mutation-related fields that might be read-sensitive, or any rate-limit considerations. The tier tag adds some transparency but is minimal.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, zero waste. It packs the resource, the HTTP method mapping, and the access tier into a compact, front-loaded format. Every element earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter, no-output-schema, read-only tool, the description is reasonably complete. It identifies the resource and access tier. It could note the return format (business info structure) slightly more, but given the low complexity of a parameterless company-info getter, this is largely sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters and 100% schema coverage (empty), so the baseline is 4. The description adds context about what the tool returns ('business info and settings'), making it clear there are no inputs needed — the tool operates on the authenticated company context.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get'), resource ('the connected company's business info and settings'), and the HTTP mapping (GET /company). This distinguishes it from sibling tools which all target specific sub-resources like customers, jobs, invoices, etc.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage context ('connected company') but provides no explicit when-to-use guidance or exclusions. With no sibling tool targeting company-level info, it's somewhat self-evident, but the description doesn't articulate when to pick this vs alternatives or note any auth or setup prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. The '[tier: readonly-owner]' tag signals a read-only operation, which adds some transparency. However, it doesn't clarify whether all price forms are returned or if there's any filtering, pagination, or ownership scope implied by 'owner'.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two compact sentences: one stating the purpose and one mapping to the API endpoint plus tier. Zero wasted words, well front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter list tool with no output schema, the description is reasonably complete. It states the resource, purpose, API mapping, and read-only tier. Could benefit from noting whether all templates are returned or if any default filtering applies, but this is a minor gap for a simple list operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters and schema coverage is 100% (nothing to document). The description clarifies the resource type and usage purpose beyond the name alone. With 0 params, the baseline is 4, and the description meets this by explaining what the returned templates are used for.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clear verb (List) + resource (price book form templates) + purpose (build estimates and invoices). The 'Maps to GET /price_forms' clarifies the API endpoint. It distinguishes somewhat from siblings by specifying these are templates for estimates/invoices, though many sibling tools also list resources.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use when needing form templates for estimate/invoice building, which gives context. However, it doesn't explicitly state when NOT to use it or name alternatives among the many sibling list tools. The tier tag ([tier: readonly-owner]) implies a read-only context but no exclusions are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the disclosure burden. The '[tier: readonly-owner]' tag explicitly discloses this is a read-only operation requiring owner-level access. This is meaningful behavioral information (auth tier, read-only nature) that an agent would benefit from. It doesn't describe pagination or returned fields, but for a 0-parameter list tool the core behavioral context is covered.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, zero waste. It clearly states the action, the endpoint mapping, and the tier in a compact form. Every element earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 0-parameter, read-only list tool with no output schema, the description is fairly complete. The tier tag and endpoint mapping help the agent. It doesn't describe the return format, but for a simple list-all operation without an output schema, this is a minor gap. Overall adequate and functional.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters, and schema description coverage is 100% (trivially, since there are no params to document). The description explains the scope of what's returned ('all organizational tags'), which is the only semantic context needed. Baseline 4 for 0-param tools applies here.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'List all organizational tags available on the account' with a clear verb (list) and resource (organizational tags). It maps to a specific endpoint (GET /tags). It's clear, though it doesn't explicitly distinguish from sibling get_tag (the singular form) — but the list vs. get distinction is inferable.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool returns all tags at the organizational level, giving some context about scope. However, it provides no explicit when-to-use guidance or exclusions — e.g., no note about when to prefer get_tag for a single tag lookup. The context is adequate but no alternatives are named.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![backcrew-mcp-housecall-pro MCP server](https://glama.ai/mcp/servers/jayson-svg/backcrew-mcp-housecall-pro/badges/card.svg)](https://glama.ai/mcp/servers/jayson-svg/backcrew-mcp-housecall-pro)

Score Badge

Copy to your README.md:

[![backcrew-mcp-housecall-pro MCP server](https://glama.ai/mcp/servers/jayson-svg/backcrew-mcp-housecall-pro/badges/score.svg)](https://glama.ai/mcp/servers/jayson-svg/backcrew-mcp-housecall-pro)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/jayson-svg/backcrew-mcp-housecall-pro'

If you have feedback or need assistance with the MCP directory API, please join our Discord server