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

Annotations are absent, so the description carries the full burden. It mentions that write permission is required, which is a useful constraint, but it does not disclose expected return values, side effects, error conditions, or any other behavioral details. For a mutation tool with no annotations, this is insufficient.

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 two short sentences and no redundant wording. However, its brevity borders on under-specification, and while it is not verbose, the lack of substantive content reduces its effectiveness. It earns points for being front-loaded with the action and permission, but the structure is minimal.

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 9 parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain the creation process, success/failure responses, validation rules, or any relationship to other entities. An agent would struggle to invoke this correctly without additional external knowledge.

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

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

Schema description coverage is only 33%, and the tool description adds no parameter details whatsoever. It does not compensate for the low schema coverage, leaving most of the 9 parameters unexplained. The agent has to infer semantics from property names alone, which is inadequate for parameters like 'authority', 'body_html', and 'skill_ids'.

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

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

The description states the specific verb 'Create' and the resource 'certification', which clearly distinguishes it from sibling tools like get_certification, update_certification, and delete_certification. It is unambiguous about the action.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention prerequisites, context, or when not to use it. The description only states the action and a permission requirement, offering no routing or exclusion information.

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

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

No annotations are provided, so the description must disclose behavioral traits. It only states that write permission is required, which is a minimal permission note. It does not mention side effects, whether the operation is idempotent, what is returned, or any constraints on the data. This is insufficient for a create operation with multiple fields.

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

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

The description is a single sentence and therefore is concise and front-loaded with the primary purpose. However, it is under-specified rather than appropriately concise—it omits crucial operational details. There is no redundancy or filler, but the brevity works against 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?

With 11 parameters, no output schema, and no annotations, the description is severely incomplete. It does not explain what an education entry consists of, how fields like 'skill_ids' or 'project_ids' relate, or what the API returns. This is drastically inadequate for an agent to reliably invoke the tool.

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

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

Schema coverage is only 27% (only 3 out of 11 parameters have descriptions in the schema). The tool description adds no parameter-level information whatsoever—not even highlighting the required 'institution' field. This leaves the agent to guess semantics from parameter names alone, which is especially problematic for ambiguous fields like 'body_html' or 'skill_ids'.

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 'Create a new education entry', which specifies the action (create) and the resource (education entry). This is unambiguous and distinguishes the tool from update/delete/get variants among the siblings. However, it lacks context such as being tied to a user profile, which would make the purpose even more explicit.

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

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

The description provides no guidance on when to use this tool versus alternatives like update_education or get_education. Mentioning 'Requires write permission' states a prerequisite but does not explain the use case. There is no explicit directive such as 'Use to add a new education record' or comparison with other tools.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does communicate that this is a mutating operation requiring write permission, which is useful. However, it says nothing about what the tool returns, whether the created entry becomes visible immediately, validation behavior, or side effects beyond insertion.

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

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

The description is a single front-loaded sentence with no filler; both the action/resource and the permission requirement earn their place. It is not bloated, though it is very sparse.

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 10-parameter CRUD operation with no output schema, no annotations, and several undocumented fields, a two-clause definition is far from complete. An agent has no guidance on what the payload should look like beyond required names, what the response is, or how to confirm success.

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 description makes no mention of any of the 10 parameters, so it adds no meaning beyond the schema. Schema description coverage is only 40%, and fields like location, body_html, skill_ids, project_ids, and is_current remain unexplained; the description fails to compensate for this gap.

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 single clear action ('Create') and a specific resource ('a new work experience entry'), which separates it from the get/update/delete/list siblings and from create_project/create_education/etc. The word 'new' also marks it as the insert operation, not an update.

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 the tool should be used when an agent needs to add a work-experience record, but it does not explicitly contrast this with update_experience for edits or list_experience for reads. The write-permission note is a prerequisite, not a full usage rule.

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 disclosure burden. It does add one useful behavioral detail—the write permission requirement—but it does not disclose duplicate-slug behavior, validation failure handling, side effects, or response shape. The disclosure is partial but not absent.

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, and the action/resource is front-loaded. It is lean and scannable, though it sacrifices completeness for brevity.

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

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

Given 12 parameters, 25% schema coverage, no annotations, and no output schema, the definition is not complete enough. The schema gives types, formats, and required fields, but an agent is left to infer the semantics of nine parameters, behavior on conflicts, and what the tool returns.

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 only 25%, so the description needed to compensate. It does not mention required title/slug, nor clarify ambiguous fields such as description, short_description, body_html, skill_ids, or category_ids. It adds no parameter-level meaning beyond the word 'project.'

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 ('Create') and the resource ('new portfolio project'), and the portfolio context distinguishes it from sibling create_* tools. It also contrasts implicitly with update_project and delete_project by indicating a new record rather than a modification or removal.

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 only guidance is 'Requires write permission,' which is a prerequisite rather than a selection rule. It does not state when to use this tool versus update_project, nor does it exclude any alternatives, leaving usage largely implied by the verb.

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

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

