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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states that the tool parses text and finds all Sefaria references, and mentions reference conversion, but it doesn't describe output format, edge cases, or any transformation details. This is adequate but not rich.

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 concise sentences front-load the core operation and then add practical use cases. There is no filler or repetition of the tool name, and every sentence contributes useful signal.

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 tool with no annotations and no output schema, the description is largely complete: it explains what the tool does, when to use it, and what input is expected. The main gap is not specifying the return format, but the simple nature of the tool makes this a minor omission.

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 schema already provides 100% coverage with 'The text to parse for references.' The description reinforces that the text is the source to search within, but it does not add substantial detail about the parameter's format, limitations, or expected input style 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 ('Parse') plus a clear resource ('text') and outcome ('find all Sefaria references within it'). This clearly distinguishes it from the sibling retrieval tools, which fetch texts or metadata rather than extracting references from supplied text.

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 gives two use cases: extracting citations from text and converting modern references to traditional ones. It doesn't name alternative tools or state when not to use it, but the intended context is clear enough for an agent to select this tool appropriately.

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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says a list is returned; it does not mention pagination, response size, ordering, or whether topic metadata like slugs and descriptions are included.

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, direct sentence with no filler. Every word earns its place and the core purpose is front-loaded.

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

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

For a zero-parameter list tool, the description is minimally viable, but without an output schema it should say more about what the returned list contains and whether it is paginated. It also leaves the relationship to get_topics unspecified, which is a meaningful gap given the sibling list.

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 documentation burden. The empty input schema and the description align cleanly, and a baseline of 4 is appropriate for parameterless tools.

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 clear action ('Get a list') and resource ('all topics in Sefaria's topic system'). It is more than a tautology and the word 'all' hints at a distinction from sibling get_topics, though it does not explicitly differentiate itself.

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 about when to use this tool versus alternatives such as get_topics, get_topic_graph, or get_recommended_topics. The agent is left to infer when 'all topics' is the right choice.

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?

With no annotations, the description carries full behavioral burden. The word 'Get' and the mention of 'today's' readings indicate a read-only, time-dependent operation, but there is no explicit statement about side effects, permissions, or how 'today' is determined.

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 one concise sentence that front-loads the action and scope. Every phrase adds meaningful information without repetition 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?

For a zero-parameter, read-only tool without an output schema, the description is largely sufficient: it names the data returned and its categories. Minor gaps remain, such as timezone handling and return format, but these are not critical for invoking the 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?

The tool has zero parameters, so the schema fully covers the input surface. The description appropriately avoids adding unnecessary parameter details.

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 is specific: it states the action ('Get'), the resource ('today's Torah readings'), and the calendar basis ('Jewish calendar'). It also lists content categories, making it easy to distinguish from the many text-related sibling tools.

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?

No guidance is given about when to prefer this tool over alternatives such as get_next_read or search. The description states what it does but does not provide selection criteria or 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?

No annotations are provided, so the description carries the full disclosure burden, and it only restates the literal operation. It does not disclose the shape of the returned 'texts', whether category names must match a known taxonomy exactly, pagination behavior, or error handling. The tool is read-only in nature so the gap is not severe, but the description adds no behavioral depth beyond the function name implies.

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 zero filler. It is appropriately sized for a one-parameter tool. One short clause about what the returned texts look like would have increased value without bloating the definition.

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 low-complexity read tool, the core call is adequately specified: one required parameter, fully documented with enums-style examples. However, with no annotations, no output schema, and no clarification of how 'category' relates to the topic-oriented siblings, the definition is only minimally complete and leaves return-format and routing questions open.

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 has a description with concrete examples ('Torah', 'Talmud', 'Mishnah'), so the baseline is 3. The tool description contributes only the phrase 'all texts,' implying the category filters a text collection, which adds marginal meaning 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?

States a specific verb+resource: 'Get all texts in a specific category.' This is clear as a standalone statement. However, it does not distinguish 'category' from the many semantically overlapping sibling tools (get_topics, get_all_topics, get_topic_graph), so an agent cannot tell whether a category and a topic are the same kind of entity.

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?

No guidance on when to use this tool versus alternatives. There are no exclusions, no named alternatives, and no conditions. Within a 28-tool family that includes get_text, get_topics, and search, the description gives an agent no basis for preferring get_category over its siblings.

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?

With no annotations, the description carries the full burden of behavioral disclosure. It states the kind of information returned, but does not disclose whether the operation is read-only, whether it has special permissions or rate limits, what errors may occur, or what the overall response format looks like.

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

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

The description is a single, front-loaded sentence with no wasted words. The parenthetical list is reasonably informative, though 'etc.' is vague and the description could be tightened by naming the key result elements more precisely.

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

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

For a tool with no annotations and no output schema, the description is only minimally complete. It gives partial metadata examples but does not specify the return format, define what 'index' means, or explain how it differs from the many related sibling tools, leaving an 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?

The schema provides full coverage for the only parameter, tref, including an explanatory example. The description adds very little parameter-specific meaning beyond restating that the tool concerns a specific text, so the schema already does the heavy lifting.

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 names the operation as 'Get metadata about a specific text' and gives concrete examples of that metadata: structure, versions, categories. However, it does not differentiate this tool from sibling tools like get_toc, get_versions, or get_category, so an agent could confuse it with those.

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?

No guidance is provided on when to use this tool versus alternatives. The description implies it is for retrieving metadata about a text, but it does not mention when to prefer get_index over get_toc, get_versions, or get_category, nor does it state 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?

With no annotations, the description carries the full burden. 'Get list' clearly signals a read-only retrieval with no side effects. It also states the scope ('all languages available'). It stops short of describing ordering, format, or pagination, but for a zero-parameter catalog endpoint these are minor omissions.

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 wasted words. Every part of the description adds useful information: the action, the resource, and the scope. It is appropriately sized for the tool's trivial complexity.

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 no-parameter, no-output-schema tool, this description is fully complete. It tells the agent exactly what the tool returns (a list of all available languages) and nothing else is needed to invoke it correctly. The absence of details about return format is not a real gap because the output is self-explanatory.

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 the schema gives no semantic burden. The description correctly implies the operation requires no input, matching the empty input schema. Baseline for zero parameters is 4, and the description does not need to compensate for any undocumented parameters.

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') and states the exact resource ('list of all languages available in Sefaria'). This clearly distinguishes it from sibling tools like get_text, get_toc, or get_calendars, which target completely different resources.

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 provides clear context: an agent should call this tool when it needs the set of languages Sefaria supports. It does not explicitly mention when not to use it, but since there are no similarly scoped siblings, the context is sufficient and no exclusions are needed.

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?

No annotations are provided, so the description carries the burden of behavioral disclosure. It does say the tool returns definitions, translations, and related words, which implies a read-only lookup, but it does not describe matching behavior, empty-result behavior, or any input constraints beyond 'Hebrew word.'

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 one concise sentence that front-loads the action and return value. Every word earns its place, with 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?

This is a simple one-parameter read tool with no output schema, and the description adequately covers what it does and what it returns. It is slightly thin on edge-case behavior, but nothing essential for a basic call 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%: the schema already documents word as 'The Hebrew word to look up.' The description repeats this without adding extra semantics such as exact-match requirements, normalization, or accepted forms. Baseline 3 is appropriate because the schema does the heavy lifting.

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–resource pair: look up a Hebrew word in the Sefaria lexicon, and enumerates the return contents: definitions, translations, and related words. This clearly distinguishes it from sibling tools like get_text or get_related.

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 use case is implied: use it to look up Hebrew words in the lexicon. However, it gives no explicit guidance on when to choose this over related siblings such as get_word_completion, get_terms, or search, and it does not 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?

With no annotations, the description carries the burden of conveying behavior. 'Get' implies a read operation and 'textual links' identifies the kind of output, but the description does not clarify link format, whether URLs or references are returned, or any edge-case behavior.

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 one tight sentence with no filler and includes useful examples in parentheses. It is appropriately sized for a simple one-parameter tool, though it sacrifices some helpful context for brevity.

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 read-only getter with one fully documented parameter, this is close to sufficient. However, without an output schema, the description does not fully explain what a 'link' looks like, so an agent may still be unsure what the 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 100% for the single parameter tref, so the schema already documents it. The description adds no parameter-specific detail beyond what the schema provides, matching the baseline for high coverage.

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 and resource ('Get textual links to other sources') and adds clarifying examples such as commentaries and parallel passages. It does not explicitly differentiate from siblings like get_related or get_ref_topic_links, so it stops 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?

No guidance is provided about when to use this tool versus alternatives. With a large sibling list including get_related, get_ref_topic_links, and get_terms, the agent gets no criteria for making that choice.

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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only implies a read-only retrieval operation through the verb 'Get,' with no mention of output structure, pagination, ordering, error behavior, or how the reference is resolved. This is minimal behavioral transparency for a tool with no annotation safety net.

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 one concise, front-loaded sentence containing only the essential action, object, and scope. There is no filler or repetition, 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?

For a single-parameter tool with no output schema and no annotations, the description is minimally adequate: an agent can determine what to pass and the conceptual return value. However, it omits useful operational context such as return format, typical use cases, and relationship to related manuscript/version tools, leaving it adequate but with clear gaps.

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%: the sole parameter tref is documented as 'The text reference.' The tool description echoes this same concept without adding constraints, format, or domain semantics. Baseline 3 is appropriate because the schema already documents the parameter fully and the description adds no meaning beyond 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 uses a specific verb and resource: 'Get manuscript variants' for 'a specific text reference.' This clearly names the tool's function and differentiates it from siblings like get_text and get_versions by focusing on manuscript variants. It does not explicitly contrast with those siblings, so it falls just 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?

The description provides no explicit when-to-use guidance or alternatives. It neither says when to prefer this tool over get_versions, get_text, or get_translations, nor gives any exclusion criteria. The only usage signal is the implied scenario of needing manuscript variants for a reference, which is not enough to guide an agent among many similar sibling 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?

With no annotations, the description carries the burden of disclosing behavior. 'Get information' indicates a read-only lookup, which is helpful, but the description does not clarify return format, whether exact-name matching is required, or how missing names are handled. It is adequate but minimal.

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 filler. It communicates the purpose and adds an illustrative parenthetical without redundancy.

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?

This is a simple one-parameter tool with no output schema, so the description is not severely incomplete. However, it does not specify what kind of information is returned or how a name should be formatted, and it lacks sibling differentiation that would help an agent choose confidently among many get_* 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?

The schema already fully describes the single parameter 'name', so the baseline is 3. The description adds value by clarifying that the name refers to Sefaria entities such as Rabbis or places, which helps the agent understand the expected semantic content of the string.

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 the verb 'Get information' and a specific resource: 'a specific name in Sefaria (Rabbi, place, etc.)'. This is clear enough to distinguish the general lookup intent, though it does not explicitly contrast with sibling tools like get_terms or get_topics.

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 usage context is implied: it should be used when you need information about a specific Sefaria name. However, there is no explicit guidance about when to prefer this over related tools, no alternatives are mentioned, and no exclusion criteria 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?

With no annotations, the description carries the full burden of behavioral disclosure, yet it only restates the operation without addressing side effects, ordering, determinism, or error conditions. The 'get' verb implies read-only but adds no behavioral detail beyond what the name and schema already suggest.

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 with no filler and gets straight to the point. It is appropriately concise for the tool's simplicity, though it sacrifices completeness.

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 no output schema and no annotations, the description is too thin to be fully self-sufficient. It doesn't explain what a 'recommended reading' looks like, what tref should be, or how this differs from closely related tools, so an agent would likely need to inspect other definitions to invoke it 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 100%, so the baseline is 3. The description adds the semantic link that tref is the 'reference' used to compute the 'next recommended reading,' which is mildly informative but does not elaborate on format, required characteristics, or relationship to other tools' parameters.

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 ('get') and resource ('next recommended reading') and specifies that it is based on a reference, which is clear enough to distinguish it from generic get_text or get_random_text. However, it does not explicitly name or contrast any sibling tool, so it earns a 4 rather than 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 description provides no guidance on when to choose this tool over siblings such as get_related, get_recommended_topics, or get_random_text. No context, exclusions, or alternative references are given, leaving the selection entirely to the agent's 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?

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It states only that the result is random and topic-filtered, but does not explain how topics map to content, what happens on invalid or unknown topics, whether results are reproducible, or what the response structure looks like.

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

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

The description is a single, well-formed sentence with no filler. It front-loads the core action and the key qualifier, making it immediately parseable by an agent.

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-like tool, the description captures the essential purpose, but it omits practical context such as how topic slugs are obtained or validated and what a 'text segment' looks like. With no output schema and no annotations, a bit more context would improve completeness, yet the tool is simple enough that the current description is minimally viable.

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 schema already provides 100% coverage for the single parameter, describing 'topic' as 'The topic slug.' The description adds little beyond restating that the result relates to a topic, so the baseline of 3 applies because the schema handles parameter documentation adequately.

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 verb ('Get'), the resource ('a random text segment'), and the scoping criterion ('related to a specific topic'). It is specific enough to distinguish this from a general random-text tool, though it does not explicitly name the sibling 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?

The description implies when to use the tool—when a topic-related random segment is needed—but gives no explicit guidance on when to prefer it over get_random_text or other siblings. There are no exclusions, prerequisites, or alternative-selection cues beyond the topic qualifier.

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?

With no annotations, the description must carry behavioral disclosure, and it does state the core behavior: returning a random text segment from the library. However, it does not explain what shape the returned segment takes, how randomness is scoped, or any limits, leaving behavior only lightly specified.

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

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

Two short sentences, no filler: the first states the operation and scope, the second states practical uses. It is front-loaded and every sentence earns its place.

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

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

For a simple no-parameter read tool, the description conveys the resource, the random nature, and likely use cases, which is enough for an agent to decide to call it. It is slightly incomplete because there is no output schema and the description does not hint at the return payload structure.

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 input schema has zero parameters and 100% coverage, so there is nothing for the description to add about arguments. Baseline 4 for a no-parameter tool 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 object: 'Get a random text segment from the Sefaria library,' so an agent can tell this returns unpredictable content rather than a specific ref. It does not explicitly distinguish this from the sibling get_random_by_topic, so it misses the top level of sibling differentiation.

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 concrete use cases: 'Useful for daily study suggestions or testing,' which is a clear context for invocation. It does not mention when another tool should be chosen instead, so it stops short of a 5.

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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only restates the action implied by the tool name and does not mention the nature of the recommendations, return format, potential side effects, or any prerequisites beyond the text reference.

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 with no redundant wording. It is concise and front-loaded, clearly stating the operation and the required input.

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 simple with one parameter, but there is no output schema and no annotation to clarify behavior. The description does not explain what 'recommended topics' means or how this tool differs from several sibling tools that also relate topics and text references, leaving some selection ambiguity.

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 schema already describes tref as 'The text reference.' The description's phrase 'specific text reference' adds no meaningful semantic detail beyond the schema, so the baseline score of 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 uses a specific verb and resource ('get recommended topics') and identifies the input ('a specific text reference'). The word 'recommended' helps distinguish it from broader siblings like get_topics or get_all_topics, though it doesn't explain what 'recommended' means.

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 when to use the tool: when you have a text reference and need recommended topics. However, it provides no explicit guidance about when not to use it or how it differs from related siblings such as get_related, get_topics, or get_topic_graph.

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?

No annotations are provided, so the description carries full behavioral disclosure burden. It does not mention whether the operation is read-only, what happens for unknown references, whether results are a list, or any edge cases. 'Get' implies read-only, but the description adds no behavioral depth beyond the tool's name.

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 concise sentence with no filler or repetition. The action is front-loaded, and every word earns its place. It sacrifices some helpful context for brevity, but remains an efficient statement.

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, no annotations, and a large sibling list containing overlapping terms like get_links and get_topics, this description is too sparse. It fails to clarify the return format, error behavior, or selection context, leaving an agent with significant uncertainty.

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%, with 'tref' described as 'The text reference.' The description's 'specific text reference' adds negligible meaning beyond the schema. Baseline 3 is appropriate because the schema already documents the parameter sufficiently.

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 verb and resource: 'Get topic links' scoped to 'a specific text reference.' It distinguishes the tool from generic get_links or get_topics by the reference requirement, though it does not name sibling tools or explicitly contrast 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?

No guidance is given about when to use this tool versus alternatives like get_links, get_topics, get_all_topics, or get_topic_graph. The description states only what the tool does, not when it should be selected.

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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It communicates that the tool returns a broad set of related content and implies a read-only operation, but it does not disclose failure modes, authorization requirements, result limits, pagination, or what happens when the reference is invalid or missing. For a tool claiming to return 'all' related content, this missing behavioral context is significant.

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 crisp sentences with no redundant filler. The first sentence states the core action and result categories; the second adds a useful framing of the tool's purpose. Every word earns its place.

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

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

The tool has a single parameter with full schema coverage, no output schema, and no annotations. The description adequately explains what the tool returns, but it omits usage context, result format, and edge-case behavior. It is sufficient for a basic understanding but not fully complete for reliable autonomous 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% and the single parameter 'tref' is already described as 'The text reference.' The description merely calls it 'a specific reference,' adding no format, syntax, or example information beyond what the schema provides. 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 uses a specific verb and resource ('Get all content related to a specific reference') and enumerates the content types included (links, sheets, notes, media, manuscripts, topics), which helps distinguish it from narrower siblings like get_links, get_topics, and get_related_websites. It falls slightly short of 5 because it doesn't explicitly name any sibling or precisely define what constitutes a 'reference' or 'connected material.'

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 'Comprehensive way to find connected material' implies this tool is for broad discovery rather than targeted retrieval, which gives some usage signal. However, it does not explicitly state when to choose this over siblings like get_links, get_topics, or get_manuscripts, and offers no when-not-to-use guidance.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It only says 'Get', implying a read operation, and reveals nothing about how relatedness is determined, whether web access is involved, pagination, or failure behavior.

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 with the verb and resource front-loaded. It contains no wasted words and is appropriately compact for a one-parameter tool.

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

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

For a tool with no annotations and no output schema, the description should clarify what kind of text reference is expected, what 'related web pages' means, and what the response contains. All of this is left to inference from the tool name and sibling set.

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 schema covers the single parameter (tref) with a description of 'The text reference.' The tool description adds only the word 'specific', so it does not materially expand the meaning of the parameter beyond the schema. 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 names a clear verb ('Get'), a resource ('related web pages'), and an input condition ('for a specific text reference'). It is broadly distinguishable from the sibling get_related because it explicitly says 'websites', though it does not directly contrast with that sibling.

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 about when to choose this tool over siblings such as get_related, get_links, or get_ref_topic_links. The phrase 'for a specific text reference' identifies the input but not the selection criteria.

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?

With no annotations, the description carries the full disclosure burden. It does reveal that the tool returns a structural summary rather than raw content, but the 'etc.' leaves the exact response fields and format underspecified. For a simple read-only tool this is acceptable but not complete.

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

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

The description is a single concise sentence with the key action and an illustrative parenthetical. It has minimal waste, though 'structure/shape' is slightly redundant and 'etc.' adds little concrete detail.

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?

This is a simple tool with one parameter and no output schema, so the description is mostly sufficient for invocation. However, the return value is underspecified ('structure/shape', 'etc.'), and there is no guidance distinguishing it from get_toc or get_text, which leaves room for mis-selection.

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 schema already describes tref as 'The text reference' and covers 100% of parameters, so the description does not need to compensate. It adds only the context that the reference points to a text whose structure is returned, with no format, examples, or constraints 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 clear action ('Get') and a specific resource: the structure or shape of a text, with concrete examples like number of chapters and sections. It is not a tautology and is understandable, but it does not explicitly differentiate itself from sibling tools such as get_toc or get_text.

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 it should be used when an agent needs a high-level structural overview of a text rather than its full content. However, it provides no explicit guidance on when to prefer it over closely related sibling tools like get_toc, and it states no exclusions or 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?

With no annotations, the description must communicate behavioral traits itself. It conveys only that information is retrieved and nothing about response shape, exact-match behavior, error cases, or whether this is the appropriate read endpoint. Minimal disclosure for a lookup tool.

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

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

The description is a single efficient sentence with no wasted words and is immediately readable. It loses a point only because the brevity leaves room for useful clarification that would not have hurt structure.

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 and no annotations, so the description is the only behavioral contract. It does not explain what information is returned, how terms are matched, or how this differs from sibling getters, leaving an incomplete picture despite the simple one-parameter API.

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 schema already documents 'terms' as an array of term names at 100% coverage. The description adds domain color ('Rabbis, concepts') but no additional semantics such as matching rules, allowed formats, or limits, so it meets the baseline without exceeding 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 names a specific verb ('Get'), a resource ('terms'), and gives illustrative examples ('Rabbis, concepts'). It is clear enough for a simple lookup, though it does not explicitly distinguish itself from sibling lookup tools like get_lexicon or get_topics.

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?

No guidance is given about when to use this tool versus the many sibling tools. 'Specific terms' implies a targeted lookup, but there are no exclusions, prerequisites, or alternative-tool mentions, so an agent must guess how to route among similar getters.

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?

No annotations are provided, so the description must carry the burden. 'Retrieve' clearly marks this as a read-only operation, and examples cover reference styles, but it doesn't disclose response format, error behavior, or default selection beyond schema-covered defaults.

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 sentences, with the action and examples first and the use-case statement second. No filler, every sentence adds value.

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 4 parameters with full schema coverage and no output schema, the description provides sufficient context for basic invocation. It could mention response shape or version distinction, but the essentials are covered.

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 baseline is 3. The description adds concrete reference examples including a range ('Exodus 20:2-6') and a daf segment ('Shabbat 2b:10'), going beyond the schema's simpler examples and clarifying tref 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 action (retrieve) on a specific resource (text passage from Sefaria) with a clear method (by reference). 'Primary way to get text content for citations and study' signals main use, though it does not explicitly name a sibling to differentiate from.

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?

Implied usage: use when you have a specific reference and need text content. However, it doesn't mention when to avoid this tool or direct to alternatives like get_text_v1 or search, leaving the choice partially 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses that this is a legacy v1 endpoint, which hints at potential behavioral differences, but it does not state whether the operation is read-only, whether parameters behave differently, or what the output looks like versus the current get_text.

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

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

The description is two short sentences with no filler. The legacy status is front-loaded, and the routing instruction to prefer get_text is immediately actionable. Every word earns its place.

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

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

For a legacy endpoint with no output schema and no annotations, the description is too thin. It does not specify what the response contains, how this version differs from get_text, or whether any parameters are deprecated or behave differently. The agent can make a basic call from the schema but lacks important context for correct and safe use.

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 input schema already documents all four parameters. The description adds no parameter-specific meaning beyond what the schema provides, so the baseline 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 identifies the tool as a legacy v1 text endpoint, which conveys the resource type and legacy status, but it never states explicitly what the tool does (e.g., 'Retrieves text for a reference'). It partially differentiates from get_text by labeling this as legacy, but the core purpose is only implicit.

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 directs the agent to use 'get_text instead when possible', which clearly establishes get_text as the preferred alternative and implies this legacy endpoint is a fallback. However, it does not explain under what conditions the legacy endpoint should be used instead, leaving some ambiguity.

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?

With no annotations, the description carries the full burden of disclosing behavior. It reveals that the response is large (~4MB) and mostly static, which is exactly the information an agent needs for caching decisions. It does not explicitly state read-only semantics, but 'get' plus the content description makes this reasonably clear.

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 filler: the first sentence defines what the tool returns, and the second provides a high-value operational note about response size and caching. The key information is front-loaded.

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

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

For a no-argument tool with no output schema, the description covers what the response contains, its size, and its stability. It is complete enough for an agent to call the tool correctly, though a bit more detail about response structure would be a minor improvement.

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 input schema has zero properties, so there are no parameter semantics to document; the baseline of 4 applies. The description appropriately adds no parameter details because none are needed.

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: 'Get the Table of Contents' and defines it as a 'hierarchical list of all available texts in Sefaria organized by category.' This clearly distinguishes it from sibling text-fetching tools like get_text or get_index.

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 does not explicitly compare this tool to alternatives or state conditions for when to use it. However, the no-parameter design and 'consider caching' note imply it is meant for retrieving the full hierarchy, which gives some contextual 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?

With no annotations, the description carries the burden of explaining behavior. It communicates that the tool is a read operation returning relationship data, but it does not disclose the output shape, graph depth, node/edge semantics, or whether any filtering or pagination applies.

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 or repetition. Every word contributes to identifying the tool's function.

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 definition is minimally viable for a one-parameter read tool, but the lack of an output schema and any annotation means the description should say more about what the returned graph actually contains. An agent can invoke it, but may be uncertain about how to interpret the result.

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 schema already fully documents the required 'topic' parameter. The description adds no extra meaning about how the topic slug is used to scope the graph, meeting the baseline but not exceeding 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 clearly identifies the action ('Get'), the resource ('topic graph'), and the core purpose ('showing relationships between topics'). This distinguishes it from list-style siblings like get_topics or get_all_topics, though it doesn't explicitly name what it is not.

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: use this tool when you need the graph of topic relationships rather than a flat list. However, the description provides no explicit guidance about when to choose this over closely related siblings such as get_related or get_ref_topic_links.

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?

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only says 'Get details.' It does not explicitly confirm read-only behavior, describe the response shape, or mention any limitations. 'Details' is vague about what kind of information the agent will receive.

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?

One sentence with zero filler, front-loading the action and resource. It is appropriately sized for the amount of content it conveys.

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?

Despite the simple one-parameter schema, the absence of an output schema means the description should clarify what 'details' includes and how it differs from sibling topic tools. It does neither, leaving an agent uncertain about expected return values and tool selection in a crowded sibling set.

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 parameter 'topic' is already well documented with examples in the schema. The tool description adds no additional parameter semantics beyond what the schema provides, so it meets the baseline but does not exceed 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 states a specific verb ('Get') and resource ('details about a specific topic in Sefaria's topic system'), making the core action clear. It implicitly distinguishes from get_all_topics by emphasizing a specific topic, but it does not explicitly name sibling tools or alternate scopes.

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?

No guidance is provided on when to use this tool versus the many topic-related siblings such as get_all_topics, get_topic_graph, or get_ref_topic_links. There are no exclusions, conditions, or alternative suggestions, leaving selection entirely 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that all translations are fetched for a language but does not disclose return format, ordering, pagination, limits, or whether 'all' may be constrained by permissions or data availability.

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 clear sentence with no filler and front-loads the core action. It is appropriately concise for a simple one-parameter tool, though it could afford a little more behavioral detail without becoming bloated.

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

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

With no annotations and no output schema, the minimal description leaves important context unstated, such as what a translation entry looks like, how the language parameter relates to the returned data, and how this tool differs from many similar get_* siblings. It is not complete enough for confident tool selection.

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 lang parameter is already documented with examples and meaning. The tool description adds nothing beyond the schema, which is acceptable under the baseline, but no extra semantic context is provided.

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: 'Get all translations' scoped to 'a specific language' via the lang parameter. This is clear about what the tool does and separates it from siblings like get_languages or get_text, though it does not explicitly name an alternative.

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

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

No guidance is given about when to use this tool versus related siblings such as get_text, get_languages, or search. The intended use is only implied by the name and description, with no exclusions or alternative routing.

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?

With no annotations, the description carries the full burden, and it does convey that this is a read-oriented operation returning all available versions/translations. However, it does not describe the return shape, behavior when the title is not found, or any other runtime characteristics, leaving some ambiguity.

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 one concise, front-loaded sentence with no filler or redundant terms. Every word contributes to understanding the tool's purpose.

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 getter with full schema description coverage, the description is nearly complete: an agent knows what to pass and what general result to expect. The lack of an output schema and the lack of sibling disambiguation are minor gaps, but the tool is simple enough that the description suffices 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?

The input schema already provides 100% coverage for the single required parameter, title, with a clear description. The tool description adds only the context of 'specific text' and 'versions/translations,' which is useful but does not materially enrich the 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 clearly identifies the action (get) and resource (all available versions/translations for a specific text), so an agent can infer the basic purpose. However, it does not distinguish itself from the sibling tool get_translations, which may cover overlapping functionality.

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 'for a specific text' gives a clear usage context: call this when you need versions/translations tied to a particular title. It does not provide explicit when-not-to-use guidance or mention alternatives, but the context is sufficient for a basic retrieval tool.

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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions only the core action ('Get') and does not disclose any additional behavioral traits such as read-only nature, response format, rate limits, or whether any input validation applies. It is a minimal statement with no context beyond the basic purpose.

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, focused sentence that is easy to parse and front-loaded with the key action. It is appropriately concise for a simple one-parameter tool. However, it does lean toward under-specification rather than deliberate conciseness, which 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?

Given the tool has no annotations, no output schema, and a large set of sibling tools, the description provides only the barest context. It does not clarify what form the autocomplete suggestions take, whether the prefix must be normalized, or how this tool relates to nearby tools like search or get_lexicon. An agent would still be uncertain about when to select this tool over alternatives.

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 parameter 'prefix' is well described in the schema as 'The Hebrew prefix to autocomplete.' The tool description adds no additional parameter meaning beyond repeating the topic ('Hebrew words'). This aligns with the baseline score of 3 when the schema handles parameter documentation adequately.

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 states a specific verb and resource: 'Get autocomplete suggestions for Hebrew words.' It is unambiguous about the tool's function. However, it does not explicitly distinguish itself from sibling tools like get_text or get_lexicon, though the unique 'autocomplete' purpose makes it reasonably identifiable.

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 or what prerequisites might exist. The description only states what it does, leaving the agent to infer usage from the name and context. No exclusions or alternative tool mentions are provided.

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?

With no annotations, the description carries the burden of behavioral disclosure. It states that the tool returns matching passages with relevance scoring, which communicates the core output behavior. However, it does not mention pagination, behavior for empty results, rate limits, or that this is a read-only operation, though 'search' strongly implies it.

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 short sentences with no redundant words. The core action and result are front-loaded, and every word earns its place.

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

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

The tool is a straightforward full-text search, and the schema fully documents all parameters. However, there is no output schema and the description only vaguely explains the return value as 'matching passages with relevance scoring'; it does not describe result count limits, categories filtering behavior, or error cases.

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 baseline is 3. The description adds the context that the query is for full-text search but does not provide additional meaning for the limit or categories parameters beyond what the schema already states.

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 full-text search operation over the Sefaria library and states that it returns matching passages with relevance scoring. This distinguishes it from sibling tools like get_text or get_ref_topic_links, which are not full-text searches, though it does not explicitly name any sibling.

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?

No explicit guidance is given about when to use this tool versus alternatives such as find_refs or get_word_completion. The phrase 'full-text search' implies usage for finding passages by keyword, but there are no exclusion conditions, prerequisites, or alternative tool references.

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