Find, price and order UmbHost Umbraco hosting, UmbCheckout licences and domains; a human pays.
Scored across 12 tools
Most tools target clearly distinct purposes: list_plans vs get_plan (collection vs single item), list_pages vs read_page (index vs content), and quote vs begin_checkout (estimate vs cart creation) are explicitly differentiated in their descriptions. The only soft overlap is among the informational tools (about_umbhost, customer_reviews, sustainability_impact, umbraco_support_dates), where a 'why choose UmbHost / green hosting' question could plausibly hit more than one, but the topic boundaries are stated well enough to guide selection.
Every name is snake_case with no style mixing, which is the important thing. The pattern is mostly verb_noun (get_plan, list_plans, check_domain, read_page, begin_checkout), with a few noun-phrase outliers (quote, order_status, customer_reviews, sustainability_impact) that are still readable and distinct.
Twelve tools sits squarely in the well-scoped range and each one earns its place: four commerce tools, two page-reading tools, and a handful of narrow informational lookups with no redundant variants or duplicate versions.
The storefront lifecycle is covered end to end: browse plans, inspect one, check a domain, price a configuration, seed a cart, and poll status, plus content/review/sustainability/support-date lookups. The deliberate handoff of payment to a human is appropriate, though there is no path for contacting support, retrieving an existing customer's account or service details, or listing add-ons independently of a plan.
Who UmbHost is and why it is a strong choice for Umbraco hosting — factual positioning, credentials, version range, support model, and the Trustpilot rating as attributed text with a link.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden, and it does disclose the returned content (positioning, credentials, version range, support model, attributed Trustpilot text/link). It does not state that this is a side-effect-free read or mention caching/static nature, so behavioral disclosure is adequate but incomplete.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, front-loaded sentence that packs the purpose and the full content inventory without filler. Every clause earns its place by telling the agent what the response will contain.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given a zero-parameter tool with no output schema, the description is the sole spec of the return payload and does cover the expected content areas, including the attributed Trustpilot link. It could be slightly stronger by noting the response is static/vendor-authored with no side effects, but nothing essential is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so there are no parameter semantics to explain. The baseline for a no-parameter tool is 4, and nothing in the description conflicts with that.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific resource (information about UmbHost as an Umbraco host) and enumerates exactly what it covers: positioning, credentials, version range, support model, and Trustpilot rating. It is clearly an informational tool, implicitly distinct from the transactional siblings (quote, begin_checkout, get_plan), but it never names or excludes any sibling explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied — an agent can infer it should call this when it needs background on the vendor, but the description gives no explicit when-to-use trigger, prerequisites, or statement of when a sibling like get_plan or quote would be preferable. No exclusions are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Start an order for a configured hosting or licence plan. Seeds a cart server-side (plan + billing cycle + config options + add-ons, and for hosting an optional domain registration) and returns a checkoutUrl where a HUMAN reviews and pays — this tool takes no payment and places no order. Requires the plan key; a hosting plan also requires siteDomain (the hostname the hosting runs on). A licence takes no siteDomain or domain and is always billed annually. Prices exclude VAT.
| Name | Required | Description | Default |
|---|---|---|---|
| addons | No | ||
| domain | No | ||
| currency | No | ||
| packageKey | Yes | ||
| siteDomain | No | The hostname the hosting runs on. Required for a hosting plan; not used for a licence. | |
| billingCycle | No | ||
| configSelections | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and does well: it discloses that a cart is seeded server-side, that a HUMAN reviews and pays at the returned URL, that no payment is taken, no order is placed, and that prices exclude VAT. It omits auth/permission requirements and what happens on repeat calls or existing carts.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded with the core action and return value, and each sentence adds information (mechanism, payment scope, plan-type rules, VAT). The middle sentence is dense and comma-heavy, but no sentence is filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 7-parameter mutation-style tool with no annotations and no output schema, the description covers the essential flow, conditional requirements, and the returned URL. Gaps remain around currency/domain semantics, configSelections, and the absence of any auth or error-handling context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is very low (14%), so the description must compensate, and it does for the critical parameters: packageKey is required, siteDomain is conditional on hosting, and domain is unused for licences. It leaves currency, billingCycle format, configSelections shape, and add-on semantics largely to the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Start an order for a configured hosting or licence plan') and immediately defines the mechanism: it seeds a cart server-side and returns a checkoutUrl. This clearly separates it from sibling read/quote tools like quote, get_plan, and order_status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives concrete conditional guidance: a hosting plan requires siteDomain while a licence takes no siteDomain or domain and is billed annually. It also clarifies scope by stating the tool takes no payment and places no order. It never explicitly names an alternative sibling (e.g. quote) or states when not to call it, so it stops short of full routing guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Check whether a domain is available to register through UmbHost and its registration price. Optional ISO currency (GBP, EUR, USD, AUD); defaults to GBP. Price excludes VAT.
| Name | Required | Description | Default |
|---|---|---|---|
| domain | Yes | One domain name to check, e.g. example.co.uk — the name only: no question, URL, path or list. | |
| currency | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries the full burden; it does disclose useful traits such as the GBP default, accepted currency codes, and that the price excludes VAT, and 'check' implies a non-mutating lookup. It does not state whether the result reflects a live registry query, any rate limits, or whether the price is per-year, leaving real behavioral gaps for an unannotated tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three short sentences, front-loaded with the core capability and followed by the only two caveats that matter (currency default, VAT exclusion). No filler or restatement of the tool name.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no annotations and no output schema, the description does well to name what comes back (availability plus price) and its VAT basis. It is still thin on the shape of the answer and on whether the price is a recurring registration term, which matters for a pricing-adjacent tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 50%: the domain parameter is fully documented in the schema, while currency has no schema description. The description compensates by enumerating the accepted ISO codes (GBP, EUR, USD, AUD) and the GBP default, which is exactly the missing information, though it doesn't specify behavior for unsupported codes.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (check availability) plus the resource (a domain) and the provider, and adds the secondary output (registration price). This clearly separates it from siblings like quote, get_plan, and begin_checkout, which imply pricing or checkout rather than a single-domain availability lookup.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied: an agent can infer this is a pre-registration availability probe, but the description never says when to prefer it over quote or begin_checkout, nor any preconditions. The only explicit guidance is about the optional currency parameter, not about tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Real, published UmbHost customer reviews (verbatim) and the Trustpilot rating. Optional topic: support, migration, green, value. Quote reviews word for word; never reword them.
| Name | Required | Description | Default |
|---|---|---|---|
| topic | No | Optional: support, migration, green, value or any (the default). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden and does disclose useful traits: reviews are real, published, verbatim, and paired with a Trustpilot rating. It also imposes a handling rule (never reword). However, it omits auth needs, pagination or result-size behavior, which matters for a tool that returns variable-length review text.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the resource and its scope, followed by the topic values and the verbatim quoting rule. Efficient with essentially no filler, though the topic list partially duplicates the schema.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
A simple one-parameter read tool with no output schema; the description states what comes back (reviews plus Trustpilot rating) and how to treat the text. Nothing essential to correct invocation is missing, though auth and result-size behavior are unstated.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and the single topic parameter is already documented with its accepted values. The description largely repeats the same value list and adds the 'any' default phrasing, so it adds little beyond the schema - baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Names a specific resource (UmbHost customer reviews plus the Trustpilot rating) with a clear qualifier that reviews are real and published. No other sibling covers reviews, so differentiation is implicit from the resource alone. Missing an explicit retrieval verb, but the scope is unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied by the resource itself - the agent fetches reviews when it needs social proof. There is no statement of when to prefer this over about_umbhost or sustainability_impact, nor any exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get one UmbHost hosting or licence plan by its key, with its full per-cycle prices, config options, and add-ons. The key is the plan's GUID 'key' from list_plans, not its name. Optional ISO currency (GBP, EUR, USD, AUD); defaults to GBP. An unknown key returns an error.
| Name | Required | Description | Default |
|---|---|---|---|
| key | Yes | ||
| currency | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden and does disclose meaningful behavior: currency defaults to GBP, the key must be a GUID from list_plans, and an unknown key returns an error. It never states the operation is read-only or mentions auth/rate-limit constraints, so it is not fully complete, but the error and default semantics are genuinely useful.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three compact sentences, each earning its place: purpose and payload first, key format second, currency and error behavior last. No filler or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema exists, and the description names what is returned (per-cycle prices, config options, add-ons), so an agent knows the payload shape. Combined with the key format and currency default, everything needed to call it correctly is present.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate and does: 'key' is defined as the plan's GUID from list_plans (not the name), and 'currency' is an optional ISO code restricted to GBP/EUR/USD/AUD defaulting to GBP. Both parameters are fully disambiguated.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Get one UmbHost hosting or licence plan by its key') and enumerates what comes back: per-cycle prices, config options, add-ons. The phrase 'one ... plan by its key' cleanly separates it from the sibling list_plans.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly routes the caller to list_plans for the key and warns that the name will not work, plus notes an unknown key errors. It lacks an explicit 'do not use when...' clause, but the retrieval context is unambiguous.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List UmbHost's public site pages worth reading (title and URL), from /llms.txt. Use with read_page to answer questions about services, policies and how UmbHost works.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries the full burden; it does disclose the return shape (title and URL) and the provenance (/llms.txt, i.e., a static published listing). It does not state that the operation is read-only/side-effect free, nor anything about caching, freshness, or completeness of the list.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, both load-bearing: the first defines scope and return values, the second defines the workflow. Nothing is padded and the key scoping constraint is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple zero-param listing tool with no output schema, the description covers what comes back (titles and URLs), where it comes from, and how to follow up. Ordering, count, and whether results can be stale are left unstated, but these are minor for this tool's role.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so there is nothing to document beyond confirming the call needs no arguments; schema coverage is 100%. Baseline of 4 applies for a parameterless tool.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('List UmbHost's public site pages'), scopes it ('worth reading'), and names both the returned fields (title and URL) and the data source (/llms.txt). An agent can immediately tell this apart from read_page, which fetches a single page's content.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly routes usage: pair with read_page to answer questions about services, policies, and how UmbHost works. It names the companion tool and the triggering scenario, but gives no explicit when-not or an alternative for cases where listed pages are insufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List UmbHost's buyable plans with live prices, resources, config options, and add-ons: Umbraco hosting, email, and UmbCheckout licences (group 'Licence': billed annually, bought without a domain, with licenceDomains/licenceInstalls limits and add-ons that raise them). Optional group filter ('hosting', 'email' or 'licence'); omit for all. Optional ISO currency (GBP, EUR, USD, AUD); defaults to GBP. Prices exclude VAT.
| Name | Required | Description | Default |
|---|---|---|---|
| group | No | Only return this group: 'hosting', 'email' or 'licence'. Omit for every group. | |
| currency | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden and adds useful context beyond a bare 'list': live pricing, VAT exclusion, annual billing for licence groups, no-domain requirement, and limit/add-on behaviour. It does not cover authentication or rate limits, but the core operational semantics are well disclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loads the core action and returned content before detailing licence specifics and parameters. The single dense sentence with parentheticals is information-rich and mostly efficient, though slightly run-on.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema and no annotations, the description still explains what the tool returns (live prices, resources, config options, add-ons) and clarifies licence group semantics. It is complete enough for correct invocation, though it omits any pagination or authentication note.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 50%, with the group parameter documented but currency undocumented in the schema. The description compensates by giving the currency options (GBP, EUR, USD, AUD) and default (GBP), while also restating the group filter and its omit behaviour, adding meaning beyond structured fields.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('List UmbHost's buyable plans') and enumerates the content type (prices, resources, config options, add-ons). It implicitly distinguishes from the sibling get_plan by being a list operation, but does not explicitly name or contrast with that alternative.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives clear context for the optional group filter ('hosting', 'email' or 'licence'; omit for all) and currency defaults, which helps invocation. However, it offers no explicit when-to-use guidance against alternatives like get_plan, leaving the choice to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Check the status of a cart started with begin_checkout, by its cartKey: started, awaiting payment, paid, or not available.
| Name | Required | Description | Default |
|---|---|---|---|
| cartKey | Yes | ||
| currency | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations and no output schema, the description carries the full burden, and it does disclose the meaningful behavioral trait: the possible result states (started, awaiting payment, paid, not available), which tells the agent what to expect back. It omits read-only/auth guarantees and what 'not available' concretely signals, so it is good but not complete.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence that front-loads the verb and resource, then appends the status enumeration. Every clause earns its place with no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no annotations, no output schema, and 0% parameter coverage, the description covers the cartKey link and the return states but leaves the currency parameter and any auth/error semantics unexplained. Adequate but with clear gaps given the absence of structured support.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% for 2 parameters. The description clarifies cartKey by linking it to begin_checkout, adding real meaning beyond the bare 'string/uuid' schema, but the currency parameter is never mentioned in either the schema or the description, leaving half the parameters undocumented.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (check) and resource (cart status) and ties itself to the sibling begin_checkout, which creates the cart being queried. The enumerated status values make the tool's scope immediately distinguishable from siblings like quote or get_plan.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The phrase 'a cart started with begin_checkout' establishes the precondition for use and implicitly routes the agent from begin_checkout to this tool. It does not state any when-not conditions or alternatives, so it stops short of a full 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Price a configured UmbHost order the way the website's pricing calculator does: base plan + config options + add-ons at the chosen billing cycle and currency, with an optional domain priced separately (annual). Returns an estimate that matches the site and the cart. Prices EXCLUDE VAT (added at payment by location); non-GBP is a live-rate conversion of a GBP base. Omit configSelections to use the plan's defaults. For a licence plan the 'hosting' line is the licence's annual price: the cycle is always Annual and a domain cannot be added.
| Name | Required | Description | Default |
|---|---|---|---|
| addons | No | ||
| domain | No | ||
| currency | No | ||
| packageKey | Yes | ||
| billingCycle | No | ||
| configSelections | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the whole burden and does substantial work: prices exclude VAT (added at payment by location), non-GBP is a live-rate conversion of a GBP base, domains are priced separately and annually, and licence plans have forced-annual semantics. It omits auth requirements, error behaviour, and rate limits, but the pricing caveats are exactly the non-obvious traits an agent needs.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loads the core purpose in the first clause, then layers the caveats (VAT, currency, licence plan) in descending order of importance. Dense but every sentence carries pricing semantics that would otherwise be unguessable; slightly more length than strictly necessary.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema and no annotations, so the description must define both call semantics and result meaning – and it does state the result is an estimate matching the site and cart. For a 6-parameter pricing tool with 0% schema coverage, the gaps are the return shape and failure modes, which are secondary.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate and largely does: it explains domain (priced separately, annual), currency (non-GBP live conversion of GBP base), billingCycle (driven by plan/licence rules), configSelections (omitted = defaults), and add-ons. Only packageKey is left implicit, and no key-format syntax is given.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('Price') and resource ('a configured UmbHost order') and pins the exact semantics: it mirrors the website's pricing calculator output. An agent can distinguish this from get_plan (retrieval) and begin_checkout (transaction) without opening any schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives concrete operating guidance: omit configSelections to take plan defaults, and the special licence-plan case where cycle is forced Annual and domains cannot be added. It does not explicitly name when to prefer this over siblings like get_plan or begin_checkout, so it falls short of a full routing statement.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Read one umbhost.net page as Markdown. Pass a full https://umbhost.net/... URL taken from list_pages or a previous answer.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | A full https://umbhost.net/... page URL. |
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 does disclose two useful traits: the output is Markdown and reads are restricted to umbhost.net URLs. It says nothing about failure behavior for malformed or off-domain URLs, redirects, auth requirements, or size/rate limits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, no filler, and the core action plus return format are front-loaded before the URL-sourcing guidance. Every clause earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter read tool with no output schema, the description compensates by naming the return format and the URL source. The main remaining gap is error/edge-case behavior for invalid URLs, which is minor given the tool's simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3, and the description adds provenance meaning beyond the schema's format constraint by specifying the URL should be taken from list_pages or a prior answer. That is genuine semantic value over the schema text.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (Read), a scoped resource (one umbhost.net page), and the return format (Markdown). The word 'one' implicitly distinguishes it from the sibling list_pages, which enumerates pages rather than fetching a single one.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives clear context for invocation by telling the agent where valid URLs come from (list_pages or a previous answer), which is effectively a prerequisite. It stops short of stating when not to use it or naming an alternative for bulk reads.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
UmbHost's sustainability facts and live Ecologi impact (trees planted, tonnes of CO2 offset). Use for questions about sustainability, carbon, green hosting, B Corp or ESG.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations, so the description must carry the behavioral burden. It discloses that the Ecologi impact data is live and gives examples of returned metrics, but it does not state whether the tool is read-only, where the live data comes from, how fresh it is, or what the response looks like.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no waste: the first defines the resource and the second states when to use it. The purpose is front-loaded and the usage guidance follows directly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter informational tool with no output schema and no annotations, the description is mostly complete: it covers purpose, usage, and examples of returned metrics. A little more detail about the response shape or the live-data dependency would make it fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, which is the baseline-4 case under the scoring rules. The description does not need to explain parameter meaning because there are none.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names the specific resource: UmbHost sustainability facts plus live Ecologi impact, including concrete metrics like trees planted and tonnes of CO2 offset. It is distinguishable by topic from siblings such as about_umbhost, though it does not explicitly contrast itself with them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly says to use the tool for questions about sustainability, carbon, green hosting, B Corp, or ESG. That gives clear usage context, but it names no alternatives or exclusions, so it stops short of full routing guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Official Umbraco support and Umbraco Cloud end-of-service dates (fixed official pages, refreshed daily). Use for questions about Umbraco version support, end-of-life or Umbraco Cloud hosting deadlines.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden. It usefully discloses data provenance and freshness ('fixed official pages, refreshed daily'), which tells the agent the answer is authoritative and current. It does not state the return shape (e.g., a list of versions mapped to dates) or explicitly confirm the operation is a safe read.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, zero filler, and the resource plus its provenance are front-loaded before the usage clause. Every phrase earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter informational lookup with no annotations and no output schema, the description covers purpose, provenance, freshness, and usage triggers. The only real gap is that it does not hint at how the dates are organized in the response, which matters slightly given no output schema exists.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so there is nothing for the description to clarify; the baseline of 4 applies. Schema description coverage is 100% and the empty object schema is self-explanatory.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific resource (Umbraco support and Umbraco Cloud end-of-service dates) and its source (fixed official pages, refreshed daily), which is far more informative than the tool name alone. It lacks an explicit action verb, but an agent can immediately tell what data it gets. None of the siblings overlap with this resource, so differentiation is not a concern.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives explicit when-to-use conditions: 'questions about Umbraco version support, end-of-life or Umbraco Cloud hosting deadlines.' That is clear routing guidance for the agent. It names no alternative tool, but no sibling covers the same subject matter, so no exclusion is needed.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
check_domain1 field changedInput schema / properties / domain / descriptionAdded value: +"One domain name to check, e.g. example.co.uk — the name only: no question, URL, path or list."customer_reviewslist_pagesread_pagesustainability_impactumbraco_support_datesbegin_checkout4 fields changedInput schema / properties / siteDomain / defaultAdded value: +nullInput schema / properties / siteDomain / descriptionAdded value: +"The hostname the hosting runs on. Required for a hosting plan; not used for a licence."Input schema / properties / siteDomain / typePrevious value: -"string"New value: +[
+ "string",
+ "null"
+]Input schema / requiredPrevious value: -[
- "packageKey",
- "siteDomain"
-]New value: +[
+ "packageKey"
+]list_plans1 field changedInput schema / properties / groupAdded value: +{
+ "default": null,
+ "description": "Only return this group: 'hosting', 'email' or 'licence'. Omit for every group.",
+ "type": [
+ "string",
+ "null"
+ ]
+}about_umbhostbegin_checkoutcheck_domainget_planlist_plansorder_statusquoteYour online store: products, stock, orders, customers and payments into your own account.
Your online store: products, stock, orders, customers and payments into your own account.
Hosted headless CMS with native commerce: pages, media, forms, products, orders, refunds, discounts.
Branding, design and web services you can order and pay for without a human on the seller side.
Add one secure layer between your agents and this server.