With no annotations, the description must carry behavioral disclosure, and it does state the write-permission requirement. However, it does not mention return value, duplicate-name behavior, validation, or any side effects beyond creating a skill. This is the minimum viable disclosure for a mutation tool.

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

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

Two short sentences state the core operation and the key precondition with no filler. It is appropriately sized and front-loads the 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 tool is a simple create operation with one required parameter documented in the schema, so the description is enough for basic invocation. However, with no output schema and sparse parameter documentation, an agent is left to infer the return value and format requirements for the undocumented fields.

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 only 25%, with logo_url, body_html, and category_ids lacking descriptions. The description adds no parameter meaning beyond the schema, so it fails to compensate for the low schema coverage. An agent receives virtually no help understanding what values to provide.

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 'Create a new skill' uses a specific verb and resource. It cleanly distinguishes this from the sibling tools update_skill, delete_skill, get_skill, and list_skills. No ambiguity about what operation this tool performs.

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 creation intent is implied by the verb 'Create' and the resource 'skill', but there is no explicit guidance about when to prefer it over update_skill or delete_skill. The 'Requires write permission' note adds a precondition but no exclusion or alternative-routing information.

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 disclosure burden, and it does add one concrete behavioral detail: 'Requires write permission.' However, it does not disclose side effects beyond creation, validation behavior, idempotency, or what happens on failure, which would be useful for a mutation tool.

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

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

The description is two short sentences with no filler. It front-loads the core operation and immediately adds the essential permission requirement, making every word earn 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 create operation with 9 parameters, no annotations, and no output schema, the description is too thin. An agent cannot confidently determine what optional fields mean, what format/constraints apply, or what the tool returns after creating a testimonial.

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 only 44%, leaving several parameters like company, image_url, is_active, is_featured, platform_name, and testimonial_date undocumented. The description does not compensate by explaining any of these, so an agent gets no guidance on the optional fields beyond their names.

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

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

The description states the action clearly with a specific verb and resource: 'Create a new testimonial.' It distinguishes from list/get/delete/update siblings by using 'new,' though it does not explicitly differentiate from update_testimonial or other create_* tools beyond the resource name.

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

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

The phrase 'Create a new testimonial' implies when to use it, but there is no explicit guidance about when not to use it or which sibling to choose instead, such as update_testimonial for existing testimonials. The permission requirement is a precondition, not an alternative-selection rule.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the permission requirement but omits critical details for a destructive operation, such as whether deletion is permanent/reversible, what happens to related data, return values, or error behavior (e.g., nonexistent ID). This is a significant gap.

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

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

The description is two short sentences with no wasted words. The core action is front-loaded, and the permission note is concise. It is appropriately sized for a simple tool.

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

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

The tool is simple (one parameter, no output schema), and the description covers the basic action and a permission prerequisite. However, it lacks information about the return value, error handling, or side effects, which are relevant for a delete operation. While not severely incomplete, it could be more thorough given the absence of annotations.

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 100% of the parameter 'id' with a description 'Certification ID'. The description adds nothing beyond the schema, so it does not enhance understanding. The baseline of 3 is appropriate since the schema already documents the parameter adequately.

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

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

The description clearly states the verb 'Delete' and the resource 'certification' with the method 'by ID'. It is distinct from sibling tools like update_certification, get_certification, and list_certifications, leaving no ambiguity about what the tool does.

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 includes a usage prerequisite ('Requires write permission'), which is useful guidance. However, it does not explicitly compare against alternatives or state when not to use it, though the purpose is clear enough that an agent would infer when deletion 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?

With no annotations provided, the description carries the disclosure burden. It does disclose the permission requirement, which is useful, but it does not state that deletion is permanent, whether related data is affected, or what happens on failure. The destructive nature is conveyed by the verb itself, earning a mid-range score.

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

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

The description is two short sentences with no filler. The core action is front-loaded, and the permission requirement is a valuable addition that 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 single-parameter delete operation with full schema coverage and no output schema, the description is mostly complete. It clearly states the action and the required permission, though it could be slightly richer by noting that the deletion is irreversible.

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

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

The schema has 100% coverage for the single parameter, documenting 'id' as 'Education ID.' The description adds no new parameter detail beyond saying 'by ID,' so the schema does the heavy lifting and 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 ('Delete') and resource ('education entry by ID'), making the operation unmistakable. It clearly differentiates from sibling tools like get_education, update_education, and list_education.

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

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

There is no guidance on when to use this tool versus alternatives, other than the implicit need to delete an education entry. It mentions a prerequisite ('Requires write permission') but does not describe conditions, alternatives, or exclusions.

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

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

