Tessryx

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

The description explicitly states that hypothetical mode makes no changes ('nothing is changed — this is a preview'), aligning with the readOnly and destructiveHint annotations. It also details the return findings structure (resource, path, severity, check, message) and the meaning of severity levels, making side effects and output fully transparent.

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 somewhat verbose, repeating concepts like 'deployability' and 'what would break' across sentences. However, each sentence adds necessary detail about severity, hypothetical behavior, and special cases, so the length is justified for the complexity. It could be trimmed slightly without losing essential 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?

Given the tool's complexity and the presence of an output schema (though not shown), the description covers all necessary context: what the tool returns, how to interpret severities, how to use hypothetical mode, and the special behavior for non-root subjects. It is complete enough for an agent to decide when and how to 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?

Although the schema already provides 100% coverage of parameter descriptions, the tool description enriches them with practical semantics: it explains version suffixes, bare slug meaning, and what hypothetical values accomplish. This goes beyond the schema by giving real-world usage context and examples, so agents can correctly formulate parameter 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?

The description clearly states the tool's purpose: to check whether a resource and its dependencies are sound for deployment. It specifies the action (analyze) and the resource, and distinguishes itself by focusing on deployability and hypothetical previews, which is not covered by sibling tools like get_resource_graph or validate_workflow.

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

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

It gives explicit guidance on when to use the hypothetical parameter: run it before a delete or publish. It explains what each hypothetical value does ('delete', 'unpublish', 'publish') and clarifies the typical subject (an app) and edge cases (non-root subjects), leaving little ambiguity for the agent.

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 indicate this is a non-idempotent, non-read-only operation, and the description adds meaningful side-effect context by explaining that it mints the template and its version 1, and that publish=true publishes in the same step while omission leaves it as an unpublished draft. This is transparent beyond the annotations, though it does not explicitly warn that the operation is non-idempotent.

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 four sentences and contains no fluff, with the primary purpose front-loaded. The extra guidance on fetch/iterate/publish is useful but keeps it slightly longer than strictly necessary. Structure is clear and each 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 covers purpose, workflow, publish behavior, and alternative tools, giving an agent enough context to use the tool correctly. Since an output schema exists, no return-value explanation is needed. It could have explicitly mentioned that this is a create operation for new templates only, but the 'BRAND-NEW' wording and contrast with create_api_template_version already convey that.

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

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

Schema coverage is 100% with already rich descriptions, so the baseline is 3. The overall description adds tool-level context (e.g., referencing get_api_template_definition_schema and the publish flow) that slightly supplements parameter understanding, but most parameter meaning already lives in the schema. The plus is that description clarifies the definition param's validation source, which is also present in the schema, so the net added value is modest.

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: 'create a BRAND-NEW api template (mints the template + its version 1)', which clearly distinguishes it from sibling tools like create_api_template_version and update_api_template. The explicit pointer to create_api_template_version for adding versions to existing templates removes ambiguity.

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

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

The description gives concrete workflow guidance: fetch the schema with get_api_template_definition_schema, author against it, iterate with execute_api_template, and optionally pass publish=true to publish in the same step. It also directs users to the alternative tool for adding versions to existing templates, covering when this tool should and should not be used.

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 clearly conveys that it creates a new version and optionally publishes it, and the annotations already indicate no destructive or read-only behavior. It doesn't explicitly repeat idempotency, but the annotation handles that. Overall it is transparent about the main side effect.

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 concise, well-structured, and front-loads the core purpose. It uses clear, direct language without redundancy or irrelevant details.

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 that an output schema exists and sibling tools are available, the description supplies enough context to use the tool correctly. It references the schema source, explains the publish behavior, and distinguishes from create_api_template, covering all necessary usage aspects.

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?

All three parameters are fully described in the schema, and the main description adds valuable context for definition (how to author it) and publish (what true means). This goes beyond the baseline but does not drastically expand on 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 states the tool's function: adding a new version to an existing API template. It distinguishes this from creating a brand-new template via the explicit note 'For a brand-new api template, use create_api_template.'

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 provides explicit guidance on when to use this tool (existing templates only), how to author the definition using get_api_template_definition_schema, and the optional publish flag with its effect. It also names the alternative for new templates.

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

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

Beyond the annotations, the description discloses real side effects: the call mints both the app and version 1, publish=true triggers immediate publication, and an empty definition is a valid draft but publishing requires a membership that selects something. The emphasis on creating a BRAND-NEW app, combined with idempotentHint=false, implies each invocation produces a fresh app, which is consistent with 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?

The description front-loads the core purpose and then orients the reader through the workflow, which is appropriate for a complex authoring tool with a large sibling set. There is some redundancy (the folder-prefix and membership-selector ideas are restated), but the density of useful guidance justifies the length.

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 (5 parameters, nested object, large sibling set, draft-vs-publish semantics), the description covers the key operational questions: what it creates, when to use it vs create_app_version, how to author the definition, and the publish behavior. An output schema exists, so return values need not be explained, and nothing critical is left ambiguous for a first-time caller.

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 descriptions are already rich (slug as folder prefix, publish behavior, definition validated against a fetched schema), so the baseline is 3. The description adds some context — slug as the prefix under which member resources are authored and definition as the membership selector — but most parameter meaning is already carried by the schema, so no higher score is warranted.

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 ('create a BRAND-NEW app') and clarifies the dual effect ('mints the app + its version 1'). It explicitly distinguishes itself from create_app_version ('To add a version to an existing app, use create_app_version'), which is the closest sibling, and names the workflow context ('Start here when building a page or an API bundle').

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 explicit when-to-use guidance: 'Start here when building a page or an API bundle', and points to the alternative tool for the adjacent case ('To add a version to an existing app, use create_app_version'). It also provides concrete usage direction for the publish flag ('Pass publish=true to publish v1 immediately') and for authoring ('fetch its JSON Schema with get_app_definition_schema and author against it').

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

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

Beyond the annotations (readOnlyHint=false, idempotentHint=false, destructiveHint=false), the description adds meaningful behavioral details: it creates a new non-destructive version, defaults to an unpublished draft unless publish=true is passed, and notes that the owning service validates the definition on submit. No contradictions with 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?

The description is concise and front-loaded. It states the core action in the first sentence, adds the crucial constraint (EXISTING app), provides the schema reference, and ends with the optional publish behavior and the explicit alternative. Every sentence serves a purpose with no fluff.

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 rich parameter descriptions and the existence of an output schema, the description is complete. It covers the tool's scope, the required schema-fetch step, the publish option with default behavior, and the alternative for new apps. No critical usage context 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% with each parameter already well explained (app_id, publish, definition). The main description enriches understanding by linking the definition parameter to 'membership selector (prefix rules, includes/excludes) or display', which clarifies the purpose of the definition object beyond the schema text. This adds value without being redundant.

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: 'add a new version to an EXISTING app' with specific use cases (membership selector, display). It explicitly distinguishes from the sibling tool create_app by adding '(For a brand-new app, use create_app.)', leaving no ambiguity about when this tool is appropriate.

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

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

