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

Annotations already indicate this is a read-only, idempotent, closed-world operation. The description adds valuable behavioral context by explaining the exact meaning of each verdict, including that 'normalized' means the quote was altered. It does not describe source scope or error behavior, so it is not 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 description is two tight sentences with no wasted wording. The core action is front-loaded, followed by concise verdict definitions that directly affect interpretation.

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 one-parameter read-only tool with no output schema, the description covers the action and the possible verdicts. It leaves some ambiguity about which sources are checked, but is otherwise complete enough to invoke correctly.

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

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

There is one required parameter and schema description coverage is 0%. The description identifies the parameter semantically as the quotation to check, but it does not add formatting details or constraints beyond what the parameter name implies.

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: 'Check a quotation against the sources.' It also defines the three possible verdicts, so the agent can distinguish this verification tool from siblings like search or sources.

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 purpose: use it to verify whether a quotation appears in the sources. However, the description does not explicitly say when to prefer this tool over alternatives such as search or sources, nor does it state 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 readOnly, idempotent, non-destructive, closed-world behavior, so safety is covered. The description adds real value beyond them by disclosing result ordering (oldest first) and per-quote structure (work and citation). It is silent on what max_chars does to output, which is the one behavior an agent would actually need to anticipate.

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 what is returned and its ordering, then the parameter note. No repetition of the tool name or 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?

With no output schema, the description does supply the return shape (quotes plus work and citation, sorted oldest first), which is the key missing piece. The remaining gap is max_chars semantics; otherwise an agent could call this correctly.

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

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

Schema description coverage is 0%, so the description must carry the load. It does well for 'author', explaining substring matching with concrete examples ('Augustine', 'Chrysostom'), but says nothing about 'max_chars' (default 2500) despite that being a truncation control with real behavioral consequences, and 'ref' is left to inference.

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 resource (church fathers and historical writers on a passage) and names the corpus (ANF/NPNF, Historical Christian Faith database), so an agent knows exactly what comes back. It does not explicitly differentiate itself from the sibling 'commentary' tool, which is the nearest alternative, so it falls short of a 5.

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 corpus named: use this when you want patristic quotes rather than modern commentary or dictionary definitions. However, there is no explicit when-to-use or when-not-to-use statement, and no routing to 'commentary', 'passage', or 'check_quote' despite those being obvious 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 declare readOnly/idempotent/non-destructive, so the safety bar is low; the description adds genuinely useful non-obvious behavior: multi-verse notes are filed under the first verse, and entries marked nearest_preceding may apply to the requested verse. It omits that max_chars truncates output, which is the one behavioral gap a caller could trip on.

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 returns, then qualifications. The parenthetical author list and the mid-sentence caveats make it slightly dense, but every clause carries information an agent would otherwise have to guess.

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?

There is no output schema, so the description rightly explains that results are quoted with citations, and the module/filing semantics are covered. Missing are the ref format and the truncation behavior of max_chars, which matter for a tool that silently caps output at 3000 characters.

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 only partly does: it explains modules (names from commentary_modules) and hints at ref semantics via nearest_preceding, but says nothing about the ref string format or the max_chars budget (default 3000) and what happens on overflow.

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 outcome: it returns what named public-domain commentaries say on a passage, quoted with citations. Naming the authors (Matthew Henry, JFB, Barnes, Clarke, Keil and Delitzsch, Calvin, Robertson) concretely bounds the resource and separates it from siblings like church_fathers and dictionary, though it never explicitly contrasts 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?

Implies the trigger clearly (you want verse-level exegetical commentary on a passage) and points to commentary_modules as the source of valid module names, which is real routing guidance. It stops short of stating when to prefer church_fathers or translation_notes instead.

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 establish read-only, idempotent, non-destructive behavior, so the description need not repeat safety traits. It adds value by disclosing that results include entry counts and licenses, but it does not describe the return structure (e.g., list format) or any behavioral nuances. With annotations covering safety, the added context is useful but thin.

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

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

