Daystruct

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

Beyond the annotations (readOnly, idempotent, non-destructive), the description discloses the tool is deprecated, no longer refreshed, and will be removed by a specific date. This is valuable context about the tool's reliability and lifespan. It does not contradict annotations.

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

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

The description is two sentences with no waste. The deprecation warning is front-loaded, followed by the functional summary. 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?

The description gives a high-level purpose but lacks detail on the structure of the claims array items (package and api) and the compatibility object fields, and does not describe the output. Given the nested schema and no output schema, more context would be helpful, though the deprecation status lowers the priority.

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?

With 0% schema description coverage, the description must compensate. It clarifies that 'claims' are package/API questions (limited to four) and that 'compatibility' is an optional runtime compatibility check. This adds meaning beyond the bare schema, though inner field details (e.g., what 'api' or 'runtime' mean) are not elaborated.

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

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

The description states a specific action ('Resolve up to four package/API questions and an optional runtime compatibility check') with a clear resource. It also names alternatives (discover_daystruct_capabilities, compat_check) and explicitly flags deprecation, which distinguishes it from sibling tools. Despite the title being generic, the description provides a precise purpose.

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 says 'For building, use discover_daystruct_capabilities and compat_check', clearly indicating when NOT to use this tool and directing to alternatives. The deprecation notice further implies it should generally be avoided, giving strong usage 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 indicate read-only and non-destructive behavior, so the description adds value by stating the deprecation with a specific removal date (2026-12-31) and the fact that it returns 'undetermined' for lines without published end-of-life. This goes beyond the annotations to disclose lifecycle and edge-case behavior, though it doesn't detail all potential return structures.

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 dense paragraph, efficient but slightly front-loaded with deprecation notice before the core function. It avoids redundancy and includes necessary caveats in a few sentences. Slightly better structure would separate the deprecation warning from the tool's function, but it's appropriately sized.

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

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

For a read-only query tool with no output schema and two parameters, the description explains the output categories (supported, maintenance, EOL) and the undetermined case, which is essential for correct use. It also provides upgrade-cycle context. However, it doesn't mention specific product names or version formats, which could be important given the deprecation warnings, but overall it's sufficiently complete for an agent to make a call.

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 mentions 'product' and 'version' implicitly but does not define allowed formats or examples. Given only two simple string parameters, the description could be more explicit about valid values (e.g., version syntax), but the minimal complexity slightly mitigates the gap. Baseline is 3 due to zero 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 clearly states the tool's purpose: to check release support status, including specific categories (supported, security-fix-only, past end-of-life) and output details (dates, upgrade cycles). It distinguishes itself from sibling tools like compat_check and discover_daystruct_capabilities by explicitly naming them and framing this as deprecated. The verb 'check' plus resource 'release support' is specific and unambiguous.

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

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

The description explicitly warns the tool is deprecated and directs users to alternatives (discover_daystruct_capabilities and compat_check) for building purposes. It clarifies when to use (given a product and version) and what to expect (undetermined if no end-of-life published). This provides clear usage context and appropriate routing to 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?

Annotations already declare read-only and idempotent, so the description adds deprecation status and data-refresh caveat, plus the undetermined handling rule. No contradiction with annotations; the added context is valuable for an agent deciding whether to rely on the 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?

Two concise sentences: deprecation warning first, then behavior and caveat. No redundant words; front-loaded with the most important decision-relevant info.

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 description covers the core behavior, return ordering, undetermined handling, and alternatives, but leaves the 'ecosystem' parameter unexplained and gives no example or output shape. For a deprecated tool with no output schema, this is adequate but not complete.

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

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

Schema coverage is 0%, so the description must explain parameters. It implicitly explains 'package' and 'version' but does not clarify the optional 'ecosystem' parameter at all. This is a notable gap given the low 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 states a specific action: given a package and version, return known vulnerabilities sorted worst-first with fixing versions. It clearly distinguishes from siblings by naming alternatives for building and indicating deprecation.

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 states it is deprecated and will be removed, directing users to discover_daystruct_capabilities and compat_check for building. Also provides guidance on interpreting 'undetermined' advisories, which clarifies when results are not safe.

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 disclose the key traits (readOnlyHint=false, idempotentHint=false, destructiveHint=false, openWorldHint=true), so the safety profile is covered. However, the description adds nothing beyond the operation name — it does not say whether closing is terminal, whether events can still be recorded afterward, or what happens on a repeated close of a non-idempotent operation.

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; every word earns its place. It is arguably under-specified rather than padded, which is a completeness issue rather than a conciseness one.

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

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

