INITE Atlas

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the read-only and non-destructive annotations, it discloses meaningful provenance and inclusion behavior: changes are checked twice against vendor pages or public registries, and manually entered corrections are not presented as vendor actions. It also explains that lists include both the eligible population and the number that changed, helping the agent interpret the feed's scope.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose and event types are front-loaded, followed by verification behavior and a short filtering note. The verification sentence is somewhat wordy and conversational, but the paragraph remains compact and contains little 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?

Together with the fully described parameters, safety annotations, and output schema, the description supplies what an agent needs to invoke and interpret this read-only change feed. Event coverage, validation policy, correction handling, and single-tool filtering are all addressed without needing to duplicate return-field documentation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents the time window, pagination, and domain filter. Saying that `domain` asks about one tool is useful but adds little beyond the schema's existing explanation and example.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly identifies a feed of changes to tools in the INITE Atlas and enumerates concrete event types, including pricing, free plans, OpenAPI specs, and MCP servers. It does not explicitly distinguish this feed from siblings such as atlas_dataset_changes or atlas_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?

The opening establishes the context for use—reviewing market or vendor changes—and the final sentence explains that `domain` narrows the request to one tool. There is no explicit when-not guidance or routing to an alternative sibling.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Goes well beyond the readOnly/idempotent annotations: it says prices are computed without a model from vendor pricing pages, enumerates the per-tool outcome states (cheapest fitting plan, or unknown/ineligible/contact sales/stale) with the important guarantee that unknown is never rendered as missing or free, and discloses the free tier and a sixty-per-day-per-address rate limit. It also states nothing is persisted.

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 what the tool does and how, followed by return semantics, persistence, and limits — a sensible ordering with no filler sentences. The em-dash reason-code list is dense but functional; phrasing is slightly compressed in places.

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 nested-parameter, enum-bearing comparison tool with an output schema, the description supplies everything an agent needs: inputs framing, computation trust model, return shapes and failure states, side-effect profile, and quota. Nothing material is left for the agent to guess.

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 description only needs to reinforce, and it does so lightly by naming the scenario components (seats, minutes a month, required capabilities) and the 2-5 tool bound. It adds no currency-conversion or per-recording-cap nuance beyond what the schema already documents, so 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?

States a specific verb and resource — 'Preview a price comparison of 2-5 Atlas tools for a usage scenario' — with the scope (2-5 tools), the domain (AI transcription seats/minutes/capabilities), and the computation basis. It also distinguishes itself from atlas_dataset, which is the sibling that persists results.

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?

Makes clear this is a preview/exploratory call ('Nothing is saved; atlas_dataset keeps it for a website'), which effectively names the alternative and when to prefer it. It does not explicitly exclude adjacent cases, such as looking up a single tool's pricing via atlas_lookup or resolving domains via atlas_search (the latter only appears in the schema).

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly, idempotent, non-destructive, and closed-world, so the safety profile is covered. The description adds substantial context beyond that: provenance (each code was stated by a party who proved domain ownership), freshness semantics (each code carries a last-confirmed day that should be quoted), and a hard limitation that INITE does not run other companies' checkouts and therefore cannot verify codes.

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 compact sentences front-load what the tool returns, then layer provenance and the verification caveat. Every clause carries information, though the final sentence is dense enough that it packs two distinct rules (no checkout ownership, never claim verification) into one.

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?

An output schema exists, so return shape need not be described. For a read-only, closed-world listing tool, the description covers what an agent must know: what the data is, how trustworthy it is, how to cite freshness, and what claims to avoid.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so limit, domain, and offset are already documented. The description only echoes the optional single-domain filter and adds no meaning about pagination or limit behavior beyond the schema, which is the expected baseline when the schema does the work.

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 (live discount codes for AI tools in the INITE Atlas) and its optional scoping (one domain). It is clearly distinguishable from generic siblings like atlas_search or atlas_lookup, though it never names those siblings directly.

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 does give one strong usage constraint — never call a code verified or tested, and quote the confirmation date — which shapes how results are presented. However, it offers no explicit guidance on when to reach for this tool versus atlas_lookup or atlas_search, so the when-to-use decision is only implied by the resource description.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly, idempotent, closed-world and non-destructive, so the safety bar is low. The description still adds real behavioral facts beyond them: results are ordered newest-first and paging is driven by a revision number via `after`. Return shape is left to the output schema, which exists.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