The description provides explicit when-to-use guidance: it is for existing apps, and the parenthetical directs users to create_app for brand-new apps. It also instructs users to author the definition against the schema from get_app_definition_schema. However, it does not explicitly contrast with update_app or explain when to use publish_app separately after leaving the version as a draft, though the publish parameter description implies the alternative.

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

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

Goes beyond annotations by explaining that the claim alone grants nothing until ownership is proven, and that it returns DNS records for verification. This contextualizes the non-idempotent and non-read-only nature without contradicting 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?

The description is slightly verbose but every sentence carries essential information: purpose, consequence, workflow, and parameter timing. It is well-structured and free of fluff, though the multi-clause sentences could be tightened.

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 workflow (claim, present records, verify) and references update_custom_domain for later configuration. It does not detail the output schema shape beyond dns_records, but that is provided separately, so the context is sufficient.

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 covers all 4 parameters with detailed descriptions, so the baseline is 3. The description adds value by noting that slug_prefix and root_endpoint are typically set later, which clarifies their optional usage in this specific call.

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?

Clearly states the action (claim a custom hostname and generate DNS challenge) and differentiates from related tools like verify_custom_domain and update_custom_domain. It specifies the primary output (two DNS records) and the provisional nature of the claim.

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 instructs to present DNS records to the human, wait for them to be added, and then call verify_custom_domain. Also notes that slug_prefix/root_endpoint are usually set later with update_custom_domain, providing clear guidance on when to use 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 cover read-only, destructive, idempotent, and open-world behavior. The description adds behavioral detail beyond annotations: property order preservation, mandatory schema binding, and that creation does not auto-publish. Doesn't state duplicate-slug behavior, but that's beyond typical expectations.

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 sentences, front-loaded with the purpose. Sentence 2 is slightly dense with the human-editor detail, but each sentence earns its place; no redundancy 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?

Output schema covers return values and annotations cover safety, so the description only needs lifecycle context, which it provides (create → schema prerequisite → publish). Not explicitly covering duplicate-slug errors is acceptable given annotation and output-schema coverage.

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 per rubric the baseline is 3. The description reinforces schema_id in prose but adds no per-parameter detail beyond the schema; the schema descriptions are thorough (e.g., use_latest_schema explains draft vs published version).

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 (Create) with resource (datafile) and content (JSON object). Distinguishes from sibling tools like publish_datafile and create_schema by noting the schema prerequisite and the separate publish step. The purpose is unmistakable.

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?

Provides explicit pre-requisite guidance (author or pick a schema with schema tools first) and post-action guidance (publish with publish_datafile to serve from the CDN). Implicitly distinguishes from update_datafile/patch_datafile via 'Create a new'; could contrast explicitly but is largely 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 establish non-read-only, non-idempotent, and non-destructive behavior, so the bar is lower. The description adds useful side effects: it mints the endpoint plus version 1 and optionally publishes immediately. It does not mention auth/rate limits, but those are not essential given 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?

The description is dense but every sentence carries distinct guidance: creation action, schema reference, publish behavior, and sibling tool distinction. No filler or redundant wording.

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

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

Covers the creation workflow, schema acquisition, publish behavior, and sibling tool distinction. Since an output schema exists, return-value details need not be described in the description field. The description is complete for successful 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?

All parameters have schema descriptions, and the description adds substantial meaning beyond them: slug path-parameter routing, input_transform pairing, 404 behavior, content_type authority, and publish default. This goes well beyond the baseline for fully covered schemas.

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 ('create'), resource ('dynamic endpoint'), and clearly distinguishes from create_dynamic_endpoint_version with an explicit sibling reference. Makes clear this tool is for brand-new endpoints, not for adding versions to existing ones.

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 directs when to use create_dynamic_endpoint_version for existing endpoints and explains the publish=true create-then-publish path versus publishing later. Also points to get_dynamic_endpoint_definition_schema for authoring the definition.

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 clarifies that the tool creates a version and optionally publishes it immediately, consistent with readOnlyHint=false. It does not imply destructive or idempotent behavior, aligning with the annotations. The side effects are described sufficiently for an agent to understand the operation's impact.

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 moderately concise, though it repeats 'dynamic endpoint' several times. It uses parentheses for the exception and provides clear stepwise guidance. The structure is logical and easy to parse, though it could be slightly tightened.

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 nested definition object and presence of an output schema, the description covers the key aspects: target, definition authoring, and publishing. It does not detail version numbering or error handling, but these are not essential for basic usage. The sibling tools provide additional context, making the description complete enough.

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?

All three parameters are fully described in the schema, with the description adding extra context for definition (author against schema, validation on submit) and publish (defaults to false). The endpoint_id parameter is clearly defined as the target identifier. This fully covers parameter meanings.

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 adds a new version to an existing dynamic endpoint identified by endpoint_id. It explicitly distinguishes this from creating a brand-new endpoint by referencing create_dynamic_endpoint, making the purpose 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 provides clear guidance on when to use this tool (for existing endpoints) and when to use the alternative (for new endpoints). It also instructs to author the definition against the schema from get_dynamic_endpoint_definition_schema and explains the publish parameter, giving practical usage context.

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

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

The description transparently discloses the creation action, the optional immediate publication, and validation by the owning service. It aligns with the readOnlyHint=false, destructiveHint=false, and idempotentHint=false annotations and adds context about the workflow definition and $input binding.

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 well-organized, using parentheticals to separate key details (e.g., workflow reference, recurrence, publish behavior). No redundant or filler content; every sentence adds functional 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 the tool's complexity (nested object, multiple related tools), the description is fully self-contained. It explains how to author the definition, how to handle publication, and how it differs from sibling tools like create_schedule_version and publish_schedule, leaving no significant gap for a caller.

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?

Every parameter is described in detail, including the nested 'definition' object which explicitly instructs fetching the JSON Schema via get_schedule_definition_schema. The 'publish' parameter's default and behavior are clearly stated, and the schema covers all five 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 clearly states it creates a brand-new schedule (mints schedule and version 1) and contrasts it with create_schedule_version for adding versions to existing schedules. The specific verb 'create' and resource 'schedule' are 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?