For a 4-parameter mutation tool with 3 required params, no output schema, and 0% schema description coverage, the definition does far too little. An agent gets no guidance on session lifecycle, outcome selection, or the relationship to the sibling session tools.

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

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

Schema description coverage is 0%, so the description must carry the parameter burden, and it does not. It gestures at 'outcome' and 'summary' but leaves session_id and request_id (both required, with min/max length constraints) entirely unexplained, and gives no meaning to the enum values.

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 ('Close a task session') plus the payload it carries (outcome, summary), so the operation is immediately identifiable. It does not explicitly differentiate itself from create_task_session or get_task_session, but the terminal 'close' semantics are clear enough.

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 when-to-use guidance is given: nothing says this is the terminal call for a session created by create_task_session, nor when to choose 'completed' vs 'abandoned' vs 'failed'. No alternatives or preconditions are named.

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 readOnlyHint=true, idempotentHint=true, and destructiveHint=false already in annotations, the description still adds substantial behavioral context: 'only those fields are read and nothing is stored', the meaning of the result scope values, the state being compatible versus verified depending on input type, refused affected versions under advisoriesAvoided, and deprecation fallback behavior named in notes. It also discloses the verify workflow's consent requirement, going well beyond the structured fields.

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

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

The purpose is front-loaded, but the description is a long, dense wall of text with several run-on sentences and parenthetical asides packed into single sentences, e.g. 'Its state is compatible, except when you pass bundle (for example security-scanners@latest-verified) instead of capabilities: then it is verified...' While nearly every sentence carries information, the lack of structural breakouts (bullets or parameter grouping) hurts scannability for a tool this complex.

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

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

For a complex tool with 4 parameters, 0% schema description coverage, nested objects, and no output schema, the description covers the input contract (what to send, what not to send), the result semantics (scope, state, advisoriesAvoided, notes), and the full project-verified workflow. It does not fully describe the response shape beyond those named fields, but it is complete enough for an agent to invoke the tool and interpret the outcome 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 carries the full burden, and it covers all four parameters: project is explained field-by-field (runtime, platform, lockfile or installed map, dependency sections), bundle is given a concrete example (security-scanners@latest-verified), and verifyReportId is tied to the verify-kit workflow ('pass the returned report id as verifyReportId'). The capabilities id/range sub-fields are only implied, not spelled out, so it is strong but not exhaustive.

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 opening clause states a specific verb and outcome: 'Resolve Daystruct capabilities to exact versions that fit each other, or get the exact constraint that broke with suggested alternatives.' It distinguishes this tool from siblings by contrasting the capabilities input with the bundle input and by the result scopes (bundle-only, project-checked, project-verified), so an agent can tell it apart from resolve_daystruct_bundle or resolve_task_capabilities.

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

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

The description gives clear invocation context: send the project manifest by default, which shifts the answer from bundle-only to project-checked, and never send source code. It also routes the project-verified workflow: fetch the verify kit, show the report, send only with user agreement, and pass the report id. It does not explicitly name sibling tools or state 'use X instead when Y', so exclusion guidance is absent, but the context is clear enough for correct selection.

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 non-readonly, non-idempotent, open-world, non-destructive. Beyond that, the description adds two genuinely useful facts: the required scopes ('read and requests:write') and a privacy guarantee that no conversation or reasoning trace is stored. That is real context an agent could not derive from structured fields.

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

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

Three terse clauses, front-loaded with the action, with no filler. Slightly telegraphic, but every sentence 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?

It covers auth and privacy, which is more than most mutation tools offer, but for a 4-param create with zero schema descriptions and no output schema it omits parameter meaning and the resulting session/state. 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 0% across 4 parameters. The description gestures at 'capability steps and dependencies' but says nothing about request_id, intent, or current_stage (which has a 'planning' default). With no schema-level descriptions, the compensation required here is missing.

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 ('Start') and resource ('task context'), and names the optional payload (capability steps and dependencies). The phrase 'compact task context' is mildly jargon-y, but it distinguishes this from close_task_session and get_task_session, which are the obvious siblings.

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 when-to-use guidance, no prerequisites or sequencing relative to close_task_session/get_task_session, no mention of when capability steps should be supplied. The agent must infer the lifecycle position 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 readOnlyHint, idempotentHint, and destructiveHint=false, and the description is consistent with these. It adds useful context beyond the annotations by specifying that the manifest is public and by outlining its thematic content, which helps the agent anticipate what information will be returned.

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

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