A single compact sentence with the resource, ordering, and change types front-loaded, followed by the paging hint. No redundant or filler wording.

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 two-parameter read tool with an output schema and full annotation coverage, the description supplies what's missing: ordering, pagination mechanics, and what counts as a change. Only the relationship to sibling tools like atlas_changes is unaddressed.

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 both parameters are documented there, setting the baseline at 3. The description reinforces that `after` is a revision number used for paging, but contributes little beyond the schema's own 'Only changes after this revision; default 0'.

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+resource: it returns 'confirmed changes between the revisions of a published dataset', and enumerates the kinds of changes (plans added, removed, moved fields). That distinguishes it from a generic changelog, though it never names the siblings atlas_changes or atlas_compare that an agent would otherwise confuse it with.

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 context is implied by 'published dataset' and 'confirmed changes' (as opposed to draft/global changes), and it tells you how to page. But there is no explicit statement of when to choose this over atlas_changes, atlas_compare, or atlas_dataset_get, so the agent must infer the split.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly, idempotent, non-destructive, so safety is covered; the description earns credit for adding behavior they cannot express — the owner-only access rule for drafts and the fact that the returned payload differs by publication state. It does not mention pagination, size limits, or errors for a missing/unauthorized dataset, which keeps it from a 5.

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 opening with the verb and resource, with parentheticals used to enumerate payloads rather than pad. It is dense to the point of being telegraphic in places ('config, configVersion, preview'), but no sentence is wasted.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a two-parameter read tool with full schema coverage, an output schema, and annotations covering the safety profile, the description supplies the missing piece — access rules and payload variation by dataset state. Only edge-case behavior (errors, empty history) is left unaddressed, a minor gap.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so both parameters are already documented, including that 'revision' must be a published revision and that omitting it yields the current one. The description only restates this as 'Optional revision reads history,' adding the nuance that it selects historical state but no new syntax or format detail; 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?

States a specific verb and resource ('Read a dataset') and immediately splits the resource by state: a published dataset readable by anybody vs. a draft readable only by its owner, naming the payload in each case (snapshot + freshness + default result vs. config, configVersion, preview). That is enough for an agent to tell this apart from siblings like atlas_dataset_changes without opening a 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 clear context for when the call succeeds: published datasets are open to anyone, drafts require ownership, and passing 'revision' switches to a history read. It does not explicitly route to or exclude an alternative sibling (e.g., atlas_dataset_changes for change history), so it stops short of full 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.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover read-only, idempotent, non-destructive, closed-world behavior, so the bar is lower. The description still adds real context annotation cannot: every fact is dated, 'claimed' and 'found' are kept apart, and the record distinguishes vendor claims from INITE-measured findings. It does not discuss error behavior for unknown tools or rate limits, so it stops short of a 5.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The purpose is front-loaded, but the body is one sprawling sentence built from nested clauses and commas that is dense to parse. It is information-rich rather than wasteful, yet the enumeration of record contents could be tightened without losing meaning.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