No annotations are provided, so the description carries the full burden. It states 'Requires write permission,' which is useful, but it does not disclose whether deletion is permanent, irreversible, or cascading, nor what happens if the ID does not exist. For a destructive operation, this is a significant gap.

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

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

The description is a single, concise sentence that front-loads the action and resource, followed by the permission requirement. 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 destructive tool with no annotations and no output schema, the description is too sparse. It does not explain the effect of deletion (permanence, cascading), error behavior, or any confirmation safeguards. An agent would benefit from knowing whether deletion is reversible or what the response indicates.

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 the 'id' parameter as 'Experience ID'. The description adds no further meaning beyond the schema, which is acceptable given full coverage. 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 the action ('Delete'), the resource ('a work experience entry'), and the required identifier ('by ID'). It is unambiguous and distinct from sibling tools like update_experience or list_experience.

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 the tool is for deleting a specific experience entry, which is clear from the verb and resource. However, it does not explicitly state when to use this tool versus alternatives, nor does it mention any prerequisites or conditions (e.g., cannot delete non-existent entries, impact on related data).

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

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

No annotations are provided, so the description carries the behavioral burden. It clearly conveys the destructive action and the write-permission requirement. However, it does not mention permanence, potential cascading effects, or response behavior, which would be richer context.

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

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

Two short sentences contain all essential information with no filler. The core action is front-loaded and the permission requirement is a valuable additional 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?

For a simple one-parameter delete operation with no output schema, the description is complete: it identifies what to call, what to pass, and the required permission. No essential 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 documents the single `id` parameter with full coverage, and the description reiterates it as 'by ID'. The description adds no extra semantic detail beyond the schema, so 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 states a specific verb ('Delete'), a resource ('project'), and the identifier used ('by ID'). It is unambiguous and clearly distinguishable from sibling get/update/create/delete 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?

The description clearly implies this tool is for deleting a project, providing enough context for the agent to select it over get_project or update_project. It does not explicitly name alternatives or exclusions, but the resource and verb are sufficiently specific.

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

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

No annotations are provided, so the description carries the full burden. It discloses a write-permission requirement, which is helpful, but it doesn't state that deletion is permanent/irreversible, what happens to related data, or the return value. This is a minimal disclosure for a destructive 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?

Two short sentences totaling nine words. Every word contributes: the operation, the target resource, the identifier, and a permission note. No 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?

The tool is simple with a single parameter, but the absence of an output schema and annotations leaves the return type and error behavior unspecified. The permission note is useful but doesn't compensate for not describing the success/failure response. Adequate for a minimum viable definition, but an agent would need to infer or test the outcome.

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

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

Schema coverage is 100%, and the schema already defines the id parameter as a required number with description 'Skill ID.' The description only references 'by ID' without adding format, source, or lifecycle information. It meets the baseline 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?

States a specific verb and resource: 'Delete a skill by ID.' Clearly distinguishes from sibling tools like create_skill, update_skill, get_skill, and list_skills. No ambiguity about the operation.

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 only usage guidance is 'Requires write permission,' which is a precondition rather than an explicit when-to-use. It doesn't mention alternatives like update_skill for reversible changes or get_skill for verification, nor does it note that deletion is permanent. Usage is largely inferred from the tool name.

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 must disclose behavioral details. It mentions 'Requires write permission' which is useful, but it does not disclose whether deletion is permanent, how the API responds to non-existent IDs, or any side effects. For a destructive operation, this is a significant gap.

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

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

The description is a single concise sentence that front-loads the primary action. There is no wasted text, and it is appropriately sized for the tool's simplicity.

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 (one parameter, no output schema), the description is still incomplete: it omits any indication of the return value or success/failure behavior, and does not state that deletion is irreversible. An agent calling this tool would benefit from knowing whether it returns the deleted object or a confirmation.

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 documents the single 'id' parameter with 100% coverage, so the description need not add parameter details. It repeats 'by ID' but adds no new information beyond the schema.

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

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

The description clearly states the verb 'Delete' and the resource 'testimonial', making the operation unambiguous. However, it does not explicitly differentiate from sibling delete tools for other resources, relying on the resource name to disambiguate.

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

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

The description provides no guidance on when to use this tool versus alternatives like update_testimonial or create_testimonial, nor does it mention any exclusions. It only states a permission requirement, which is a prerequisite but not 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?

No annotations are provided, so the description carries the full behavioral burden, but it only says 'Get' and adds no details about return format, error behavior, or whether the full certification object is returned. It does not provide insight beyond the operation implied by the tool's name.

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

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