Explicitly directs when to use this tool versus create_schedule_version ('To add a version to a schedule that already exists, use create_schedule_version') and explains the publish parameter for one-step activation versus using publish_schedule later.

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 aligns with the annotations (readOnlyHint=false, destructiveHint=false) and adds clarity about the draft/publish semantics. It does not contradict any annotation, but it could be more explicit about side effects like whether the previous version remains intact. However, given that it is a versioning operation, the behavior is reasonably well conveyed.

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, tightly packed with relevant information, and front-loaded with the core purpose. It avoids redundant detail and uses a clear structure that separates the primary action from the publish option and the alternative tool for new schedules.

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 is self-contained for its intended use. It references the related definition-schema tool and the alternative create_schedule tool, providing enough context for an agent to understand the workflow. The output schema is not described, but that is not necessary for successful invocation, and the description fully covers the calling conventions.

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 of all three parameters, so the description does not need to repeat them. It adds value by directing the agent to fetch the definition schema from get_schedule_definition_schema to author the 'definition' parameter correctly, which goes beyond the schema's static description.

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 action (add a new version), the target resource (an existing schedule), and explicitly differentiates from creating a brand-new schedule by pointing to create_schedule. This precise scoping makes it easy for an agent to select this tool over siblings like create_schedule or update_schedule.

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 provides explicit guidance on when to use this tool (only for existing schedules) and when not to (use create_schedule for new ones). It also explains the publish parameter's effect ('Pass publish=true to activate this version immediately'), giving the agent clear instructions on how to invoke it in different scenarios.

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?

Explicitly states behavior: mints schema + version 1, preserves property order, defaults to unpublished draft, and publish=true publishes immediately. Also notes datafiles validate against json_schema. No contradictions with 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?

Well-structured and concise despite covering multiple nuances. Two main sentences plus a parenthetical alternative. No redundant content; 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?

Complete for the context: covers purpose, usage, parameters, and alternatives. Output schema is indicated as present, so no need to describe return values. All relevant operational details are included.

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?

Adds significant meaning beyond the schema's field descriptions: explains json_schema role, property order preservation, x-tessryx-ui hints, and publish parameter's one-step convenience. The schema already covers basic descriptions, but this enhances understanding.

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?

Clear purpose: creates a brand-new schema and its version 1. Explicitly distinguishes from create_schema_version and mentions publishing in the same step. No ambiguity.

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

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

Provides strong guidance: when to use vs create_schema_version, how to publish immediately, and instructs to get_guide for UI hints. Clarifies property order importance and x-tessryx-ui needs.

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 indicate readOnlyHint=false (write) and destructiveHint=false, so the description doesn't contradict them. It adds valuable behavior beyond annotations: property order preservation and the need for x-tessryx-ui hints for certain types. It doesn't disclose side effects or reversibility, but for a versioning tool that's acceptable given the annotation coverage.

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

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

Three sentences, each earning its place: purpose, a critical behavioral note, and usage routing. It is front-loaded with the primary action and tightly packed without fluff.

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 (nested json_schema, publish logic), the description covers when to use, key behavioral constraints, and alternatives. It does not detail the return value, but the presence of an output schema covers that. It's sufficiently complete for an agent 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 description coverage is 100%, so baseline is 3. The description adds context beyond the schema: it explains property order impacts the editor, mentions the publish parameter's effect, and directs to get_guide for hints. This adds meaning to the parameters, justifying a 4.

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 adds a new version to an existing schema, using a specific verb and resource, and distinguishes it from create_schema for brand-new schemas. It also specifies the key action (evolve) and differentiates from update_schema implicitly by focusing on versioning.

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 tells when to use this tool ('to evolve a schema you already created') and when not to ('For a brand-new schema, use create_schema'). It also mentions publish_schema as an alternative for publishing, and get_guide for hints, providing clear routing among 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?

Beyond the annotations (readOnlyHint=false, destructiveHint=false), the description discloses critical behaviors: static validation before write (on error-severity findings nothing is minted, valid=false, created=false, findings returned), advisory findings on success, and the publish flag effect. It also mentions the return shape of the workflow itself, adding context not captured by annotations. No contradiction with 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 every sentence carries purpose. It front-loads the core purpose, then explains composition, validation, advisory findings, and the publish option, and ends with the sibling alternative. No redundancy or filler; it is efficiently structured for an agent 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?

Given the tool's complexity (5 params, nested objects, output schema present), the description covers all essentials: what it does, how to author the definition, validation behavior, publish option, and when to use the alternative. The output schema is provided separately, so return value details are not required. The description is complete for correct invocation.

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

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

Schema coverage is 100%, so all parameters are documented in the schema. The description adds value by instructing to fetch the JSON Schema for the definition and author against it, and by explaining the publish parameter's default and effect. It also clarifies that the definition is the JSON object to be validated. These additions go beyond the schema, though not extensively, so a 4 is appropriate.

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

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

The description states a specific verb and resource ('create a BRAND-NEW workflow (mints the workflow + its version 1)') and differentiates from siblings by explicitly naming create_workflow_version for existing workflows. It also explains the composition model (blocks over $input returning {content_type, output}), so an agent understands exactly what the tool does and how it differs from update or patch 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?

Provides explicit when-to-use guidance: it's for brand-new workflows only, and the last sentence directs to create_workflow_version for adding versions to existing workflows. It also explains that validation is built-in, so no separate validate_workflow pass is needed, and describes the publish=true option for one-step creation and publishing. This leaves no ambiguity about selection among 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?

Beyond the annotations (readOnlyHint=false, destructiveHint=false), the description discloses validation-before-write behavior, that error-severity findings result in valid=false and created=false, and that successful writes return advisory findings. This adds significant context about the tool's execution and side effects, fully compensating for the absence of such detail 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 a single paragraph but efficiently front-loads the core purpose and then adds essential details on validation, publishing, and alternatives. Every sentence adds value, though it is slightly long; it avoids redundancy and remains well-structured.

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 complexity (nested objects, output schema exists, three parameters), the description is complete. It covers the primary use case, validation semantics, publish behavior, and points to the definition schema. The return structure is covered by the output schema, so nothing critical 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?

The schema already covers all parameters with 100% coverage, so the baseline is 3. The description adds valuable guidance for the 'definition' parameter: 'Fetch the exact JSON Schema it must satisfy with get_workflow_definition_schema and author against it (or copy an existing one with the get_*_version tool).' This goes beyond the schema's bare description and helps the agent use the parameter correctly.

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: 'add a new version to an EXISTING workflow (by workflow_id) to evolve a workflow you already created.' It uses a specific verb and resource, and explicitly distinguishes itself from create_workflow for brand-new workflows, making its scope 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?