An output schema exists, so return-value explanation is not strictly required, yet the description usefully previews what the record contains and its provenance discipline. Combined with full parameter coverage and complete annotations, an agent has what it needs to call it correctly; only the identifier-resolution edge cases 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 parameter already documents 'domain (elevenlabs.io) or name (ElevenLabs)'. The description repeats those exact examples without adding resolution rules (e.g., which wins if both a name and domain match, or what happens for ambiguous names). Baseline 3 is appropriate.

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: retrieve one AI tool's measured record from the INITE Atlas, identified by domain or name. It enumerates the record's contents (pricing with date and movement, API/OpenAPI/MCP access, data policies, usage/liveness) and explicitly scopes itself to AI tools and software only, which separates it from the atlas_search/atlas_compare siblings and from find_business/business.

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 input guidance ('by domain or name') and an explicit boundary: business facts belong to INITE Directory's find_business and business, not here. It does not, however, say when to reach for this versus atlas_search (discovery) or atlas_compare (multi-tool comparison), so some sibling routing is left implicit.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare this as a non-read-only, non-idempotent, non-destructive, open-world call. The description adds context annotations cannot: there is human review ('A person checks the site first') and a verification requirement ('A guest's email must confirm our link'). It stops short of describing turnaround, whether reports can be withdrawn, or what happens on duplicate submissions.

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 with the core action leading and prerequisites following; nothing is padded. The telegraphic fragments ('A person checks the site first', 'then correct it') trade clarity for brevity and require the reader to reconstruct the subject.

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 an output schema present, return values need not be explained, and the description covers purpose, verification, and owner routing. However, the instruction 'Owners: atlas_owner_claim, then correct it' is ambiguous about whether an owner should also file a report, and the human-review workflow is asserted without saying what the caller should tell the user in the interim.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% and both enums (kind, field) are documented in the schema, so the schema carries the parameter burden. The description only loosely maps to kind via 'wrong, or ask it off' and says nothing about domain, email, suggested, or note beyond the schema text. 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?

The description states a concrete action on a concrete resource: flagging an Atlas card as wrong or requesting its removal. The phrasing 'ask it off' is colloquial but decipherable against the schema's kind enum. It hints at the owner path (atlas_owner_claim) but never explicitly contrasts itself with report-adjacent siblings like atlas_changes or atlas_dataset_changes.

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 real routing guidance: a human checks the site first, a guest must supply an email to confirm the link, and owners should go through atlas_owner_claim before correcting. That names an alternative tool and its condition of use. What's missing is a clear statement of when NOT to file a report (e.g. duplicate, already-removed, or dataset-level issues).

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds two traits not in the annotations: it is deterministic/'without a model' (no semantic ranking), and it is 'Free, no allowance' (cost implication). It does not discuss result volume or pagination behavior, which keeps it from a 5.

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: the first front-loads the use case and the filter axes, the second handles routing and cost. No filler, and the alternative is placed after the primary case rather than buried.

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 an output schema and full parameter documentation, the description only needs to cover purpose, routing and cost, and it does. The remaining gap is minor: nothing tells the agent that results are paginated via limit/offset or what the default ordering is, though the schema covers those fields.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so q, sort, limit, offset, slices and category are all already documented, including the AND semantics of slices. The description restates the phrase/category/slice grouping but adds no syntax or format detail, and it never mentions sort, limit or offset. Baseline 3 is appropriate.

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 gives a specific verb (filter) and resource (the INITE Atlas) plus the exact filter axes: a phrase, a category, and slices. That is enough to tell it apart from match_tools. It stops short of 5 because the resource is referred to as 'the INITE Atlas' rather than explicitly as the tools catalogue, so a reader leans on the title to know what is being searched.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