A single sentence that front-loads the action and object ('Read the public Daystruct manifest') before a clarifying colon phrase. Every word contributes meaning, and there is no filler or redundant restatement of the title.

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 parameterless, read-only, idempotent tool with strong annotations, this description is nearly complete. It names the resource, its public nature, and the topics covered. The output format is not described, but with no output schema and low complexity this is acceptable. Minor ambiguity remains around the word 'status' from the title, but it does not undermine 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 tool has zero parameters and the schema is trivially fully covered. Per the baseline for parameterless tools, the description does not need to explain parameter details, and it does not introduce any misleading parameter-related information.

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 ('Read') and resource ('public Daystruct manifest'), and explains the manifest's conceptual content: how capabilities are discovered, checked for compatibility, and delivered. This clearly distinguishes it from sibling tools that perform discovery, preparation, or compatibility checking.

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 usage is implied by the phrase 'public Daystruct manifest' – an agent can infer this is for inspecting the manifest. However, there is no explicit guidance on when to choose this tool over closely related siblings like discover_daystruct_capabilities or compat_check, 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?

Annotations only cover read-only/open-world/idempotent safety; the description adds substantial behavioral context beyond that: default eight compact descriptors, view:full returning up to 100 records, pagination via meta.nextOffset, response payload contents (freshness, requirements, limitations, prices), the caveat that provider availability is not proof of success, and that licensing findings are evidence not legal advice.

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

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

Front-loaded with the core purpose, then pagination, then filters, then caveats and follow-up tools in a logical order. Dense but largely earns its length given 15 parameters; the licensing-disclaimer and provider-availability sentences edge into boilerplate.

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 15 parameters, and the description does describe the response envelope (meta.nextOffset, card field, freshness/requirements) which is genuinely helpful. However, with no schema descriptions at all, the unexplained 'type', 'reference', and licensing filter parameters leave real gaps for an agent trying to call 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 0% across 15 parameters. The description explains limit (1-100), offset/nextOffset, view:full, category and delivery filters, and query as a task sentence or tool name, but leaves 'type', 'reference', and the seven licensing parameters (licenseSpdx, licenseStatus, licenseEvidence, licenseReciprocal, licenseUnresolved, licensePolicyState, bundleMembers) undocumented. This compensates for only about half the parameter surface.

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 ('Browse every public Daystruct capability... or search using a task sentence or tool name'), and scopes it against siblings: private Data/Memory cards go to list_daystruct_cards instead. An agent can distinguish this catalog from search_daystruct_library or search_entities without opening a schema.

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

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

Gives clear operating context: use search by task sentence or tool name, follow meta.nextOffset until null, and 'inspect a reference for its full contract before using it.' It also names the exclusion (private cards) and the follow-up tool (get_daystruct_card_image). No explicit statement of when to prefer sibling search_daystruct_library, so not a full 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the bar is lower. The description adds meaningful behavioral context beyond annotations: the script sends nothing unless --send is used, requires user agreement, and native members are unsupported. This is useful safety-relevant disclosure not available in annotations.

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

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

The description is dense but mostly purposeful, with the core purpose front-loaded. The second sentence is long and combines instructions with script behavior, making it slightly harder to parse, but every clause carries relevant 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?

With no output schema, the description covers what is returned (script, plan, conformance suites), how to use it (write to scratch, run node command), what the script reports (counts and versions only), and safety behavior (--send). It does not describe exact file names or response structure, but it gives enough context for the agent to proceed.

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%, but the description helps by specifying that the members must be 'exact source members from compat_check', adding provenance and resolution semantics beyond the raw id/version schema. The single parameter's structure is already fully documented in the schema, so the description's semantic constraint compensates well.

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 opens with a specific verb and resource: 'Return the files of the local verify step for exact source members from compat_check.' It clearly names the artifact types (script, plan, conformance suites) and distinguishes this from generic compat_check by emphasizing the local verify step.

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 by tying the tool to 'exact source members from compat_check' and gives an explicit exclusion ('Native members cannot be verified locally'). It lacks explicit alternative tool names, but the condition and restriction are enough to guide selection.

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?

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable lifecycle context: the tool is no longer refreshed and will be removed on 2026-12-31. This goes beyond the structured annotations.

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

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

Two sentences, front-loaded with the deprecation warning, followed by the read purpose. Every sentence earns its place and there is no filler.

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

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

