guide-registry

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

Annotations already declare readOnlyHint, idempotentHint and non-destructive behavior, so the bar is lower. The description still adds real value beyond those flags: it states the return shape (question, grounded answer, visible citations) and the concrete 'Returns null if not found' behavior, which annotations cannot express.

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 front-loads the resource, the lookup key, and the returned contents, then tacks on the read-only and null-return facts. No sentence is wasted and nothing is 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 no output schema, the description takes on the burden of describing returns and does so via the field list plus the null case and a pointer to the Answer contract doc. It is close to complete; the shape reference is a doc name rather than an inline structure, leaving a small gap for an agent that cannot read ANSWERS-PROGRAM.md.

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% with a single self-documented parameter, so the schema already carries the semantics. 'By id or slug' matches the schema's 'stable id or slug' description and adds no format, validation, or ambiguity-resolution detail beyond it; 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 ('Get') and resource ('one Answer') scoped to a single lookup by id or slug, and enumerates the returned fields (question, grounded answer, visible citations). The singular 'one Answer ... by id or slug' distinguishes it from list_answers and search_answers without ambiguity.

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

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

The id-or-slug lookup key implies when this tool is appropriate versus the list/search siblings, but there is no explicit when-to-use or when-not statement. An agent can infer the case, but the description never names search_answers or list_answers as the 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?

Annotations already mark this as read-only and non-destructive, so the description does not need to cover safety. It adds useful behavioral context by specifying that the result includes artifact and routing-surface status, going beyond the tool's title.

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

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

The description is a single sentence that front-loads the core action and resource, then appends the relevant included statuses. There is no filler or repetition.

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

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