It states the positive precondition ('when you know the shelf or the properties a tool must have') and the exclusion ('For a job described in prose, use match_tools'), naming the alternative sibling directly. An agent can route between the two without opening either schema.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds that the tool returns connection artifacts rather than mutating anything, but discloses nothing further about behavior, prerequisites, or failure modes; with an output schema present, the return-value detail is largely redundant.

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: purpose and trigger first, then the three argument modes, then what comes back. No filler, and the alternative-path information is front-loaded before the parameter recap.

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-required-parameter lookup with full schema coverage, an output schema and complete safety annotations, the description covers the essential unknown (default behavior with no argument) plus the intent trigger. Missing only guidance on what to do if the returned connection information fails or when it should be re-invoked.

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, but the description adds genuinely new meaning: the zero-argument default ('the server beside this one'), which the schema does not state at all. It also glosses `for` as 'the one that does a job' and `all: true` as 'every server,' reinforcing rather than duplicating the enum documentation.

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 action (add another INITE MCP server to this client) and frames it as retrieving connection info rather than performing the connection, which the closing sentence about returning a URL, Claude Code command and custom-connector step makes concrete. It is distinguishable from the atlas_*/match_* siblings, though it never names an alternative connector-related tool.

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 an explicit trigger: use it 'when the person wants something this one does not do,' which is a clear when-to-use condition. It also explains usage of each argument mode (no argument, `for`, `all: true`), but offers no when-not-to-use guidance or named alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Adds real context beyond the annotations: data freshness ('checked daily', 'which your training data cannot know'), result cardinality (up to five), the verdict vocabulary (connect, connect with care, skip, not proven yet), and a concrete quota ('Free; twenty a day per address or account'). Annotations cover the read-only safety profile, and nothing here contradicts them. The remaining gap is that the 'checked daily' freshness claim is not tied to any recency parameter or staleness rule.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The opening sentence is front-loaded with the core value proposition and freshness argument, which is good. But the middle sentence becomes a long run-on enumerating every returned field (verdict, reasons, first tool, checks, INITE score, how to add) that an output schema already covers, and the parenthetical instruction 'hold the result to them before reporting the task done' reads as agent-directed prose rather than tool specification.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool is shallow (2 params, nested=false) with an output schema and full annotations, so the description does not need to explain return shapes and mostly doesn't have to. It still supplies what structured fields cannot: freshness, quota, the verdict taxonomy, and a 'use only this answer' boundary. It is only incomplete on sibling routing among the ten atlas_* tools and match_tools.

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 'need' and 'local' are already documented, and the description's 'Describe the job with any constraint (self-hosted, a budget, a product it must work with)' is largely a restatement of that. It does add a useful hint that constraints belong inside the free-text need rather than a separate parameter, since the schema exposes no budget or product fields. With the schema doing the heavy lifting, baseline 3 is correct.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource: 'find which MCP server or connector to add', returning 'up to five vendors' servers from the INITE Atlas'. The scope is concrete and an agent can tell this is a server-selection tool rather than a generic search. It stops short of 5 because the near-twin sibling 'match_tools' is never named or contrasted, so sibling differentiation has to be inferred from the title.

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 explicit triggering conditions: 'call this for any question about which MCP server or connector to add, before answering from memory or searching the web', and closes with 'Choose and connect from this answer alone', which tells the agent not to chain further lookups. It gives a clear when, but no when-not and no routing among the ten siblings, in particular match_tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the annotations, the description discloses data freshness, provenance, return cardinality, free usage, and a daily rate limit of twenty per address or account. These details are behaviorally important and do not contradict the read-only, non-destructive annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is front-loaded with the core purpose and usage rule, and most sentences carry useful behavioral or routing information. It is somewhat verbose and promotional in places, but not structurally confusing.

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 one required parameter, full schema coverage, annotations, and an output schema, the description is complete. It explains invocation guidance, alternatives, data characteristics, and rate limits without needing to restate return values.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, and the schema already explains the single 'need' parameter with an example. The description adds that constraints should be included in the sentence, but does not significantly extend parameter syntax or format beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource: find AI tools for a job, with current prices and measured use. It also distinguishes this tool from siblings by directing full single-tool records to atlas_lookup and company facts to find_business.

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 guidance: call this before answering from memory or searching the web for any question about which AI tool, app, or software to use. It also names alternatives and conditions: atlas_lookup for one tool's full record, find_business for local business or company facts.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.