It provides explicit usage context: author against the schema from get_workflow_definition_schema, use for existing workflows, and explicitly says 'For a brand-new workflow, use create_workflow.' It also explains the publish option and how to publish later with publish_workflow, offering clear alternatives and conditions.

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

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

Goes beyond the destructiveHint annotation by specifying that deletion is permanent, affects all versions, and causes referencing workflow calls to fail cleanly. This provides clear side-effect information.

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 cover the action, scope, and key consequence. No redundant information or verbose phrasing.

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 delete operation, the description is complete: it states what is deleted, that it is irreversible, and the impact on dependent workflows. No missing information is needed 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?

The only parameter, template_id, is described in the schema itself as 'the api template id to delete'. The description adds no additional semantic detail beyond the schema, so it meets the baseline.

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 action (delete), the resource (api template), and the scope (all its versions). It distinguishes from other delete_* tools by explicitly naming 'api template' and highlighting the permanent nature.

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

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

Usage is implied by the verb 'delete' and the resource. It warns about the consequence (workflow calls fail), which helps decide when to use this tool over other operations like update or unpublish, though alternatives are not explicitly 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?

The description goes beyond the destructiveHint annotation by explaining the permanent nature, the deletion of all versions, and the fact that member resources are untouched. This gives users a precise understanding of the operation's 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?

The description is concise and well-structured, consisting of short, direct sentences. Every sentence adds important information without unnecessary fluff.

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 simple schema and destructive nature, the description covers all necessary context: what is deleted, what is not affected, the irreversibility, and the alternative action. No important information 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?

The schema already describes app_id as 'the app id to delete permanently', so the parameter is clear. The description adds useful context about scope and side effects, though it does not significantly alter the parameter meaning itself.

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 action is to permanently delete an app and all its versions. It also distinguishes this from unpublish_app, which merely hides the app. The resource and scope are 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 that the operation cannot be undone and clarifies that only the app is deleted while member resources remain. It also directs users to unpublish_app when the intent is to hide rather than delete, providing clear 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?

The description goes well beyond the annotations by explaining that published datafiles are first unpublished from the CDN, that deletion is irreversible, and that referencing items become dangling and degrade. This matches the destructiveHint and idempotentHint annotations with no contradiction.

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 concise and front-loaded with the primary action, followed by essential caveats. Every sentence adds meaningful information without unnecessary verbosity.

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 single-parameter destructive operation, the description covers the action, the side effect on CDN publishing, irreversibility, and downstream impact. Nothing critical 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?

The schema already fully describes the single datafile_id parameter at 100% coverage. The description adds no additional parameter-level meaning beyond what the schema and tool name already convey.

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 action ('Permanently delete') and a specific resource ('datafile'), distinguishing it from other datafile operations like get, list, patch, publish, and unpublish.

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 clearly communicates that this tool is for permanent deletion and includes critical side-effect warnings. It does not explicitly contrast with update/patch alternatives, but the destructive framing makes the use case unambiguous.

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

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

Beyond the annotations (destructiveHint=true), the description discloses specific side effects: the server purges the public URL, the resource is removed entirely, and it will no longer appear in listings. This is more detailed than the annotation 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 two sentences, tightly packed with essential information: the action, the side effect, the contrast with unpublish, and the irreversibility. No unnecessary 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?

The description covers the key caveats (purges URL, removes from listing, irreversible) and differentiates from the similar unpublish operation. Since there is no output schema, no return-value details are needed. The context for using this tool is fully addressed.

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 endpoint_id as 'the endpoint id to delete,' which is clear and sufficient for a simple identifier. The description doesn't add extra detail, but given the high schema coverage, the parameter is well understood.

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 action: 'Permanently delete a dynamic endpoint' with a specific verb and resource. It also distinguishes itself from the sibling 'unpublish' by explaining the difference, making its purpose 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?

It explicitly contrasts with unpublish: 'Unlike unpublish, this removes the resource entirely — it no longer appears in list_dynamic_endpoints.' This guidance helps the agent choose between delete and unpublish. It also warns 'Cannot be undone,' which is critical for a destructive operation.

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

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

Annotations already signal destructiveHint: true, and the description adds specificity: it mentions deletion of versions and run history and that it cannot be undone. This provides additional behavioral context beyond the annotation, though it does not cover auth or rate limits, which are not essential here.

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 with no filler. The first sentence states the core action and scope, the second provides the alternative. Information 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 one-parameter destructive tool with an output schema and annotations covering destructiveness, the description provides all necessary context: what it does, what it affects, and when to use the alternative. Nothing critical 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?

The schema covers the single parameter (schedule_id) with a clear description, and schema_description_coverage is 100%. The tool description does not add extra semantics beyond the schema, but the schema itself is sufficient. 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 clearly states a specific verb ('Permanently delete'), resource ('schedule'), and scope ('all its versions and run history'). It also distinguishes itself from the sibling tool unpublish_schedule, making the purpose 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?

Explicitly states when to use the alternative: 'To simply stop it firing without deleting, use unpublish_schedule.' This provides clear guidance on when this tool is appropriate versus not, and names the alternative directly.

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 destructiveHint annotation, the description explicitly warns that deletion cannot be undone and explains the impact on bound datafiles/workflows, which is valuable behavioral disclosure.

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, with two sentences conveying scope, irreversibility, and side effects. No redundant or irrelevant content.

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

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

For a simple one-parameter destructive operation, the description is complete: it states what is deleted, the irreversibility, and the effect on dependent resources. No additional information is necessary.

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 fully describes the single required parameter schema_id, and the description does not need to add much. The description's mention of deleting all versions adds context but is not required for parameter understanding.

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?

Clearly states the tool permanently deletes a schema and all its versions, a specific action on a specific resource. It is easily distinguished from other delete_* sibling tools by resource type.

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?

Description gives strong guidance on consequences (permanent, cannot be undone, dangling references). It does not explicitly name alternatives, but the context of sibling tools makes the usage 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 mark destructiveHint=true, but the description adds valuable context: permanence, deletion of all versions, and that endpoints/sub_workflow references will 'fail cleanly at run/serve time.' This goes beyond the annotation and informs the agent of side effects, without contradicting the destructive flag.

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. It front-loads the core action ('Permanently delete a workflow and all its versions') and immediately follows with the critical consequence ('Cannot be undone'). Every phrase earns its place; it is appropriately concise.

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

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

For a simple one-parameter delete operation with an output schema, the description covers the primary effect, permanence, and behavior of dependent references. It does not mention authentication or ownership requirements, but those are not essential for invoking the tool correctly. The output schema covers return values, so this is sufficiently 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?