For a single-parameter read-only lookup with an output schema and safety annotations, the description provides enough context for correct invocation. It clearly identifies the input and the expected scope of the returned data.

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 fully documents the slug parameter. The description only restates that lookup happens by slug, adding no meaningful parameter semantics 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 uses a specific verb ('Get'), a clear resource ('one guide's registry row'), and a precise lookup method ('by slug'). It also states what is included (artifact + routing-surface status), and the singular scope distinguishes it from list_guides.

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

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

The description implies usage when you have a specific guide slug and need one registry row rather than a list. However, it does not explicitly state when to prefer this over list_guides or mention any exclusions.

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, and destructiveHint=false, so 'Read-only' largely repeats structured data. The one genuine addition is that results are cursor-paginated, which tells the agent how to iterate, but nothing is said about ordering or return shape.

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 that front-loads the resource and pagination behavior. The 'Read-only' clause is partly redundant with annotations and 'contract v0' carries little actionable meaning, but there is no padding.

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 read-only list tool with 100% schema coverage and annotations covering safety, this is minimally adequate. It omits what an answer is, whether ordering is stable, and how it differs from search_answers, and with no output schema it never hints at the nextCursor return value.

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 both `limit` and `cursor` are already fully documented in the schema. The description's 'opaque cursor' phrasing merely echoes the schema without adding format or syntax guidance; 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 ('List Answers') and adds the scope detail that it is cursor-paginated. It is distinguishable from get_answer by being a list operation, though it never explicitly contrasts itself with the sibling search_answers.

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 mention of an opaque cursor implies the intended usage (enumerating results page by page), but there is no explicit when-to-use or when-not-to-use guidance, and no routing to search_answers for filtered queries.

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 signal a safe read-only operation, and the description adds valuable behavior beyond that: nulls mean 'not yet joined' rather than 'no link', ksao_type 'other' is unvalidated, and construct_class filters to only ~30% person-attribute elements. These are exactly the kind of non-obvious behaviors an agent needs to know.

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

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

Three sentences, each earning its place: purpose, parameter-to-use-case mapping, and the critical null-semantics caveat. The description is dense but not bloated, and the opening sentence immediately establishes what the tool does.

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

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

For a complex 12-parameter read-only query tool with an output schema, the description covers the domain model, key usage modes, data-quality caveats, and null interpretation. The output schema handles return-value details, so nothing critical is missing for correct invocation.

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%, but the description enriches the parameters with domain meaning: min_guides=2 identifies the cross-cutting spine, capability_detail hydrates a package, canon_promotion_candidate represents real promotion candidates, and construct_class distinguishes 'what a job requires' from 'what a capability produces'. This goes well beyond the schema's basic field descriptions.

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 operation: traverse the capability spine to join books, guides, KSAO elements, and jobs. It is clearly differentiated from siblings like list_guides and get_guide by focusing on cross-entity traversal and element-level query modes.

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

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

The description explicitly maps parameters to use cases: min_guides=2 for cross-cutting capabilities, role=<role> for job requirements, and capability_detail=<slug> for a hydrated package. It does not explicitly contrast with sibling tools, but gives enough situational guidance for an agent to choose correctly.

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 and destructiveHint=false, so the safety profile is known. The description adds useful behavioral context by specifying what the tool returns and excludes ('no addresses, no passages') and what filters are supported, going beyond the bare 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 two sentences with no wasted words. It front-loads the action and resource, then the returned fields, filters, and output limitation, making it easy for an agent to parse quickly.

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 detailed parameter schema, read-only annotations, and an output schema, the description covers the decision-relevant facts: what is returned, what filters are available, and what is excluded. Nothing an agent needs to call this tool correctly 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?

Schema description coverage is 100%, so the schema already documents all six parameters. The description summarizes the filter dimensions and output scope but does not add material information beyond the schema, so the baseline score of 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 uses a specific verb and resource ('List organizational conditions') and enumerates the returned fields (identity, label, guide count, causal-role counts). It clearly distinguishes this tool from siblings like list_guides and list_capabilities by naming the exact resource being listed.

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

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

The description gives clear context for when to use this tool: when you need organizational condition metadata and counts. It also draws an explicit boundary with 'Names and counts only — no addresses, no passages,' signaling that this tool is not for full content retrieval, though it does not name a specific sibling alternative.

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 provide readOnlyHint=true and destructiveHint=false, so the safety profile is known. The description adds value by disclosing that only names and provenance are returned, no passages, and by specifying the returned fields (title, author, library_id, guide URL). This shapes expectations beyond the read-only hint and is helpful for downstream processing.

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

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

The description is two sentences, with the purpose stated up front and the key limitation (no passages) at the end. No filler, no redundancy, and every clause contributes to understanding the tool's scope and constraints.

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 a modest all-optional parameter set fully documented in schema and an output schema present, the coverage is sufficient for correct invocation. The description states the essential scope (disagreement names, pole books, URL), the filtering dimensions, and the exclusion of passages. It does not address alternative tool selection, but that gap belongs to usage guidelines rather than completeness.

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 each parameter already has a useful schema description (e.g., slug notes that persona/category are ignored when set). The description merely repeats 'Filter by slug, persona, or category' without adding new meaning. This meets the baseline for full schema coverage but does not augment it.

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

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

The description starts with a pointed question ('Where does the field disagree?') and then enumerates the exact deliverable: cross-book tension names, the books on each pole with title/author/library_id, and the guide URL. It also names the filter dimensions and explicitly excludes passages, making it clearly distinct from sibling list tools like list_conditions or list_taxonomy.

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

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

The description implies its use by stating it returns disagreements and can be filtered, but it does not explicitly compare against alternatives or state when not to use it. The 'no passages' note is a limitation, but it is not framed as a directive to choose search_guides or another sibling. An agent choosing between this and list_conditions or list_taxonomy gets no direct routing signal beyond the title.

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 and destructiveHint=false, and the description adds meaningful behavioral context by explicitly noting that the distribution roll-up includes guides homed to a property with no rendering surface. This goes beyond the schema and clarifies an inclusion edge case without contradicting 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 entire description is one information-dense sentence with no filler. It front-loads the core action and resource, then appends the important scope details and edge-case inclusion, making every word earn 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?

Given the tool's complexity (13 optional filters), the 100% schema coverage, output schema, and annotations, the description sufficiently conveys what the tool returns and highlights the notable distribution roll-up behavior. It is complete enough for an agent to invoke correctly, though it could slightly improve by explicitly contrasting with sibling list 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?

Parameter descriptions in the schema already cover 100% of the 13 parameters with detailed examples and default values, so the description does not need to compensate. It adds no parameter-specific meaning, which is acceptable given the high schema coverage; 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?

Description uses a specific verb and resource: 'List the bicycle.guide registry' and enumerates the exact scope of what is returned (home, status, access, standard, syndication, grounding, distribution roll-up). This clearly differentiates it from siblings like get_guide (a single guide) and list_capabilities/list_taxonomy (different registries).

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

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

The description implies use when you need the full registry of guides rather than a single guide or another taxonomy, but it never explicitly states when to prefer this tool over alternatives or when not to use it. The context is inferable from the name and sibling list, but the description itself gives no direct routing 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 declare readOnlyHint and non-destructive behavior. The description adds useful behavioral context beyond that by promising live guide counts and machine-readable output rather than prose. There is no contradiction with annotations, and no hidden state-changing behavior is implied.

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

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

A single front-loaded sentence with no filler. The enumeration of returned vocabulary elements earns its place, and the clarification 'machine-readable data rather than prose' adds value without bloating the description.

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, read-only vocabulary tool with an output schema, the description is complete: it names the resource, the returned categories, and the data format. An agent has enough information to decide to call it and know what to expect.

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, so there is no parameter burden for the description to carry; the empty schema is already unambiguous and schema description coverage is 100%. The nominal baseline for zero-parameter tools 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 uses a specific verb and resource: 'Get the bicycle.guide vocabulary' and enumerates the exact returned components (domains, shelves, series, personas, guide_types, classification conventions). It does not explicitly call out a sibling alternative, but the resource name and content list make the tool's purpose clear.

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 intended use is implied rather than explicit: an agent can infer to call this when it needs taxonomy or classification data instead of a specific guide, guide list, or capability list. However, there is no direct 'use when' guidance or comparison with siblings like get_guide, list_guides, or list_capabilities.

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, idempotentHint, destructiveHint=false and openWorldHint=false, so the trailing 'Read-only' is largely redundant. The one added fact is 'Returns contract v0 records,' which hints at the result shape but is never defined; no pagination or result-ordering behavior is 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?

Three short sentences, front-loaded with the verb-resource-query core, then return shape, then safety. No filler; the only waste is the redundant 'Read-only' that annotations already cover.

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 search tool with no output schema, the description covers the query surface but leaves 'contract v0 records' undefined and says nothing about result ordering or how the limit interacts with the default. Adequate but with clear gaps an agent would notice.

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% for both parameters, so the schema already documents 'query' and the 'limit' cap of 200. The description restates the query semantics in prose but adds nothing about limit behavior, 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 (Search) plus resource (Answers) and the retrieval mechanism (free-text query over question/answer text), which implicitly separates it from list_answers and get_answer. It never names a sibling explicitly, so differentiation is inferable rather than stated.

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 'free-text query over question/answer text' implies this tool is for keyword lookup rather than enumeration (list_answers) or id retrieval (get_answer), but no when-to-use or when-not-to-use condition is stated. Usage is left to inference from the verb.

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 read-only annotation, the description discloses valuable behavior: 'Returns matches, or a structured refusal with the nearest owned guides and the missing topic' and 'No model call' warn the agent about cost and fallback behavior. This is substantive behavioral context not present in the annotations.

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

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

Three terse sentences front-load the operation, then describe the return/refusal behavior footnote, then the filters. Every sentence earns its place with 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?

For a 4-parameter read-only search tool with a full input schema and an output schema, the description is complete enough for correct invocation. It covers the main purpose, miss behavior, the model-call constraint, and the optional filters; remaining details live in the structured schemas.

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?

Input schema coverage is 100%, so the schema already documents all four parameters. The description adds only a light restatement of the persona/category filters and 'No model call', which appears in the schema's q description too; no deeper semantic value is added.

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 verb ('Search'), a resource ('published guides'), and a query mode ('by topic'), which clearly distinguishes it from list_guides and get_guide. The title and body also convey the refusal behavior, so the agent knows this is a search-with-miss-handling tool, not a simple enumerator.

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

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

The description gives clear context for when to use it — topic-based search with persona/category filters — but it never names siblings like list_guides or get_guide, nor does it state when-not-to-use it. The distinction from other guide tools is implied rather than explicit.

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