The description is a single, front-loaded sentence with no extraneous words. Every element ('commentary modules', 'library', 'entry counts', 'licenses') contributes to understanding the tool's output.

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 simple, parameterless listing tool with no output schema, the description is nearly complete: it states the resource and the key return fields. It could be improved by clarifying that the result is a list of modules, but an agent can infer this from the name and description.

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 the schema is empty and the description need not explain parameter semantics. Baseline 4 applies because there are no parameters to document or misinterpret.

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

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

The description clearly identifies the resource (commentary modules in the library) and adds informative detail (entry counts and licenses). It distinguishes itself from siblings like 'commentary' and 'dictionary_modules' by name and scope, though the verb ('list') is implied 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?

There is no guidance on when to use this tool versus alternatives such as 'commentary' (likely fetches content) or 'dictionary_modules' (likely lists dictionary modules). An agent must infer the use case from the name alone.

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 safety is covered. The description adds real value by disclosing the fallback-to-full-text behaviour when no headword matches, but says nothing about result ordering, which lexicons win when several match, or output truncation.

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 action and corpus, then the fallback. The module enumeration is dense but earns its place by telling the agent what content exists. 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?

With no output schema and no parameter descriptions, the description is the only prose an agent gets. It covers scope and fallback adequately but omits result shape, truncation via max_chars, and how module selection interacts with the search fallback.

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 0%, so the description must carry the parameter burden. It implicitly maps 'term' to a headword or Strong's number and names the dictionary modules that the `modules` filter presumably selects from, but `max_chars` (default 4000) is never mentioned, so truncation behaviour is invisible.

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 ('look up a headword or Strong's number in the dictionaries and lexicons') and enumerates the source collections, so the agent knows exactly what corpus is queried. It does not explicitly contrast with near-neighbours like dictionary_modules or search, so it falls short of 5.

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 trigger condition is implied — use it when you have a headword or Strong's number — and the fallback to full-text search is disclosed. However, there is no explicit when-not or pointer to the sibling that lists modules or to `search` for free-text queries, leaving the routing partly to inference.

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 fully covered by structured data. The description adds only that entries carry entry counts and licenses, giving a modest hint about payload contents but nothing on ordering, filtering, or how results feed downstream tools.

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 short sentence with no filler, so nothing is wasted. The trade-off is that its brevity comes at the cost of a missing verb and any routing information, but structurally it is tight and 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?

With no parameters and no output schema, the description must convey what comes back and what to do with it. It hints at counts and licenses but never explains that the returned module identifiers are meant to be passed to 'dictionary' or similar tools, leaving the workflow incomplete.

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 disambiguate; baseline 4 applies. The schema is an empty object with full coverage, leaving no semantic gap to fill.

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 sentence names the resource ('dictionary and lexicon modules') and hints at returned fields (entry counts, licenses), but it omits a verb entirely — is this listing, fetching, or describing modules? It also fails to distinguish itself from the sibling 'dictionary' tool, which an agent could easily confuse with it.

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?

There is no statement of when to call this versus 'dictionary', 'commentary_modules', or any other sibling, and no mention of prerequisites or follow-up steps. The agent must infer that this is a discovery step preceding an actual dictionary lookup.

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 and closed-world behavior, so the bar is lower; the description adds real value by disclosing that every text carries a source citation and by enumerating exactly what interlinear mode returns (transliteration, gloss, Strong's, lemma, lexicon gloss, morphology). It stops short of saying what happens on an unresolvable reference or whether translations other than BSB are available.

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 what is returned before the optional-mode detail. The parenthetical field list is dense but each item is informative rather than 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?

With no output schema and only two parameters, the description suffices: it names the translation, the reference input, the optional per-word expansion and the presence of citations. Remaining gaps (error behavior, reference-range edge cases) are minor for a simple lookup 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 0%, so the description must carry the load, and it does for both parameters: 'ref' is illustrated with three concrete reference formats, and 'interlinear' is spelled out field by field. Only minor gaps remain, such as the default-off behavior and accepted range/boundary syntax.

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 resource (verse text in BSB plus original-language text) keyed to a reference, with concrete reference examples ('John 3:16', 'Rom 8:28-30', 'Ps 23'). It doesn't explicitly distinguish itself from siblings like 'word' or 'search', whose per-word and lookup functions partially overlap with interlinear mode.

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: the examples show the expected reference syntax, and interlinear=true is described as an optional enrichment. There is no statement of when to prefer this over 'word', 'search' or 'commentary', nor any exclusion or prerequisite.

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, non-destructive and closed-world, so the safety profile is fully covered by structured data. The description adds that the payload is DDL text plus a specific documentation file, which is useful context, but says nothing about output format, size, or whether the notes are optional/absent in some deployments.

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 tight sentence with zero waste, front-loading the main artifact (CREATE statements) and then the secondary content (design notes). It is a sentence fragment rather than a full statement, which is a minor stylistic ding but costs no clarity.

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

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

For a zero-parameter, read-only document-fetch tool with no output schema, the description tells the agent what will come back (DDL plus design notes) and where those notes originate. Only the return format (raw text/markdown) and rough size are unstated, which is a small gap.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. Schema coverage is 100% and empty, consistent with the description's parameterless nature.

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 resource and its content precisely: the index CREATE statements plus design notes from docs/SCHEMA.md. This is clearly distinguishable from the sibling 'sql' tool (which runs queries) even though it doesn't say so explicitly. The verb is only implied ('returns'), which keeps it short of a 5.

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 rather than stated: an agent can infer this is the reference to consult before writing SQL, but the description never says 'call this before using sql' or names any alternative or exclusion. No prerequisites or caveats are given.

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, non-destructive, so the safety profile is covered. The description usefully adds that matching is accent- and case-insensitive, but says nothing about result ordering, relevance ranking, or truncation behavior at the default limit of 20.

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 tight clauses with the defining behavior (full-text, accent/case-insensitive) front-loaded before the scope list. No filler, though the scope list could be structured more scannably.

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 three-parameter search tool with no output schema and no enum on `scope`, the description covers the scope dimension but leaves the query-string semantics and the limit/truncation contract unaddressed, so an agent still has to guess how results are shaped and limited.

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. It does document the `scope` values (all, translation, lexicon, original, commentary) in prose, which the schema does not, but leaves `text` (matching semantics) and `limit` (truncation behavior) entirely unexplained.

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

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

States a specific verb and resource (full-text search) plus a distinct behavioral trait (accent- and case-insensitive), and enumerates the corpora it spans. That partially separates it from siblings like `word`, `dictionary`, and `commentary`, though it never explicitly says how it differs from 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?

The scope enumeration implies that a caller can target a single corpus instead of the default, which is a usage hint, but there is no explicit when-to-use guidance and no mention of when to prefer `word`, `dictionary`, or `commentary` over the scope-specific search.

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 safety is covered. The description adds value by disclosing the returned fields (versions, licenses, row counts) and the verification concept, which is important given there is no output schema. It does not explain what 'verifies against its manifests and matches the index' means operationally, leaving interpretation gaps.

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?

It is a single sentence with no wasted words, but it is not front-loaded with an action verb and the trailing verification clause is dense. Structuring it as 'List index sources with …' would improve scanability.

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 listing tool with no output schema, the description does cover the likely return fields. It still leaves ambiguity about what 'the index' refers to and whether this enumerates installed modules or another collection, which an agent would need to know before calling.

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. Baseline 4 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 names the resource ('Sources in the index') and the metadata returned (versions, licenses, row counts, verification status), which differentiates it from siblings like xrefs, schema, and search. However, it is a noun-phrase fragment with no action verb ('list' or 'enumerate'), so the precise operation is only implied.

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?

There is no indication of when to call this tool versus alternatives such as schema or search, nor any prerequisites or exclusions. The description states content but gives no usage context.

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. The description adds meaningful operational context beyond those annotations: SELECT-only execution, a 200-row result cap, the schema prerequisite, and the SQLite dialect.

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 constraints, and every sentence carries useful information. It is dense but efficient, with no obvious 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 one-parameter SQL tool with no output schema, the description supplies the key constraints, prerequisite, dialect, and query examples. It does not describe result shape, but for arbitrary SQL returns that is reasonably covered by the instruction to call `schema` first.

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%, but there is only one parameter and the description compensates well by explaining that it is a SQLite SQL query, must be SELECT-only, is capped at 200 rows, and benefits from checking `schema` first. The Hebrew and Greek examples add useful query-shape guidance.

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: read-only SQLite queries against the index. It also clearly positions the tool against siblings by saying it is for questions the other tools do not cover, such as morphology patterns.

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 when to use this tool: only for questions not covered by other tools, and gives an example use case. It also gives a prerequisite, 'Call `schema` first,' and a hard constraint, 'Only SELECT is permitted.'

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 read-only, idempotent, non-destructive, closed-world behavior, so the safety profile is covered. The description adds licensing (CC BY-SA) and content-boundary context, but says nothing about output volume, truncation via max_chars, or what a missing passage yields.

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, with the resource and its scope front-loaded and the sibling pointer at the end. Every clause carries information.

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

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

The content semantics are well covered and annotations handle safety, but with 0% parameter documentation and no output schema, an agent still lacks guidance on reference syntax, what max_chars truncates, and what include_intros adds.

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% across three parameters, and the description never mentions any of them. The 'on a passage' phrasing hints that ref is a passage reference but gives no format, and max_chars and include_intros are entirely undocumented anywhere.

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 the specific resource (unfoldingWord Translation Notes), its scope (per Greek/Hebrew phrase, translation and lexical issues) and explicitly excludes doctrinal commentary, which separates it from the commentary sibling. An agent can tell what it returns without opening the 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?

Explicitly routes key-term article lookups to the dictionary tool and implicitly steers doctrinal material to commentary via the 'not doctrinal commentary' clause. It does not state a positive 'use this when' condition or prerequisites (e.g. reference format), 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 declare this is a read-only, idempotent, non-destructive, closed-world operation. The description adds meaningful behavioral context by enumerating the full range of returned data (lexicons, semantic senses, occurrence counts, distribution, forms, references), which is important since there is no output schema. It does not mention rate limits or pagination, but for a read-only research tool this is a solid 4.

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?

It is a single, front-loaded sentence that states the tool's purpose first, followed by a compact list of outputs. Every item in the list adds information about what the agent can retrieve; there is no filler. Slightly dense formatting prevents a 5.

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 specialized research tool with no output schema, the description does a good job covering the returned data types and giving key format examples. The main gaps are the absence of usage guidance and the lack of any explanation for max_refs, but overall an agent can call this correctly.

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

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

Schema coverage is 0%, so the description must carry parameter meaning. It gives useful format examples for the required key parameter (G26, H7225G, agape, λόγος), but never mentions max_refs, its default of 25, or how it limits references. That leaves one of two parameters unexplained, so a 3.

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 ('Word study') and resource (Strong's number or lemma), with concrete key format examples (G26, H7225G, agape, λόγος). It does not explicitly differentiate from sibling tools like dictionary or search, which may overlap in lexical lookup, so a 4 is appropriate.

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 by specifying input types and examples, but offers no explicit when-to-use guidance, no when-not-to-use conditions, and no named alternatives among the many siblings. An agent can infer it is for word-level lexical research, but must guess how it differs from dictionary or search.

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 read-only, idempotent, non-open-world, and non-destructive behavior. The description adds useful behavioral context by disclosing the data source and that results are ranked by community votes, though it does not describe pagination, response shape, or how limit/min_votes affect output.

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, front-loaded sentence with no wasted words. It conveys the core resource, scope, source, and ranking in a compact form.

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 0% parameter description coverage, the description should do more to explain parameter effects and return values. It mentions ranking and source but omits how limit and min_votes work and what a response contains.

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. It implies that 'ref' is a single verse and hints at community-vote ranking, but it does not explain 'limit' or 'min_votes' clearly, leaving two of three parameters semantically underspecified.

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

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

The description clearly identifies the resource (cross-references), the scope (one verse), and the source/ranking (OpenBible.info, community votes). It distinguishes itself from siblings like passage or search by being specifically about cross-references, though it does not explicitly name alternatives.

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 'for one verse,' suggesting this is the tool for retrieving cross-references tied to a single verse. However, it does not explicitly say when to use this versus passage, search, or commentary, nor does it provide exclusions.

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