The input schema has 100% coverage for workflow_id with 'the workflow id to delete.' The description does not add additional meaning about the parameter (e.g., format, validation, or how it relates to versions). With full schema coverage, the baseline of 3 applies; the description adds no extra value here.

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: 'Permanently delete a workflow and all its versions.' It specifies the scope (all versions) and the irreversible nature, which distinguishes it from other delete tools (e.g., delete_schema) by focusing on workflows. The purpose is unambiguous and does not rely on the title alone.

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

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

The description implies usage (when you want to remove a workflow permanently) but does not explicitly state when to use this tool versus alternatives like update_workflow or unpublish_workflow. It gives consequences for references but no explicit exclusions or alternative routing. This is implied guidance, not explicit.

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 explicitly states that this runs the real outbound request, which is a key behavioral detail given readOnlyHint=false. It also describes the return format (full trace). It does not mention potential side effects or rate limits, but the core side effect (executing a real request) is clearly disclosed.

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

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

The description is concise (two sentences) and well-structured. It first states the action and output, then provides the use case and an important caveat (real request). No redundant or vague language.

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 essential aspects: what the tool does, its primary use case, and a key behavioral note (live execution). Since an output schema is present, it does not need to enumerate response fields. It could mention how to handle cases where both slug and template_id are provided, but that is a minor omission given the schema already explains the 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?

Each parameter has a clear description in the schema, including the alternative relationship between 'slug' and 'template_id' ('provide this or template_id') and the optional nature of 'version'. The 'variables' parameter is explained as values bound to template variables. Schema coverage is 100%, so no ambiguity remains.

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 function: execute an API template live and return the full trace of request and response. It also identifies the specific use case (debugging before wiring into a workflow) and differentiates from other tools by focusing on API templates and real execution.

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 a clear 'when to use' scenario ('debug a template before wiring it into a workflow') and implies when not to use (after wiring, use a workflow). It could be more explicit about alternatives like preview_dynamic_endpoint, but the guidance is adequate for selecting this 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?

Discloses the important version-selection behavior: returns the published version if any, otherwise the latest. Annotations already cover read-only/idempotent safety, and the description adds meaningful retrieval semantics without contradicting 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?

Two concise sentences with no redundant wording. Key distinctions and version behavior are front-loaded and easy 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 core purpose, the version behavior, and the alternative for older versions. Since output schema is present and annotations cover safety, the description is sufficient for correct use, though it could mention that at least one of slug or template_id should be supplied.

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 both parameters and their mutual exclusivity ('provide this or template_id'). The description adds little beyond the schema, but the version-selection behavior gives some extra context for how the selected template is resolved.

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

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

States a specific verb ('get') and resource ('api template'), and clarifies it returns a single template with its current definition body. It distinguishes itself from get_api_template_version for older versions and from list_api_templates by the word 'single'.

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 directs users to get_api_template_version for reading a specific older version, which is a clear when-to-use alternative. It does not explicitly mention list_api_templates for listing, but 'single' plus 'current version' makes the primary use case unambiguous.

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 readOnly and idempotent behavior. The description does not add further details about return format or side effects, but for a simple getter this is acceptable.

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 concise, consisting of two sentences with no redundant information, and the key usage guidance 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 parameterless getter, the description fully explains the purpose and when to invoke it, leaving no ambiguity for the agent.

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 no parameters, so schema coverage is effectively 100%. The description correctly omits parameter details, meeting the baseline for high 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 clearly states the tool retrieves the JSON Schema that an API template definition must satisfy, and it is distinguished from similar definition schema getters by explicitly referencing the create operations (create_api_template / create_api_template_version).

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?

Provides explicit guidance on when to use the tool ('Fetch this before authoring the definition'), making the intended usage unambiguous.

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 explains the exact return structure (definition body as JSON string plus checksum) and the optional version behavior. Combined with annotations indicating read-only, idempotent, and non-destructive, the tool's behavior is fully transparent without any contradictions.

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 concise, using two sentences to convey the purpose, key parameters, and return format without unnecessary detail. It is well-structured and front-loads the primary action.

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 is complete for a read operation, covering what is returned, how parameters affect the result, and the optional version default. The presence of an output schema supplements the description, but the description itself is sufficient for an agent to understand the tool's context and usage.

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 description covers 100% of parameters, and the description text further clarifies semantics: 'by slug or id' for slug/template_id and 'Omit version to get the latest version' for version. This adds meaning beyond field names and numeric 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?

The description clearly states the tool reads back the full stored definition of an api template version, distinguishing it from sibling tools like get_api_template (which likely retrieves the template itself) and get_api_template_definition_schema (which retrieves the schema). It specifies the key parameters (slug or id) and the behavior of omitting version.

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 usage context by explaining the return format (JSON string for diffing/patching) and that omitting version fetches the latest. However, it does not explicitly compare with alternatives or state when to prefer this over get_api_template or get_api_template_definition_schema, which could be inferred but is not explicit.

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 and idempotent traits; description adds context about the published_manifest content and its absence when unpublished, which is useful behavioral detail beyond annotations.

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

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

Three sentences, no fluff, front-loads the purpose and then adds necessary distinctions, making it well-structured and concise.

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 output schema exists, the description adequately covers the key aspects: what is returned (metadata + published_manifest), when it is absent, and when to use the alternative tool. No significant 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 descriptions already explain slug and app_id as alternatives. The description mentions 'by slug or id' but adds no significant semantic detail beyond the schema, so 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?

Clearly states it gets a single app by slug or id, and explicitly distinguishes it from get_app_version by noting it returns metadata plus published_manifest, while get_app_version is for raw definition body.

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?

Provides explicit guidance on when to use this tool vs get_app_version (when you need the published manifest vs raw definition body), and notes that published_manifest is absent when unpublished.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds no additional behavioral traits beyond the safe read nature; it focuses on purpose and content rather than side effects or limitations.

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 long, front-loads the primary purpose, and packs useful detail (membership selector, display metadata) without verbosity.

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 lacking an output schema, the description fully explains what the returned schema contains and when to use the tool, making it contextually complete for an agent.

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 schema coverage is complete by default. The baseline for 0 parameters is 4, and the description does not need to elaborate on parameter behavior.

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 retrieves the JSON Schema for an app definition, including the membership selector and display metadata, and naturally distinguishes itself from other definition schema tools by specifying 'app'.

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 instructs to 'Fetch this before authoring the definition for create_app / create_app_version', providing a clear when-to-use directive and differentiating from related create/update operations.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds valuable behavioral context beyond that: it explains that members are a live lens, that version resolution defaults to published but can preview drafts, and that summarized kinds are omitted from members with a members_complete flag. It also clarifies the union formula. No contradiction with 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 relatively long (~200 words) but every sentence addresses a necessary aspect: core purpose, resolution logic, summarization behavior, alternatives, and usage guidance. It is front-loaded with the primary action and well-structured. While it could be tightened, the length is justified by the tool's 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?