The description is one short, front-loaded sentence with no filler. It communicates the essential operation and selector immediately.

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 getter, this description plus the fully covered schema is sufficient for an agent to select and invoke the tool correctly. The response shape is strongly inferable, though a brief note about the returned object would make it fully 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 schema already fully describes the single id parameter as a Certification ID, achieving 100% schema description coverage. The description's 'by ID' adds no additional semantic meaning beyond what the schema provides, so a baseline 3 is appropriate.

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

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

The description uses a clear verb and resource: 'Get a specific certification by ID.' It cleanly distinguishes this single-item getter from sibling list_certifications, so an agent can tell them apart without inspecting the schema.

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

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

'Get a specific certification by ID' clearly signals that this tool is for retrieving one known certification by its identifier. It does not explicitly name list_certifications as the alternative for browsing, but the scope is clear enough to guide selection.

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

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

With no annotations, the description carries the full burden of behavior disclosure. It implies a read-only operation via 'Get', but does not specify error behavior, return format, or any access requirements. For a simple getter this is minimally adequate but lacks depth.

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

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

A single concise sentence that front-loads the core action and resource. No wasted words, but it is sparse and could include a brief usage hint without sacrificing conciseness.

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 getter, the description is functionally sufficient. However, it could explicitly state that the ID must come from a list operation or mention that only one entry is returned. Lacks any context on output layout, but that is not required without an output schema. Overall adequate with minor 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 coverage is 100% (the 'id' parameter has a description), so the schema already documents it. The tool description adds no extra semantic detail beyond 'by ID', relying entirely on the schema. Baseline 3 is appropriate.

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

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

The description states a clear verb ('Get') and resource ('specific education entry by ID'), which distinctly identifies the operation. It is unambiguous and distinguishes from list_education, though it does not explicitly name the sibling or contrast with it.

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

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

No guidance is provided on when to use this tool versus list_education or any other sibling. There is no mention of prerequisite steps (e.g., obtaining the ID from a list call) or alternative tools, leaving the agent to infer 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?

With no annotations, the description carries the full burden. 'Get' clearly signals a read operation with no side effects, but the description does not disclose response format, error behavior for non-existent IDs, or access requirements. This is adequate but sparse.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes meaning, making it both concise 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?

For a simple one-parameter read tool, the description says what the tool does and implies the return value. However, it lacks alternative routing guidance (e.g., use list_experience for all entries) and does not specify edge-case behavior. These are noticeable but not critical gaps for this low-complexity tool.

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

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

The schema already documents the only parameter 'id' at 100% coverage. The description adds no new parameter details beyond confirming that the ID selects the specific entry, which matches the schema. Baseline 3 applies.

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

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

The description uses a specific verb ('Get'), a precise resource ('specific work experience entry'), and a clear qualifier ('by ID'). This makes it easy to distinguish from list_experience and other get_* siblings without opening the schema.

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

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

The description does not mention when to prefer this tool over list_experience or any sibling. It implies the situation where you have a specific ID, but no explicit alternatives or exclusions are 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 provided, the description carries the transparency burden. The verb 'Get' and the listed fields communicate that this is a read operation returning profile content, but explicit side-effect, authentication, or missing-profile behavior is not disclosed. This is adequate but not rich.

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

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

The description is a single front-loaded sentence with no filler. Every phrase adds information: the operation, the target resource, and the expected content categories.

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

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

For a zero-parameter, single-resource getter, the description covers what an agent needs to select and invoke it. It could have specified the output shape or behavior when no profile exists, but those are minor gaps given the tool's simplicity and absent output 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 tool has zero parameters, so the schema is trivially complete at 100% coverage and the description has no parameter meanings to add. The baseline for a no-parameter tool applies cleanly.

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

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