For a single-parameter read tool with strong safety annotations, the description covers the key operational facts: deprecation, alternatives, and what is read. It does not define 'context-packet contract' or describe the return shape, but the low complexity and annotations make this acceptable.

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 only ties the parameter to the resource with 'a databank's', which is largely redundant with the parameter name 'databank'. It does not explain identifier format, expected values, or how to reference a databank.

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 ('Read') and a specific resource ('a databank's identity, temporal, dimension, and context-packet contract'). It also names sibling tools that should be used instead, which helps distinguish it from discover_daystruct_capabilities and compat_check.

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 marks the tool as deprecated, gives a removal date, and says 'For building, use discover_daystruct_capabilities and compat_check.' This is clear when-not-to-use guidance with named alternatives.

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

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

Annotations already carry readOnlyHint/idempotent/destructive=false, so the safety profile is covered; the description still adds the meaningful claim that it never returns the key and clarifies the null-means-no-limit semantics of the spending limit. It does not describe the response shape beyond field names, but with the safety profile already structured that is a minor gap.

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 tight sentences: contents first, then the workflow trigger, then the safety guarantee. Every clause carries information and nothing is repeated verbatim from annotations beyond a two-word 'Read-only'.

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, no-output-schema tool, the description enumerates the returnable fields and states the key is never returned, which is everything an agent needs to call and interpret it. No missing prerequisites or auth caveats.

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 no parameters, so there is nothing for the description to disambiguate and the baseline of 4 applies. The 'null means none' note concerns a returned field rather than an input, and is useful but not a parameter-semantics contribution.

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

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

Names a specific verb and resource (read the connected key's account) and enumerates exactly what comes back: available and reserved credits, scopes, the per-call spending limit, and where credits are added. No sibling in the list (daystruct_status, discover_daystruct_capabilities) covers this same surface, so an agent can pick it without opening a schema.

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

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

Explicitly prescribes when to call it: before a paid call, show the user the price first, and report spend afterwards. That is a concrete when-to-use workflow rather than implied 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?

Beyond the read-only and idempotent annotations, the description discloses the return format (PNG plus card name, type, and page link), the fallback behavior when images cannot be displayed, authentication requirements for public versus private cards, and billing/requirement status. These are operationally relevant details an agent would not get from the annotations alone.

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 primary purpose and then layers on only actionable details: parameter constraints, return behavior, fallback handling, auth conditions, display frequency, and cost/requirement status. Every sentence contributes operational guidance without redundant restatement.

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?

Although there is no output schema, the description fully covers the return content and fallback display behavior. It also provides authentication context and usage constraints, making the definition complete enough for an agent to invoke it correctly and interpret its 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 documents the single card parameter. The description adds useful guidance by emphasizing that it must be a card ID or exact reference and never a guessed name, which reduces lookup errors beyond the schema's basic type information.

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: retrieve the image of a Daystruct card, explicitly naming Source, Data, and Memory card types. It also explains the user-facing purpose of showing the card beside the assistant's text, which distinguishes it from the other Daystruct 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?

It gives clear when-to-use guidance: introduce, use, update, or report on a card. It also states explicit constraints, including passing an exact ID or reference, not guessing names, showing a card once per response rather than on repeated steps, and that the tool is never required for capability use.

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 safety, so the bar is lower. The description adds meaningful behavioral facts beyond them: only live, unexpired promotions are returned, evidence limits are included, and private test fixtures are never exposed. That is real return-scope context an agent cannot get from the annotations.

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

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

Two tight sentences, front-loaded with the action and resource, then the return constraints. Every clause earns its place with no filler.

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

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

For a read-only, no-output-schema tool whose annotations carry the safety profile, the description adequately covers what is returned and what is excluded. It is slightly thin on how to resolve the three required scope identifiers if unknown, which is the only notable gap.

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

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

Schema coverage is 0%, so the description must carry parameter meaning. It names all three concepts (databank, task family, tested model) and stresses they must be exact, but provides no value formats, accepted ranges, or guidance on resolving unknown scope values, leaving gaps against the 0% schema 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 gives a specific verb (Retrieve) and resource (reviewed Frontier guidance) with a precise scope (exact databank, task family, tested model). An agent can distinguish this from the broad discovery siblings like list_daystruct_guidance_scopes and discover_daystruct_capabilities, though no sibling is named explicitly.

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

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

It implies you must already know the exact databank, task family, and model, but never states when to reach for this tool versus list_daystruct_guidance_scopes or get_daystruct_validated_guidance alternatives. No exclusions or prerequisites 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 cover readOnly, idempotent, and non-destructive behavior. The description adds critical non-obvious lifecycle behavior: the tool is deprecated, no longer refreshed, and will be removed on a specific date. This is exactly the kind of context an agent cannot infer from annotations or the schema.

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

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

Three short sentences, with the deprecation warning front-loaded before the purpose and alternatives. Every clause carries useful information: lifecycle status, removal date, replacement tools, and the exact read scope.

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 deprecated, read-only tool with one parameter and rich annotations, the description covers the key decisions: it warns about staleness, names substitutes, and defines the read scope. Return payload details are not supplied, but the annotations and simple schema make this a minor omission rather than a real gap.

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

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

Schema description coverage is 0%, so the description needed to explain entityId, but it only refers indirectly to 'an entity.' The schema gives type and format, but the description adds no practical guidance about what entityId should identify or how to obtain a valid value.

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 canonical facts, aliases, history, and provenance for an entity.' It also distinguishes itself from alternatives by naming discover_daystruct_capabilities and compat_check, so an agent can tell what this tool is for even with the deprecation warning.

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 says 'For building, use discover_daystruct_capabilities and compat_check,' which is a clear exclusion and hands the agent the correct alternatives. It does not provide a positive 'use this when...' statement, but the deprecation context plus the read-purpose sentence make the intended scope reasonably clear.

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 and destructiveHint=false, so the safety profile is covered. The description then adds genuinely new behavioral context beyond the annotations: it does not consume the ready capabilities and does not extend the session TTL, both of which matter for a session-state read.

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

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

A single sentence that front-loads the core action and appends two useful non-side-effect guarantees. It is appropriately tight, though the dense mid-sentence 'or' clause requires some parsing.

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

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

No output schema exists, yet the description never hints at what the returned 'compact task context' contains. For a read-only two-parameter tool this is minimally adequate, but the parameter semantics and return shape are under-specified.

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 carries the burden for two parameters. It only obliquely gestures at the 'next' boolean via 'preview the next ready capabilities' and says nothing about session_id format or the relationship between the parameter and the two stated modes, leaving the mapping ambiguous.

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 verb+resource: 'Read compact task context or preview the next ready capabilities.' This distinguishes it from the create_/close_task_session siblings, which mutate session lifecycle rather than read state. However, the noun phrase 'compact task context' is somewhat vague about what data is actually returned.

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 explicit when-to-use guidance or any mention of alternatives such as create_task_session, close_task_session, or resolve_task_capabilities. The 'next' behavior is described but not framed as a routing condition for selecting this tool over a sibling.

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

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

Annotations already declare readOnly, idempotent, non-destructive, openWorld, so the safety profile is covered. The description adds that the guidance is 'live' (i.e., dynamically sourced), which is mild corroboration of openWorldHint but no new operational detail such as freshness, caching, 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?

A single sentence with no filler; the scope ('for a databank') and timing cue are packed in without redundancy. Slightly jargon-heavy ('Frontier guidance', 'task families') but not 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?

There is no output schema, so the description must convey the return shape; it does indicate that task families and tested models come back, but gives no sense of structure, size, or pagination. For a low-complexity, one-parameter read tool this is adequate but not thorough.

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

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

Schema description coverage is 0% for the single required parameter, so the description carries the burden. 'for a databank' merely restates the parameter name and adds no format, identity, or validity guidance beyond the schema's maxLength/minLength constraints.

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?

Specific verb ('Find') plus concrete resources ('task families and exact tested models') scoped 'for a databank'. It implicitly distinguishes itself from get_daystruct_validated_guidance by positioning itself as the lookup that precedes the guidance request, though it never names that sibling outright.

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?

'before requesting that guidance' gives a real sequencing cue that points at a downstream tool. However, it does not name the alternative tool or state any when-not conditions, leaving the agent to infer the workflow.

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?

The description goes far beyond the annotations (readOnlyHint, idempotentHint, etc.) to explain the semantics of statuses and authorities, how to interpret 'unknown' and null fields, and that exploitation status is never falsely reported from a partial catalog. It also warns about deprecation and the tool not being refreshed. This is comprehensive behavioral disclosure that the annotations alone do not provide.

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 long and front-loaded with the deprecation notice, which is important information that should be prominent. It packs a significant amount of behavioral detail in a structured way, moving from deprecation warning to core function to interpretation rules. It is not overly verbose relative to the complexity it conveys, but it could be more concise by trimming some redundancy (e.g., repeating 'status' explanations). The structure is logical: warning, purpose, and interpretation guidance.

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

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

Given the tool's complexity (returning structured claims with authority semantics, handling unknowns, nulls, and partial catalog behavior), the description covers all necessary aspects: what it returns, how to interpret statuses and authorities, what null means, and the deprecation timeline. The output schema is absent, so the description must explain the return format, and it does sufficiently for an agent to understand the results. The annotations cover safety, so the description doesn't need to repeat them. This is complete for the tool's purpose.

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 has only one parameter 'cve' with minLength 1, and no description in the schema (coverage 0%). The tool description explains that the parameter is a vulnerability identifier such as a CVE, which adds some meaning. However, the schema is minimal and the description doesn't specify expected format (e.g., 'CVE-2024-1234') beyond the example, but since there is only one parameter, the description is sufficient to guide invocation. The baseline for 0 params is 4, but here there is one param, and the description covers it adequately, so 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 clearly states the tool looks up a vulnerability by identifier (e.g., CVE) and returns held evidence about it, including affected package, version range, fix version, severity, and known-exploited status. It distinguishes itself from sibling tools like discover_daystruct_capabilities and compat_check by naming them explicitly as alternatives for building. However, the purpose is slightly muddled by the deprecation notice and the extensive behavioral detail, which could distract from the core function.

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 explicit usage guidance: it is for when you have an identifier rather than a package you are running, and it names specific alternatives (discover_daystruct_capabilities and compat_check) for building use cases. It also warns that the tool is deprecated and will be removed, effectively telling the agent when not to use it. This is strong, clear 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?

Annotations already establish readOnly, idempotent, non-destructive and open-world, and the description usefully goes beyond them: 'Keep source and full snapshots local' discloses a privacy/local-data constraint, 'Caller-reported outcomes are not verified execution' warns that inputs are untrusted, and the exclusion list makes clear it is stateless and non-persisting.

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?

Four short sentences with the capability statement front-loaded and constraints following; no filler. The dense, protocol-flavored vocabulary costs some clarity but nothing is redundant.

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 12-parameter tool with nested objects, a non-trivial enum, and no output schema, an agent needs guidance on what projection data to supply and what 'caller-reported outcomes' implies. The description covers boundaries and one caveat but gives zero parameter-level orientation, leaving a substantial gap.

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

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

Schema description coverage is 0% across 12 parameters (including nested checks/impact/pending objects with enums), so the description carries full burden and largely fails. Only indirect hints exist ('stage-specific' for stage, 'project projection' for the input bundle); goal, needs, stack, checks, impact, pending, hasContext and the revision fields are never explained.

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 clear verb (Get) and resource (stage-specific capability selection and concrete next actions) with the scope 'from a caller-approved project projection'. It does not name or contrast any sibling such as resolve_task_capabilities or get_daystruct_validated_guidance, and terms like 'capability selection' and 'project projection' are invented jargon an agent must infer.

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 'use this when' condition or named alternative is given. The closing exclusions ('does not acquire, execute, store project context or send reminders') do implicitly delimit it from session/event siblings, which is real routing value, but the agent must still infer when to pick this over resolve_task_capabilities.

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

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

Annotations already indicate read-only, idempotent, open-world, non-destructive behavior. The description adds meaningful context beyond these: it does not charge credits, does not check combined compatibility, and that missing entries remain explicit rather than causing failure.

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 compact and front-loaded, with the core action in the first sentence and caveats following. The first sentence is slightly dense and the final sentence is somewhat generic, but no words are wasted.

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

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

Given a single-parameter input, rich annotations, and no output schema, the description provides sufficient context about the result ('a plan with each profile and delivery instructions') and about limitations. It does not fully define 'profile' or 'delivery instructions,' but the domain-specific language is probably adequate for an agent with Daystruct knowledge.

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?

With zero schema description coverage, the description compensates by defining references as 'discovered capability IDs' and by stating the six-item upper bound, which maps to the schema's maxItems. The note about missing entries also clarifies how unresolved IDs are treated.

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 operation: 'Group up to six discovered capability IDs into a plan with each profile and delivery instructions.' It also explicitly contrasts itself with execution and acquisition tools by stating what it does not do, making its purpose distinct from siblings like discover_daystruct_capabilities.

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 'discovered capability IDs' places the tool after discovery, and 'Does not acquire, execute...' gives clear when-not conditions. It does not name an alternative tool explicitly, but the intended workflow is evident from the description.

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

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

Annotations already cover read-only, idempotent, and non-destructive behavior. The description adds important context beyond annotations: the tool is stale ('no longer refreshed'), deprecated, and scheduled for removal. This is valuable behavioral disclosure for an agent deciding whether to rely on the data.

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 short and front-loads the most important information: deprecation and removal date. The final sentence is terse but could be clearer about what the change feed actually contains. No wasted words.

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 deprecated one-parameter read tool, the description covers the essential decision context: it is stale and should not be used for building. However, there is no output schema and the description does not describe the return shape or content of the change feed, leaving some ambiguity for an agent that might still call it.

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%, and the description does not mention the 'limit' parameter at all. The schema provides type, default, minimum, and maximum, so the parameter is self-explanatory, but the description adds no semantic value beyond the schema.

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

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

The description states a specific action ('Read the bounded canonical change feed') and clearly identifies the tool as a deprecated evidence tool. It distinguishes itself from siblings by explicitly naming alternatives (discover_daystruct_capabilities and compat_check), though 'bounded canonical change feed' remains somewhat jargon-heavy.

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 says the tool is deprecated, no longer refreshed, and will be removed, and it directs users to specific alternatives for building. This gives clear when-not-to-use guidance and names the correct 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?

Annotations already declare the safety profile (readOnlyHint=false, idempotentHint=false, openWorldHint=true, destructiveHint=false), so the agent knows this is a non-idempotent write to an open-world store. The description usefully adds that 'usage and outcomes remain client-reported' (unverified self-reported data), but says nothing about accumulation behavior or duplicate request_id handling.

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 purpose front-loaded and zero filler; the client-reported caveat earns its place. It could be slightly more explicit about the event-type mapping.

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 an 8-parameter write tool with 0% schema coverage and no output schema, the definition omits parameter semantics, return behavior, and event accumulation rules. Annotations cover safety but not the operational details an agent needs to 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 parameter burden, and it only enumerates the type values already present in the enum. The other seven parameters (session_id, request_id, capability, current_stage, summary, reported_cost_usd, reported_tool_turns) get no meaning, format, or constraint 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 gives a clear verb ('Report') and resource ('viewed, called, succeeded, failed or skipped capability status, or task stage'), which maps directly onto the type enum values. However, it does not distinguish this tool from siblings like create_task_session or get_task_session, leaving the agent to infer the boundary.

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 use this tool versus alternatives, no prerequisites, and no exclusions. The closing sentence about client-reported data is a provenance caveat, not usage guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the description does not need to repeat safety properties. It adds useful behavioral context: the tool returns a composition plan (not an execution or purchase) and notes that each capability retains its usage terms.

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

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

Three short sentences, front-loaded with the core action and resource. Each sentence adds distinct information: what is read, what is returned, and the retention of usage terms.

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

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

For a single-parameter read tool with rich annotations and no output schema, the description gives sufficient context about the return type and non-execution nature. The only material gap is not explaining the id parameter or the bundle lookup behavior.

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 has one required parameter (id) with 0% description coverage, so the description must compensate. It mentions reading a bundle but never explains what the id parameter identifies, its expected format, or any constraints beyond what the schema already enforces.

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

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

States a specific verb (Read) and resource (bundle) with clear scope: saved, owned, or public bundles with pinned source versions and current member availability. It also distinguishes its output as a composition plan rather than an execution or purchase, which separates it from sibling preparation/execution 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?

The description implies usage by saying it returns a composition plan and not an execution or purchase, but it does not explicitly say when to choose this tool over alternatives like prepare_daystruct_capabilities or discover_daystruct_capabilities. Usage context is implied rather than stated.

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?

Far exceeds the annotations: annotations only say readOnlyHint=false/idempotentHint=false, while the description discloses that the call charges the published resolve price, requires a key with read + requests:write scope, reports chargedCredits and creditsRemaining via data.economics, and that selection never executes or acquires a capability. These are exactly the behavioral traits an agent needs to reason about cost and side effects.

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?

Information-dense and front-loaded, leading with the core action before billing and session details. The semicolon-chained clauses are efficient, though the packing of billing, scope, session, and non-execution guarantees into one block makes it slightly dense to parse.

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?

Covers the critical cost/safety story well (billing, scopes, non-execution) which suits a charged, non-idempotent call, but with 10 parameters at 0% schema coverage and no output schema, the individual parameter contracts for limit, intent, bundle_id, request_id, capabilities, include_repeat, and include_considered remain unexplained.

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 10 parameters, so the description carries the full burden, yet it only clarifies three (delivery modes, maxPriceCredits as a cap, session for memory). Limit, intent, bundle_id, request_id, capabilities, include_repeat, and include_considered are left entirely undocumented in both schema and prose.

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 ('select relevant capabilities') and distinguishes the two modes ('progressively, or request full delivery'). It does not, however, name how it differs from close siblings like discover_daystruct_capabilities or prepare_daystruct_capabilities, leaving the agent to infer the boundary.

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 progressive-vs-full delivery distinction implies a usage context, and maxPriceCredits implies a cost-control context, but there is no explicit when-to-use, when-not-to-use, or named alternative among the ~23 siblings. Usage is inferable but not stated.

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/openWorld, so the safety profile is covered. The description adds genuinely new context beyond that: results are only a shortlist, and finding/saving a capability "does not acquire, execute or grant access to source," clarifying the operation is non-committal.

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 front-loaded sentences with little waste; the core purpose and the non-commitment caveat arrive early. The middle clause ("saving does not acquire, execute or grant access to source") is slightly awkward for a search tool but earns its place by preempting a misunderstanding.

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

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

No output schema exists, so the description should describe returns more fully; it says "small shortlist" but not the result shape. For a 3-param tool with 0% schema coverage it leaves parameter details and result structure thin, though purpose and next-step guidance are present.

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

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

With 0% schema description coverage, the description carries the burden of explaining params. It partially compensates by naming "saved or owned," which maps onto two of the three scope enum values, but leaves "library," limit, and query semantics undocumented.

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

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

The description uses a specific verb ("Search") with a clearly scoped resource ("this account's saved or owned capabilities and bundles"), which helps separate it from a generic catalog. It stops short of naming a sibling like discover_daystruct_capabilities, so the boundary between this and other search/discovery tools must be inferred.

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 implies the workflow (search, then "inspect a selected profile before use") and notes the result is a "small shortlist." However, it never states when to choose this over siblings such as discover_daystruct_capabilities or resolve_daystruct_bundle, so usage is only implied.

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 readOnly, idempotent, and non-destructive behavior. The description adds valuable context beyond those: the tool is deprecated, not refreshed, and has a removal date. This significantly changes how an agent should treat the 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?

Two sentences with no filler. The deprecation warning and removal date are front-loaded, immediately followed by alternatives and then the search purpose. 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 tool with 8 optional parameters, no output schema, and zero schema-level descriptions, the description is not complete enough to invoke correctly. It is strong for steering agents away, but weak on invocation semantics beyond a few filter names.

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 for 8 undocumented parameters. It only names four search dimensions (databank, type, provider, capability) and leaves lane, limit, modelType, and minContextWindow unexplained. It also does not clarify whether filters combine as AND/OR, which is essential for correct invocation.

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 verb and resource: 'Search normalized entities by databank, type, provider, or capability.' It also names two siblings (discover_daystruct_capabilities and compat_check) and labels itself as a deprecated evidence tool, which distinguishes it from building-focused 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?

The description explicitly says the tool is deprecated, no longer refreshed, and will be removed, and it gives concrete alternatives for building: 'use discover_daystruct_capabilities and compat_check.' This is explicit when-not-to-use guidance with named alternatives.

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

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

Annotations already mark it read-only and idempotent, and the description adds crucial behavioral context: deprecation with a removal date, no data refresh, sorting order, price units, and the handling of unpriced models as undetermined rather than excluded. This goes well beyond the structured annotations and does not contradict them.

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 deprecation warning and redirect are front-loaded, followed by compact, meaningful behavior details. Every sentence earns its place, and there is no repetition of schema names 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?

Given no output schema, the description reasonably explains what is returned: candidate models, corroboration, sorting, and the undetermined category. It clearly routes to current alternatives. The main gap is not explaining how limit and provider interact with the results, though their property names give some hint.

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?

With 0% schema description coverage, the description must compensate for missing parameter documentation. It clarifies constraints for minContextWindow, capabilities, and input price limits, and notes prices are per million tokens. However, it does not explain provider or limit, leaving some parameters dependent on their self-explanatory names.

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: return models satisfying user constraints from evidence, sorted by cheapest input price. It distinguishes itself from siblings by explicitly flagging deprecation and naming the replacement tools. The scope and output are clear.

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

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

It explicitly tells users not to use this for building and directs them to discover_daystruct_capabilities and compat_check instead. It also clarifies that this tool returns candidates with evidence, not a recommendation, which helps an agent decide when the tool is or isn't appropriate.

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