Given the output schema exists (which would document return fields), the description still covers essential behavioral details: the union formula, summarized kind handling, members_complete flag, and version resolution. It also provides guidance on alternatives and when to use this tool. Nothing an agent needs to invoke it correctly appears missing.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description adds no new parameter-specific meaning beyond what the schema provides (e.g., the version behavior is already in the schema). It does add context about summarized kinds, but that is output behavior, not parameter semantics. Per the baseline for high coverage, a score of 3 is appropriate.

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

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

The description clearly identifies the tool as resolving an app's live member set and specifies the exact output structure ({kind, slug, display_name}). It explicitly contrasts with other tools (e.g., get_app, list_datafiles) by explaining this is a resolved view based on rules, not a stored list. The purpose is unambiguous and distinct from 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?

It states precisely when to use the tool: 'Use this to see or verify what an app contains.' It also gives explicit guidance for summarized kinds, directing the agent to call the kind's own list tool with a slug_prefix, and notes this tool never pages a whole collection. This provides clear alternatives and exclusion 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?

The description confirms the read-only nature by saying 'Read back' and 'Returns', consistent with the readOnlyHint annotation. It adds details about returning the authored JSON string and checksum, providing transparency beyond 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?

The description is concise, starting with the primary action and then providing key details and the comparison with get_app. No redundant information, well-organized.

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 that there is no output schema, the description explains what is returned: the exact definition body as a JSON string and checksum. It also indicates the editing view and the alternative, making it complete for an agent's decision.

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 parameter descriptions in the schema already cover the meaning and optionality of slug, app_id, and version. The tool description does not add new information about parameters, so it relies on the schema's 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 'Read back the full stored definition of an app version by slug or id' and explains the return value, distinguishing it from get_app. This makes the tool's purpose 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?

It explicitly contrasts with get_app: 'This is the EDITING view; get_app returns the typed published manifest for reading.' It also instructs on omitting version to get the latest, guiding when to use this 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?

Annotations already declare readOnly/idempotent/non-destructive behavior; the description adds that only published assets are returned and that the call can confirm existence. No contradictions with 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 with no fluff: states the operation, key output fields, and a concrete use case. Information is front-loaded and easy to scan.

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 lookup-by-identifier tool, the description provides enough context to use it correctly: target, identifier options, and purpose. The output schema exists, so detailed return fields are not required in the description.

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

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

Both parameters have descriptions and the description makes clear they are alternative lookup keys. However, the schema does not enforce one-of/either-or, and no format or validation details are provided, so the description adds little 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?

Clearly specifies the action ('Get'), target ('single published asset'), and key result ('including absolute CDN URL, content type, and size'). The 'single' qualifier distinguishes it from list-type siblings such as list_assets.

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 when to use the tool: to confirm an asset exists and fetch a URL to embed. It does not mention alternatives or state when not to use it, so it falls just short of full 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?

The annotations already indicate readOnlyHint and idempotentHint, so the description adds limited behavioral detail beyond the 'get' verb and what fields are returned. No contradiction with 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?

Concise two-sentence description that front-loads the purpose, lists the returned data, and closes with a practical use case. No redundant 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?

Sufficient for a caller to understand what the tool does and when to use it. It does not specify exact status values or response format, but these are not necessary for invoking the tool 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?

The single parameter hostname is described with an example in both the schema and the description, making its meaning fully clear. The description adds context but the schema already provides adequate semantics.

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?

Clearly states it gets a single custom domain by hostname and lists the specific information returned (lifecycle status, DNS records, routing, messages), distinguishing it from list_custom_domains and other related 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?

Explicitly provides use cases: answering 'is my domain live yet?' and re-displaying DNS records for a pending domain. Does not explicitly mention when not to use, but the specific guidance is 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, so the description does not need to repeat these. It adds value by specifying the response includes JSON content and the last published CDN path, which is beyond the schema and annotations. No contradictions.

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 fluff. It states the verb and resource first, then the specific return details. Every word contributes.

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 get-by-identifier tool with an output schema and full annotation coverage, the description is complete. It conveys the essential purpose and return content, and the schema covers parameter requirements.

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

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

Schema description coverage is 100%, and both parameters are well documented in the schema with 'provide this or the other' semantics. The description's 'by slug or id' adds no new meaning beyond the schema, 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 states a specific verb ('Get'), a resource ('single datafile'), and the distinguishing detail that it returns JSON content and the CDN path. This clearly differentiates it from list_datafiles and other datafile operations.

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 makes the context clear (fetching a single datafile) but does not explicitly mention alternatives or exclusions. An agent can infer when to use it, but it lacks explicit guidance like 'for multiple datafiles, use list_datafiles'.

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, covering the safety profile. The description adds the version selection logic (published if any, else latest) and specifies the return payload (public URL and definition body), which goes beyond annotations and informs the agent of what to expect.

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 fluff. The core purpose is front-loaded, and the alternative tool is mentioned immediately after. 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 read-only tool with two optional parameters and an existing output schema, the description fully covers what is returned and how the version is selected. Nothing critical is missing for an agent 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 description coverage is 100%, with both parameters fully documented in the schema ('provide this or endpoint_id' and 'provide this or slug'). The description merely reiterates the 'by slug or id' concept without adding new semantics. 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 clearly identifies the action (get), the resource (dynamic endpoint), the identification methods (slug or id), and the return contents (public URL and definition body). It also distinguishes itself from the sibling get_dynamic_endpoint_version by specifying it returns the current version. This 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 states 'Use get_dynamic_endpoint_version to read a specific older version,' which tells the agent when not to use this tool and directs it to the correct alternative. This is clear guidance for 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 indicate readOnlyHint and idempotentHint. The description adds behavioral context by instructing to fetch the schema before authoring, which is consistent with a read-only operation. No contradictions.

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

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

The description is a single sentence that efficiently conveys the tool's purpose and usage without any fluff or redundant information.

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

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

The description tells the user exactly what they will get (the JSON Schema) and when to use it (before authoring a definition). Since no output schema is provided, the description sufficiently covers the return value and context.

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 is an empty object with no parameters, so schema coverage is 100% and there is nothing for the description to add. 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 clearly states the tool retrieves the JSON Schema for dynamic endpoint definitions, using the specific verb 'Get' and resource 'dynamic endpoint definition schema'. It distinguishes itself from sibling get_*_definition_schema tools by explicitly naming the dynamic endpoint resource.

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?