The description uses a specific verb ('Get'), identifies the resource ('portfolio owner's profile'), and enumerates the contained fields (name, bio, contact details, social links). This clearly distinguishes it from the sibling update_profile and from the many collection-style list_*/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?

Usage is implied through the singular 'portfolio owner's profile': an agent can infer this is for fetching the single profile rather than for mutating it. However, the description gives no explicit alternatives or when-not-to-use conditions, leaving some routing 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 must carry the full burden of behavioral disclosure. The verb 'Get' suggests a read-only operation, but it does not mention return format, error behavior, or what happens if neither 'id' nor 'slug' is provided, which is especially relevant since both parameters are optional in the schema.

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

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

A single sentence with no redundant words. 'Specific' adds useful distinction from list operations, and the description is immediately readable and front-loaded with the core purpose.

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

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

Given there is no output schema and no annotations, the description should explain what the response looks like and note that at least one identifier must be supplied. The description covers only the lookup intent, leaving agents without guidance on return values or the optional-parameter ambiguity.

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

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

Schema coverage is 100%, so baseline is 3. The description adds semantic value by indicating 'ID or slug' are alternative selectors, which clarifies how the parameters relate even though the schema marks neither as required. It does not explicitly state that at least one is necessary, which would fully close the gap.

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

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

The description uses a specific verb 'Get' with a clear resource 'specific project' and states the two lookup methods (ID or slug). This distinguishes it from 'list_projects' (which returns multiple) and from other entity getters like 'get_skill' or 'get_experience'.

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: call this when you need a single project identified by ID or slug, rather than a list. However, it does not explicitly state when not to use it or mention alternatives such as 'list_projects' for querying multiple projects.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a read-only fetch but does not mention what happens if neither id nor name is given, or if both are provided, nor any error handling. The description is not misleading but offers minimal behavioral insight beyond the obvious action.

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

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

The description is a single, concise sentence with zero filler. It is front-loaded with the verb and resource, making it easy to scan and understand quickly.

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

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

For a simple getter with no output schema and no required parameters, the description is adequate. It does not specify the response format, but that is not expected given the absence of an output schema. It could mention whether both parameters are optional or if one is preferred, but the lack of that detail is a minor gap rather than a critical omission.

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

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

The input schema already documents both id and name with 100% coverage, so the baseline is 3. The description simply restates that the skill can be looked up by ID or name, adding no extra meaning beyond what the schema provides. It does not explain precedence or mutual exclusivity, but the schema itself is sufficient.

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

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

The description states the verb 'Get' and the resource 'a specific skill', which clearly identifies what the tool does. The word 'specific' implies a contrast with listing all skills, but it does not explicitly name a sibling tool, so it falls short of a 5.

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

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

The description indicates this tool is for retrieving a single skill by providing an ID or name, which gives clear context on when to use it. However, it does not explicitly state when not to use it or mention alternatives like list_skills, so it lacks the exclusions that would earn a 5.

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

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

Annotations are absent, so the description carries the full burden of behavioral disclosure. It only states the action ('get by ID') but does not mention the return format, error behavior on missing ID, response shape, or any side effects. For a simple get operation, more context would be helpful but is not provided.

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, succinct sentence that immediately conveys the purpose. It is front-loaded with the key action and reference, and contains no filler or redundant 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?

The tool is simple (one required parameter, no output schema), so the description is minimally acceptable for understanding what it does. However, given the lack of annotations and output schema, it would be more complete if it indicated the return type (e.g., a testimonial object) or what happens for non-existent IDs. As it stands, an agent can call it correctly for the basic action but may lack clarity on expected results.

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 the single parameter 'id' described as 'Testimonial ID'. The description adds no additional meaning beyond the schema, so the baseline of 3 is appropriate. There is no extra nuance about id format or constraints beyond what the schema already declares.

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 specific resource ('testimonial'), and a specific selector ('by ID'). It clearly differentiates from list_testimonials (which returns all) and from create/update/delete operations. The intent is 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 implies usage: retrieve a single testimonial when you have its ID. However, it does not explicitly say when to prefer this over list_testimonials or what conditions would make it inappropriate (e.g., needing all testimonials). No explicit alternatives or exclusions are given.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It states that certifications are listed, but does not mention pagination, ordering, response shape, or whether 'all' is affected by the page/limit parameters.

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 extremely short and avoidably under-specified. It has no fluff, but it also provides little useful guidance; this is minimalism rather than effective conciseness.

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

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

Given no annotations, no output schema, and no parameter documentation, the description is not complete enough for an agent to fully understand pagination behavior or what the list operation returns. It covers the basic action but omits important contextual details.

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

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

Schema description coverage is 0%, and the description gives no explanation of page or limit. Although the parameter names and schema constraints are somewhat self-evident, the description adds no meaning beyond 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 uses a specific verb-resource pair, 'List all certifications', which clearly indicates a collection operation. It is distinguishable from get_certification by the plural resource and 'all' wording, though it does not explicitly name that sibling.

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

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

No guidance is provided about when to use this tool versus get_certification or the other list tools. The intended usage is only implied by the simple wording, and no alternatives or exclusions are mentioned.

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

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

No annotations are provided, so the description carries the full burden. It states 'List all education history' but gives no information about pagination, ordering, return format, or side effects. This is a minimal statement with no behavioral disclosure beyond the name.

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

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

The description is a single concise sentence with no filler words, making it efficient and front-loaded. However, it is so terse that it sacrifices essential detail for brevity.

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

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

For a simple list tool with pagination parameters and no output schema, the description is inadequate. It does not explain the pagination parameters or any selection behavior, leaving the agent to infer meaning from the schema alone.

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 description makes no mention of the page and limit parameters. With 0% schema description coverage, the agent receives no guidance on how these parameters affect the result. This is a significant gap that leaves parameter meaning entirely to inference.

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

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

The description states the verb 'list' and the resource 'education history' clearly, which distinguishes it from get_education (which implies a single record). However, it does not explicitly name the sibling alternative or elaborate on the distinction.

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

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

No guidance is provided about when to use this tool versus get_education or other list tools. The description is a bare statement with no usage context, exclusions, or alternatives.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only restates the operation. It does not mention pagination behavior, default limits, ordering, return format, or whether 'all' is truly unbounded despite the page/limit parameters.

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

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

The description is a single, front-loaded sentence with no filler or redundancy. It states the operation and resource as efficiently as possible, earning its place despite being minimal.

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 paginated list operation with no output schema and no annotations, the description is incomplete. It fails to clarify pagination semantics, return structure, or the relationship to get_experience, leaving an agent without enough context to know whether 'all' respects the limit parameter.

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

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

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It does not explain how 'page' and 'limit' affect the result or reconcile 'all' with pagination. The parameter names are somewhat self-explanatory, but the description adds no semantic value beyond the schema.

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

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

The description uses a specific verb and resource: 'List all work experience.' It is clear this is a collection operation, and the word 'all' loosely distinguishes it from the sibling get_experience, though it does not explicitly name that alternative or clarify the difference.

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

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

No guidance is provided about when to use this tool versus get_experience or the other list tools. An agent must infer usage solely from the name and the word 'all'; there are no exclusions, conditions, or alternative recommendations.

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

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

No annotations are provided, so the description carries full behavioral disclosure. It only states 'List published projects,' implying a read operation, but doesn't mention pagination behavior, filter matching semantics (exact vs partial), or the response format. These gaps leave the agent uncertain about runtime behavior.

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

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

The description is a single sentence that front-loads the core action ('List published projects') and then mentions optional filters. It contains no filler or redundancy, making it efficiently 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?

The tool is simple with no required parameters, and the schema covers pagination details. However, the description doesn't mention that results are paginated (though page/limit exist) or describe the response shape. Since there is no output schema, the agent is left without knowledge of what the list returns. This is a moderate gap for a list 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 description coverage is 100%, with all four parameters (page, limit, skill, category) already documented. The description adds only that filtering is optional, which is implicit in the schema (all properties are optional). It adds minimal value beyond the schema, so the baseline 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 states a specific verb (list) and resource (published projects), with a clear qualifier 'published' that distinguishes it from project mutation or retrieval tools. It also notes optional filters, making the scope precise. This clearly separates it from siblings like get_project, create_project, and update_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?

No guidance is given on when to use this tool versus alternatives. It doesn't mention that get_project is for a single project or that list_skills is for skills. The description provides no context on selection criteria, leaving the agent to infer based on resource name alone.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, yet it only states the basic list/filter behavior. It does not mention pagination semantics (page/limit), result ordering, or what the response contains, which are important for an agent calling the tool correctly.

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

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

The description is one tight sentence with no filler and the primary action front-loaded before the optional filter. It earns its place.

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

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

For a tool with no annotations and no output schema, the description is too thin: it omits pagination semantics, return shape, and category matching behavior. An agent cannot reliably choose correct page/limit usage or know what to expect.

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 only 33%, with page and limit left undocumented, and the description does not fill that gap. It merely restates the category filter that already appears in the schema, adding no detail about pagination parameters or exact-match 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 states a specific verb and resource: 'List all skills', and the optional category filter defines the operation's scope. It is clearly distinguished from sibling tools like get_skill (single item) and create_skill/update_skill/delete_skill (mutations).

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

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

The phrase 'List all skills' gives an implied use case, and the category filter suggests when narrowing is appropriate, but the description never names alternatives such as get_skill for a single skill. The when-not/alternative guidance is left to inference from sibling names.

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 are absent, so the description carries the full behavioral burden. It implies a read operation but does not disclose the pagination cap (limit maximum 50), default page/limit values, filtering behavior, or return shape. The wording 'List all' sits awkwardly against the schema's 50-item limit, which is an undisclosed behavioral nuance.

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

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

The description is a single, front-loaded, grammatically clean sentence with zero wasted words. It efficiently conveys action and resource. While the content is thin, the structure itself is appropriately sized for a simple list operation.

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

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

With no output schema and no annotations, the description needed to carry more weight. It fails to mention return format, pagination defaults, ordering, or how the featured filter modifies results. For a tool with 3 optional parameters at 33% coverage, callers are left guessing about basic invocation 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?

Schema description coverage is only 33%: only 'featured' has a schema description, while 'page' and 'limit' are undocumented. The description adds zero parameter context, so page/limit semantics, defaults, and their interaction remain completely unexplained. With coverage below 50%, the description was required to compensate and did not.

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?

"List all testimonials" states a specific verb (list) and resource (testimonials). The list verb distinguishes it from the singular get_testimonial and the mutating create/update/delete_testimonial siblings. Minor imprecision: "all" is undercut by the featured filter and pagination parameters in the schema, so the scope is not literally "all" in every invocation.

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

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

No guidance is given on when to use this tool vs. get_testimonial, how pagination should be handled across pages, or when the featured filter is appropriate. The bare statement merely implies 'use when you want testimonials' but provides no decision context or exclusions.

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

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

With no annotations available, the description carries the full behavioral disclosure burden. It does disclose a key trait by noting 'Requires write permission,' which is valuable context. Yet it omits other important behavioral details such as whether the update is partial or a full replacement, what happens if the ID is not found, or what the response contains.

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 extremely concise with no filler—two short sentences each add value. The core action is front-loaded, and the permission note is a separate, clear sentence. It could have been more informative while still being concise, but efficiency is strong.

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

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

This is a 10-parameter mutation tool with no annotations, no output schema, and no parameter explanations. The description only covers the action and a permission prerequisite, leaving an agent without crucial information about updatable fields, partial vs. full update semantics, return values, or error behavior. This is insufficient for reliable 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 description coverage is only 10% (only the 'id' parameter is described in the schema), and the description does not compensate for this gap. Saying 'by ID' adds no meaning beyond the schema's own 'Certification ID' note, and the other nine parameters are left completely unexplained.

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

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

The description states a specific verb ('Update'), a precise resource ('existing certification'), and a key identifier ('by ID'). This clearly distinguishes it from create, delete, get, and list siblings, and makes the tool's primary function immediately obvious.

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

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

The phrase 'existing certification' implies this tool is for modifying an already-created resource rather than creating or deleting, and 'Requires write permission' gives a necessary precondition. However, it does not explicitly state when to choose this over alternatives like create_certification or delete_certification, nor does it list any exclusions.

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

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

No annotations are provided, so the description carries the behavioral burden. It discloses the write-permission requirement, which is useful, but omits other key behaviors such as failure on missing ID, partial-update semantics, return value, or whether all fields are optional once ID is supplied. This is a clear gap but not a 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?

Two sentences with no fluff: first states the primary action and target, second discloses a permission prerequisite. Every word contributes; the essential purpose is front-loaded.

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

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

For a 12-parameter mutation tool with no annotations and no output schema, the description is severely incomplete. It provides no information on parameter semantics, behavior on partial updates, error handling, or return values, so the agent cannot confidently construct or interpret a correct 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 only 8% (just 'id'), yet the description adds no meaning for the other 11 parameters. An agent cannot infer what 'grade', 'body_html', 'skill_ids', or 'project_ids' represent or how they are updated from either the schema or the 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 states a specific verb ('Update'), resource ('education entry'), and targeting mechanism ('by ID'), which clearly distinguishes it from create/delete/get siblings. It does not explicitly name alternatives but the scope is obvious from the phrasing.

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

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

No guidance on when to use this tool versus alternatives, no exclusions or conditions beyond 'Requires write permission.' The name implies it, but the description does not state when to prefer it over create_education or mention related tools.

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

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

With no annotations, the description carries the behavioral burden. It discloses that the operation requires write permission and targets an existing entry. However, it does not clarify whether updates are partial or full replacements, what happens on invalid IDs, or what response to expect. This is a moderate disclosure for a mutation tool.

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

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

The description is a single, front-loaded sentence that conveys the core operation and a key requirement without any filler. 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 tool with 11 parameters, no output schema, and no annotations, this description is inadequate. An agent needs to know whether fields are merged or replaced, how related skill/project IDs are handled, and what the response contains. The minimal text leaves too much unsaid for safe 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 description coverage is only 9%, so the description must compensate. It mentions 'by ID', which aligns with the required id parameter, but provides no additional meaning for the other 10 parameters. The description adds minimal value beyond the schema and leaves field semantics largely unexplained.

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

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

The description clearly states a specific verb ('Update'), the resource ('existing work experience entry'), and the key identifier ('by ID'). It distinguishes itself from create_experience and delete_experience without needing to open the schema.

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

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

The context is clear: use this to modify an existing experience entry, not to create or delete one. It does not explicitly name alternatives or list exclusion conditions, but the purpose statement strongly implies the appropriate usage.

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 only says the operation updates the profile and requires write permission. Since there are no annotations, the description carries the full burden of disclosing behavior, but it does not explain whether unspecified fields are preserved or overwritten, whether the update is partial or full, or what the response contains.

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 brief and front-loaded: the core action appears first, followed by a necessary permission note. Both sentences earn their place. It could be considered too short given the tool's complexity, but there is no fluff or poor structural ordering.

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 13 optional parameters, no annotations, no output schema, and no parameter descriptions, the tool definition is incomplete. A caller cannot tell whether omitted fields are left unchanged or cleared, whether a response is returned, or what the expected update behavior is. The description covers only scope and permissions.

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

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

With 13 parameters and 0% schema description coverage, the description should compensate by explaining parameter meaning or update semantics, but it does not. The phrase 'portfolio owner profile' weakly hints that fields like bio, email, and website belong to the owner, but it provides no real guidance beyond the property names already present in the schema.

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

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

The description states a specific verb and resource: 'Update the portfolio owner profile.' This clearly distinguishes it from sibling tools like get_profile or update_project, whose resource targets are different. The addition of the write-permission requirement reinforces the intent.

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

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

The intended use is implied by the name and description: use this when updating the portfolio owner's profile. However, it does not explicitly contrast with alternatives, such as using get_profile for reads, or clarify whether this should be used for owner-only changes versus other profile updates.

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 disclosure burden and does add one useful behavioral fact: 'Requires write permission'. However, it does not disclose partial-update semantics, error behavior, or response contents, so transparency is only partial for a mutating tool.

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

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

The description is two short sentences with no filler. The primary action is front-loaded, and the permission note earns its place as the only additional operational information provided.

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 14 parameters, no output schema, and no annotations, the description is too thin. It does not explain whether this performs a full replacement or partial patch, which fields are updatable, or what the caller should expect in return, forcing the agent to infer too much.

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 only 14%, so the description should compensate for the many undocumented parameters, but it only clarifies `id` via 'by ID'. The meanings of slug, title, URLs, body_html, skill_ids, category_ids, and other fields are left entirely to inference from their names.

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

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

The description states the exact action ('Update'), the resource ('an existing project'), and the selection criterion ('by ID'). This cleanly distinguishes it from create_project, delete_project, and the get/list siblings without needing to inspect their schemas.

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?

'Existing project by ID' implies when to use this tool, and 'Requires write permission' gives a prerequisite, but no alternatives are named and no explicit when-not-to-use guidance is given. Usage is implied rather than stated.

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

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

With no annotations, the description carries the full burden. It discloses a permission requirement ('Requires write permission'), but it does not describe what happens to existing data (e.g., partial vs. full update), the effect of missing fields, or the return value. As a mutation tool, this is a significant gap—the agent cannot predict side effects or response format.

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, concise and front-loaded with the core purpose. It avoids redundancy, but it is so brief that it omits critical context. It earns points for brevity, but the lack of substance prevents a 5.

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

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

For a 5-parameter update tool with no output schema and no annotations, the description is incomplete. It does not clarify the meaning of optional parameters, the update semantics (partial vs. full), or the return value. An agent would struggle to use it correctly beyond knowing it updates by ID. The description is too sparse for the complexity.

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 only 20% (only 'id' has a description). The description does not mention any parameters or explain what fields can be updated (name, logo_url, body_html, category_ids). The agent must infer semantics from field names alone, which is insufficient for correct invocation. The description adds no value beyond the schema.

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

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

The description clearly states the action: 'Update an existing skill by ID.' This specifies the verb (update), the resource (skill), and the unique identifier (ID). It distinguishes from siblings like create_skill, delete_skill, and get_skill by implying the skill already exists. It is not a tautology and is 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?

The description implies usage: you update when you have an existing skill ID. It mentions a prerequisite ('Requires write permission') but does not explicitly compare to alternatives like create_skill or provide exclusions. The usage context is implied rather than stated, and there is no guidance on when not to use 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?

With no annotations provided, the description bears the full burden of behavioral disclosure. It admits the operation mutates and requires write permission, but it does not disclose whether updates are partial or full, what happens to unspecified fields, error behavior for invalid IDs, or the return format. This is insufficient for a mutation tool with no annotation support.

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

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

The description is short, front-loaded with the operation, and includes the permission requirement in a second sentence. Every word contributes, but it is so terse that it sacrifices necessary detail; still, the structure itself is clean and efficient.

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 10-parameter mutation tool with no annotations and no output schema, this description is drastically incomplete. It omits update semantics (partial vs. full), field meanings, error handling, response shape, and any guidance on behavioral nuances. An agent cannot reliably invoke this 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?

Schema description coverage is only 10% (only 'id' has a description), and the description itself adds no meaning to the remaining 9 parameters. It merely mentions 'by ID', which is already required in the schema. The description fails to compensate for the lack of schema documentation on fields like image_url, platform_name, and testimonial_date.

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 verb 'update', the resource 'testimonial', and that it operates on an existing record by ID. It distinguishes from create/delete/list siblings by focusing on modification of an existing item, though it doesn't explicitly name alternatives.

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

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

The description implies this is for modifying an existing testimonial when write permission is present, but it does not explicitly contrast with create_testimonial or delete_testimonial, nor does it mention when not to use this tool. The 'requires write permission' note gives some context but no clear exclusions or alternatives.

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