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

No annotations are provided, so the description carries the full burden. It implies a read-only lookup via 'safe metadata' but never states that nothing is mutated, nor does it cover auth requirements, availability of a missing artifact, or the 'latest' default resolution behavior. With zero annotation coverage this is thin.

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

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

Two short, front-loaded sentences with no filler; the core purpose leads and the enumeration supports it. The list formatting is slightly awkward but costs nothing in 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?

An output schema exists, so return-value shape need not be described. For a 3-parameter lookup tool this is roughly adequate, but the absence of annotations plus undocumented project_id/version semantics leaves gaps an agent may hit when constructing a call.

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

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

Schema description coverage is 0%, so the description must compensate. It does so well for the critical 'artifact' parameter by enumerating the six valid choices, which the schema lacks as an enum, but it says nothing about project_id or the version parameter (including how 'latest' 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?

The description states a specific verb and resource ('Get safe metadata and resource/file URIs for one generated artifact') and enumerates the artifact kinds, so an agent knows exactly what comes back. It does not, however, differentiate itself from siblings like get_presentation_ir or list_versions, leaving the boundary to inference.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no named alternative, even though get_presentation_ir and list_versions are plausible competing entry points. The artifact enumeration implies the tool is the entry point for any artifact type, but that is inferred rather than stated.

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

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

With no annotations, the description carries the full behavioral burden. The word 'Read' implies a safe read-only operation, but there is no disclosure of auth requirements, failure behavior for missing projects/versions, or rate limits. Thin for a tool with zero 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?

A single front-loaded sentence with no waste. It is appropriately sized for a simple read tool, though brevity here partly reflects omission of useful detail rather than editorial tightness.

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 values need not be explained, but with 0% parameter schema coverage and no annotations the description leaves key semantics undocumented. For a lookup tool with two params, it should do more to orient 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?

Schema description coverage is 0%, so the description must compensate, but it only alludes to the version parameter via 'a project version or the latest version'. It adds no format, acceptable values, or meaning for project_id beyond what the parameter names 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?

States a specific verb (Read), a specific resource (the canonical Presentation IR), and the scoping (project version or latest). An agent can grasp what it returns, though it does not distinguish itself from the sibling get_artifact, which could plausibly also return IR-like content.

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

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

No guidance on when to use this versus siblings like get_artifact or get_project, and no prerequisites or exclusions. The 'version or latest' phrasing only hints at a parameter choice, not at when this tool is the right one.

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

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

With no annotations, the description carries the full behavioral burden, and it does disclose the returned content surfaces (current state, immutable versions, artifact references), which usefully signals this is a composite read. It says nothing about permissions, error behavior, or whether the read is safe/non-mutating beyond the verb 'Get'.

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 that names the verb, the target, and the returned scope with no filler. It is efficiently sized, though the enumerated payload list is doing double duty since an output schema already exists.

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-value documentation is not strictly required, yet the description still needs to cover the read-only nature and identity of the target given the absence of annotations. It does the former implicitly via 'Get' but leaves permissions and error cases unaddressed.

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 project_id parameter has 0% schema description coverage, so the description must compensate. The phrase 'one project's' implies that an identifier selects the target, but no format, source, or example for project_id is given, leaving the semantics largely assumed.

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

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

States a specific verb ('Get') and resource ('one project') and enumerates the payload scope (current state, immutable versions, artifact references). It does not, however, distinguish itself from siblings like get_artifact or list_versions, which overlap on the version/artifact content it advertises.

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

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

There is no when-to-use guidance, no mention of prerequisites, and no routing to alternatives such as list_projects for enumeration or get_artifact when only an artifact is needed. The singular 'one project' faintly implies a single-ID lookup, but this is inference rather than stated guidance.

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

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

With no annotations provided, the description carries the full disclosure burden, and it does add one useful behavioral trait: results are ordered most-recently-updated first. However, it says nothing about pagination, result limits, permissions, or whether 'locally rendered' implies only a subset of projects is returned.

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

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

A single tight sentence with the resource and the ordering constraint front-loaded. Every word earns its place with no filler.

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

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

For a zero-argument read-only listing tool with an output schema that already defines return values, describing the resource and sort order is largely sufficient. It could still note result limits or whether the list is workspace-scoped, but nothing essential for invocation 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 tool takes zero parameters, so there are no parameter semantics to document and the baseline of 4 applies. The description correctly adds no misleading parameter claims.

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

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

The description gives a specific verb ('List') and resource ('locally rendered presentation projects'), and the singular sibling get_project contrasts reasonably well with this plural listing tool. It is clear about what it returns but does not explicitly name or distinguish itself from siblings like list_versions or get_project.

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

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

There is no guidance on when to use this tool versus get_project, list_versions, or get_presentation_ir. The phrase 'locally rendered' hints at scope, but no prerequisites, conditions, or alternatives are stated, 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.

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

With no annotations, the description carries the full behavioral burden. It does disclose one useful trait — only *successfully rendered* versions are returned, implying failed renders are excluded — but says nothing about ordering, pagination, result limits, or permissions.

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

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

One well-formed sentence with the resource and scope front-loaded and no wasted words. It is appropriately terse for a simple list operation, though it borders on under-specified.

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 values need not be explained, and this is a simple one-parameter read. However, the missing parameter documentation, absent usage guidance, and lack of pagination/ordering behavior leave the definition only minimally viable.

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

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

Schema description coverage is 0% for the single required parameter, so the description must compensate. The phrase 'of a presentation project' only loosely ties project_id to a project, adding no format, source, or validation semantics for the identifier.

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

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

The description gives a precise verb ('List') and resource ('successfully rendered versions of a presentation project'), so the operation is unambiguous. It stops short of differentiating itself from siblings like get_artifact or get_presentation_ir, which also retrieve presentation artifacts.

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

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

There is no guidance on when to use this versus get_artifact, get_presentation_ir, or render_presentation, nor any stated prerequisites. The agent must infer the selection criteria from tool names alone.

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

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

With no annotations, the description carries the behavioral burden and does disclose the key trait: every successful call produces a new immutable version and never overwrites an earlier deck. It omits auth requirements, what happens on a base-version mismatch, and any rate/performance characteristics.

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

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

Three short sentences, front-loaded with the operation and its outputs before the parameter-mode guidance. No filler and every sentence carries distinct 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?

An output schema exists, so return values need no explanation, and the versioning model is well covered. What remains thin is the expected shape of the nested 'presentation' object and the failure path when expected_base_version does not match.

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

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

Schema description coverage is 0%, so the description must compensate; it usefully explains project_id (omit for a new project) and expected_base_version (the current version for revisions). The third parameter, the nested 'presentation' IR payload, is left entirely undefined, so compensation is partial.

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 ('Render'), the precise input ('complete Presentation IR'), and both outputs ('editable PPTX and source bundle'). That output profile cleanly separates it from siblings like validate_presentation and get_presentation_ir without the agent opening any schema.

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

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

Explicitly covers the two operating modes: omit project_id for a new project, or pass project_id plus expected_base_version for a revision. It does not mention alternatives or prerequisites (e.g., validate first), so it stops short of the full when/when-not/alternatives bar.

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

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

No annotations are supplied, so the description carries the full behavioral burden. It usefully discloses the dry-run nature ('without writing files') and the recommended call order, but says nothing about what validation checks, whether failures raise errors or return a report, or what happens with a malformed IR.

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

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

Three short sentences, front-loaded with the purpose and side-effect guarantee, then usage, then parameter hint. No filler, though the phrase 'when the model needs' is slightly ambiguous about who the consumer is.

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 presence of an output schema removes any need to describe return values, and the workflow role is clear. However, with zero annotations and full behavioral burden on the description, missing failure-mode behavior leaves gaps for a validation tool operating on a nested object.

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

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

Schema description coverage is 0%, so the description must compensate. It does so well for include_canonical, explaining the normalized form and default theme fields the schema never mentions; the required 'presentation' parameter relies entirely on its self-evident name and the surrounding context.

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

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

States a specific verb and resource ('Validate complete Presentation IR') and immediately scopes it with 'without writing files', which separates it from the sibling render_presentation. An agent can distinguish this from get_presentation_ir and render_presentation without opening any schema.

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

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

'Call this before render_presentation' gives an explicit sequencing condition tied to a named sibling, and the include_canonical sentence adds a conditional use case. There is no explicit 'do not use when' guidance, so it falls just short of the top band.

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