Provides explicit guidance to fetch the schema before authoring definitions for create_dynamic_endpoint / create_dynamic_endpoint_version. While it doesn't name alternative tools, the specific usage condition is clear and actionable.

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 beyond the readOnly/destructive/idempotent annotations by specifying that the return value is a JSON string of the exact definition plus a checksum, and that omitting version fetches the latest. This gives a clear behavioral contract.

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 concise (two sentences) without redundant wording. It front-loads the primary purpose, then adds return details and a usage note, making it easy 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?

Given the output schema exists, the description sufficiently covers what is returned (exact definition as JSON, checksum) and the version behavior. No critical information seems missing for a 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 schema already describes all three parameters, and the description adds essential context: 'by slug or id' clarifies the mutual exclusivity, and 'Omit version to get the latest' explains the special meaning of omitting version. This enriches the raw 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 states the tool reads back the full definition of a dynamic endpoint version by slug or id, and explicitly mentions returning the exact authored definition plus checksum. It distinguishes itself from related tools like get_dynamic_endpoint and get_dynamic_endpoint_definition_schema by focusing on version retrieval.

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 usage hints such as providing slug or id, and omitting version to get the latest. However, it does not explicitly contrast with sibling tools like get_dynamic_endpoint or get_dynamic_endpoint_definition_schema, which could clarify when to choose this tool over them.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds value by specifying the output is markdown and that it serves as reference material to avoid trial-and-error, which is context beyond the annotations. No contradiction found.

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 waste, front-loaded with the core action and format. The reference to list_guides and the authoring use case are essential guidance, not padding.

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

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

For a single-parameter read-only tool with an output schema, the description fully covers discovery (via list_guides), when to use it, and the return format. Nothing an agent needs to invoke it correctly is missing.

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

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

Schema description coverage is 100% with a complete enum and description for the 'topic' parameter. The description only repeats 'by topic' without adding new meaning, so it stays at the baseline 3 for fully documented 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 ('Fetch'), resource ('Tessryx guide'), and the key parameter ('by topic'), and explicitly notes the markdown format. It distinguishes from the sibling list_guides by clarifying it fetches a guide's content rather than listing 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?

It explicitly instructs the agent to use list_guides to see available topics and provides a clear when-to-use context ('before authoring to avoid trial-and-error'). This both directs to an alternative and explains the tool's purpose in the authoring 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?

Annotations already indicate read-only and idempotent behavior. The description adds valuable caveats about depended_on_by being transitive and the unscanned_kinds warning for reverse results, which go beyond 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?

Each sentence adds value, but there is some redundancy: 'transitive and not depth-limited' is later repeated as 'depended_on_by is transitive', and 'version drift is visible' echoes 'what that resolves to right now'. Could be tightened without losing 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?

Covers the main use cases (pre-delete checks), explains transitive traversal, addresses the 'empty result does not mean no dependencies' caveat for unscanned kinds, and points to analyze_resource for breakage detection. This is complete for a graph traversal tool.

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

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

Schema already covers all parameters with descriptions, but the description adds meaningful context: depth is a browsing control, resource can have version suffixes, bare slug means @published, and custom_domain uses hostname. This goes beyond the schema's basic field descriptions.

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

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

Clearly states it browses resource connections and distinguishes from analyze_resource by focusing on the graph structure rather than breakage detection. The verb 'browse' and object 'how resources connect' are 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?

Explicitly says to use it before delete or breaking changes, and provides the alternative analyze_resource for checking if something is broken. This leaves no ambiguity about when to choose this tool over 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 readOnlyHint and non-destructive, so the tool's safety profile is clear. The description adds useful context about the returned data structure (cron status and version body) without contradicting 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?

The description is two sentences, tightly packed with relevant information. It states the purpose, the returned fields, the version selection logic, and a pointer to the sibling tool, all 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?

Given the presence of an output schema (noted in context), the description doesn't need to enumerate return fields. It covers the key nuances of version selection and mentions the cron status fields, which is sufficient for the agent to understand the tool's 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 input schema descriptions cover both parameters and explicitly note that one of them should be provided, achieving 100% coverage. The description reinforces this by saying 'by slug or id', confirming the relationship, though it doesn't add much 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 the specific verb 'Get' and identifies the resource 'schedule'. It differentiates from get_schedule_version by explicitly directing users to that tool for older versions, which clarifies its scope.

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 mentions when to use an alternative: 'Use get_schedule_version to read a specific older version.' This provides clear guidance on tool selection. It also clarifies the default behavior (published if any, else latest) which helps the agent decide when this tool is appropriate.

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 uses safe, read-only language ('Get' and 'Fetch') and is fully consistent with the annotations (readOnlyHint, idempotentHint). It does not discuss side effects, but the annotations already cover safety, and the wording reinforces a non-mutating 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?

The description is a single, information-dense sentence with no filler or redundant wording. It front-loads the primary purpose and packs the essential schema constraints into parentheticals without losing clarity.

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

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

For a parameterless getter, the description is complete: it explains what is returned, why it matters, and when to call it. The expected output is self-evident from the tool name and description, so no additional context is needed.

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 are no parameter semantics to document. The description adds useful context about the returned schema's content, exceeding what the empty input schema alone conveys.

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 ('JSON Schema a schedule definition must satisfy'), and even summarizes the schema's key constraints. The intended output and purpose are unambiguous, and the tool is well differentiated by resource type.

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 states when to use the tool ('Fetch this before authoring the definition for create_schedule / create_schedule_version'). It does not explicitly name alternative definition-schema tools, but the resource-specific naming makes the intended context 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 establish readOnly, idempotent, and non-destructive behavior. The description adds useful detail about returning the exact definition body as a JSON string plus checksum, but does not cover error or auth behavior; the annotation burden is reduced.

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 no filler. It conveys the core behavior, use case, and version semantics in two efficient sentences.

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

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

An output schema exists, so return fields are already specified. The description supplements this with checksum and JSON-string details, and the version omission behavior is clearly stated. No important context 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 descriptions already cover slug, schedule_id, and version semantics, so the added parameter meaning is minimal. The description reinforces that version 0 means latest but does not substantially go 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?

Clearly states it reads back the full stored definition of a schedule version, distinguishing it from listing versions or fetching schedule metadata. The verb 'read back' and object 'schedule version' are precise and specific.

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 identifies the intended use case (diff, patch, resubmit as a new version) and explains the behavior when version is omitted. This helps the agent choose this tool over list_schedule_versions or get_schedule.

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 useful behavioral detail about the return content, specifically that the JSON Schema body of the current version is included, and that lookup is by slug or id. No contradictions with 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?

A single, well-structured sentence that front-loads the action and resource, then states the return content and purpose. 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 simple two-parameter read operation with an output schema present, the description gives enough context to invoke correctly. It clearly identifies the resource, lookup keys, and primary use case, though it leaves minor edge-case handling (e.g., both args provided) to the schema.

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 documents both parameters and their mutual-exclusion relationship. The description restates 'by slug or id' but adds little beyond the schema, so it meets the baseline without significantly enriching parameter semantics.

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 action ('Get a single schema'), the resource ('schema'), the lookup keys ('slug or id'), and the key return content ('JSON Schema body of its current version'). It also gives a concrete purpose ('use it to author a datafile that conforms'), which distinguishes it from list_schemas and other get_* 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 provides a clear use case: when you need the current JSON Schema to author a conforming datafile. It does not explicitly contrast with alternatives like list_schemas or version-specific getters, but the singular 'single schema' and 'current version' wording imply the intended scope.

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 the tool as read-only and idempotent; the description adds important transparency that the actual secret value is never returned and that value_preview is non-sensitive, which goes beyond 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 concise sentences convey the core behavior, the return restriction, and the alternative for mutations without unnecessary 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?

The description is sufficient for correct usage given the output schema exists, and it clarifies the non-sensitive nature of value_preview. It could be slightly more explicit about the need to provide one of the two identifiers.

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

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

Parameter descriptions are present and clarify the either/or relationship between slug and secret_id, but the schema marks both as optional without requiring at least one, leaving a potential ambiguity about calling with neither.

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?

Clearly states the tool gets a single secret by slug or id, distinguishing it from list_secrets and other tools. The metadata-only restriction further clarifies its exact 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?

Implicitly indicates when to use it for a single secret and explicitly points users to the dashboard for creating or changing secrets, but does not explicitly contrast with list_secrets for listing multiple secrets.

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 non-destructive, so the safety profile is covered. The description adds meaningful behavioral detail: it returns the definition body of the current version (published if any, else latest) and version numbers, clarifying exactly what data the agent will receive. This goes beyond the annotations without contradicting 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?

Two sentences, no wasted words. The primary function is front-loaded, and the alternative is provided immediately after. Perfectly sized for quick comprehension.

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 tool with an output schema (not shown but indicated), the description covers the essential return content and points to the sibling for older versions. No critical gaps for an agent to call this correctly; annotations cover safety, schema covers parameters.

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 describes both parameters (slug and workflow_id) with 100% coverage. The description reinforces that the tool accepts 'slug or id' but adds no new semantic detail beyond the schema. Baseline 3 is appropriate when schema fully documents 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'), a clear resource ('single workflow'), and adds distinguishing details: it retrieves the current version's definition body and version numbers, and explicitly contrasts with get_workflow_version. This makes its purpose unmistakable and distinct from sibling get_* 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 tells the agent when to use an alternative: 'Use get_workflow_version to read a specific older version.' This provides clear routing guidance and implies the appropriate context for this tool (current version retrieval). No further conditions 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?

Annotations already cover read-only, idempotent, non-destructive behavior. The description adds useful context that fetching the schema is a preparatory step, but does not describe any additional behavioral side effects or error conditions.

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 with no filler. The main purpose and the usage context are front-loaded and immediately actionable.

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 simplicity and the presence of clear annotations, the description is complete enough. It names the resource, the purpose, and the relevant authoring operations an agent would need.

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 no parameters, so no parameter description is needed. The baseline of 4 applies and the description does not need to add parameter-specific meaning.

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?

Clearly states it retrieves the JSON Schema for workflow definitions, distinguishing it from get_workflow and related workflow tools. Explicitly ties it to create_workflow / create_workflow_version, making the resource and purpose 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?

Provides explicit when-to-use guidance: fetch before authoring a workflow definition for create_workflow or create_workflow_version. This makes the intended workflow context clear among many 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?

Beyond the annotations, the description discloses specific behavioral details: live endpoint serve runs store only the first few KB, runs triggered via run_workflow/preview store full output, and the output is decoded as a string with an output_truncated flag. This significantly enhances transparency.

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 concise, with three sentences each adding value: the main purpose, truncation behavior for live endpoint runs, and full storage for triggered runs. No redundant or extraneous 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?

For a tool with a single parameter and an output schema, the description covers the purpose, returned fields, and important caveats about output truncation. It is sufficiently complete for an agent to decide when and how to use 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?

The schema already describes run_id as 'the run id returned by run_workflow', and the description adds no further parameter details. With 100% schema coverage, the baseline score of 3 is appropriate.

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

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

The description clearly states the tool retrieves a stored workflow run by run ID and lists the key fields returned (status, content_type, output). It distinguishes this from sibling list/get tools by focusing on past run records.

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 usage context by explaining that runs from live endpoint serves have truncated output and suggests re-running or previewing to get full output. This gives some guidance on when alternatives might be more appropriate, though it does not explicitly compare with list_runs or other run-related 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?

The description goes well beyond the readOnly/idempotent/destructive annotations by disclosing concrete behaviors: paged step traces, shortened large values, harder truncation on UNATTENDED runs, literal replacement by paths, and special loop/agent iteration structures with token counts and stop_reason. These are exactly the kind of non-obvious behaviors an agent needs to interpret results correctly. No contradiction with annotations was found.

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?

Though lengthy, the description is front-loaded with the core purpose and then introduces details in a logical order: value shortening, unattended-run differences, remediation advice, loops/agents. Every sentence adds non-redundant behavioral information, so the size is justified and nothing could be cut without losing 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?

For a moderately complex tool with an output schema, the description covers all the non-obvious semantics an agent would need: per-step blocks, consumed inputs, produced outputs, error_message, variable scope, truncation markers, literal paths, pagination, and iteration/turn details. The presence of an output schema reduces the need to describe return values, and this description goes far beyond that minimum.

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 provides 100% coverage and already describes run_id, page_size, and page_token with meaningful text. The description reinforces that run_id refers to a run from run_workflow and that paging applies to steps, but it adds little parameter-specific meaning beyond the schema. This is the baseline for high 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 opens with an explicit verb and resource: 'Get the full per-step execution trace of a run by run id (paged)', which clearly identifies what the tool does. It also narrows the intent to debugging by stating 'Use this to debug why an expression or block produced the wrong value', making it distinct from related run- and workflow-level 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 explicitly states when to use the tool ('Use this to debug why an expression or block produced the wrong value') and provides practical alternatives for different needs, such as reading literals with get_workflow_version and re-running to capture full values with run_workflow, preview_dynamic_endpoint, or run_schedule_now. This gives the agent clear routing guidance rather than leaving usage to inference.

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